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" 5525e992a4SHeiner Kallweit #define FIRMWARE_8107E_1 "rtl_nic/rtl8107e-1.fw" 5625e992a4SHeiner Kallweit #define FIRMWARE_8107E_2 "rtl_nic/rtl8107e-2.fw" 5702bf642bSHeiner Kallweit #define FIRMWARE_8125A_3 "rtl_nic/rtl8125a-3.fw" 5825e992a4SHeiner Kallweit 5925e992a4SHeiner Kallweit #define R8169_MSG_DEFAULT \ 6025e992a4SHeiner Kallweit (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN) 6125e992a4SHeiner Kallweit 6225e992a4SHeiner Kallweit /* Maximum number of multicast addresses to filter (vs. Rx-all-multicast). 6325e992a4SHeiner Kallweit The RTL chips use a 64 element hash table based on the Ethernet CRC. */ 6481cd17a4SHeiner Kallweit #define MC_FILTER_LIMIT 32 6525e992a4SHeiner Kallweit 6625e992a4SHeiner Kallweit #define TX_DMA_BURST 7 /* Maximum PCI burst, '7' is unlimited */ 6725e992a4SHeiner Kallweit #define InterFrameGap 0x03 /* 3 means InterFrameGap = the shortest one */ 6825e992a4SHeiner Kallweit 6925e992a4SHeiner Kallweit #define R8169_REGS_SIZE 256 7025e992a4SHeiner Kallweit #define R8169_RX_BUF_SIZE (SZ_16K - 1) 7125e992a4SHeiner Kallweit #define NUM_TX_DESC 64 /* Number of Tx descriptor registers */ 7225e992a4SHeiner Kallweit #define NUM_RX_DESC 256U /* Number of Rx descriptor registers */ 7325e992a4SHeiner Kallweit #define R8169_TX_RING_BYTES (NUM_TX_DESC * sizeof(struct TxDesc)) 7425e992a4SHeiner Kallweit #define R8169_RX_RING_BYTES (NUM_RX_DESC * sizeof(struct RxDesc)) 7525e992a4SHeiner Kallweit 76145a40e8SHeiner Kallweit #define RTL_CFG_NO_GBIT 1 77145a40e8SHeiner Kallweit 7825e992a4SHeiner Kallweit /* write/read MMIO register */ 7925e992a4SHeiner Kallweit #define RTL_W8(tp, reg, val8) writeb((val8), tp->mmio_addr + (reg)) 8025e992a4SHeiner Kallweit #define RTL_W16(tp, reg, val16) writew((val16), tp->mmio_addr + (reg)) 8125e992a4SHeiner Kallweit #define RTL_W32(tp, reg, val32) writel((val32), tp->mmio_addr + (reg)) 8225e992a4SHeiner Kallweit #define RTL_R8(tp, reg) readb(tp->mmio_addr + (reg)) 8325e992a4SHeiner Kallweit #define RTL_R16(tp, reg) readw(tp->mmio_addr + (reg)) 8425e992a4SHeiner Kallweit #define RTL_R32(tp, reg) readl(tp->mmio_addr + (reg)) 8525e992a4SHeiner Kallweit 8625e992a4SHeiner Kallweit enum mac_version { 8725e992a4SHeiner Kallweit /* support for ancient RTL_GIGA_MAC_VER_01 has been removed */ 8825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_02, 8925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_03, 9025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_04, 9125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_05, 9225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_06, 9325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_07, 9425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_08, 9525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_09, 9625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_10, 9725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_11, 9825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_12, 9925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_13, 10025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_14, 10125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_15, 10225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_16, 10325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_17, 10425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_18, 10525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_19, 10625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_20, 10725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_21, 10825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_22, 10925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_23, 11025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_24, 11125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_25, 11225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_26, 11325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_27, 11425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_28, 11525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_29, 11625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_30, 11725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_31, 11825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_32, 11925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_33, 12025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_34, 12125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_35, 12225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_36, 12325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_37, 12425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_38, 12525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_39, 12625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_40, 12725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_41, 12825e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_42, 12925e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_43, 13025e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_44, 13125e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_45, 13225e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_46, 13325e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_47, 13425e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_48, 13525e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_49, 13625e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_50, 13725e992a4SHeiner Kallweit RTL_GIGA_MAC_VER_51, 138f1bce4adSHeiner Kallweit RTL_GIGA_MAC_VER_60, 139f1bce4adSHeiner Kallweit RTL_GIGA_MAC_VER_61, 14025e992a4SHeiner Kallweit RTL_GIGA_MAC_NONE 14125e992a4SHeiner Kallweit }; 14225e992a4SHeiner Kallweit 14325e992a4SHeiner Kallweit #define JUMBO_1K ETH_DATA_LEN 14425e992a4SHeiner Kallweit #define JUMBO_4K (4*1024 - ETH_HLEN - 2) 14525e992a4SHeiner Kallweit #define JUMBO_6K (6*1024 - ETH_HLEN - 2) 14625e992a4SHeiner Kallweit #define JUMBO_7K (7*1024 - ETH_HLEN - 2) 14725e992a4SHeiner Kallweit #define JUMBO_9K (9*1024 - ETH_HLEN - 2) 14825e992a4SHeiner Kallweit 14925e992a4SHeiner Kallweit static const struct { 15025e992a4SHeiner Kallweit const char *name; 15125e992a4SHeiner Kallweit const char *fw_name; 15225e992a4SHeiner Kallweit } rtl_chip_infos[] = { 15325e992a4SHeiner Kallweit /* PCI devices. */ 15425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_02] = {"RTL8169s" }, 15525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_03] = {"RTL8110s" }, 15625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_04] = {"RTL8169sb/8110sb" }, 15725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_05] = {"RTL8169sc/8110sc" }, 15825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_06] = {"RTL8169sc/8110sc" }, 15925e992a4SHeiner Kallweit /* PCI-E devices. */ 16025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = {"RTL8102e" }, 16125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = {"RTL8102e" }, 1629e0773c3SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = {"RTL8102e/RTL8103e" }, 16325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = {"RTL8101e" }, 16425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = {"RTL8168b/8111b" }, 16525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = {"RTL8168b/8111b" }, 16625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = {"RTL8101e" }, 16725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = {"RTL8100e" }, 16825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = {"RTL8100e" }, 16925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = {"RTL8101e" }, 17025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = {"RTL8168b/8111b" }, 17125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = {"RTL8168cp/8111cp" }, 17225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = {"RTL8168c/8111c" }, 17325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = {"RTL8168c/8111c" }, 17425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = {"RTL8168c/8111c" }, 17525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = {"RTL8168c/8111c" }, 17625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = {"RTL8168cp/8111cp" }, 17725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = {"RTL8168cp/8111cp" }, 17825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = {"RTL8168d/8111d", FIRMWARE_8168D_1}, 17925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = {"RTL8168d/8111d", FIRMWARE_8168D_2}, 18025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = {"RTL8168dp/8111dp" }, 18125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = {"RTL8168dp/8111dp" }, 18225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = {"RTL8105e", FIRMWARE_8105E_1}, 18325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = {"RTL8105e", FIRMWARE_8105E_1}, 18425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_31] = {"RTL8168dp/8111dp" }, 18525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = {"RTL8168e/8111e", FIRMWARE_8168E_1}, 18625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = {"RTL8168e/8111e", FIRMWARE_8168E_2}, 18725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = {"RTL8168evl/8111evl", FIRMWARE_8168E_3}, 18825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = {"RTL8168f/8111f", FIRMWARE_8168F_1}, 18925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = {"RTL8168f/8111f", FIRMWARE_8168F_2}, 19025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = {"RTL8402", FIRMWARE_8402_1 }, 19125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = {"RTL8411", FIRMWARE_8411_1 }, 19225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = {"RTL8106e", FIRMWARE_8106E_1}, 19325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = {"RTL8168g/8111g", FIRMWARE_8168G_2}, 19425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = {"RTL8168g/8111g" }, 1959e0773c3SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = {"RTL8168gu/8111gu", FIRMWARE_8168G_3}, 1969e0773c3SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = {"RTL8106eus", FIRMWARE_8106E_2}, 1979e0773c3SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = {"RTL8411b", FIRMWARE_8411_2 }, 19825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = {"RTL8168h/8111h", FIRMWARE_8168H_1}, 19925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = {"RTL8168h/8111h", FIRMWARE_8168H_2}, 20025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = {"RTL8107e", FIRMWARE_8107E_1}, 20125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = {"RTL8107e", FIRMWARE_8107E_2}, 20225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = {"RTL8168ep/8111ep" }, 20325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = {"RTL8168ep/8111ep" }, 20425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = {"RTL8168ep/8111ep" }, 205f1bce4adSHeiner Kallweit [RTL_GIGA_MAC_VER_60] = {"RTL8125" }, 20602bf642bSHeiner Kallweit [RTL_GIGA_MAC_VER_61] = {"RTL8125", FIRMWARE_8125A_3}, 20725e992a4SHeiner Kallweit }; 20825e992a4SHeiner Kallweit 20925e992a4SHeiner Kallweit static const struct pci_device_id rtl8169_pci_tbl[] = { 210145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x2502) }, 211145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x2600) }, 212145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8129) }, 213145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8136), RTL_CFG_NO_GBIT }, 214145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8161) }, 215145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8167) }, 216145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8168) }, 217145a40e8SHeiner Kallweit { PCI_VDEVICE(NCUBE, 0x8168) }, 218145a40e8SHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8169) }, 21925e992a4SHeiner Kallweit { PCI_VENDOR_ID_DLINK, 0x4300, 220145a40e8SHeiner Kallweit PCI_VENDOR_ID_DLINK, 0x4b10, 0, 0 }, 2219d9f3fbaSHeiner Kallweit { PCI_VDEVICE(DLINK, 0x4300) }, 2229d9f3fbaSHeiner Kallweit { PCI_VDEVICE(DLINK, 0x4302) }, 2239d9f3fbaSHeiner Kallweit { PCI_VDEVICE(AT, 0xc107) }, 2249d9f3fbaSHeiner Kallweit { PCI_VDEVICE(USR, 0x0116) }, 2259d9f3fbaSHeiner Kallweit { PCI_VENDOR_ID_LINKSYS, 0x1032, PCI_ANY_ID, 0x0024 }, 2269d9f3fbaSHeiner Kallweit { 0x0001, 0x8168, PCI_ANY_ID, 0x2410 }, 227f1bce4adSHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x8125) }, 228f1bce4adSHeiner Kallweit { PCI_VDEVICE(REALTEK, 0x3000) }, 22925e992a4SHeiner Kallweit {} 23025e992a4SHeiner Kallweit }; 23125e992a4SHeiner Kallweit 23225e992a4SHeiner Kallweit MODULE_DEVICE_TABLE(pci, rtl8169_pci_tbl); 23325e992a4SHeiner Kallweit 23425e992a4SHeiner Kallweit static struct { 23525e992a4SHeiner Kallweit u32 msg_enable; 23625e992a4SHeiner Kallweit } debug = { -1 }; 23725e992a4SHeiner Kallweit 23825e992a4SHeiner Kallweit enum rtl_registers { 23925e992a4SHeiner Kallweit MAC0 = 0, /* Ethernet hardware address. */ 24025e992a4SHeiner Kallweit MAC4 = 4, 24125e992a4SHeiner Kallweit MAR0 = 8, /* Multicast filter. */ 24225e992a4SHeiner Kallweit CounterAddrLow = 0x10, 24325e992a4SHeiner Kallweit CounterAddrHigh = 0x14, 24425e992a4SHeiner Kallweit TxDescStartAddrLow = 0x20, 24525e992a4SHeiner Kallweit TxDescStartAddrHigh = 0x24, 24625e992a4SHeiner Kallweit TxHDescStartAddrLow = 0x28, 24725e992a4SHeiner Kallweit TxHDescStartAddrHigh = 0x2c, 24825e992a4SHeiner Kallweit FLASH = 0x30, 24925e992a4SHeiner Kallweit ERSR = 0x36, 25025e992a4SHeiner Kallweit ChipCmd = 0x37, 25125e992a4SHeiner Kallweit TxPoll = 0x38, 25225e992a4SHeiner Kallweit IntrMask = 0x3c, 25325e992a4SHeiner Kallweit IntrStatus = 0x3e, 25425e992a4SHeiner Kallweit 25525e992a4SHeiner Kallweit TxConfig = 0x40, 25625e992a4SHeiner Kallweit #define TXCFG_AUTO_FIFO (1 << 7) /* 8111e-vl */ 25725e992a4SHeiner Kallweit #define TXCFG_EMPTY (1 << 11) /* 8111e-vl */ 25825e992a4SHeiner Kallweit 25925e992a4SHeiner Kallweit RxConfig = 0x44, 26025e992a4SHeiner Kallweit #define RX128_INT_EN (1 << 15) /* 8111c and later */ 26125e992a4SHeiner Kallweit #define RX_MULTI_EN (1 << 14) /* 8111c only */ 26225e992a4SHeiner Kallweit #define RXCFG_FIFO_SHIFT 13 26325e992a4SHeiner Kallweit /* No threshold before first PCI xfer */ 26425e992a4SHeiner Kallweit #define RX_FIFO_THRESH (7 << RXCFG_FIFO_SHIFT) 26525e992a4SHeiner Kallweit #define RX_EARLY_OFF (1 << 11) 26625e992a4SHeiner Kallweit #define RXCFG_DMA_SHIFT 8 26725e992a4SHeiner Kallweit /* Unlimited maximum PCI burst. */ 26825e992a4SHeiner Kallweit #define RX_DMA_BURST (7 << RXCFG_DMA_SHIFT) 26925e992a4SHeiner Kallweit 27025e992a4SHeiner Kallweit RxMissed = 0x4c, 27125e992a4SHeiner Kallweit Cfg9346 = 0x50, 27225e992a4SHeiner Kallweit Config0 = 0x51, 27325e992a4SHeiner Kallweit Config1 = 0x52, 27425e992a4SHeiner Kallweit Config2 = 0x53, 27525e992a4SHeiner Kallweit #define PME_SIGNAL (1 << 5) /* 8168c and later */ 27625e992a4SHeiner Kallweit 27725e992a4SHeiner Kallweit Config3 = 0x54, 27825e992a4SHeiner Kallweit Config4 = 0x55, 27925e992a4SHeiner Kallweit Config5 = 0x56, 28025e992a4SHeiner Kallweit PHYAR = 0x60, 28125e992a4SHeiner Kallweit PHYstatus = 0x6c, 28225e992a4SHeiner Kallweit RxMaxSize = 0xda, 28325e992a4SHeiner Kallweit CPlusCmd = 0xe0, 28425e992a4SHeiner Kallweit IntrMitigate = 0xe2, 28525e992a4SHeiner Kallweit 28625e992a4SHeiner Kallweit #define RTL_COALESCE_MASK 0x0f 28725e992a4SHeiner Kallweit #define RTL_COALESCE_SHIFT 4 28825e992a4SHeiner Kallweit #define RTL_COALESCE_T_MAX (RTL_COALESCE_MASK) 28925e992a4SHeiner Kallweit #define RTL_COALESCE_FRAME_MAX (RTL_COALESCE_MASK << 2) 29025e992a4SHeiner Kallweit 29125e992a4SHeiner Kallweit RxDescAddrLow = 0xe4, 29225e992a4SHeiner Kallweit RxDescAddrHigh = 0xe8, 29325e992a4SHeiner Kallweit EarlyTxThres = 0xec, /* 8169. Unit of 32 bytes. */ 29425e992a4SHeiner Kallweit 29525e992a4SHeiner Kallweit #define NoEarlyTx 0x3f /* Max value : no early transmit. */ 29625e992a4SHeiner Kallweit 29725e992a4SHeiner Kallweit MaxTxPacketSize = 0xec, /* 8101/8168. Unit of 128 bytes. */ 29825e992a4SHeiner Kallweit 29925e992a4SHeiner Kallweit #define TxPacketMax (8064 >> 7) 30025e992a4SHeiner Kallweit #define EarlySize 0x27 30125e992a4SHeiner Kallweit 30225e992a4SHeiner Kallweit FuncEvent = 0xf0, 30325e992a4SHeiner Kallweit FuncEventMask = 0xf4, 30425e992a4SHeiner Kallweit FuncPresetState = 0xf8, 30525e992a4SHeiner Kallweit IBCR0 = 0xf8, 30625e992a4SHeiner Kallweit IBCR2 = 0xf9, 30725e992a4SHeiner Kallweit IBIMR0 = 0xfa, 30825e992a4SHeiner Kallweit IBISR0 = 0xfb, 30925e992a4SHeiner Kallweit FuncForceEvent = 0xfc, 31025e992a4SHeiner Kallweit }; 31125e992a4SHeiner Kallweit 31225e992a4SHeiner Kallweit enum rtl8168_8101_registers { 31325e992a4SHeiner Kallweit CSIDR = 0x64, 31425e992a4SHeiner Kallweit CSIAR = 0x68, 31525e992a4SHeiner Kallweit #define CSIAR_FLAG 0x80000000 31625e992a4SHeiner Kallweit #define CSIAR_WRITE_CMD 0x80000000 31725e992a4SHeiner Kallweit #define CSIAR_BYTE_ENABLE 0x0000f000 31825e992a4SHeiner Kallweit #define CSIAR_ADDR_MASK 0x00000fff 31925e992a4SHeiner Kallweit PMCH = 0x6f, 32025e992a4SHeiner Kallweit EPHYAR = 0x80, 32125e992a4SHeiner Kallweit #define EPHYAR_FLAG 0x80000000 32225e992a4SHeiner Kallweit #define EPHYAR_WRITE_CMD 0x80000000 32325e992a4SHeiner Kallweit #define EPHYAR_REG_MASK 0x1f 32425e992a4SHeiner Kallweit #define EPHYAR_REG_SHIFT 16 32525e992a4SHeiner Kallweit #define EPHYAR_DATA_MASK 0xffff 32625e992a4SHeiner Kallweit DLLPR = 0xd0, 32725e992a4SHeiner Kallweit #define PFM_EN (1 << 6) 32825e992a4SHeiner Kallweit #define TX_10M_PS_EN (1 << 7) 32925e992a4SHeiner Kallweit DBG_REG = 0xd1, 33025e992a4SHeiner Kallweit #define FIX_NAK_1 (1 << 4) 33125e992a4SHeiner Kallweit #define FIX_NAK_2 (1 << 3) 33225e992a4SHeiner Kallweit TWSI = 0xd2, 33325e992a4SHeiner Kallweit MCU = 0xd3, 33425e992a4SHeiner Kallweit #define NOW_IS_OOB (1 << 7) 33525e992a4SHeiner Kallweit #define TX_EMPTY (1 << 5) 33625e992a4SHeiner Kallweit #define RX_EMPTY (1 << 4) 33725e992a4SHeiner Kallweit #define RXTX_EMPTY (TX_EMPTY | RX_EMPTY) 33825e992a4SHeiner Kallweit #define EN_NDP (1 << 3) 33925e992a4SHeiner Kallweit #define EN_OOB_RESET (1 << 2) 34025e992a4SHeiner Kallweit #define LINK_LIST_RDY (1 << 1) 34125e992a4SHeiner Kallweit EFUSEAR = 0xdc, 34225e992a4SHeiner Kallweit #define EFUSEAR_FLAG 0x80000000 34325e992a4SHeiner Kallweit #define EFUSEAR_WRITE_CMD 0x80000000 34425e992a4SHeiner Kallweit #define EFUSEAR_READ_CMD 0x00000000 34525e992a4SHeiner Kallweit #define EFUSEAR_REG_MASK 0x03ff 34625e992a4SHeiner Kallweit #define EFUSEAR_REG_SHIFT 8 34725e992a4SHeiner Kallweit #define EFUSEAR_DATA_MASK 0xff 34825e992a4SHeiner Kallweit MISC_1 = 0xf2, 34925e992a4SHeiner Kallweit #define PFM_D3COLD_EN (1 << 6) 35025e992a4SHeiner Kallweit }; 35125e992a4SHeiner Kallweit 35225e992a4SHeiner Kallweit enum rtl8168_registers { 35325e992a4SHeiner Kallweit LED_FREQ = 0x1a, 35425e992a4SHeiner Kallweit EEE_LED = 0x1b, 35525e992a4SHeiner Kallweit ERIDR = 0x70, 35625e992a4SHeiner Kallweit ERIAR = 0x74, 35725e992a4SHeiner Kallweit #define ERIAR_FLAG 0x80000000 35825e992a4SHeiner Kallweit #define ERIAR_WRITE_CMD 0x80000000 35925e992a4SHeiner Kallweit #define ERIAR_READ_CMD 0x00000000 36025e992a4SHeiner Kallweit #define ERIAR_ADDR_BYTE_ALIGN 4 36125e992a4SHeiner Kallweit #define ERIAR_TYPE_SHIFT 16 36225e992a4SHeiner Kallweit #define ERIAR_EXGMAC (0x00 << ERIAR_TYPE_SHIFT) 36325e992a4SHeiner Kallweit #define ERIAR_MSIX (0x01 << ERIAR_TYPE_SHIFT) 36425e992a4SHeiner Kallweit #define ERIAR_ASF (0x02 << ERIAR_TYPE_SHIFT) 36525e992a4SHeiner Kallweit #define ERIAR_OOB (0x02 << ERIAR_TYPE_SHIFT) 36625e992a4SHeiner Kallweit #define ERIAR_MASK_SHIFT 12 36725e992a4SHeiner Kallweit #define ERIAR_MASK_0001 (0x1 << ERIAR_MASK_SHIFT) 36825e992a4SHeiner Kallweit #define ERIAR_MASK_0011 (0x3 << ERIAR_MASK_SHIFT) 36925e992a4SHeiner Kallweit #define ERIAR_MASK_0100 (0x4 << ERIAR_MASK_SHIFT) 37025e992a4SHeiner Kallweit #define ERIAR_MASK_0101 (0x5 << ERIAR_MASK_SHIFT) 37125e992a4SHeiner Kallweit #define ERIAR_MASK_1111 (0xf << ERIAR_MASK_SHIFT) 37225e992a4SHeiner Kallweit EPHY_RXER_NUM = 0x7c, 37325e992a4SHeiner Kallweit OCPDR = 0xb0, /* OCP GPHY access */ 37425e992a4SHeiner Kallweit #define OCPDR_WRITE_CMD 0x80000000 37525e992a4SHeiner Kallweit #define OCPDR_READ_CMD 0x00000000 37625e992a4SHeiner Kallweit #define OCPDR_REG_MASK 0x7f 37725e992a4SHeiner Kallweit #define OCPDR_GPHY_REG_SHIFT 16 37825e992a4SHeiner Kallweit #define OCPDR_DATA_MASK 0xffff 37925e992a4SHeiner Kallweit OCPAR = 0xb4, 38025e992a4SHeiner Kallweit #define OCPAR_FLAG 0x80000000 38125e992a4SHeiner Kallweit #define OCPAR_GPHY_WRITE_CMD 0x8000f060 38225e992a4SHeiner Kallweit #define OCPAR_GPHY_READ_CMD 0x0000f060 38325e992a4SHeiner Kallweit GPHY_OCP = 0xb8, 38425e992a4SHeiner Kallweit RDSAR1 = 0xd0, /* 8168c only. Undocumented on 8168dp */ 38525e992a4SHeiner Kallweit MISC = 0xf0, /* 8168e only. */ 38625e992a4SHeiner Kallweit #define TXPLA_RST (1 << 29) 38725e992a4SHeiner Kallweit #define DISABLE_LAN_EN (1 << 23) /* Enable GPIO pin */ 38825e992a4SHeiner Kallweit #define PWM_EN (1 << 22) 38925e992a4SHeiner Kallweit #define RXDV_GATED_EN (1 << 19) 39025e992a4SHeiner Kallweit #define EARLY_TALLY_EN (1 << 16) 39125e992a4SHeiner Kallweit }; 39225e992a4SHeiner Kallweit 393f1bce4adSHeiner Kallweit enum rtl8125_registers { 394f1bce4adSHeiner Kallweit IntrMask_8125 = 0x38, 395f1bce4adSHeiner Kallweit IntrStatus_8125 = 0x3c, 396f1bce4adSHeiner Kallweit TxPoll_8125 = 0x90, 397f1bce4adSHeiner Kallweit MAC0_BKP = 0x19e0, 398f1bce4adSHeiner Kallweit }; 399f1bce4adSHeiner Kallweit 400f1bce4adSHeiner Kallweit #define RX_VLAN_INNER_8125 BIT(22) 401f1bce4adSHeiner Kallweit #define RX_VLAN_OUTER_8125 BIT(23) 402f1bce4adSHeiner Kallweit #define RX_VLAN_8125 (RX_VLAN_INNER_8125 | RX_VLAN_OUTER_8125) 403f1bce4adSHeiner Kallweit 404f1bce4adSHeiner Kallweit #define RX_FETCH_DFLT_8125 (8 << 27) 405f1bce4adSHeiner Kallweit 40625e992a4SHeiner Kallweit enum rtl_register_content { 40725e992a4SHeiner Kallweit /* InterruptStatusBits */ 40825e992a4SHeiner Kallweit SYSErr = 0x8000, 40925e992a4SHeiner Kallweit PCSTimeout = 0x4000, 41025e992a4SHeiner Kallweit SWInt = 0x0100, 41125e992a4SHeiner Kallweit TxDescUnavail = 0x0080, 41225e992a4SHeiner Kallweit RxFIFOOver = 0x0040, 41325e992a4SHeiner Kallweit LinkChg = 0x0020, 41425e992a4SHeiner Kallweit RxOverflow = 0x0010, 41525e992a4SHeiner Kallweit TxErr = 0x0008, 41625e992a4SHeiner Kallweit TxOK = 0x0004, 41725e992a4SHeiner Kallweit RxErr = 0x0002, 41825e992a4SHeiner Kallweit RxOK = 0x0001, 41925e992a4SHeiner Kallweit 42025e992a4SHeiner Kallweit /* RxStatusDesc */ 42125e992a4SHeiner Kallweit RxRWT = (1 << 22), 42225e992a4SHeiner Kallweit RxRES = (1 << 21), 42325e992a4SHeiner Kallweit RxRUNT = (1 << 20), 42425e992a4SHeiner Kallweit RxCRC = (1 << 19), 42525e992a4SHeiner Kallweit 42625e992a4SHeiner Kallweit /* ChipCmdBits */ 42725e992a4SHeiner Kallweit StopReq = 0x80, 42825e992a4SHeiner Kallweit CmdReset = 0x10, 42925e992a4SHeiner Kallweit CmdRxEnb = 0x08, 43025e992a4SHeiner Kallweit CmdTxEnb = 0x04, 43125e992a4SHeiner Kallweit RxBufEmpty = 0x01, 43225e992a4SHeiner Kallweit 43325e992a4SHeiner Kallweit /* TXPoll register p.5 */ 43425e992a4SHeiner Kallweit HPQ = 0x80, /* Poll cmd on the high prio queue */ 43525e992a4SHeiner Kallweit NPQ = 0x40, /* Poll cmd on the low prio queue */ 43625e992a4SHeiner Kallweit FSWInt = 0x01, /* Forced software interrupt */ 43725e992a4SHeiner Kallweit 43825e992a4SHeiner Kallweit /* Cfg9346Bits */ 43925e992a4SHeiner Kallweit Cfg9346_Lock = 0x00, 44025e992a4SHeiner Kallweit Cfg9346_Unlock = 0xc0, 44125e992a4SHeiner Kallweit 44225e992a4SHeiner Kallweit /* rx_mode_bits */ 44325e992a4SHeiner Kallweit AcceptErr = 0x20, 44425e992a4SHeiner Kallweit AcceptRunt = 0x10, 44525e992a4SHeiner Kallweit AcceptBroadcast = 0x08, 44625e992a4SHeiner Kallweit AcceptMulticast = 0x04, 44725e992a4SHeiner Kallweit AcceptMyPhys = 0x02, 44825e992a4SHeiner Kallweit AcceptAllPhys = 0x01, 44925e992a4SHeiner Kallweit #define RX_CONFIG_ACCEPT_MASK 0x3f 45025e992a4SHeiner Kallweit 45125e992a4SHeiner Kallweit /* TxConfigBits */ 45225e992a4SHeiner Kallweit TxInterFrameGapShift = 24, 45325e992a4SHeiner Kallweit TxDMAShift = 8, /* DMA burst value (0-7) is shift this many bits */ 45425e992a4SHeiner Kallweit 45525e992a4SHeiner Kallweit /* Config1 register p.24 */ 45625e992a4SHeiner Kallweit LEDS1 = (1 << 7), 45725e992a4SHeiner Kallweit LEDS0 = (1 << 6), 45825e992a4SHeiner Kallweit Speed_down = (1 << 4), 45925e992a4SHeiner Kallweit MEMMAP = (1 << 3), 46025e992a4SHeiner Kallweit IOMAP = (1 << 2), 46125e992a4SHeiner Kallweit VPD = (1 << 1), 46225e992a4SHeiner Kallweit PMEnable = (1 << 0), /* Power Management Enable */ 46325e992a4SHeiner Kallweit 46425e992a4SHeiner Kallweit /* Config2 register p. 25 */ 46525e992a4SHeiner Kallweit ClkReqEn = (1 << 7), /* Clock Request Enable */ 46625e992a4SHeiner Kallweit MSIEnable = (1 << 5), /* 8169 only. Reserved in the 8168. */ 46725e992a4SHeiner Kallweit PCI_Clock_66MHz = 0x01, 46825e992a4SHeiner Kallweit PCI_Clock_33MHz = 0x00, 46925e992a4SHeiner Kallweit 47025e992a4SHeiner Kallweit /* Config3 register p.25 */ 47125e992a4SHeiner Kallweit MagicPacket = (1 << 5), /* Wake up when receives a Magic Packet */ 47225e992a4SHeiner Kallweit LinkUp = (1 << 4), /* Wake up when the cable connection is re-established */ 47325e992a4SHeiner Kallweit Jumbo_En0 = (1 << 2), /* 8168 only. Reserved in the 8168b */ 47425e992a4SHeiner Kallweit Rdy_to_L23 = (1 << 1), /* L23 Enable */ 47525e992a4SHeiner Kallweit Beacon_en = (1 << 0), /* 8168 only. Reserved in the 8168b */ 47625e992a4SHeiner Kallweit 47725e992a4SHeiner Kallweit /* Config4 register */ 47825e992a4SHeiner Kallweit Jumbo_En1 = (1 << 1), /* 8168 only. Reserved in the 8168b */ 47925e992a4SHeiner Kallweit 48025e992a4SHeiner Kallweit /* Config5 register p.27 */ 48125e992a4SHeiner Kallweit BWF = (1 << 6), /* Accept Broadcast wakeup frame */ 48225e992a4SHeiner Kallweit MWF = (1 << 5), /* Accept Multicast wakeup frame */ 48325e992a4SHeiner Kallweit UWF = (1 << 4), /* Accept Unicast wakeup frame */ 48425e992a4SHeiner Kallweit Spi_en = (1 << 3), 48525e992a4SHeiner Kallweit LanWake = (1 << 1), /* LanWake enable/disable */ 48625e992a4SHeiner Kallweit PMEStatus = (1 << 0), /* PME status can be reset by PCI RST# */ 48725e992a4SHeiner Kallweit ASPM_en = (1 << 0), /* ASPM enable */ 48825e992a4SHeiner Kallweit 48925e992a4SHeiner Kallweit /* CPlusCmd p.31 */ 49025e992a4SHeiner Kallweit EnableBist = (1 << 15), // 8168 8101 49125e992a4SHeiner Kallweit Mac_dbgo_oe = (1 << 14), // 8168 8101 49225e992a4SHeiner Kallweit Normal_mode = (1 << 13), // unused 49325e992a4SHeiner Kallweit Force_half_dup = (1 << 12), // 8168 8101 49425e992a4SHeiner Kallweit Force_rxflow_en = (1 << 11), // 8168 8101 49525e992a4SHeiner Kallweit Force_txflow_en = (1 << 10), // 8168 8101 49625e992a4SHeiner Kallweit Cxpl_dbg_sel = (1 << 9), // 8168 8101 49725e992a4SHeiner Kallweit ASF = (1 << 8), // 8168 8101 49825e992a4SHeiner Kallweit PktCntrDisable = (1 << 7), // 8168 8101 49925e992a4SHeiner Kallweit Mac_dbgo_sel = 0x001c, // 8168 50025e992a4SHeiner Kallweit RxVlan = (1 << 6), 50125e992a4SHeiner Kallweit RxChkSum = (1 << 5), 50225e992a4SHeiner Kallweit PCIDAC = (1 << 4), 50325e992a4SHeiner Kallweit PCIMulRW = (1 << 3), 50425e992a4SHeiner Kallweit #define INTT_MASK GENMASK(1, 0) 505bc73241eSHeiner Kallweit #define CPCMD_MASK (Normal_mode | RxVlan | RxChkSum | INTT_MASK) 50625e992a4SHeiner Kallweit 50725e992a4SHeiner Kallweit /* rtl8169_PHYstatus */ 50825e992a4SHeiner Kallweit TBI_Enable = 0x80, 50925e992a4SHeiner Kallweit TxFlowCtrl = 0x40, 51025e992a4SHeiner Kallweit RxFlowCtrl = 0x20, 51125e992a4SHeiner Kallweit _1000bpsF = 0x10, 51225e992a4SHeiner Kallweit _100bps = 0x08, 51325e992a4SHeiner Kallweit _10bps = 0x04, 51425e992a4SHeiner Kallweit LinkStatus = 0x02, 51525e992a4SHeiner Kallweit FullDup = 0x01, 51625e992a4SHeiner Kallweit 51725e992a4SHeiner Kallweit /* ResetCounterCommand */ 51825e992a4SHeiner Kallweit CounterReset = 0x1, 51925e992a4SHeiner Kallweit 52025e992a4SHeiner Kallweit /* DumpCounterCommand */ 52125e992a4SHeiner Kallweit CounterDump = 0x8, 52225e992a4SHeiner Kallweit 52325e992a4SHeiner Kallweit /* magic enable v2 */ 52425e992a4SHeiner Kallweit MagicPacket_v2 = (1 << 16), /* Wake up when receives a Magic Packet */ 52525e992a4SHeiner Kallweit }; 52625e992a4SHeiner Kallweit 52725e992a4SHeiner Kallweit enum rtl_desc_bit { 52825e992a4SHeiner Kallweit /* First doubleword. */ 52925e992a4SHeiner Kallweit DescOwn = (1 << 31), /* Descriptor is owned by NIC */ 53025e992a4SHeiner Kallweit RingEnd = (1 << 30), /* End of descriptor ring */ 53125e992a4SHeiner Kallweit FirstFrag = (1 << 29), /* First segment of a packet */ 53225e992a4SHeiner Kallweit LastFrag = (1 << 28), /* Final segment of a packet */ 53325e992a4SHeiner Kallweit }; 53425e992a4SHeiner Kallweit 53525e992a4SHeiner Kallweit /* Generic case. */ 53625e992a4SHeiner Kallweit enum rtl_tx_desc_bit { 53725e992a4SHeiner Kallweit /* First doubleword. */ 53825e992a4SHeiner Kallweit TD_LSO = (1 << 27), /* Large Send Offload */ 53925e992a4SHeiner Kallweit #define TD_MSS_MAX 0x07ffu /* MSS value */ 54025e992a4SHeiner Kallweit 54125e992a4SHeiner Kallweit /* Second doubleword. */ 54225e992a4SHeiner Kallweit TxVlanTag = (1 << 17), /* Add VLAN tag */ 54325e992a4SHeiner Kallweit }; 54425e992a4SHeiner Kallweit 54525e992a4SHeiner Kallweit /* 8169, 8168b and 810x except 8102e. */ 54625e992a4SHeiner Kallweit enum rtl_tx_desc_bit_0 { 54725e992a4SHeiner Kallweit /* First doubleword. */ 54825e992a4SHeiner Kallweit #define TD0_MSS_SHIFT 16 /* MSS position (11 bits) */ 54925e992a4SHeiner Kallweit TD0_TCP_CS = (1 << 16), /* Calculate TCP/IP checksum */ 55025e992a4SHeiner Kallweit TD0_UDP_CS = (1 << 17), /* Calculate UDP/IP checksum */ 55125e992a4SHeiner Kallweit TD0_IP_CS = (1 << 18), /* Calculate IP checksum */ 55225e992a4SHeiner Kallweit }; 55325e992a4SHeiner Kallweit 55425e992a4SHeiner Kallweit /* 8102e, 8168c and beyond. */ 55525e992a4SHeiner Kallweit enum rtl_tx_desc_bit_1 { 55625e992a4SHeiner Kallweit /* First doubleword. */ 55725e992a4SHeiner Kallweit TD1_GTSENV4 = (1 << 26), /* Giant Send for IPv4 */ 55825e992a4SHeiner Kallweit TD1_GTSENV6 = (1 << 25), /* Giant Send for IPv6 */ 55925e992a4SHeiner Kallweit #define GTTCPHO_SHIFT 18 560e64e0c89SHeiner Kallweit #define GTTCPHO_MAX 0x7f 56125e992a4SHeiner Kallweit 56225e992a4SHeiner Kallweit /* Second doubleword. */ 56325e992a4SHeiner Kallweit #define TCPHO_SHIFT 18 564e64e0c89SHeiner Kallweit #define TCPHO_MAX 0x3ff 56525e992a4SHeiner Kallweit #define TD1_MSS_SHIFT 18 /* MSS position (11 bits) */ 56625e992a4SHeiner Kallweit TD1_IPv6_CS = (1 << 28), /* Calculate IPv6 checksum */ 56725e992a4SHeiner Kallweit TD1_IPv4_CS = (1 << 29), /* Calculate IPv4 checksum */ 56825e992a4SHeiner Kallweit TD1_TCP_CS = (1 << 30), /* Calculate TCP/IP checksum */ 56925e992a4SHeiner Kallweit TD1_UDP_CS = (1 << 31), /* Calculate UDP/IP checksum */ 57025e992a4SHeiner Kallweit }; 57125e992a4SHeiner Kallweit 57225e992a4SHeiner Kallweit enum rtl_rx_desc_bit { 57325e992a4SHeiner Kallweit /* Rx private */ 57425e992a4SHeiner Kallweit PID1 = (1 << 18), /* Protocol ID bit 1/2 */ 57525e992a4SHeiner Kallweit PID0 = (1 << 17), /* Protocol ID bit 0/2 */ 57625e992a4SHeiner Kallweit 57725e992a4SHeiner Kallweit #define RxProtoUDP (PID1) 57825e992a4SHeiner Kallweit #define RxProtoTCP (PID0) 57925e992a4SHeiner Kallweit #define RxProtoIP (PID1 | PID0) 58025e992a4SHeiner Kallweit #define RxProtoMask RxProtoIP 58125e992a4SHeiner Kallweit 58225e992a4SHeiner Kallweit IPFail = (1 << 16), /* IP checksum failed */ 58325e992a4SHeiner Kallweit UDPFail = (1 << 15), /* UDP/IP checksum failed */ 58425e992a4SHeiner Kallweit TCPFail = (1 << 14), /* TCP/IP checksum failed */ 58525e992a4SHeiner Kallweit RxVlanTag = (1 << 16), /* VLAN tag available */ 58625e992a4SHeiner Kallweit }; 58725e992a4SHeiner Kallweit 58825e992a4SHeiner Kallweit #define RsvdMask 0x3fffc000 58925e992a4SHeiner Kallweit 5900170d594SHeiner Kallweit #define RTL_GSO_MAX_SIZE_V1 32000 5910170d594SHeiner Kallweit #define RTL_GSO_MAX_SEGS_V1 24 5920170d594SHeiner Kallweit #define RTL_GSO_MAX_SIZE_V2 64000 5930170d594SHeiner Kallweit #define RTL_GSO_MAX_SEGS_V2 64 5940170d594SHeiner Kallweit 59525e992a4SHeiner Kallweit struct TxDesc { 59625e992a4SHeiner Kallweit __le32 opts1; 59725e992a4SHeiner Kallweit __le32 opts2; 59825e992a4SHeiner Kallweit __le64 addr; 59925e992a4SHeiner Kallweit }; 60025e992a4SHeiner Kallweit 60125e992a4SHeiner Kallweit struct RxDesc { 60225e992a4SHeiner Kallweit __le32 opts1; 60325e992a4SHeiner Kallweit __le32 opts2; 60425e992a4SHeiner Kallweit __le64 addr; 60525e992a4SHeiner Kallweit }; 60625e992a4SHeiner Kallweit 60725e992a4SHeiner Kallweit struct ring_info { 60825e992a4SHeiner Kallweit struct sk_buff *skb; 60925e992a4SHeiner Kallweit u32 len; 61025e992a4SHeiner Kallweit }; 61125e992a4SHeiner Kallweit 61225e992a4SHeiner Kallweit struct rtl8169_counters { 61325e992a4SHeiner Kallweit __le64 tx_packets; 61425e992a4SHeiner Kallweit __le64 rx_packets; 61525e992a4SHeiner Kallweit __le64 tx_errors; 61625e992a4SHeiner Kallweit __le32 rx_errors; 61725e992a4SHeiner Kallweit __le16 rx_missed; 61825e992a4SHeiner Kallweit __le16 align_errors; 61925e992a4SHeiner Kallweit __le32 tx_one_collision; 62025e992a4SHeiner Kallweit __le32 tx_multi_collision; 62125e992a4SHeiner Kallweit __le64 rx_unicast; 62225e992a4SHeiner Kallweit __le64 rx_broadcast; 62325e992a4SHeiner Kallweit __le32 rx_multicast; 62425e992a4SHeiner Kallweit __le16 tx_aborted; 62525e992a4SHeiner Kallweit __le16 tx_underun; 62625e992a4SHeiner Kallweit }; 62725e992a4SHeiner Kallweit 62825e992a4SHeiner Kallweit struct rtl8169_tc_offsets { 62925e992a4SHeiner Kallweit bool inited; 63025e992a4SHeiner Kallweit __le64 tx_errors; 63125e992a4SHeiner Kallweit __le32 tx_multi_collision; 63225e992a4SHeiner Kallweit __le16 tx_aborted; 63325e992a4SHeiner Kallweit }; 63425e992a4SHeiner Kallweit 63525e992a4SHeiner Kallweit enum rtl_flag { 63625e992a4SHeiner Kallweit RTL_FLAG_TASK_ENABLED = 0, 63725e992a4SHeiner Kallweit RTL_FLAG_TASK_RESET_PENDING, 63825e992a4SHeiner Kallweit RTL_FLAG_MAX 63925e992a4SHeiner Kallweit }; 64025e992a4SHeiner Kallweit 64125e992a4SHeiner Kallweit struct rtl8169_stats { 64225e992a4SHeiner Kallweit u64 packets; 64325e992a4SHeiner Kallweit u64 bytes; 64425e992a4SHeiner Kallweit struct u64_stats_sync syncp; 64525e992a4SHeiner Kallweit }; 64625e992a4SHeiner Kallweit 64725e992a4SHeiner Kallweit struct rtl8169_private { 64825e992a4SHeiner Kallweit void __iomem *mmio_addr; /* memory map physical address */ 64925e992a4SHeiner Kallweit struct pci_dev *pci_dev; 65025e992a4SHeiner Kallweit struct net_device *dev; 65125e992a4SHeiner Kallweit struct phy_device *phydev; 65225e992a4SHeiner Kallweit struct napi_struct napi; 65325e992a4SHeiner Kallweit u32 msg_enable; 65425e992a4SHeiner Kallweit enum mac_version mac_version; 65525e992a4SHeiner Kallweit u32 cur_rx; /* Index into the Rx descriptor buffer of next Rx pkt. */ 65625e992a4SHeiner Kallweit u32 cur_tx; /* Index into the Tx descriptor buffer of next Rx pkt. */ 65725e992a4SHeiner Kallweit u32 dirty_tx; 65825e992a4SHeiner Kallweit struct rtl8169_stats rx_stats; 65925e992a4SHeiner Kallweit struct rtl8169_stats tx_stats; 66025e992a4SHeiner Kallweit struct TxDesc *TxDescArray; /* 256-aligned Tx descriptor ring */ 66125e992a4SHeiner Kallweit struct RxDesc *RxDescArray; /* 256-aligned Rx descriptor ring */ 66225e992a4SHeiner Kallweit dma_addr_t TxPhyAddr; 66325e992a4SHeiner Kallweit dma_addr_t RxPhyAddr; 66432879f00SHeiner Kallweit struct page *Rx_databuff[NUM_RX_DESC]; /* Rx data buffers */ 66525e992a4SHeiner Kallweit struct ring_info tx_skb[NUM_TX_DESC]; /* Tx data buffers */ 66625e992a4SHeiner Kallweit u16 cp_cmd; 667c1d532d2SHeiner Kallweit u32 irq_mask; 66825e992a4SHeiner Kallweit struct clk *clk; 66925e992a4SHeiner Kallweit 67025e992a4SHeiner Kallweit struct { 67125e992a4SHeiner Kallweit DECLARE_BITMAP(flags, RTL_FLAG_MAX); 67225e992a4SHeiner Kallweit struct mutex mutex; 67325e992a4SHeiner Kallweit struct work_struct work; 67425e992a4SHeiner Kallweit } wk; 67525e992a4SHeiner Kallweit 67625e992a4SHeiner Kallweit unsigned irq_enabled:1; 67725e992a4SHeiner Kallweit unsigned supports_gmii:1; 67862b1b3b3SHeiner Kallweit unsigned aspm_manageable:1; 67925e992a4SHeiner Kallweit dma_addr_t counters_phys_addr; 68025e992a4SHeiner Kallweit struct rtl8169_counters *counters; 68125e992a4SHeiner Kallweit struct rtl8169_tc_offsets tc_offset; 68225e992a4SHeiner Kallweit u32 saved_wolopts; 68325e992a4SHeiner Kallweit 68425e992a4SHeiner Kallweit const char *fw_name; 6858197f9d2SHeiner Kallweit struct rtl_fw *rtl_fw; 68625e992a4SHeiner Kallweit 68725e992a4SHeiner Kallweit u32 ocp_base; 68825e992a4SHeiner Kallweit }; 68925e992a4SHeiner Kallweit 69025e992a4SHeiner Kallweit typedef void (*rtl_generic_fct)(struct rtl8169_private *tp); 69125e992a4SHeiner Kallweit 69225e992a4SHeiner Kallweit MODULE_AUTHOR("Realtek and the Linux r8169 crew <netdev@vger.kernel.org>"); 69325e992a4SHeiner Kallweit MODULE_DESCRIPTION("RealTek RTL-8169 Gigabit Ethernet driver"); 69425e992a4SHeiner Kallweit module_param_named(debug, debug.msg_enable, int, 0); 69525e992a4SHeiner Kallweit MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 16=all)"); 69625e992a4SHeiner Kallweit MODULE_SOFTDEP("pre: realtek"); 69725e992a4SHeiner Kallweit MODULE_LICENSE("GPL"); 69825e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168D_1); 69925e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168D_2); 70025e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_1); 70125e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_2); 70225e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168E_3); 70325e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8105E_1); 70425e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168F_1); 70525e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168F_2); 70625e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8402_1); 70725e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8411_1); 70825e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8411_2); 70925e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8106E_1); 71025e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8106E_2); 71125e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168G_2); 71225e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168G_3); 71325e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168H_1); 71425e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8168H_2); 71525e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8107E_1); 71625e992a4SHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8107E_2); 71702bf642bSHeiner Kallweit MODULE_FIRMWARE(FIRMWARE_8125A_3); 71825e992a4SHeiner Kallweit 71925e992a4SHeiner Kallweit static inline struct device *tp_to_dev(struct rtl8169_private *tp) 72025e992a4SHeiner Kallweit { 72125e992a4SHeiner Kallweit return &tp->pci_dev->dev; 72225e992a4SHeiner Kallweit } 72325e992a4SHeiner Kallweit 72425e992a4SHeiner Kallweit static void rtl_lock_work(struct rtl8169_private *tp) 72525e992a4SHeiner Kallweit { 72625e992a4SHeiner Kallweit mutex_lock(&tp->wk.mutex); 72725e992a4SHeiner Kallweit } 72825e992a4SHeiner Kallweit 72925e992a4SHeiner Kallweit static void rtl_unlock_work(struct rtl8169_private *tp) 73025e992a4SHeiner Kallweit { 73125e992a4SHeiner Kallweit mutex_unlock(&tp->wk.mutex); 73225e992a4SHeiner Kallweit } 73325e992a4SHeiner Kallweit 73425e992a4SHeiner Kallweit static void rtl_lock_config_regs(struct rtl8169_private *tp) 73525e992a4SHeiner Kallweit { 73625e992a4SHeiner Kallweit RTL_W8(tp, Cfg9346, Cfg9346_Lock); 73725e992a4SHeiner Kallweit } 73825e992a4SHeiner Kallweit 73925e992a4SHeiner Kallweit static void rtl_unlock_config_regs(struct rtl8169_private *tp) 74025e992a4SHeiner Kallweit { 74125e992a4SHeiner Kallweit RTL_W8(tp, Cfg9346, Cfg9346_Unlock); 74225e992a4SHeiner Kallweit } 74325e992a4SHeiner Kallweit 744f1bce4adSHeiner Kallweit static bool rtl_is_8125(struct rtl8169_private *tp) 745f1bce4adSHeiner Kallweit { 746f1bce4adSHeiner Kallweit return tp->mac_version >= RTL_GIGA_MAC_VER_60; 747f1bce4adSHeiner Kallweit } 748f1bce4adSHeiner Kallweit 7499e9f33baSHeiner Kallweit static bool rtl_is_8168evl_up(struct rtl8169_private *tp) 7509e9f33baSHeiner Kallweit { 7519e9f33baSHeiner Kallweit return tp->mac_version >= RTL_GIGA_MAC_VER_34 && 752c623305bSHeiner Kallweit tp->mac_version != RTL_GIGA_MAC_VER_39 && 753c623305bSHeiner Kallweit tp->mac_version <= RTL_GIGA_MAC_VER_51; 7549e9f33baSHeiner Kallweit } 7559e9f33baSHeiner Kallweit 7562e779ddbSHeiner Kallweit static bool rtl_supports_eee(struct rtl8169_private *tp) 7572e779ddbSHeiner Kallweit { 7582e779ddbSHeiner Kallweit return tp->mac_version >= RTL_GIGA_MAC_VER_34 && 7592e779ddbSHeiner Kallweit tp->mac_version != RTL_GIGA_MAC_VER_37 && 7602e779ddbSHeiner Kallweit tp->mac_version != RTL_GIGA_MAC_VER_39; 7612e779ddbSHeiner Kallweit } 7622e779ddbSHeiner Kallweit 763ce37115eSHeiner Kallweit static void rtl_read_mac_from_reg(struct rtl8169_private *tp, u8 *mac, int reg) 764ce37115eSHeiner Kallweit { 765ce37115eSHeiner Kallweit int i; 766ce37115eSHeiner Kallweit 767ce37115eSHeiner Kallweit for (i = 0; i < ETH_ALEN; i++) 768ce37115eSHeiner Kallweit mac[i] = RTL_R8(tp, reg + i); 769ce37115eSHeiner Kallweit } 770ce37115eSHeiner Kallweit 77125e992a4SHeiner Kallweit struct rtl_cond { 77225e992a4SHeiner Kallweit bool (*check)(struct rtl8169_private *); 77325e992a4SHeiner Kallweit const char *msg; 77425e992a4SHeiner Kallweit }; 77525e992a4SHeiner Kallweit 77625e992a4SHeiner Kallweit static void rtl_udelay(unsigned int d) 77725e992a4SHeiner Kallweit { 77825e992a4SHeiner Kallweit udelay(d); 77925e992a4SHeiner Kallweit } 78025e992a4SHeiner Kallweit 78125e992a4SHeiner Kallweit static bool rtl_loop_wait(struct rtl8169_private *tp, const struct rtl_cond *c, 78225e992a4SHeiner Kallweit void (*delay)(unsigned int), unsigned int d, int n, 78325e992a4SHeiner Kallweit bool high) 78425e992a4SHeiner Kallweit { 78525e992a4SHeiner Kallweit int i; 78625e992a4SHeiner Kallweit 78725e992a4SHeiner Kallweit for (i = 0; i < n; i++) { 78825e992a4SHeiner Kallweit if (c->check(tp) == high) 78925e992a4SHeiner Kallweit return true; 79025e992a4SHeiner Kallweit delay(d); 79125e992a4SHeiner Kallweit } 79225e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "%s == %d (loop: %d, delay: %d).\n", 79325e992a4SHeiner Kallweit c->msg, !high, n, d); 79425e992a4SHeiner Kallweit return false; 79525e992a4SHeiner Kallweit } 79625e992a4SHeiner Kallweit 79725e992a4SHeiner Kallweit static bool rtl_udelay_loop_wait_high(struct rtl8169_private *tp, 79825e992a4SHeiner Kallweit const struct rtl_cond *c, 79925e992a4SHeiner Kallweit unsigned int d, int n) 80025e992a4SHeiner Kallweit { 80125e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, rtl_udelay, d, n, true); 80225e992a4SHeiner Kallweit } 80325e992a4SHeiner Kallweit 80425e992a4SHeiner Kallweit static bool rtl_udelay_loop_wait_low(struct rtl8169_private *tp, 80525e992a4SHeiner Kallweit const struct rtl_cond *c, 80625e992a4SHeiner Kallweit unsigned int d, int n) 80725e992a4SHeiner Kallweit { 80825e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, rtl_udelay, d, n, false); 80925e992a4SHeiner Kallweit } 81025e992a4SHeiner Kallweit 81125e992a4SHeiner Kallweit static bool rtl_msleep_loop_wait_high(struct rtl8169_private *tp, 81225e992a4SHeiner Kallweit const struct rtl_cond *c, 81325e992a4SHeiner Kallweit unsigned int d, int n) 81425e992a4SHeiner Kallweit { 81525e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, msleep, d, n, true); 81625e992a4SHeiner Kallweit } 81725e992a4SHeiner Kallweit 81825e992a4SHeiner Kallweit static bool rtl_msleep_loop_wait_low(struct rtl8169_private *tp, 81925e992a4SHeiner Kallweit const struct rtl_cond *c, 82025e992a4SHeiner Kallweit unsigned int d, int n) 82125e992a4SHeiner Kallweit { 82225e992a4SHeiner Kallweit return rtl_loop_wait(tp, c, msleep, d, n, false); 82325e992a4SHeiner Kallweit } 82425e992a4SHeiner Kallweit 82525e992a4SHeiner Kallweit #define DECLARE_RTL_COND(name) \ 82625e992a4SHeiner Kallweit static bool name ## _check(struct rtl8169_private *); \ 82725e992a4SHeiner Kallweit \ 82825e992a4SHeiner Kallweit static const struct rtl_cond name = { \ 82925e992a4SHeiner Kallweit .check = name ## _check, \ 83025e992a4SHeiner Kallweit .msg = #name \ 83125e992a4SHeiner Kallweit }; \ 83225e992a4SHeiner Kallweit \ 83325e992a4SHeiner Kallweit static bool name ## _check(struct rtl8169_private *tp) 83425e992a4SHeiner Kallweit 83525e992a4SHeiner Kallweit static bool rtl_ocp_reg_failure(struct rtl8169_private *tp, u32 reg) 83625e992a4SHeiner Kallweit { 83725e992a4SHeiner Kallweit if (reg & 0xffff0001) { 83825e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "Invalid ocp reg %x!\n", reg); 83925e992a4SHeiner Kallweit return true; 84025e992a4SHeiner Kallweit } 84125e992a4SHeiner Kallweit return false; 84225e992a4SHeiner Kallweit } 84325e992a4SHeiner Kallweit 84425e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocp_gphy_cond) 84525e992a4SHeiner Kallweit { 84625e992a4SHeiner Kallweit return RTL_R32(tp, GPHY_OCP) & OCPAR_FLAG; 84725e992a4SHeiner Kallweit } 84825e992a4SHeiner Kallweit 84925e992a4SHeiner Kallweit static void r8168_phy_ocp_write(struct rtl8169_private *tp, u32 reg, u32 data) 85025e992a4SHeiner Kallweit { 85125e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 85225e992a4SHeiner Kallweit return; 85325e992a4SHeiner Kallweit 85425e992a4SHeiner Kallweit RTL_W32(tp, GPHY_OCP, OCPAR_FLAG | (reg << 15) | data); 85525e992a4SHeiner Kallweit 85625e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocp_gphy_cond, 25, 10); 85725e992a4SHeiner Kallweit } 85825e992a4SHeiner Kallweit 8599b994b4aSHeiner Kallweit static int r8168_phy_ocp_read(struct rtl8169_private *tp, u32 reg) 86025e992a4SHeiner Kallweit { 86125e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 86225e992a4SHeiner Kallweit return 0; 86325e992a4SHeiner Kallweit 86425e992a4SHeiner Kallweit RTL_W32(tp, GPHY_OCP, reg << 15); 86525e992a4SHeiner Kallweit 86625e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocp_gphy_cond, 25, 10) ? 8679b994b4aSHeiner Kallweit (RTL_R32(tp, GPHY_OCP) & 0xffff) : -ETIMEDOUT; 86825e992a4SHeiner Kallweit } 86925e992a4SHeiner Kallweit 87025e992a4SHeiner Kallweit static void r8168_mac_ocp_write(struct rtl8169_private *tp, u32 reg, u32 data) 87125e992a4SHeiner Kallweit { 87225e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 87325e992a4SHeiner Kallweit return; 87425e992a4SHeiner Kallweit 87525e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, OCPAR_FLAG | (reg << 15) | data); 87625e992a4SHeiner Kallweit } 87725e992a4SHeiner Kallweit 87825e992a4SHeiner Kallweit static u16 r8168_mac_ocp_read(struct rtl8169_private *tp, u32 reg) 87925e992a4SHeiner Kallweit { 88025e992a4SHeiner Kallweit if (rtl_ocp_reg_failure(tp, reg)) 88125e992a4SHeiner Kallweit return 0; 88225e992a4SHeiner Kallweit 88325e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, reg << 15); 88425e992a4SHeiner Kallweit 88525e992a4SHeiner Kallweit return RTL_R32(tp, OCPDR); 88625e992a4SHeiner Kallweit } 88725e992a4SHeiner Kallweit 888ef712edeSHeiner Kallweit static void r8168_mac_ocp_modify(struct rtl8169_private *tp, u32 reg, u16 mask, 889ef712edeSHeiner Kallweit u16 set) 890ef712edeSHeiner Kallweit { 891ef712edeSHeiner Kallweit u16 data = r8168_mac_ocp_read(tp, reg); 892ef712edeSHeiner Kallweit 893ef712edeSHeiner Kallweit r8168_mac_ocp_write(tp, reg, (data & ~mask) | set); 894ef712edeSHeiner Kallweit } 895ef712edeSHeiner Kallweit 89625e992a4SHeiner Kallweit #define OCP_STD_PHY_BASE 0xa400 89725e992a4SHeiner Kallweit 89825e992a4SHeiner Kallweit static void r8168g_mdio_write(struct rtl8169_private *tp, int reg, int value) 89925e992a4SHeiner Kallweit { 90025e992a4SHeiner Kallweit if (reg == 0x1f) { 90125e992a4SHeiner Kallweit tp->ocp_base = value ? value << 4 : OCP_STD_PHY_BASE; 90225e992a4SHeiner Kallweit return; 90325e992a4SHeiner Kallweit } 90425e992a4SHeiner Kallweit 90525e992a4SHeiner Kallweit if (tp->ocp_base != OCP_STD_PHY_BASE) 90625e992a4SHeiner Kallweit reg -= 0x10; 90725e992a4SHeiner Kallweit 90825e992a4SHeiner Kallweit r8168_phy_ocp_write(tp, tp->ocp_base + reg * 2, value); 90925e992a4SHeiner Kallweit } 91025e992a4SHeiner Kallweit 91125e992a4SHeiner Kallweit static int r8168g_mdio_read(struct rtl8169_private *tp, int reg) 91225e992a4SHeiner Kallweit { 9139c6850feSHeiner Kallweit if (reg == 0x1f) 9149c6850feSHeiner Kallweit return tp->ocp_base == OCP_STD_PHY_BASE ? 0 : tp->ocp_base >> 4; 9159c6850feSHeiner Kallweit 91625e992a4SHeiner Kallweit if (tp->ocp_base != OCP_STD_PHY_BASE) 91725e992a4SHeiner Kallweit reg -= 0x10; 91825e992a4SHeiner Kallweit 91925e992a4SHeiner Kallweit return r8168_phy_ocp_read(tp, tp->ocp_base + reg * 2); 92025e992a4SHeiner Kallweit } 92125e992a4SHeiner Kallweit 92225e992a4SHeiner Kallweit static void mac_mcu_write(struct rtl8169_private *tp, int reg, int value) 92325e992a4SHeiner Kallweit { 92425e992a4SHeiner Kallweit if (reg == 0x1f) { 92525e992a4SHeiner Kallweit tp->ocp_base = value << 4; 92625e992a4SHeiner Kallweit return; 92725e992a4SHeiner Kallweit } 92825e992a4SHeiner Kallweit 92925e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, tp->ocp_base + reg, value); 93025e992a4SHeiner Kallweit } 93125e992a4SHeiner Kallweit 93225e992a4SHeiner Kallweit static int mac_mcu_read(struct rtl8169_private *tp, int reg) 93325e992a4SHeiner Kallweit { 93425e992a4SHeiner Kallweit return r8168_mac_ocp_read(tp, tp->ocp_base + reg); 93525e992a4SHeiner Kallweit } 93625e992a4SHeiner Kallweit 93725e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_phyar_cond) 93825e992a4SHeiner Kallweit { 93925e992a4SHeiner Kallweit return RTL_R32(tp, PHYAR) & 0x80000000; 94025e992a4SHeiner Kallweit } 94125e992a4SHeiner Kallweit 94225e992a4SHeiner Kallweit static void r8169_mdio_write(struct rtl8169_private *tp, int reg, int value) 94325e992a4SHeiner Kallweit { 94425e992a4SHeiner Kallweit RTL_W32(tp, PHYAR, 0x80000000 | (reg & 0x1f) << 16 | (value & 0xffff)); 94525e992a4SHeiner Kallweit 94625e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_phyar_cond, 25, 20); 94725e992a4SHeiner Kallweit /* 94825e992a4SHeiner Kallweit * According to hardware specs a 20us delay is required after write 94925e992a4SHeiner Kallweit * complete indication, but before sending next command. 95025e992a4SHeiner Kallweit */ 95125e992a4SHeiner Kallweit udelay(20); 95225e992a4SHeiner Kallweit } 95325e992a4SHeiner Kallweit 95425e992a4SHeiner Kallweit static int r8169_mdio_read(struct rtl8169_private *tp, int reg) 95525e992a4SHeiner Kallweit { 95625e992a4SHeiner Kallweit int value; 95725e992a4SHeiner Kallweit 95825e992a4SHeiner Kallweit RTL_W32(tp, PHYAR, 0x0 | (reg & 0x1f) << 16); 95925e992a4SHeiner Kallweit 96025e992a4SHeiner Kallweit value = rtl_udelay_loop_wait_high(tp, &rtl_phyar_cond, 25, 20) ? 9619b994b4aSHeiner Kallweit RTL_R32(tp, PHYAR) & 0xffff : -ETIMEDOUT; 96225e992a4SHeiner Kallweit 96325e992a4SHeiner Kallweit /* 96425e992a4SHeiner Kallweit * According to hardware specs a 20us delay is required after read 96525e992a4SHeiner Kallweit * complete indication, but before sending next command. 96625e992a4SHeiner Kallweit */ 96725e992a4SHeiner Kallweit udelay(20); 96825e992a4SHeiner Kallweit 96925e992a4SHeiner Kallweit return value; 97025e992a4SHeiner Kallweit } 97125e992a4SHeiner Kallweit 97225e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocpar_cond) 97325e992a4SHeiner Kallweit { 97425e992a4SHeiner Kallweit return RTL_R32(tp, OCPAR) & OCPAR_FLAG; 97525e992a4SHeiner Kallweit } 97625e992a4SHeiner Kallweit 97725e992a4SHeiner Kallweit static void r8168dp_1_mdio_access(struct rtl8169_private *tp, int reg, u32 data) 97825e992a4SHeiner Kallweit { 97925e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, data | ((reg & OCPDR_REG_MASK) << OCPDR_GPHY_REG_SHIFT)); 98025e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_GPHY_WRITE_CMD); 98125e992a4SHeiner Kallweit RTL_W32(tp, EPHY_RXER_NUM, 0); 98225e992a4SHeiner Kallweit 98325e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocpar_cond, 1000, 100); 98425e992a4SHeiner Kallweit } 98525e992a4SHeiner Kallweit 98625e992a4SHeiner Kallweit static void r8168dp_1_mdio_write(struct rtl8169_private *tp, int reg, int value) 98725e992a4SHeiner Kallweit { 98825e992a4SHeiner Kallweit r8168dp_1_mdio_access(tp, reg, 98925e992a4SHeiner Kallweit OCPDR_WRITE_CMD | (value & OCPDR_DATA_MASK)); 99025e992a4SHeiner Kallweit } 99125e992a4SHeiner Kallweit 99225e992a4SHeiner Kallweit static int r8168dp_1_mdio_read(struct rtl8169_private *tp, int reg) 99325e992a4SHeiner Kallweit { 99425e992a4SHeiner Kallweit r8168dp_1_mdio_access(tp, reg, OCPDR_READ_CMD); 99525e992a4SHeiner Kallweit 99625e992a4SHeiner Kallweit mdelay(1); 99725e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_GPHY_READ_CMD); 99825e992a4SHeiner Kallweit RTL_W32(tp, EPHY_RXER_NUM, 0); 99925e992a4SHeiner Kallweit 100025e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocpar_cond, 1000, 100) ? 10019b994b4aSHeiner Kallweit RTL_R32(tp, OCPDR) & OCPDR_DATA_MASK : -ETIMEDOUT; 100225e992a4SHeiner Kallweit } 100325e992a4SHeiner Kallweit 100425e992a4SHeiner Kallweit #define R8168DP_1_MDIO_ACCESS_BIT 0x00020000 100525e992a4SHeiner Kallweit 100625e992a4SHeiner Kallweit static void r8168dp_2_mdio_start(struct rtl8169_private *tp) 100725e992a4SHeiner Kallweit { 100825e992a4SHeiner Kallweit RTL_W32(tp, 0xd0, RTL_R32(tp, 0xd0) & ~R8168DP_1_MDIO_ACCESS_BIT); 100925e992a4SHeiner Kallweit } 101025e992a4SHeiner Kallweit 101125e992a4SHeiner Kallweit static void r8168dp_2_mdio_stop(struct rtl8169_private *tp) 101225e992a4SHeiner Kallweit { 101325e992a4SHeiner Kallweit RTL_W32(tp, 0xd0, RTL_R32(tp, 0xd0) | R8168DP_1_MDIO_ACCESS_BIT); 101425e992a4SHeiner Kallweit } 101525e992a4SHeiner Kallweit 101625e992a4SHeiner Kallweit static void r8168dp_2_mdio_write(struct rtl8169_private *tp, int reg, int value) 101725e992a4SHeiner Kallweit { 101825e992a4SHeiner Kallweit r8168dp_2_mdio_start(tp); 101925e992a4SHeiner Kallweit 102025e992a4SHeiner Kallweit r8169_mdio_write(tp, reg, value); 102125e992a4SHeiner Kallweit 102225e992a4SHeiner Kallweit r8168dp_2_mdio_stop(tp); 102325e992a4SHeiner Kallweit } 102425e992a4SHeiner Kallweit 102525e992a4SHeiner Kallweit static int r8168dp_2_mdio_read(struct rtl8169_private *tp, int reg) 102625e992a4SHeiner Kallweit { 102725e992a4SHeiner Kallweit int value; 102825e992a4SHeiner Kallweit 102962bdc8fdSHeiner Kallweit /* Work around issue with chip reporting wrong PHY ID */ 103062bdc8fdSHeiner Kallweit if (reg == MII_PHYSID2) 103162bdc8fdSHeiner Kallweit return 0xc912; 103262bdc8fdSHeiner Kallweit 103325e992a4SHeiner Kallweit r8168dp_2_mdio_start(tp); 103425e992a4SHeiner Kallweit 103525e992a4SHeiner Kallweit value = r8169_mdio_read(tp, reg); 103625e992a4SHeiner Kallweit 103725e992a4SHeiner Kallweit r8168dp_2_mdio_stop(tp); 103825e992a4SHeiner Kallweit 103925e992a4SHeiner Kallweit return value; 104025e992a4SHeiner Kallweit } 104125e992a4SHeiner Kallweit 104225e992a4SHeiner Kallweit static void rtl_writephy(struct rtl8169_private *tp, int location, int val) 104325e992a4SHeiner Kallweit { 104425e992a4SHeiner Kallweit switch (tp->mac_version) { 104525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 104625e992a4SHeiner Kallweit r8168dp_1_mdio_write(tp, location, val); 104725e992a4SHeiner Kallweit break; 104825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 104925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 105025e992a4SHeiner Kallweit r8168dp_2_mdio_write(tp, location, val); 105125e992a4SHeiner Kallweit break; 1052f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_61: 105325e992a4SHeiner Kallweit r8168g_mdio_write(tp, location, val); 105425e992a4SHeiner Kallweit break; 105525e992a4SHeiner Kallweit default: 105625e992a4SHeiner Kallweit r8169_mdio_write(tp, location, val); 105725e992a4SHeiner Kallweit break; 105825e992a4SHeiner Kallweit } 105925e992a4SHeiner Kallweit } 106025e992a4SHeiner Kallweit 106125e992a4SHeiner Kallweit static int rtl_readphy(struct rtl8169_private *tp, int location) 106225e992a4SHeiner Kallweit { 106325e992a4SHeiner Kallweit switch (tp->mac_version) { 106425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 106525e992a4SHeiner Kallweit return r8168dp_1_mdio_read(tp, location); 106625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 106725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 106825e992a4SHeiner Kallweit return r8168dp_2_mdio_read(tp, location); 1069f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_61: 107025e992a4SHeiner Kallweit return r8168g_mdio_read(tp, location); 107125e992a4SHeiner Kallweit default: 107225e992a4SHeiner Kallweit return r8169_mdio_read(tp, location); 107325e992a4SHeiner Kallweit } 107425e992a4SHeiner Kallweit } 107525e992a4SHeiner Kallweit 107625e992a4SHeiner Kallweit static void rtl_patchphy(struct rtl8169_private *tp, int reg_addr, int value) 107725e992a4SHeiner Kallweit { 107825e992a4SHeiner Kallweit rtl_writephy(tp, reg_addr, rtl_readphy(tp, reg_addr) | value); 107925e992a4SHeiner Kallweit } 108025e992a4SHeiner Kallweit 108125e992a4SHeiner Kallweit static void rtl_w0w1_phy(struct rtl8169_private *tp, int reg_addr, int p, int m) 108225e992a4SHeiner Kallweit { 108325e992a4SHeiner Kallweit int val; 108425e992a4SHeiner Kallweit 108525e992a4SHeiner Kallweit val = rtl_readphy(tp, reg_addr); 108625e992a4SHeiner Kallweit rtl_writephy(tp, reg_addr, (val & ~m) | p); 108725e992a4SHeiner Kallweit } 108825e992a4SHeiner Kallweit 10890721914aSHeiner Kallweit static void r8168d_modify_extpage(struct phy_device *phydev, int extpage, 10900721914aSHeiner Kallweit int reg, u16 mask, u16 val) 10910721914aSHeiner Kallweit { 10920721914aSHeiner Kallweit int oldpage = phy_select_page(phydev, 0x0007); 10930721914aSHeiner Kallweit 10940721914aSHeiner Kallweit __phy_write(phydev, 0x1e, extpage); 10950721914aSHeiner Kallweit __phy_modify(phydev, reg, mask, val); 10960721914aSHeiner Kallweit 10970721914aSHeiner Kallweit phy_restore_page(phydev, oldpage, 0); 10980721914aSHeiner Kallweit } 10990721914aSHeiner Kallweit 1100b5e189b4SHeiner Kallweit static void r8168d_phy_param(struct phy_device *phydev, u16 parm, 1101b5e189b4SHeiner Kallweit u16 mask, u16 val) 1102b5e189b4SHeiner Kallweit { 1103b5e189b4SHeiner Kallweit int oldpage = phy_select_page(phydev, 0x0005); 1104b5e189b4SHeiner Kallweit 1105b5e189b4SHeiner Kallweit __phy_write(phydev, 0x05, parm); 1106b5e189b4SHeiner Kallweit __phy_modify(phydev, 0x06, mask, val); 1107b5e189b4SHeiner Kallweit 1108b5e189b4SHeiner Kallweit phy_restore_page(phydev, oldpage, 0); 1109b5e189b4SHeiner Kallweit } 1110b5e189b4SHeiner Kallweit 11118bfdce1dSHeiner Kallweit static void r8168g_phy_param(struct phy_device *phydev, u16 parm, 11128bfdce1dSHeiner Kallweit u16 mask, u16 val) 11138bfdce1dSHeiner Kallweit { 11148bfdce1dSHeiner Kallweit int oldpage = phy_select_page(phydev, 0x0a43); 11158bfdce1dSHeiner Kallweit 11168bfdce1dSHeiner Kallweit __phy_write(phydev, 0x13, parm); 11178bfdce1dSHeiner Kallweit __phy_modify(phydev, 0x14, mask, val); 11188bfdce1dSHeiner Kallweit 11198bfdce1dSHeiner Kallweit phy_restore_page(phydev, oldpage, 0); 11208bfdce1dSHeiner Kallweit } 11218bfdce1dSHeiner Kallweit 112225e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ephyar_cond) 112325e992a4SHeiner Kallweit { 112425e992a4SHeiner Kallweit return RTL_R32(tp, EPHYAR) & EPHYAR_FLAG; 112525e992a4SHeiner Kallweit } 112625e992a4SHeiner Kallweit 112725e992a4SHeiner Kallweit static void rtl_ephy_write(struct rtl8169_private *tp, int reg_addr, int value) 112825e992a4SHeiner Kallweit { 112925e992a4SHeiner Kallweit RTL_W32(tp, EPHYAR, EPHYAR_WRITE_CMD | (value & EPHYAR_DATA_MASK) | 113025e992a4SHeiner Kallweit (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT); 113125e992a4SHeiner Kallweit 113225e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ephyar_cond, 10, 100); 113325e992a4SHeiner Kallweit 113425e992a4SHeiner Kallweit udelay(10); 113525e992a4SHeiner Kallweit } 113625e992a4SHeiner Kallweit 113725e992a4SHeiner Kallweit static u16 rtl_ephy_read(struct rtl8169_private *tp, int reg_addr) 113825e992a4SHeiner Kallweit { 113925e992a4SHeiner Kallweit RTL_W32(tp, EPHYAR, (reg_addr & EPHYAR_REG_MASK) << EPHYAR_REG_SHIFT); 114025e992a4SHeiner Kallweit 114125e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ephyar_cond, 10, 100) ? 114225e992a4SHeiner Kallweit RTL_R32(tp, EPHYAR) & EPHYAR_DATA_MASK : ~0; 114325e992a4SHeiner Kallweit } 114425e992a4SHeiner Kallweit 114525e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_eriar_cond) 114625e992a4SHeiner Kallweit { 114725e992a4SHeiner Kallweit return RTL_R32(tp, ERIAR) & ERIAR_FLAG; 114825e992a4SHeiner Kallweit } 114925e992a4SHeiner Kallweit 115025e992a4SHeiner Kallweit static void _rtl_eri_write(struct rtl8169_private *tp, int addr, u32 mask, 115125e992a4SHeiner Kallweit u32 val, int type) 115225e992a4SHeiner Kallweit { 115325e992a4SHeiner Kallweit BUG_ON((addr & 3) || (mask == 0)); 115425e992a4SHeiner Kallweit RTL_W32(tp, ERIDR, val); 115525e992a4SHeiner Kallweit RTL_W32(tp, ERIAR, ERIAR_WRITE_CMD | type | mask | addr); 115625e992a4SHeiner Kallweit 115725e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_eriar_cond, 100, 100); 115825e992a4SHeiner Kallweit } 115925e992a4SHeiner Kallweit 116025e992a4SHeiner Kallweit static void rtl_eri_write(struct rtl8169_private *tp, int addr, u32 mask, 116125e992a4SHeiner Kallweit u32 val) 116225e992a4SHeiner Kallweit { 116325e992a4SHeiner Kallweit _rtl_eri_write(tp, addr, mask, val, ERIAR_EXGMAC); 116425e992a4SHeiner Kallweit } 116525e992a4SHeiner Kallweit 116625e992a4SHeiner Kallweit static u32 _rtl_eri_read(struct rtl8169_private *tp, int addr, int type) 116725e992a4SHeiner Kallweit { 116825e992a4SHeiner Kallweit RTL_W32(tp, ERIAR, ERIAR_READ_CMD | type | ERIAR_MASK_1111 | addr); 116925e992a4SHeiner Kallweit 117025e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_eriar_cond, 100, 100) ? 117125e992a4SHeiner Kallweit RTL_R32(tp, ERIDR) : ~0; 117225e992a4SHeiner Kallweit } 117325e992a4SHeiner Kallweit 117425e992a4SHeiner Kallweit static u32 rtl_eri_read(struct rtl8169_private *tp, int addr) 117525e992a4SHeiner Kallweit { 117625e992a4SHeiner Kallweit return _rtl_eri_read(tp, addr, ERIAR_EXGMAC); 117725e992a4SHeiner Kallweit } 117825e992a4SHeiner Kallweit 117925e992a4SHeiner Kallweit static void rtl_w0w1_eri(struct rtl8169_private *tp, int addr, u32 mask, u32 p, 118025e992a4SHeiner Kallweit u32 m) 118125e992a4SHeiner Kallweit { 118225e992a4SHeiner Kallweit u32 val; 118325e992a4SHeiner Kallweit 118425e992a4SHeiner Kallweit val = rtl_eri_read(tp, addr); 118525e992a4SHeiner Kallweit rtl_eri_write(tp, addr, mask, (val & ~m) | p); 118625e992a4SHeiner Kallweit } 118725e992a4SHeiner Kallweit 118825e992a4SHeiner Kallweit static void rtl_eri_set_bits(struct rtl8169_private *tp, int addr, u32 mask, 118925e992a4SHeiner Kallweit u32 p) 119025e992a4SHeiner Kallweit { 119125e992a4SHeiner Kallweit rtl_w0w1_eri(tp, addr, mask, p, 0); 119225e992a4SHeiner Kallweit } 119325e992a4SHeiner Kallweit 119425e992a4SHeiner Kallweit static void rtl_eri_clear_bits(struct rtl8169_private *tp, int addr, u32 mask, 119525e992a4SHeiner Kallweit u32 m) 119625e992a4SHeiner Kallweit { 119725e992a4SHeiner Kallweit rtl_w0w1_eri(tp, addr, mask, 0, m); 119825e992a4SHeiner Kallweit } 119925e992a4SHeiner Kallweit 120025e992a4SHeiner Kallweit static u32 r8168dp_ocp_read(struct rtl8169_private *tp, u8 mask, u16 reg) 120125e992a4SHeiner Kallweit { 120225e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, ((u32)mask & 0x0f) << 12 | (reg & 0x0fff)); 120325e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_ocpar_cond, 100, 20) ? 120425e992a4SHeiner Kallweit RTL_R32(tp, OCPDR) : ~0; 120525e992a4SHeiner Kallweit } 120625e992a4SHeiner Kallweit 120725e992a4SHeiner Kallweit static u32 r8168ep_ocp_read(struct rtl8169_private *tp, u8 mask, u16 reg) 120825e992a4SHeiner Kallweit { 120925e992a4SHeiner Kallweit return _rtl_eri_read(tp, reg, ERIAR_OOB); 121025e992a4SHeiner Kallweit } 121125e992a4SHeiner Kallweit 121225e992a4SHeiner Kallweit static void r8168dp_ocp_write(struct rtl8169_private *tp, u8 mask, u16 reg, 121325e992a4SHeiner Kallweit u32 data) 121425e992a4SHeiner Kallweit { 121525e992a4SHeiner Kallweit RTL_W32(tp, OCPDR, data); 121625e992a4SHeiner Kallweit RTL_W32(tp, OCPAR, OCPAR_FLAG | ((u32)mask & 0x0f) << 12 | (reg & 0x0fff)); 121725e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_ocpar_cond, 100, 20); 121825e992a4SHeiner Kallweit } 121925e992a4SHeiner Kallweit 122025e992a4SHeiner Kallweit static void r8168ep_ocp_write(struct rtl8169_private *tp, u8 mask, u16 reg, 122125e992a4SHeiner Kallweit u32 data) 122225e992a4SHeiner Kallweit { 122325e992a4SHeiner Kallweit _rtl_eri_write(tp, reg, ((u32)mask & 0x0f) << ERIAR_MASK_SHIFT, 122425e992a4SHeiner Kallweit data, ERIAR_OOB); 122525e992a4SHeiner Kallweit } 122625e992a4SHeiner Kallweit 122725e992a4SHeiner Kallweit static void r8168dp_oob_notify(struct rtl8169_private *tp, u8 cmd) 122825e992a4SHeiner Kallweit { 122925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe8, ERIAR_MASK_0001, cmd); 123025e992a4SHeiner Kallweit 123125e992a4SHeiner Kallweit r8168dp_ocp_write(tp, 0x1, 0x30, 0x00000001); 123225e992a4SHeiner Kallweit } 123325e992a4SHeiner Kallweit 123425e992a4SHeiner Kallweit #define OOB_CMD_RESET 0x00 123525e992a4SHeiner Kallweit #define OOB_CMD_DRIVER_START 0x05 123625e992a4SHeiner Kallweit #define OOB_CMD_DRIVER_STOP 0x06 123725e992a4SHeiner Kallweit 123825e992a4SHeiner Kallweit static u16 rtl8168_get_ocp_reg(struct rtl8169_private *tp) 123925e992a4SHeiner Kallweit { 124025e992a4SHeiner Kallweit return (tp->mac_version == RTL_GIGA_MAC_VER_31) ? 0xb8 : 0x10; 124125e992a4SHeiner Kallweit } 124225e992a4SHeiner Kallweit 124325e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_dp_ocp_read_cond) 124425e992a4SHeiner Kallweit { 124525e992a4SHeiner Kallweit u16 reg; 124625e992a4SHeiner Kallweit 124725e992a4SHeiner Kallweit reg = rtl8168_get_ocp_reg(tp); 124825e992a4SHeiner Kallweit 124925e992a4SHeiner Kallweit return r8168dp_ocp_read(tp, 0x0f, reg) & 0x00000800; 125025e992a4SHeiner Kallweit } 125125e992a4SHeiner Kallweit 125225e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ep_ocp_read_cond) 125325e992a4SHeiner Kallweit { 125425e992a4SHeiner Kallweit return r8168ep_ocp_read(tp, 0x0f, 0x124) & 0x00000001; 125525e992a4SHeiner Kallweit } 125625e992a4SHeiner Kallweit 125725e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_ocp_tx_cond) 125825e992a4SHeiner Kallweit { 125925e992a4SHeiner Kallweit return RTL_R8(tp, IBISR0) & 0x20; 126025e992a4SHeiner Kallweit } 126125e992a4SHeiner Kallweit 126225e992a4SHeiner Kallweit static void rtl8168ep_stop_cmac(struct rtl8169_private *tp) 126325e992a4SHeiner Kallweit { 126425e992a4SHeiner Kallweit RTL_W8(tp, IBCR2, RTL_R8(tp, IBCR2) & ~0x01); 126525e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_ocp_tx_cond, 50, 2000); 126625e992a4SHeiner Kallweit RTL_W8(tp, IBISR0, RTL_R8(tp, IBISR0) | 0x20); 126725e992a4SHeiner Kallweit RTL_W8(tp, IBCR0, RTL_R8(tp, IBCR0) & ~0x01); 126825e992a4SHeiner Kallweit } 126925e992a4SHeiner Kallweit 127025e992a4SHeiner Kallweit static void rtl8168dp_driver_start(struct rtl8169_private *tp) 127125e992a4SHeiner Kallweit { 127225e992a4SHeiner Kallweit r8168dp_oob_notify(tp, OOB_CMD_DRIVER_START); 127325e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_dp_ocp_read_cond, 10, 10); 127425e992a4SHeiner Kallweit } 127525e992a4SHeiner Kallweit 127625e992a4SHeiner Kallweit static void rtl8168ep_driver_start(struct rtl8169_private *tp) 127725e992a4SHeiner Kallweit { 127825e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x180, OOB_CMD_DRIVER_START); 127925e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x30, 128025e992a4SHeiner Kallweit r8168ep_ocp_read(tp, 0x01, 0x30) | 0x01); 128125e992a4SHeiner Kallweit rtl_msleep_loop_wait_high(tp, &rtl_ep_ocp_read_cond, 10, 10); 128225e992a4SHeiner Kallweit } 128325e992a4SHeiner Kallweit 128425e992a4SHeiner Kallweit static void rtl8168_driver_start(struct rtl8169_private *tp) 128525e992a4SHeiner Kallweit { 128625e992a4SHeiner Kallweit switch (tp->mac_version) { 128725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 128825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 128925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 129025e992a4SHeiner Kallweit rtl8168dp_driver_start(tp); 129125e992a4SHeiner Kallweit break; 129225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 129325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 129425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 129525e992a4SHeiner Kallweit rtl8168ep_driver_start(tp); 129625e992a4SHeiner Kallweit break; 129725e992a4SHeiner Kallweit default: 129825e992a4SHeiner Kallweit BUG(); 129925e992a4SHeiner Kallweit break; 130025e992a4SHeiner Kallweit } 130125e992a4SHeiner Kallweit } 130225e992a4SHeiner Kallweit 130325e992a4SHeiner Kallweit static void rtl8168dp_driver_stop(struct rtl8169_private *tp) 130425e992a4SHeiner Kallweit { 130525e992a4SHeiner Kallweit r8168dp_oob_notify(tp, OOB_CMD_DRIVER_STOP); 130625e992a4SHeiner Kallweit rtl_msleep_loop_wait_low(tp, &rtl_dp_ocp_read_cond, 10, 10); 130725e992a4SHeiner Kallweit } 130825e992a4SHeiner Kallweit 130925e992a4SHeiner Kallweit static void rtl8168ep_driver_stop(struct rtl8169_private *tp) 131025e992a4SHeiner Kallweit { 131125e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 131225e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x180, OOB_CMD_DRIVER_STOP); 131325e992a4SHeiner Kallweit r8168ep_ocp_write(tp, 0x01, 0x30, 131425e992a4SHeiner Kallweit r8168ep_ocp_read(tp, 0x01, 0x30) | 0x01); 131525e992a4SHeiner Kallweit rtl_msleep_loop_wait_low(tp, &rtl_ep_ocp_read_cond, 10, 10); 131625e992a4SHeiner Kallweit } 131725e992a4SHeiner Kallweit 131825e992a4SHeiner Kallweit static void rtl8168_driver_stop(struct rtl8169_private *tp) 131925e992a4SHeiner Kallweit { 132025e992a4SHeiner Kallweit switch (tp->mac_version) { 132125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 132225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 132325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 132425e992a4SHeiner Kallweit rtl8168dp_driver_stop(tp); 132525e992a4SHeiner Kallweit break; 132625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 132725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 132825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 132925e992a4SHeiner Kallweit rtl8168ep_driver_stop(tp); 133025e992a4SHeiner Kallweit break; 133125e992a4SHeiner Kallweit default: 133225e992a4SHeiner Kallweit BUG(); 133325e992a4SHeiner Kallweit break; 133425e992a4SHeiner Kallweit } 133525e992a4SHeiner Kallweit } 133625e992a4SHeiner Kallweit 133725e992a4SHeiner Kallweit static bool r8168dp_check_dash(struct rtl8169_private *tp) 133825e992a4SHeiner Kallweit { 133925e992a4SHeiner Kallweit u16 reg = rtl8168_get_ocp_reg(tp); 134025e992a4SHeiner Kallweit 134125e992a4SHeiner Kallweit return !!(r8168dp_ocp_read(tp, 0x0f, reg) & 0x00008000); 134225e992a4SHeiner Kallweit } 134325e992a4SHeiner Kallweit 134425e992a4SHeiner Kallweit static bool r8168ep_check_dash(struct rtl8169_private *tp) 134525e992a4SHeiner Kallweit { 134625e992a4SHeiner Kallweit return !!(r8168ep_ocp_read(tp, 0x0f, 0x128) & 0x00000001); 134725e992a4SHeiner Kallweit } 134825e992a4SHeiner Kallweit 134925e992a4SHeiner Kallweit static bool r8168_check_dash(struct rtl8169_private *tp) 135025e992a4SHeiner Kallweit { 135125e992a4SHeiner Kallweit switch (tp->mac_version) { 135225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 135325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 135425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 135525e992a4SHeiner Kallweit return r8168dp_check_dash(tp); 135625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 135725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 135825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 135925e992a4SHeiner Kallweit return r8168ep_check_dash(tp); 136025e992a4SHeiner Kallweit default: 136125e992a4SHeiner Kallweit return false; 136225e992a4SHeiner Kallweit } 136325e992a4SHeiner Kallweit } 136425e992a4SHeiner Kallweit 136525e992a4SHeiner Kallweit static void rtl_reset_packet_filter(struct rtl8169_private *tp) 136625e992a4SHeiner Kallweit { 136725e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0xdc, ERIAR_MASK_0001, BIT(0)); 136825e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xdc, ERIAR_MASK_0001, BIT(0)); 136925e992a4SHeiner Kallweit } 137025e992a4SHeiner Kallweit 137125e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_efusear_cond) 137225e992a4SHeiner Kallweit { 137325e992a4SHeiner Kallweit return RTL_R32(tp, EFUSEAR) & EFUSEAR_FLAG; 137425e992a4SHeiner Kallweit } 137525e992a4SHeiner Kallweit 137625e992a4SHeiner Kallweit static u8 rtl8168d_efuse_read(struct rtl8169_private *tp, int reg_addr) 137725e992a4SHeiner Kallweit { 137825e992a4SHeiner Kallweit RTL_W32(tp, EFUSEAR, (reg_addr & EFUSEAR_REG_MASK) << EFUSEAR_REG_SHIFT); 137925e992a4SHeiner Kallweit 138025e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_efusear_cond, 100, 300) ? 138125e992a4SHeiner Kallweit RTL_R32(tp, EFUSEAR) & EFUSEAR_DATA_MASK : ~0; 138225e992a4SHeiner Kallweit } 138325e992a4SHeiner Kallweit 1384c1d532d2SHeiner Kallweit static u32 rtl_get_events(struct rtl8169_private *tp) 1385c1d532d2SHeiner Kallweit { 1386f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1387f1bce4adSHeiner Kallweit return RTL_R32(tp, IntrStatus_8125); 1388f1bce4adSHeiner Kallweit else 1389c1d532d2SHeiner Kallweit return RTL_R16(tp, IntrStatus); 1390c1d532d2SHeiner Kallweit } 1391c1d532d2SHeiner Kallweit 1392c1d532d2SHeiner Kallweit static void rtl_ack_events(struct rtl8169_private *tp, u32 bits) 139325e992a4SHeiner Kallweit { 1394f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1395f1bce4adSHeiner Kallweit RTL_W32(tp, IntrStatus_8125, bits); 1396f1bce4adSHeiner Kallweit else 139725e992a4SHeiner Kallweit RTL_W16(tp, IntrStatus, bits); 139825e992a4SHeiner Kallweit } 139925e992a4SHeiner Kallweit 140025e992a4SHeiner Kallweit static void rtl_irq_disable(struct rtl8169_private *tp) 140125e992a4SHeiner Kallweit { 1402f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1403f1bce4adSHeiner Kallweit RTL_W32(tp, IntrMask_8125, 0); 1404f1bce4adSHeiner Kallweit else 140525e992a4SHeiner Kallweit RTL_W16(tp, IntrMask, 0); 140625e992a4SHeiner Kallweit tp->irq_enabled = 0; 140725e992a4SHeiner Kallweit } 140825e992a4SHeiner Kallweit 140925e992a4SHeiner Kallweit #define RTL_EVENT_NAPI_RX (RxOK | RxErr) 141025e992a4SHeiner Kallweit #define RTL_EVENT_NAPI_TX (TxOK | TxErr) 141125e992a4SHeiner Kallweit #define RTL_EVENT_NAPI (RTL_EVENT_NAPI_RX | RTL_EVENT_NAPI_TX) 141225e992a4SHeiner Kallweit 141325e992a4SHeiner Kallweit static void rtl_irq_enable(struct rtl8169_private *tp) 141425e992a4SHeiner Kallweit { 141525e992a4SHeiner Kallweit tp->irq_enabled = 1; 1416f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1417f1bce4adSHeiner Kallweit RTL_W32(tp, IntrMask_8125, tp->irq_mask); 1418f1bce4adSHeiner Kallweit else 141925e992a4SHeiner Kallweit RTL_W16(tp, IntrMask, tp->irq_mask); 142025e992a4SHeiner Kallweit } 142125e992a4SHeiner Kallweit 142225e992a4SHeiner Kallweit static void rtl8169_irq_mask_and_ack(struct rtl8169_private *tp) 142325e992a4SHeiner Kallweit { 142425e992a4SHeiner Kallweit rtl_irq_disable(tp); 1425c1d532d2SHeiner Kallweit rtl_ack_events(tp, 0xffffffff); 142625e992a4SHeiner Kallweit /* PCI commit */ 142725e992a4SHeiner Kallweit RTL_R8(tp, ChipCmd); 142825e992a4SHeiner Kallweit } 142925e992a4SHeiner Kallweit 143025e992a4SHeiner Kallweit static void rtl_link_chg_patch(struct rtl8169_private *tp) 143125e992a4SHeiner Kallweit { 143225e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 143325e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 143425e992a4SHeiner Kallweit 143525e992a4SHeiner Kallweit if (!netif_running(dev)) 143625e992a4SHeiner Kallweit return; 143725e992a4SHeiner Kallweit 143825e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_34 || 143925e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_38) { 144025e992a4SHeiner Kallweit if (phydev->speed == SPEED_1000) { 144125e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x00000011); 144225e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 144325e992a4SHeiner Kallweit } else if (phydev->speed == SPEED_100) { 144425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 144525e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 144625e992a4SHeiner Kallweit } else { 144725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 144825e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x0000003f); 144925e992a4SHeiner Kallweit } 145025e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 145125e992a4SHeiner Kallweit } else if (tp->mac_version == RTL_GIGA_MAC_VER_35 || 145225e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_36) { 145325e992a4SHeiner Kallweit if (phydev->speed == SPEED_1000) { 145425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x00000011); 145525e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x00000005); 145625e992a4SHeiner Kallweit } else { 145725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1bc, ERIAR_MASK_1111, 0x0000001f); 145825e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_1111, 0x0000003f); 145925e992a4SHeiner Kallweit } 146025e992a4SHeiner Kallweit } else if (tp->mac_version == RTL_GIGA_MAC_VER_37) { 146125e992a4SHeiner Kallweit if (phydev->speed == SPEED_10) { 146225e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x4d02); 146325e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1dc, ERIAR_MASK_0011, 0x0060a); 146425e992a4SHeiner Kallweit } else { 146525e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x0000); 146625e992a4SHeiner Kallweit } 146725e992a4SHeiner Kallweit } 146825e992a4SHeiner Kallweit } 146925e992a4SHeiner Kallweit 147025e992a4SHeiner Kallweit #define WAKE_ANY (WAKE_PHY | WAKE_MAGIC | WAKE_UCAST | WAKE_BCAST | WAKE_MCAST) 147125e992a4SHeiner Kallweit 147225e992a4SHeiner Kallweit static void rtl8169_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 147325e992a4SHeiner Kallweit { 147425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 147525e992a4SHeiner Kallweit 147625e992a4SHeiner Kallweit rtl_lock_work(tp); 147725e992a4SHeiner Kallweit wol->supported = WAKE_ANY; 147825e992a4SHeiner Kallweit wol->wolopts = tp->saved_wolopts; 147925e992a4SHeiner Kallweit rtl_unlock_work(tp); 148025e992a4SHeiner Kallweit } 148125e992a4SHeiner Kallweit 148225e992a4SHeiner Kallweit static void __rtl8169_set_wol(struct rtl8169_private *tp, u32 wolopts) 148325e992a4SHeiner Kallweit { 148425e992a4SHeiner Kallweit static const struct { 148525e992a4SHeiner Kallweit u32 opt; 148625e992a4SHeiner Kallweit u16 reg; 148725e992a4SHeiner Kallweit u8 mask; 148825e992a4SHeiner Kallweit } cfg[] = { 148925e992a4SHeiner Kallweit { WAKE_PHY, Config3, LinkUp }, 149025e992a4SHeiner Kallweit { WAKE_UCAST, Config5, UWF }, 149125e992a4SHeiner Kallweit { WAKE_BCAST, Config5, BWF }, 149225e992a4SHeiner Kallweit { WAKE_MCAST, Config5, MWF }, 149325e992a4SHeiner Kallweit { WAKE_ANY, Config5, LanWake }, 149425e992a4SHeiner Kallweit { WAKE_MAGIC, Config3, MagicPacket } 149525e992a4SHeiner Kallweit }; 1496f1bce4adSHeiner Kallweit unsigned int i, tmp = ARRAY_SIZE(cfg); 149725e992a4SHeiner Kallweit u8 options; 149825e992a4SHeiner Kallweit 149925e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 150025e992a4SHeiner Kallweit 15019e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp)) { 1502f1bce4adSHeiner Kallweit tmp--; 150325e992a4SHeiner Kallweit if (wolopts & WAKE_MAGIC) 150425e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x0dc, ERIAR_MASK_0100, 150525e992a4SHeiner Kallweit MagicPacket_v2); 150625e992a4SHeiner Kallweit else 150725e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x0dc, ERIAR_MASK_0100, 150825e992a4SHeiner Kallweit MagicPacket_v2); 1509f1bce4adSHeiner Kallweit } else if (rtl_is_8125(tp)) { 1510f1bce4adSHeiner Kallweit tmp--; 1511f1bce4adSHeiner Kallweit if (wolopts & WAKE_MAGIC) 1512f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xc0b6, 0, BIT(0)); 1513f1bce4adSHeiner Kallweit else 1514f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xc0b6, BIT(0), 0); 151525e992a4SHeiner Kallweit } 151625e992a4SHeiner Kallweit 151725e992a4SHeiner Kallweit for (i = 0; i < tmp; i++) { 151825e992a4SHeiner Kallweit options = RTL_R8(tp, cfg[i].reg) & ~cfg[i].mask; 151925e992a4SHeiner Kallweit if (wolopts & cfg[i].opt) 152025e992a4SHeiner Kallweit options |= cfg[i].mask; 152125e992a4SHeiner Kallweit RTL_W8(tp, cfg[i].reg, options); 152225e992a4SHeiner Kallweit } 152325e992a4SHeiner Kallweit 152425e992a4SHeiner Kallweit switch (tp->mac_version) { 1525edcde3eeSHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 152625e992a4SHeiner Kallweit options = RTL_R8(tp, Config1) & ~PMEnable; 152725e992a4SHeiner Kallweit if (wolopts) 152825e992a4SHeiner Kallweit options |= PMEnable; 152925e992a4SHeiner Kallweit RTL_W8(tp, Config1, options); 153025e992a4SHeiner Kallweit break; 1531edcde3eeSHeiner Kallweit case RTL_GIGA_MAC_VER_34: 1532edcde3eeSHeiner Kallweit case RTL_GIGA_MAC_VER_37: 1533edcde3eeSHeiner Kallweit case RTL_GIGA_MAC_VER_39 ... RTL_GIGA_MAC_VER_51: 153425e992a4SHeiner Kallweit options = RTL_R8(tp, Config2) & ~PME_SIGNAL; 153525e992a4SHeiner Kallweit if (wolopts) 153625e992a4SHeiner Kallweit options |= PME_SIGNAL; 153725e992a4SHeiner Kallweit RTL_W8(tp, Config2, options); 153825e992a4SHeiner Kallweit break; 1539edcde3eeSHeiner Kallweit default: 1540edcde3eeSHeiner Kallweit break; 154125e992a4SHeiner Kallweit } 154225e992a4SHeiner Kallweit 154325e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 154425e992a4SHeiner Kallweit 154525e992a4SHeiner Kallweit device_set_wakeup_enable(tp_to_dev(tp), wolopts); 154625e992a4SHeiner Kallweit } 154725e992a4SHeiner Kallweit 154825e992a4SHeiner Kallweit static int rtl8169_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol) 154925e992a4SHeiner Kallweit { 155025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 155125e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 155225e992a4SHeiner Kallweit 155325e992a4SHeiner Kallweit if (wol->wolopts & ~WAKE_ANY) 155425e992a4SHeiner Kallweit return -EINVAL; 155525e992a4SHeiner Kallweit 155625e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 155725e992a4SHeiner Kallweit 155825e992a4SHeiner Kallweit rtl_lock_work(tp); 155925e992a4SHeiner Kallweit 156025e992a4SHeiner Kallweit tp->saved_wolopts = wol->wolopts; 156125e992a4SHeiner Kallweit 156225e992a4SHeiner Kallweit if (pm_runtime_active(d)) 156325e992a4SHeiner Kallweit __rtl8169_set_wol(tp, tp->saved_wolopts); 156425e992a4SHeiner Kallweit 156525e992a4SHeiner Kallweit rtl_unlock_work(tp); 156625e992a4SHeiner Kallweit 156725e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 156825e992a4SHeiner Kallweit 156925e992a4SHeiner Kallweit return 0; 157025e992a4SHeiner Kallweit } 157125e992a4SHeiner Kallweit 157225e992a4SHeiner Kallweit static void rtl8169_get_drvinfo(struct net_device *dev, 157325e992a4SHeiner Kallweit struct ethtool_drvinfo *info) 157425e992a4SHeiner Kallweit { 157525e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 157625e992a4SHeiner Kallweit struct rtl_fw *rtl_fw = tp->rtl_fw; 157725e992a4SHeiner Kallweit 157825e992a4SHeiner Kallweit strlcpy(info->driver, MODULENAME, sizeof(info->driver)); 157925e992a4SHeiner Kallweit strlcpy(info->bus_info, pci_name(tp->pci_dev), sizeof(info->bus_info)); 158025e992a4SHeiner Kallweit BUILD_BUG_ON(sizeof(info->fw_version) < sizeof(rtl_fw->version)); 158125e992a4SHeiner Kallweit if (rtl_fw) 158225e992a4SHeiner Kallweit strlcpy(info->fw_version, rtl_fw->version, 158325e992a4SHeiner Kallweit sizeof(info->fw_version)); 158425e992a4SHeiner Kallweit } 158525e992a4SHeiner Kallweit 158625e992a4SHeiner Kallweit static int rtl8169_get_regs_len(struct net_device *dev) 158725e992a4SHeiner Kallweit { 158825e992a4SHeiner Kallweit return R8169_REGS_SIZE; 158925e992a4SHeiner Kallweit } 159025e992a4SHeiner Kallweit 159125e992a4SHeiner Kallweit static netdev_features_t rtl8169_fix_features(struct net_device *dev, 159225e992a4SHeiner Kallweit netdev_features_t features) 159325e992a4SHeiner Kallweit { 159425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 159525e992a4SHeiner Kallweit 159625e992a4SHeiner Kallweit if (dev->mtu > TD_MSS_MAX) 159725e992a4SHeiner Kallweit features &= ~NETIF_F_ALL_TSO; 159825e992a4SHeiner Kallweit 159925e992a4SHeiner Kallweit if (dev->mtu > JUMBO_1K && 160025e992a4SHeiner Kallweit tp->mac_version > RTL_GIGA_MAC_VER_06) 16017cb83b21SHeiner Kallweit features &= ~(NETIF_F_CSUM_MASK | NETIF_F_ALL_TSO); 160225e992a4SHeiner Kallweit 160325e992a4SHeiner Kallweit return features; 160425e992a4SHeiner Kallweit } 160525e992a4SHeiner Kallweit 160625e992a4SHeiner Kallweit static int rtl8169_set_features(struct net_device *dev, 160725e992a4SHeiner Kallweit netdev_features_t features) 160825e992a4SHeiner Kallweit { 160925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 161025e992a4SHeiner Kallweit u32 rx_config; 161125e992a4SHeiner Kallweit 161225e992a4SHeiner Kallweit rtl_lock_work(tp); 161325e992a4SHeiner Kallweit 161425e992a4SHeiner Kallweit rx_config = RTL_R32(tp, RxConfig); 161525e992a4SHeiner Kallweit if (features & NETIF_F_RXALL) 161625e992a4SHeiner Kallweit rx_config |= (AcceptErr | AcceptRunt); 161725e992a4SHeiner Kallweit else 161825e992a4SHeiner Kallweit rx_config &= ~(AcceptErr | AcceptRunt); 161925e992a4SHeiner Kallweit 1620f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) { 1621f1bce4adSHeiner Kallweit if (features & NETIF_F_HW_VLAN_CTAG_RX) 1622f1bce4adSHeiner Kallweit rx_config |= RX_VLAN_8125; 1623f1bce4adSHeiner Kallweit else 1624f1bce4adSHeiner Kallweit rx_config &= ~RX_VLAN_8125; 1625f1bce4adSHeiner Kallweit } 1626f1bce4adSHeiner Kallweit 162725e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, rx_config); 162825e992a4SHeiner Kallweit 162925e992a4SHeiner Kallweit if (features & NETIF_F_RXCSUM) 163025e992a4SHeiner Kallweit tp->cp_cmd |= RxChkSum; 163125e992a4SHeiner Kallweit else 163225e992a4SHeiner Kallweit tp->cp_cmd &= ~RxChkSum; 163325e992a4SHeiner Kallweit 1634f1bce4adSHeiner Kallweit if (!rtl_is_8125(tp)) { 163525e992a4SHeiner Kallweit if (features & NETIF_F_HW_VLAN_CTAG_RX) 163625e992a4SHeiner Kallweit tp->cp_cmd |= RxVlan; 163725e992a4SHeiner Kallweit else 163825e992a4SHeiner Kallweit tp->cp_cmd &= ~RxVlan; 1639f1bce4adSHeiner Kallweit } 164025e992a4SHeiner Kallweit 164125e992a4SHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 164225e992a4SHeiner Kallweit RTL_R16(tp, CPlusCmd); 164325e992a4SHeiner Kallweit 164425e992a4SHeiner Kallweit rtl_unlock_work(tp); 164525e992a4SHeiner Kallweit 164625e992a4SHeiner Kallweit return 0; 164725e992a4SHeiner Kallweit } 164825e992a4SHeiner Kallweit 164925e992a4SHeiner Kallweit static inline u32 rtl8169_tx_vlan_tag(struct sk_buff *skb) 165025e992a4SHeiner Kallweit { 165125e992a4SHeiner Kallweit return (skb_vlan_tag_present(skb)) ? 16527424edbbSHeiner Kallweit TxVlanTag | swab16(skb_vlan_tag_get(skb)) : 0x00; 165325e992a4SHeiner Kallweit } 165425e992a4SHeiner Kallweit 165525e992a4SHeiner Kallweit static void rtl8169_rx_vlan_tag(struct RxDesc *desc, struct sk_buff *skb) 165625e992a4SHeiner Kallweit { 165725e992a4SHeiner Kallweit u32 opts2 = le32_to_cpu(desc->opts2); 165825e992a4SHeiner Kallweit 165925e992a4SHeiner Kallweit if (opts2 & RxVlanTag) 16607424edbbSHeiner Kallweit __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), swab16(opts2 & 0xffff)); 166125e992a4SHeiner Kallweit } 166225e992a4SHeiner Kallweit 166325e992a4SHeiner Kallweit static void rtl8169_get_regs(struct net_device *dev, struct ethtool_regs *regs, 166425e992a4SHeiner Kallweit void *p) 166525e992a4SHeiner Kallweit { 166625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 166725e992a4SHeiner Kallweit u32 __iomem *data = tp->mmio_addr; 166825e992a4SHeiner Kallweit u32 *dw = p; 166925e992a4SHeiner Kallweit int i; 167025e992a4SHeiner Kallweit 167125e992a4SHeiner Kallweit rtl_lock_work(tp); 167225e992a4SHeiner Kallweit for (i = 0; i < R8169_REGS_SIZE; i += 4) 167325e992a4SHeiner Kallweit memcpy_fromio(dw++, data++, 4); 167425e992a4SHeiner Kallweit rtl_unlock_work(tp); 167525e992a4SHeiner Kallweit } 167625e992a4SHeiner Kallweit 167725e992a4SHeiner Kallweit static u32 rtl8169_get_msglevel(struct net_device *dev) 167825e992a4SHeiner Kallweit { 167925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 168025e992a4SHeiner Kallweit 168125e992a4SHeiner Kallweit return tp->msg_enable; 168225e992a4SHeiner Kallweit } 168325e992a4SHeiner Kallweit 168425e992a4SHeiner Kallweit static void rtl8169_set_msglevel(struct net_device *dev, u32 value) 168525e992a4SHeiner Kallweit { 168625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 168725e992a4SHeiner Kallweit 168825e992a4SHeiner Kallweit tp->msg_enable = value; 168925e992a4SHeiner Kallweit } 169025e992a4SHeiner Kallweit 169125e992a4SHeiner Kallweit static const char rtl8169_gstrings[][ETH_GSTRING_LEN] = { 169225e992a4SHeiner Kallweit "tx_packets", 169325e992a4SHeiner Kallweit "rx_packets", 169425e992a4SHeiner Kallweit "tx_errors", 169525e992a4SHeiner Kallweit "rx_errors", 169625e992a4SHeiner Kallweit "rx_missed", 169725e992a4SHeiner Kallweit "align_errors", 169825e992a4SHeiner Kallweit "tx_single_collisions", 169925e992a4SHeiner Kallweit "tx_multi_collisions", 170025e992a4SHeiner Kallweit "unicast", 170125e992a4SHeiner Kallweit "broadcast", 170225e992a4SHeiner Kallweit "multicast", 170325e992a4SHeiner Kallweit "tx_aborted", 170425e992a4SHeiner Kallweit "tx_underrun", 170525e992a4SHeiner Kallweit }; 170625e992a4SHeiner Kallweit 170725e992a4SHeiner Kallweit static int rtl8169_get_sset_count(struct net_device *dev, int sset) 170825e992a4SHeiner Kallweit { 170925e992a4SHeiner Kallweit switch (sset) { 171025e992a4SHeiner Kallweit case ETH_SS_STATS: 171125e992a4SHeiner Kallweit return ARRAY_SIZE(rtl8169_gstrings); 171225e992a4SHeiner Kallweit default: 171325e992a4SHeiner Kallweit return -EOPNOTSUPP; 171425e992a4SHeiner Kallweit } 171525e992a4SHeiner Kallweit } 171625e992a4SHeiner Kallweit 171725e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_counters_cond) 171825e992a4SHeiner Kallweit { 171925e992a4SHeiner Kallweit return RTL_R32(tp, CounterAddrLow) & (CounterReset | CounterDump); 172025e992a4SHeiner Kallweit } 172125e992a4SHeiner Kallweit 172225e992a4SHeiner Kallweit static bool rtl8169_do_counters(struct rtl8169_private *tp, u32 counter_cmd) 172325e992a4SHeiner Kallweit { 172425e992a4SHeiner Kallweit dma_addr_t paddr = tp->counters_phys_addr; 172525e992a4SHeiner Kallweit u32 cmd; 172625e992a4SHeiner Kallweit 172725e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrHigh, (u64)paddr >> 32); 172825e992a4SHeiner Kallweit RTL_R32(tp, CounterAddrHigh); 172925e992a4SHeiner Kallweit cmd = (u64)paddr & DMA_BIT_MASK(32); 173025e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrLow, cmd); 173125e992a4SHeiner Kallweit RTL_W32(tp, CounterAddrLow, cmd | counter_cmd); 173225e992a4SHeiner Kallweit 173325e992a4SHeiner Kallweit return rtl_udelay_loop_wait_low(tp, &rtl_counters_cond, 10, 1000); 173425e992a4SHeiner Kallweit } 173525e992a4SHeiner Kallweit 173625e992a4SHeiner Kallweit static bool rtl8169_reset_counters(struct rtl8169_private *tp) 173725e992a4SHeiner Kallweit { 173825e992a4SHeiner Kallweit /* 173925e992a4SHeiner Kallweit * Versions prior to RTL_GIGA_MAC_VER_19 don't support resetting the 174025e992a4SHeiner Kallweit * tally counters. 174125e992a4SHeiner Kallweit */ 174225e992a4SHeiner Kallweit if (tp->mac_version < RTL_GIGA_MAC_VER_19) 174325e992a4SHeiner Kallweit return true; 174425e992a4SHeiner Kallweit 174525e992a4SHeiner Kallweit return rtl8169_do_counters(tp, CounterReset); 174625e992a4SHeiner Kallweit } 174725e992a4SHeiner Kallweit 174825e992a4SHeiner Kallweit static bool rtl8169_update_counters(struct rtl8169_private *tp) 174925e992a4SHeiner Kallweit { 175025e992a4SHeiner Kallweit u8 val = RTL_R8(tp, ChipCmd); 175125e992a4SHeiner Kallweit 175225e992a4SHeiner Kallweit /* 175325e992a4SHeiner Kallweit * Some chips are unable to dump tally counters when the receiver 175425e992a4SHeiner Kallweit * is disabled. If 0xff chip may be in a PCI power-save state. 175525e992a4SHeiner Kallweit */ 175625e992a4SHeiner Kallweit if (!(val & CmdRxEnb) || val == 0xff) 175725e992a4SHeiner Kallweit return true; 175825e992a4SHeiner Kallweit 175925e992a4SHeiner Kallweit return rtl8169_do_counters(tp, CounterDump); 176025e992a4SHeiner Kallweit } 176125e992a4SHeiner Kallweit 176225e992a4SHeiner Kallweit static bool rtl8169_init_counter_offsets(struct rtl8169_private *tp) 176325e992a4SHeiner Kallweit { 176425e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 176525e992a4SHeiner Kallweit bool ret = false; 176625e992a4SHeiner Kallweit 176725e992a4SHeiner Kallweit /* 176825e992a4SHeiner Kallweit * rtl8169_init_counter_offsets is called from rtl_open. On chip 176925e992a4SHeiner Kallweit * versions prior to RTL_GIGA_MAC_VER_19 the tally counters are only 177025e992a4SHeiner Kallweit * reset by a power cycle, while the counter values collected by the 177125e992a4SHeiner Kallweit * driver are reset at every driver unload/load cycle. 177225e992a4SHeiner Kallweit * 177325e992a4SHeiner Kallweit * To make sure the HW values returned by @get_stats64 match the SW 177425e992a4SHeiner Kallweit * values, we collect the initial values at first open(*) and use them 177525e992a4SHeiner Kallweit * as offsets to normalize the values returned by @get_stats64. 177625e992a4SHeiner Kallweit * 177725e992a4SHeiner Kallweit * (*) We can't call rtl8169_init_counter_offsets from rtl_init_one 177825e992a4SHeiner Kallweit * for the reason stated in rtl8169_update_counters; CmdRxEnb is only 177925e992a4SHeiner Kallweit * set at open time by rtl_hw_start. 178025e992a4SHeiner Kallweit */ 178125e992a4SHeiner Kallweit 178225e992a4SHeiner Kallweit if (tp->tc_offset.inited) 178325e992a4SHeiner Kallweit return true; 178425e992a4SHeiner Kallweit 178525e992a4SHeiner Kallweit /* If both, reset and update fail, propagate to caller. */ 178625e992a4SHeiner Kallweit if (rtl8169_reset_counters(tp)) 178725e992a4SHeiner Kallweit ret = true; 178825e992a4SHeiner Kallweit 178925e992a4SHeiner Kallweit if (rtl8169_update_counters(tp)) 179025e992a4SHeiner Kallweit ret = true; 179125e992a4SHeiner Kallweit 179225e992a4SHeiner Kallweit tp->tc_offset.tx_errors = counters->tx_errors; 179325e992a4SHeiner Kallweit tp->tc_offset.tx_multi_collision = counters->tx_multi_collision; 179425e992a4SHeiner Kallweit tp->tc_offset.tx_aborted = counters->tx_aborted; 179525e992a4SHeiner Kallweit tp->tc_offset.inited = true; 179625e992a4SHeiner Kallweit 179725e992a4SHeiner Kallweit return ret; 179825e992a4SHeiner Kallweit } 179925e992a4SHeiner Kallweit 180025e992a4SHeiner Kallweit static void rtl8169_get_ethtool_stats(struct net_device *dev, 180125e992a4SHeiner Kallweit struct ethtool_stats *stats, u64 *data) 180225e992a4SHeiner Kallweit { 180325e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 180425e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 180525e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 180625e992a4SHeiner Kallweit 180725e992a4SHeiner Kallweit ASSERT_RTNL(); 180825e992a4SHeiner Kallweit 180925e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 181025e992a4SHeiner Kallweit 181125e992a4SHeiner Kallweit if (pm_runtime_active(d)) 181225e992a4SHeiner Kallweit rtl8169_update_counters(tp); 181325e992a4SHeiner Kallweit 181425e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 181525e992a4SHeiner Kallweit 181625e992a4SHeiner Kallweit data[0] = le64_to_cpu(counters->tx_packets); 181725e992a4SHeiner Kallweit data[1] = le64_to_cpu(counters->rx_packets); 181825e992a4SHeiner Kallweit data[2] = le64_to_cpu(counters->tx_errors); 181925e992a4SHeiner Kallweit data[3] = le32_to_cpu(counters->rx_errors); 182025e992a4SHeiner Kallweit data[4] = le16_to_cpu(counters->rx_missed); 182125e992a4SHeiner Kallweit data[5] = le16_to_cpu(counters->align_errors); 182225e992a4SHeiner Kallweit data[6] = le32_to_cpu(counters->tx_one_collision); 182325e992a4SHeiner Kallweit data[7] = le32_to_cpu(counters->tx_multi_collision); 182425e992a4SHeiner Kallweit data[8] = le64_to_cpu(counters->rx_unicast); 182525e992a4SHeiner Kallweit data[9] = le64_to_cpu(counters->rx_broadcast); 182625e992a4SHeiner Kallweit data[10] = le32_to_cpu(counters->rx_multicast); 182725e992a4SHeiner Kallweit data[11] = le16_to_cpu(counters->tx_aborted); 182825e992a4SHeiner Kallweit data[12] = le16_to_cpu(counters->tx_underun); 182925e992a4SHeiner Kallweit } 183025e992a4SHeiner Kallweit 183125e992a4SHeiner Kallweit static void rtl8169_get_strings(struct net_device *dev, u32 stringset, u8 *data) 183225e992a4SHeiner Kallweit { 183325e992a4SHeiner Kallweit switch(stringset) { 183425e992a4SHeiner Kallweit case ETH_SS_STATS: 183525e992a4SHeiner Kallweit memcpy(data, *rtl8169_gstrings, sizeof(rtl8169_gstrings)); 183625e992a4SHeiner Kallweit break; 183725e992a4SHeiner Kallweit } 183825e992a4SHeiner Kallweit } 183925e992a4SHeiner Kallweit 184025e992a4SHeiner Kallweit /* 184125e992a4SHeiner Kallweit * Interrupt coalescing 184225e992a4SHeiner Kallweit * 184325e992a4SHeiner Kallweit * > 1 - the availability of the IntrMitigate (0xe2) register through the 184425e992a4SHeiner Kallweit * > 8169, 8168 and 810x line of chipsets 184525e992a4SHeiner Kallweit * 184625e992a4SHeiner Kallweit * 8169, 8168, and 8136(810x) serial chipsets support it. 184725e992a4SHeiner Kallweit * 184825e992a4SHeiner Kallweit * > 2 - the Tx timer unit at gigabit speed 184925e992a4SHeiner Kallweit * 185025e992a4SHeiner Kallweit * The unit of the timer depends on both the speed and the setting of CPlusCmd 185125e992a4SHeiner Kallweit * (0xe0) bit 1 and bit 0. 185225e992a4SHeiner Kallweit * 185325e992a4SHeiner Kallweit * For 8169 185425e992a4SHeiner Kallweit * bit[1:0] \ speed 1000M 100M 10M 185525e992a4SHeiner Kallweit * 0 0 320ns 2.56us 40.96us 185625e992a4SHeiner Kallweit * 0 1 2.56us 20.48us 327.7us 185725e992a4SHeiner Kallweit * 1 0 5.12us 40.96us 655.4us 185825e992a4SHeiner Kallweit * 1 1 10.24us 81.92us 1.31ms 185925e992a4SHeiner Kallweit * 186025e992a4SHeiner Kallweit * For the other 186125e992a4SHeiner Kallweit * bit[1:0] \ speed 1000M 100M 10M 186225e992a4SHeiner Kallweit * 0 0 5us 2.56us 40.96us 186325e992a4SHeiner Kallweit * 0 1 40us 20.48us 327.7us 186425e992a4SHeiner Kallweit * 1 0 80us 40.96us 655.4us 186525e992a4SHeiner Kallweit * 1 1 160us 81.92us 1.31ms 186625e992a4SHeiner Kallweit */ 186725e992a4SHeiner Kallweit 186825e992a4SHeiner Kallweit /* rx/tx scale factors for one particular CPlusCmd[0:1] value */ 186925e992a4SHeiner Kallweit struct rtl_coalesce_scale { 187025e992a4SHeiner Kallweit /* Rx / Tx */ 187125e992a4SHeiner Kallweit u32 nsecs[2]; 187225e992a4SHeiner Kallweit }; 187325e992a4SHeiner Kallweit 187425e992a4SHeiner Kallweit /* rx/tx scale factors for all CPlusCmd[0:1] cases */ 187525e992a4SHeiner Kallweit struct rtl_coalesce_info { 187625e992a4SHeiner Kallweit u32 speed; 187725e992a4SHeiner Kallweit struct rtl_coalesce_scale scalev[4]; /* each CPlusCmd[0:1] case */ 187825e992a4SHeiner Kallweit }; 187925e992a4SHeiner Kallweit 188025e992a4SHeiner Kallweit /* produce (r,t) pairs with each being in series of *1, *8, *8*2, *8*2*2 */ 188125e992a4SHeiner Kallweit #define rxtx_x1822(r, t) { \ 188225e992a4SHeiner Kallweit {{(r), (t)}}, \ 188325e992a4SHeiner Kallweit {{(r)*8, (t)*8}}, \ 188425e992a4SHeiner Kallweit {{(r)*8*2, (t)*8*2}}, \ 188525e992a4SHeiner Kallweit {{(r)*8*2*2, (t)*8*2*2}}, \ 188625e992a4SHeiner Kallweit } 188725e992a4SHeiner Kallweit static const struct rtl_coalesce_info rtl_coalesce_info_8169[] = { 188825e992a4SHeiner Kallweit /* speed delays: rx00 tx00 */ 188925e992a4SHeiner Kallweit { SPEED_10, rxtx_x1822(40960, 40960) }, 189025e992a4SHeiner Kallweit { SPEED_100, rxtx_x1822( 2560, 2560) }, 189125e992a4SHeiner Kallweit { SPEED_1000, rxtx_x1822( 320, 320) }, 189225e992a4SHeiner Kallweit { 0 }, 189325e992a4SHeiner Kallweit }; 189425e992a4SHeiner Kallweit 189525e992a4SHeiner Kallweit static const struct rtl_coalesce_info rtl_coalesce_info_8168_8136[] = { 189625e992a4SHeiner Kallweit /* speed delays: rx00 tx00 */ 189725e992a4SHeiner Kallweit { SPEED_10, rxtx_x1822(40960, 40960) }, 189825e992a4SHeiner Kallweit { SPEED_100, rxtx_x1822( 2560, 2560) }, 189925e992a4SHeiner Kallweit { SPEED_1000, rxtx_x1822( 5000, 5000) }, 190025e992a4SHeiner Kallweit { 0 }, 190125e992a4SHeiner Kallweit }; 190225e992a4SHeiner Kallweit #undef rxtx_x1822 190325e992a4SHeiner Kallweit 190425e992a4SHeiner Kallweit /* get rx/tx scale vector corresponding to current speed */ 190525e992a4SHeiner Kallweit static const struct rtl_coalesce_info *rtl_coalesce_info(struct net_device *dev) 190625e992a4SHeiner Kallweit { 190725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 190825e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 190925e992a4SHeiner Kallweit 191020023d3eSHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 191120023d3eSHeiner Kallweit ci = rtl_coalesce_info_8169; 191220023d3eSHeiner Kallweit else 191320023d3eSHeiner Kallweit ci = rtl_coalesce_info_8168_8136; 191425e992a4SHeiner Kallweit 191520023d3eSHeiner Kallweit for (; ci->speed; ci++) { 191620023d3eSHeiner Kallweit if (tp->phydev->speed == ci->speed) 191725e992a4SHeiner Kallweit return ci; 191825e992a4SHeiner Kallweit } 191925e992a4SHeiner Kallweit 192025e992a4SHeiner Kallweit return ERR_PTR(-ELNRNG); 192125e992a4SHeiner Kallweit } 192225e992a4SHeiner Kallweit 192325e992a4SHeiner Kallweit static int rtl_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec) 192425e992a4SHeiner Kallweit { 192525e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 192625e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 192725e992a4SHeiner Kallweit const struct rtl_coalesce_scale *scale; 192825e992a4SHeiner Kallweit struct { 192925e992a4SHeiner Kallweit u32 *max_frames; 193025e992a4SHeiner Kallweit u32 *usecs; 193125e992a4SHeiner Kallweit } coal_settings [] = { 193225e992a4SHeiner Kallweit { &ec->rx_max_coalesced_frames, &ec->rx_coalesce_usecs }, 193325e992a4SHeiner Kallweit { &ec->tx_max_coalesced_frames, &ec->tx_coalesce_usecs } 193425e992a4SHeiner Kallweit }, *p = coal_settings; 193525e992a4SHeiner Kallweit int i; 193625e992a4SHeiner Kallweit u16 w; 193725e992a4SHeiner Kallweit 1938f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 1939f1bce4adSHeiner Kallweit return -EOPNOTSUPP; 1940f1bce4adSHeiner Kallweit 194125e992a4SHeiner Kallweit memset(ec, 0, sizeof(*ec)); 194225e992a4SHeiner Kallweit 194325e992a4SHeiner Kallweit /* get rx/tx scale corresponding to current speed and CPlusCmd[0:1] */ 194425e992a4SHeiner Kallweit ci = rtl_coalesce_info(dev); 194525e992a4SHeiner Kallweit if (IS_ERR(ci)) 194625e992a4SHeiner Kallweit return PTR_ERR(ci); 194725e992a4SHeiner Kallweit 194825e992a4SHeiner Kallweit scale = &ci->scalev[tp->cp_cmd & INTT_MASK]; 194925e992a4SHeiner Kallweit 195025e992a4SHeiner Kallweit /* read IntrMitigate and adjust according to scale */ 195125e992a4SHeiner Kallweit for (w = RTL_R16(tp, IntrMitigate); w; w >>= RTL_COALESCE_SHIFT, p++) { 195225e992a4SHeiner Kallweit *p->max_frames = (w & RTL_COALESCE_MASK) << 2; 195325e992a4SHeiner Kallweit w >>= RTL_COALESCE_SHIFT; 195425e992a4SHeiner Kallweit *p->usecs = w & RTL_COALESCE_MASK; 195525e992a4SHeiner Kallweit } 195625e992a4SHeiner Kallweit 195725e992a4SHeiner Kallweit for (i = 0; i < 2; i++) { 195825e992a4SHeiner Kallweit p = coal_settings + i; 195925e992a4SHeiner Kallweit *p->usecs = (*p->usecs * scale->nsecs[i]) / 1000; 196025e992a4SHeiner Kallweit 196125e992a4SHeiner Kallweit /* 196225e992a4SHeiner Kallweit * ethtool_coalesce says it is illegal to set both usecs and 196325e992a4SHeiner Kallweit * max_frames to 0. 196425e992a4SHeiner Kallweit */ 196525e992a4SHeiner Kallweit if (!*p->usecs && !*p->max_frames) 196625e992a4SHeiner Kallweit *p->max_frames = 1; 196725e992a4SHeiner Kallweit } 196825e992a4SHeiner Kallweit 196925e992a4SHeiner Kallweit return 0; 197025e992a4SHeiner Kallweit } 197125e992a4SHeiner Kallweit 197225e992a4SHeiner Kallweit /* choose appropriate scale factor and CPlusCmd[0:1] for (speed, nsec) */ 197325e992a4SHeiner Kallweit static const struct rtl_coalesce_scale *rtl_coalesce_choose_scale( 197425e992a4SHeiner Kallweit struct net_device *dev, u32 nsec, u16 *cp01) 197525e992a4SHeiner Kallweit { 197625e992a4SHeiner Kallweit const struct rtl_coalesce_info *ci; 197725e992a4SHeiner Kallweit u16 i; 197825e992a4SHeiner Kallweit 197925e992a4SHeiner Kallweit ci = rtl_coalesce_info(dev); 198025e992a4SHeiner Kallweit if (IS_ERR(ci)) 198125e992a4SHeiner Kallweit return ERR_CAST(ci); 198225e992a4SHeiner Kallweit 198325e992a4SHeiner Kallweit for (i = 0; i < 4; i++) { 198425e992a4SHeiner Kallweit u32 rxtx_maxscale = max(ci->scalev[i].nsecs[0], 198525e992a4SHeiner Kallweit ci->scalev[i].nsecs[1]); 198625e992a4SHeiner Kallweit if (nsec <= rxtx_maxscale * RTL_COALESCE_T_MAX) { 198725e992a4SHeiner Kallweit *cp01 = i; 198825e992a4SHeiner Kallweit return &ci->scalev[i]; 198925e992a4SHeiner Kallweit } 199025e992a4SHeiner Kallweit } 199125e992a4SHeiner Kallweit 199225e992a4SHeiner Kallweit return ERR_PTR(-EINVAL); 199325e992a4SHeiner Kallweit } 199425e992a4SHeiner Kallweit 199525e992a4SHeiner Kallweit static int rtl_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec) 199625e992a4SHeiner Kallweit { 199725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 199825e992a4SHeiner Kallweit const struct rtl_coalesce_scale *scale; 199925e992a4SHeiner Kallweit struct { 200025e992a4SHeiner Kallweit u32 frames; 200125e992a4SHeiner Kallweit u32 usecs; 200225e992a4SHeiner Kallweit } coal_settings [] = { 200325e992a4SHeiner Kallweit { ec->rx_max_coalesced_frames, ec->rx_coalesce_usecs }, 200425e992a4SHeiner Kallweit { ec->tx_max_coalesced_frames, ec->tx_coalesce_usecs } 200525e992a4SHeiner Kallweit }, *p = coal_settings; 200625e992a4SHeiner Kallweit u16 w = 0, cp01; 200725e992a4SHeiner Kallweit int i; 200825e992a4SHeiner Kallweit 2009f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 2010f1bce4adSHeiner Kallweit return -EOPNOTSUPP; 2011f1bce4adSHeiner Kallweit 201225e992a4SHeiner Kallweit scale = rtl_coalesce_choose_scale(dev, 201325e992a4SHeiner Kallweit max(p[0].usecs, p[1].usecs) * 1000, &cp01); 201425e992a4SHeiner Kallweit if (IS_ERR(scale)) 201525e992a4SHeiner Kallweit return PTR_ERR(scale); 201625e992a4SHeiner Kallweit 201725e992a4SHeiner Kallweit for (i = 0; i < 2; i++, p++) { 201825e992a4SHeiner Kallweit u32 units; 201925e992a4SHeiner Kallweit 202025e992a4SHeiner Kallweit /* 202125e992a4SHeiner Kallweit * accept max_frames=1 we returned in rtl_get_coalesce. 202225e992a4SHeiner Kallweit * accept it not only when usecs=0 because of e.g. the following scenario: 202325e992a4SHeiner Kallweit * 202425e992a4SHeiner Kallweit * - both rx_usecs=0 & rx_frames=0 in hardware (no delay on RX) 202525e992a4SHeiner Kallweit * - rtl_get_coalesce returns rx_usecs=0, rx_frames=1 202625e992a4SHeiner Kallweit * - then user does `ethtool -C eth0 rx-usecs 100` 202725e992a4SHeiner Kallweit * 202825e992a4SHeiner Kallweit * since ethtool sends to kernel whole ethtool_coalesce 202925e992a4SHeiner Kallweit * settings, if we do not handle rx_usecs=!0, rx_frames=1 203025e992a4SHeiner Kallweit * we'll reject it below in `frames % 4 != 0`. 203125e992a4SHeiner Kallweit */ 203225e992a4SHeiner Kallweit if (p->frames == 1) { 203325e992a4SHeiner Kallweit p->frames = 0; 203425e992a4SHeiner Kallweit } 203525e992a4SHeiner Kallweit 203625e992a4SHeiner Kallweit units = p->usecs * 1000 / scale->nsecs[i]; 203725e992a4SHeiner Kallweit if (p->frames > RTL_COALESCE_FRAME_MAX || p->frames % 4) 203825e992a4SHeiner Kallweit return -EINVAL; 203925e992a4SHeiner Kallweit 204025e992a4SHeiner Kallweit w <<= RTL_COALESCE_SHIFT; 204125e992a4SHeiner Kallweit w |= units; 204225e992a4SHeiner Kallweit w <<= RTL_COALESCE_SHIFT; 204325e992a4SHeiner Kallweit w |= p->frames >> 2; 204425e992a4SHeiner Kallweit } 204525e992a4SHeiner Kallweit 204625e992a4SHeiner Kallweit rtl_lock_work(tp); 204725e992a4SHeiner Kallweit 204825e992a4SHeiner Kallweit RTL_W16(tp, IntrMitigate, swab16(w)); 204925e992a4SHeiner Kallweit 205025e992a4SHeiner Kallweit tp->cp_cmd = (tp->cp_cmd & ~INTT_MASK) | cp01; 205125e992a4SHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 205225e992a4SHeiner Kallweit RTL_R16(tp, CPlusCmd); 205325e992a4SHeiner Kallweit 205425e992a4SHeiner Kallweit rtl_unlock_work(tp); 205525e992a4SHeiner Kallweit 205625e992a4SHeiner Kallweit return 0; 205725e992a4SHeiner Kallweit } 205825e992a4SHeiner Kallweit 205925e992a4SHeiner Kallweit static int rtl8169_get_eee(struct net_device *dev, struct ethtool_eee *data) 206025e992a4SHeiner Kallweit { 206125e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 206225e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 206325e992a4SHeiner Kallweit int ret; 206425e992a4SHeiner Kallweit 20652e779ddbSHeiner Kallweit if (!rtl_supports_eee(tp)) 20662e779ddbSHeiner Kallweit return -EOPNOTSUPP; 20672e779ddbSHeiner Kallweit 206825e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 206925e992a4SHeiner Kallweit 207025e992a4SHeiner Kallweit if (!pm_runtime_active(d)) { 207125e992a4SHeiner Kallweit ret = -EOPNOTSUPP; 20722e779ddbSHeiner Kallweit } else { 20732e779ddbSHeiner Kallweit ret = phy_ethtool_get_eee(tp->phydev, data); 207425e992a4SHeiner Kallweit } 207525e992a4SHeiner Kallweit 207625e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 20772e779ddbSHeiner Kallweit 20782e779ddbSHeiner Kallweit return ret; 207925e992a4SHeiner Kallweit } 208025e992a4SHeiner Kallweit 208125e992a4SHeiner Kallweit static int rtl8169_set_eee(struct net_device *dev, struct ethtool_eee *data) 208225e992a4SHeiner Kallweit { 208325e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 208425e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 20852e779ddbSHeiner Kallweit int ret; 20862e779ddbSHeiner Kallweit 20872e779ddbSHeiner Kallweit if (!rtl_supports_eee(tp)) 20882e779ddbSHeiner Kallweit return -EOPNOTSUPP; 208925e992a4SHeiner Kallweit 209025e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 209125e992a4SHeiner Kallweit 20922e779ddbSHeiner Kallweit if (!pm_runtime_active(d)) { 209325e992a4SHeiner Kallweit ret = -EOPNOTSUPP; 209425e992a4SHeiner Kallweit goto out; 209525e992a4SHeiner Kallweit } 209625e992a4SHeiner Kallweit 209725e992a4SHeiner Kallweit if (dev->phydev->autoneg == AUTONEG_DISABLE || 209825e992a4SHeiner Kallweit dev->phydev->duplex != DUPLEX_FULL) { 209925e992a4SHeiner Kallweit ret = -EPROTONOSUPPORT; 210025e992a4SHeiner Kallweit goto out; 210125e992a4SHeiner Kallweit } 210225e992a4SHeiner Kallweit 21032e779ddbSHeiner Kallweit ret = phy_ethtool_set_eee(tp->phydev, data); 210425e992a4SHeiner Kallweit out: 210525e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 21062e779ddbSHeiner Kallweit return ret; 210725e992a4SHeiner Kallweit } 210825e992a4SHeiner Kallweit 210925e992a4SHeiner Kallweit static const struct ethtool_ops rtl8169_ethtool_ops = { 211025e992a4SHeiner Kallweit .get_drvinfo = rtl8169_get_drvinfo, 211125e992a4SHeiner Kallweit .get_regs_len = rtl8169_get_regs_len, 211225e992a4SHeiner Kallweit .get_link = ethtool_op_get_link, 211325e992a4SHeiner Kallweit .get_coalesce = rtl_get_coalesce, 211425e992a4SHeiner Kallweit .set_coalesce = rtl_set_coalesce, 211525e992a4SHeiner Kallweit .get_msglevel = rtl8169_get_msglevel, 211625e992a4SHeiner Kallweit .set_msglevel = rtl8169_set_msglevel, 211725e992a4SHeiner Kallweit .get_regs = rtl8169_get_regs, 211825e992a4SHeiner Kallweit .get_wol = rtl8169_get_wol, 211925e992a4SHeiner Kallweit .set_wol = rtl8169_set_wol, 212025e992a4SHeiner Kallweit .get_strings = rtl8169_get_strings, 212125e992a4SHeiner Kallweit .get_sset_count = rtl8169_get_sset_count, 212225e992a4SHeiner Kallweit .get_ethtool_stats = rtl8169_get_ethtool_stats, 212325e992a4SHeiner Kallweit .get_ts_info = ethtool_op_get_ts_info, 212425e992a4SHeiner Kallweit .nway_reset = phy_ethtool_nway_reset, 212525e992a4SHeiner Kallweit .get_eee = rtl8169_get_eee, 212625e992a4SHeiner Kallweit .set_eee = rtl8169_set_eee, 212725e992a4SHeiner Kallweit .get_link_ksettings = phy_ethtool_get_link_ksettings, 212825e992a4SHeiner Kallweit .set_link_ksettings = phy_ethtool_set_link_ksettings, 212925e992a4SHeiner Kallweit }; 213025e992a4SHeiner Kallweit 213125e992a4SHeiner Kallweit static void rtl_enable_eee(struct rtl8169_private *tp) 213225e992a4SHeiner Kallweit { 21332e779ddbSHeiner Kallweit struct phy_device *phydev = tp->phydev; 21342e779ddbSHeiner Kallweit int supported = phy_read_mmd(phydev, MDIO_MMD_PCS, MDIO_PCS_EEE_ABLE); 213525e992a4SHeiner Kallweit 213625e992a4SHeiner Kallweit if (supported > 0) 21372e779ddbSHeiner Kallweit phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, supported); 213825e992a4SHeiner Kallweit } 213925e992a4SHeiner Kallweit 214025e992a4SHeiner Kallweit static void rtl8169_get_mac_version(struct rtl8169_private *tp) 214125e992a4SHeiner Kallweit { 214225e992a4SHeiner Kallweit /* 214325e992a4SHeiner Kallweit * The driver currently handles the 8168Bf and the 8168Be identically 214425e992a4SHeiner Kallweit * but they can be identified more specifically through the test below 214525e992a4SHeiner Kallweit * if needed: 214625e992a4SHeiner Kallweit * 214725e992a4SHeiner Kallweit * (RTL_R32(tp, TxConfig) & 0x700000) == 0x500000 ? 8168Bf : 8168Be 214825e992a4SHeiner Kallweit * 214925e992a4SHeiner Kallweit * Same thing for the 8101Eb and the 8101Ec: 215025e992a4SHeiner Kallweit * 215125e992a4SHeiner Kallweit * (RTL_R32(tp, TxConfig) & 0x700000) == 0x200000 ? 8101Eb : 8101Ec 215225e992a4SHeiner Kallweit */ 215325e992a4SHeiner Kallweit static const struct rtl_mac_info { 215425e992a4SHeiner Kallweit u16 mask; 215525e992a4SHeiner Kallweit u16 val; 215625e992a4SHeiner Kallweit u16 mac_version; 215725e992a4SHeiner Kallweit } mac_info[] = { 2158f1bce4adSHeiner Kallweit /* 8125 family. */ 2159f1bce4adSHeiner Kallweit { 0x7cf, 0x608, RTL_GIGA_MAC_VER_60 }, 2160f1bce4adSHeiner Kallweit { 0x7c8, 0x608, RTL_GIGA_MAC_VER_61 }, 2161f1bce4adSHeiner Kallweit 216225e992a4SHeiner Kallweit /* 8168EP family. */ 216325e992a4SHeiner Kallweit { 0x7cf, 0x502, RTL_GIGA_MAC_VER_51 }, 216425e992a4SHeiner Kallweit { 0x7cf, 0x501, RTL_GIGA_MAC_VER_50 }, 216525e992a4SHeiner Kallweit { 0x7cf, 0x500, RTL_GIGA_MAC_VER_49 }, 216625e992a4SHeiner Kallweit 216725e992a4SHeiner Kallweit /* 8168H family. */ 216825e992a4SHeiner Kallweit { 0x7cf, 0x541, RTL_GIGA_MAC_VER_46 }, 216925e992a4SHeiner Kallweit { 0x7cf, 0x540, RTL_GIGA_MAC_VER_45 }, 217025e992a4SHeiner Kallweit 217125e992a4SHeiner Kallweit /* 8168G family. */ 217225e992a4SHeiner Kallweit { 0x7cf, 0x5c8, RTL_GIGA_MAC_VER_44 }, 217325e992a4SHeiner Kallweit { 0x7cf, 0x509, RTL_GIGA_MAC_VER_42 }, 217425e992a4SHeiner Kallweit { 0x7cf, 0x4c1, RTL_GIGA_MAC_VER_41 }, 217525e992a4SHeiner Kallweit { 0x7cf, 0x4c0, RTL_GIGA_MAC_VER_40 }, 217625e992a4SHeiner Kallweit 217725e992a4SHeiner Kallweit /* 8168F family. */ 217825e992a4SHeiner Kallweit { 0x7c8, 0x488, RTL_GIGA_MAC_VER_38 }, 217925e992a4SHeiner Kallweit { 0x7cf, 0x481, RTL_GIGA_MAC_VER_36 }, 218025e992a4SHeiner Kallweit { 0x7cf, 0x480, RTL_GIGA_MAC_VER_35 }, 218125e992a4SHeiner Kallweit 218225e992a4SHeiner Kallweit /* 8168E family. */ 218325e992a4SHeiner Kallweit { 0x7c8, 0x2c8, RTL_GIGA_MAC_VER_34 }, 218425e992a4SHeiner Kallweit { 0x7cf, 0x2c1, RTL_GIGA_MAC_VER_32 }, 218525e992a4SHeiner Kallweit { 0x7c8, 0x2c0, RTL_GIGA_MAC_VER_33 }, 218625e992a4SHeiner Kallweit 218725e992a4SHeiner Kallweit /* 8168D family. */ 218825e992a4SHeiner Kallweit { 0x7cf, 0x281, RTL_GIGA_MAC_VER_25 }, 218925e992a4SHeiner Kallweit { 0x7c8, 0x280, RTL_GIGA_MAC_VER_26 }, 219025e992a4SHeiner Kallweit 219125e992a4SHeiner Kallweit /* 8168DP family. */ 219225e992a4SHeiner Kallweit { 0x7cf, 0x288, RTL_GIGA_MAC_VER_27 }, 219325e992a4SHeiner Kallweit { 0x7cf, 0x28a, RTL_GIGA_MAC_VER_28 }, 219425e992a4SHeiner Kallweit { 0x7cf, 0x28b, RTL_GIGA_MAC_VER_31 }, 219525e992a4SHeiner Kallweit 219625e992a4SHeiner Kallweit /* 8168C family. */ 219725e992a4SHeiner Kallweit { 0x7cf, 0x3c9, RTL_GIGA_MAC_VER_23 }, 219825e992a4SHeiner Kallweit { 0x7cf, 0x3c8, RTL_GIGA_MAC_VER_18 }, 219925e992a4SHeiner Kallweit { 0x7c8, 0x3c8, RTL_GIGA_MAC_VER_24 }, 220025e992a4SHeiner Kallweit { 0x7cf, 0x3c0, RTL_GIGA_MAC_VER_19 }, 220125e992a4SHeiner Kallweit { 0x7cf, 0x3c2, RTL_GIGA_MAC_VER_20 }, 220225e992a4SHeiner Kallweit { 0x7cf, 0x3c3, RTL_GIGA_MAC_VER_21 }, 220325e992a4SHeiner Kallweit { 0x7c8, 0x3c0, RTL_GIGA_MAC_VER_22 }, 220425e992a4SHeiner Kallweit 220525e992a4SHeiner Kallweit /* 8168B family. */ 220625e992a4SHeiner Kallweit { 0x7cf, 0x380, RTL_GIGA_MAC_VER_12 }, 220725e992a4SHeiner Kallweit { 0x7c8, 0x380, RTL_GIGA_MAC_VER_17 }, 220825e992a4SHeiner Kallweit { 0x7c8, 0x300, RTL_GIGA_MAC_VER_11 }, 220925e992a4SHeiner Kallweit 221025e992a4SHeiner Kallweit /* 8101 family. */ 221125e992a4SHeiner Kallweit { 0x7c8, 0x448, RTL_GIGA_MAC_VER_39 }, 221225e992a4SHeiner Kallweit { 0x7c8, 0x440, RTL_GIGA_MAC_VER_37 }, 221325e992a4SHeiner Kallweit { 0x7cf, 0x409, RTL_GIGA_MAC_VER_29 }, 221425e992a4SHeiner Kallweit { 0x7c8, 0x408, RTL_GIGA_MAC_VER_30 }, 221525e992a4SHeiner Kallweit { 0x7cf, 0x349, RTL_GIGA_MAC_VER_08 }, 221625e992a4SHeiner Kallweit { 0x7cf, 0x249, RTL_GIGA_MAC_VER_08 }, 221725e992a4SHeiner Kallweit { 0x7cf, 0x348, RTL_GIGA_MAC_VER_07 }, 221825e992a4SHeiner Kallweit { 0x7cf, 0x248, RTL_GIGA_MAC_VER_07 }, 221925e992a4SHeiner Kallweit { 0x7cf, 0x340, RTL_GIGA_MAC_VER_13 }, 222025e992a4SHeiner Kallweit { 0x7cf, 0x343, RTL_GIGA_MAC_VER_10 }, 222125e992a4SHeiner Kallweit { 0x7cf, 0x342, RTL_GIGA_MAC_VER_16 }, 222225e992a4SHeiner Kallweit { 0x7c8, 0x348, RTL_GIGA_MAC_VER_09 }, 222325e992a4SHeiner Kallweit { 0x7c8, 0x248, RTL_GIGA_MAC_VER_09 }, 222425e992a4SHeiner Kallweit { 0x7c8, 0x340, RTL_GIGA_MAC_VER_16 }, 222525e992a4SHeiner Kallweit /* FIXME: where did these entries come from ? -- FR */ 222625e992a4SHeiner Kallweit { 0xfc8, 0x388, RTL_GIGA_MAC_VER_15 }, 222725e992a4SHeiner Kallweit { 0xfc8, 0x308, RTL_GIGA_MAC_VER_14 }, 222825e992a4SHeiner Kallweit 222925e992a4SHeiner Kallweit /* 8110 family. */ 223025e992a4SHeiner Kallweit { 0xfc8, 0x980, RTL_GIGA_MAC_VER_06 }, 223125e992a4SHeiner Kallweit { 0xfc8, 0x180, RTL_GIGA_MAC_VER_05 }, 223225e992a4SHeiner Kallweit { 0xfc8, 0x100, RTL_GIGA_MAC_VER_04 }, 223325e992a4SHeiner Kallweit { 0xfc8, 0x040, RTL_GIGA_MAC_VER_03 }, 223425e992a4SHeiner Kallweit { 0xfc8, 0x008, RTL_GIGA_MAC_VER_02 }, 223525e992a4SHeiner Kallweit 223625e992a4SHeiner Kallweit /* Catch-all */ 223725e992a4SHeiner Kallweit { 0x000, 0x000, RTL_GIGA_MAC_NONE } 223825e992a4SHeiner Kallweit }; 223925e992a4SHeiner Kallweit const struct rtl_mac_info *p = mac_info; 224025e992a4SHeiner Kallweit u16 reg = RTL_R32(tp, TxConfig) >> 20; 224125e992a4SHeiner Kallweit 224225e992a4SHeiner Kallweit while ((reg & p->mask) != p->val) 224325e992a4SHeiner Kallweit p++; 224425e992a4SHeiner Kallweit tp->mac_version = p->mac_version; 224525e992a4SHeiner Kallweit 224625e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_NONE) { 224725e992a4SHeiner Kallweit dev_err(tp_to_dev(tp), "unknown chip XID %03x\n", reg & 0xfcf); 224825e992a4SHeiner Kallweit } else if (!tp->supports_gmii) { 224925e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_42) 225025e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_43; 225125e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_45) 225225e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_47; 225325e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_46) 225425e992a4SHeiner Kallweit tp->mac_version = RTL_GIGA_MAC_VER_48; 225525e992a4SHeiner Kallweit } 225625e992a4SHeiner Kallweit } 225725e992a4SHeiner Kallweit 225825e992a4SHeiner Kallweit struct phy_reg { 225925e992a4SHeiner Kallweit u16 reg; 226025e992a4SHeiner Kallweit u16 val; 226125e992a4SHeiner Kallweit }; 226225e992a4SHeiner Kallweit 226325e992a4SHeiner Kallweit static void __rtl_writephy_batch(struct rtl8169_private *tp, 226425e992a4SHeiner Kallweit const struct phy_reg *regs, int len) 226525e992a4SHeiner Kallweit { 226625e992a4SHeiner Kallweit while (len-- > 0) { 226725e992a4SHeiner Kallweit rtl_writephy(tp, regs->reg, regs->val); 226825e992a4SHeiner Kallweit regs++; 226925e992a4SHeiner Kallweit } 227025e992a4SHeiner Kallweit } 227125e992a4SHeiner Kallweit 227225e992a4SHeiner Kallweit #define rtl_writephy_batch(tp, a) __rtl_writephy_batch(tp, a, ARRAY_SIZE(a)) 227325e992a4SHeiner Kallweit 227425e992a4SHeiner Kallweit static void rtl_release_firmware(struct rtl8169_private *tp) 227525e992a4SHeiner Kallweit { 227625e992a4SHeiner Kallweit if (tp->rtl_fw) { 227725e992a4SHeiner Kallweit rtl_fw_release_firmware(tp->rtl_fw); 227825e992a4SHeiner Kallweit kfree(tp->rtl_fw); 227925e992a4SHeiner Kallweit tp->rtl_fw = NULL; 228025e992a4SHeiner Kallweit } 228125e992a4SHeiner Kallweit } 228225e992a4SHeiner Kallweit 228325e992a4SHeiner Kallweit static void rtl_apply_firmware(struct rtl8169_private *tp) 228425e992a4SHeiner Kallweit { 228525e992a4SHeiner Kallweit /* TODO: release firmware if rtl_fw_write_firmware signals failure. */ 228625e992a4SHeiner Kallweit if (tp->rtl_fw) 228725e992a4SHeiner Kallweit rtl_fw_write_firmware(tp, tp->rtl_fw); 228825e992a4SHeiner Kallweit } 228925e992a4SHeiner Kallweit 229025e992a4SHeiner Kallweit static void rtl_apply_firmware_cond(struct rtl8169_private *tp, u8 reg, u16 val) 229125e992a4SHeiner Kallweit { 229225e992a4SHeiner Kallweit if (rtl_readphy(tp, reg) != val) 229325e992a4SHeiner Kallweit netif_warn(tp, hw, tp->dev, "chipset not ready for firmware\n"); 229425e992a4SHeiner Kallweit else 229525e992a4SHeiner Kallweit rtl_apply_firmware(tp); 229625e992a4SHeiner Kallweit } 229725e992a4SHeiner Kallweit 229825e992a4SHeiner Kallweit static void rtl8168_config_eee_mac(struct rtl8169_private *tp) 229925e992a4SHeiner Kallweit { 230025e992a4SHeiner Kallweit /* Adjust EEE LED frequency */ 230125e992a4SHeiner Kallweit if (tp->mac_version != RTL_GIGA_MAC_VER_38) 230225e992a4SHeiner Kallweit RTL_W8(tp, EEE_LED, RTL_R8(tp, EEE_LED) & ~0x07); 230325e992a4SHeiner Kallweit 230425e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_1111, 0x0003); 230525e992a4SHeiner Kallweit } 230625e992a4SHeiner Kallweit 2307b3a42e3aSHeiner Kallweit static void rtl8125_config_eee_mac(struct rtl8169_private *tp) 2308b3a42e3aSHeiner Kallweit { 2309b3a42e3aSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe040, 0, BIT(1) | BIT(0)); 2310b3a42e3aSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb62, 0, BIT(2) | BIT(1)); 2311b3a42e3aSHeiner Kallweit } 2312b3a42e3aSHeiner Kallweit 231325e992a4SHeiner Kallweit static void rtl8168f_config_eee_phy(struct rtl8169_private *tp) 231425e992a4SHeiner Kallweit { 231525e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 231625e992a4SHeiner Kallweit 231725e992a4SHeiner Kallweit phy_write(phydev, 0x1f, 0x0007); 231825e992a4SHeiner Kallweit phy_write(phydev, 0x1e, 0x0020); 231925e992a4SHeiner Kallweit phy_set_bits(phydev, 0x15, BIT(8)); 232025e992a4SHeiner Kallweit phy_write(phydev, 0x1f, 0x0000); 2321b5e189b4SHeiner Kallweit 2322b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0, BIT(13)); 232325e992a4SHeiner Kallweit } 232425e992a4SHeiner Kallweit 232525e992a4SHeiner Kallweit static void rtl8168g_config_eee_phy(struct rtl8169_private *tp) 232625e992a4SHeiner Kallweit { 232725e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a43, 0x11, 0, BIT(4)); 232825e992a4SHeiner Kallweit } 232925e992a4SHeiner Kallweit 2330b6cef26fSHeiner Kallweit static void rtl8168h_config_eee_phy(struct rtl8169_private *tp) 2331b6cef26fSHeiner Kallweit { 2332b6cef26fSHeiner Kallweit struct phy_device *phydev = tp->phydev; 2333b6cef26fSHeiner Kallweit 2334b6cef26fSHeiner Kallweit rtl8168g_config_eee_phy(tp); 2335b6cef26fSHeiner Kallweit 2336b6cef26fSHeiner Kallweit phy_modify_paged(phydev, 0xa4a, 0x11, 0x0000, 0x0200); 2337b6cef26fSHeiner Kallweit phy_modify_paged(phydev, 0xa42, 0x14, 0x0000, 0x0080); 2338b6cef26fSHeiner Kallweit } 2339b6cef26fSHeiner Kallweit 2340b3a42e3aSHeiner Kallweit static void rtl8125_config_eee_phy(struct rtl8169_private *tp) 2341b3a42e3aSHeiner Kallweit { 2342b3a42e3aSHeiner Kallweit struct phy_device *phydev = tp->phydev; 2343b3a42e3aSHeiner Kallweit 2344b3a42e3aSHeiner Kallweit rtl8168h_config_eee_phy(tp); 2345b3a42e3aSHeiner Kallweit 2346b3a42e3aSHeiner Kallweit phy_modify_paged(phydev, 0xa6d, 0x12, 0x0001, 0x0000); 2347b3a42e3aSHeiner Kallweit phy_modify_paged(phydev, 0xa6d, 0x14, 0x0010, 0x0000); 2348b3a42e3aSHeiner Kallweit } 2349b3a42e3aSHeiner Kallweit 235025e992a4SHeiner Kallweit static void rtl8169s_hw_phy_config(struct rtl8169_private *tp) 235125e992a4SHeiner Kallweit { 235225e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 235325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 235425e992a4SHeiner Kallweit { 0x06, 0x006e }, 235525e992a4SHeiner Kallweit { 0x08, 0x0708 }, 235625e992a4SHeiner Kallweit { 0x15, 0x4000 }, 235725e992a4SHeiner Kallweit { 0x18, 0x65c7 }, 235825e992a4SHeiner Kallweit 235925e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 236025e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 236125e992a4SHeiner Kallweit { 0x02, 0x0008 }, 236225e992a4SHeiner Kallweit { 0x01, 0x0120 }, 236325e992a4SHeiner Kallweit { 0x00, 0x1000 }, 236425e992a4SHeiner Kallweit { 0x04, 0x0800 }, 236525e992a4SHeiner Kallweit { 0x04, 0x0000 }, 236625e992a4SHeiner Kallweit 236725e992a4SHeiner Kallweit { 0x03, 0xff41 }, 236825e992a4SHeiner Kallweit { 0x02, 0xdf60 }, 236925e992a4SHeiner Kallweit { 0x01, 0x0140 }, 237025e992a4SHeiner Kallweit { 0x00, 0x0077 }, 237125e992a4SHeiner Kallweit { 0x04, 0x7800 }, 237225e992a4SHeiner Kallweit { 0x04, 0x7000 }, 237325e992a4SHeiner Kallweit 237425e992a4SHeiner Kallweit { 0x03, 0x802f }, 237525e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 237625e992a4SHeiner Kallweit { 0x01, 0x0409 }, 237725e992a4SHeiner Kallweit { 0x00, 0xf0f9 }, 237825e992a4SHeiner Kallweit { 0x04, 0x9800 }, 237925e992a4SHeiner Kallweit { 0x04, 0x9000 }, 238025e992a4SHeiner Kallweit 238125e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 238225e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 238325e992a4SHeiner Kallweit { 0x01, 0xff95 }, 238425e992a4SHeiner Kallweit { 0x00, 0xba00 }, 238525e992a4SHeiner Kallweit { 0x04, 0xa800 }, 238625e992a4SHeiner Kallweit { 0x04, 0xa000 }, 238725e992a4SHeiner Kallweit 238825e992a4SHeiner Kallweit { 0x03, 0xff41 }, 238925e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 239025e992a4SHeiner Kallweit { 0x01, 0x0140 }, 239125e992a4SHeiner Kallweit { 0x00, 0x00bb }, 239225e992a4SHeiner Kallweit { 0x04, 0xb800 }, 239325e992a4SHeiner Kallweit { 0x04, 0xb000 }, 239425e992a4SHeiner Kallweit 239525e992a4SHeiner Kallweit { 0x03, 0xdf41 }, 239625e992a4SHeiner Kallweit { 0x02, 0xdc60 }, 239725e992a4SHeiner Kallweit { 0x01, 0x6340 }, 239825e992a4SHeiner Kallweit { 0x00, 0x007d }, 239925e992a4SHeiner Kallweit { 0x04, 0xd800 }, 240025e992a4SHeiner Kallweit { 0x04, 0xd000 }, 240125e992a4SHeiner Kallweit 240225e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 240325e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 240425e992a4SHeiner Kallweit { 0x01, 0x100a }, 240525e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 240625e992a4SHeiner Kallweit { 0x04, 0xf800 }, 240725e992a4SHeiner Kallweit { 0x04, 0xf000 }, 240825e992a4SHeiner Kallweit 240925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 241025e992a4SHeiner Kallweit { 0x0b, 0x0000 }, 241125e992a4SHeiner Kallweit { 0x00, 0x9200 } 241225e992a4SHeiner Kallweit }; 241325e992a4SHeiner Kallweit 241425e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 241525e992a4SHeiner Kallweit } 241625e992a4SHeiner Kallweit 241725e992a4SHeiner Kallweit static void rtl8169sb_hw_phy_config(struct rtl8169_private *tp) 241825e992a4SHeiner Kallweit { 24193a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0002, 0x01, 0x90d0); 242025e992a4SHeiner Kallweit } 242125e992a4SHeiner Kallweit 242225e992a4SHeiner Kallweit static void rtl8169scd_hw_phy_config_quirk(struct rtl8169_private *tp) 242325e992a4SHeiner Kallweit { 242425e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 242525e992a4SHeiner Kallweit 242625e992a4SHeiner Kallweit if ((pdev->subsystem_vendor != PCI_VENDOR_ID_GIGABYTE) || 242725e992a4SHeiner Kallweit (pdev->subsystem_device != 0xe000)) 242825e992a4SHeiner Kallweit return; 242925e992a4SHeiner Kallweit 24303a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0001, 0x10, 0xf01b); 243125e992a4SHeiner Kallweit } 243225e992a4SHeiner Kallweit 243325e992a4SHeiner Kallweit static void rtl8169scd_hw_phy_config(struct rtl8169_private *tp) 243425e992a4SHeiner Kallweit { 243525e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 243625e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 243725e992a4SHeiner Kallweit { 0x04, 0x0000 }, 243825e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 243925e992a4SHeiner Kallweit { 0x02, 0x0008 }, 244025e992a4SHeiner Kallweit { 0x01, 0x0120 }, 244125e992a4SHeiner Kallweit { 0x00, 0x1000 }, 244225e992a4SHeiner Kallweit { 0x04, 0x0800 }, 244325e992a4SHeiner Kallweit { 0x04, 0x9000 }, 244425e992a4SHeiner Kallweit { 0x03, 0x802f }, 244525e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 244625e992a4SHeiner Kallweit { 0x01, 0x0409 }, 244725e992a4SHeiner Kallweit { 0x00, 0xf099 }, 244825e992a4SHeiner Kallweit { 0x04, 0x9800 }, 244925e992a4SHeiner Kallweit { 0x04, 0xa000 }, 245025e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 245125e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 245225e992a4SHeiner Kallweit { 0x01, 0xff95 }, 245325e992a4SHeiner Kallweit { 0x00, 0xba00 }, 245425e992a4SHeiner Kallweit { 0x04, 0xa800 }, 245525e992a4SHeiner Kallweit { 0x04, 0xf000 }, 245625e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 245725e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 245825e992a4SHeiner Kallweit { 0x01, 0x101a }, 245925e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 246025e992a4SHeiner Kallweit { 0x04, 0xf800 }, 246125e992a4SHeiner Kallweit { 0x04, 0x0000 }, 246225e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 246325e992a4SHeiner Kallweit 246425e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 246525e992a4SHeiner Kallweit { 0x10, 0xf41b }, 246625e992a4SHeiner Kallweit { 0x14, 0xfb54 }, 246725e992a4SHeiner Kallweit { 0x18, 0xf5c7 }, 246825e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 246925e992a4SHeiner Kallweit 247025e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 247125e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 247225e992a4SHeiner Kallweit { 0x1f, 0x0000 } 247325e992a4SHeiner Kallweit }; 247425e992a4SHeiner Kallweit 247525e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 247625e992a4SHeiner Kallweit 247725e992a4SHeiner Kallweit rtl8169scd_hw_phy_config_quirk(tp); 247825e992a4SHeiner Kallweit } 247925e992a4SHeiner Kallweit 248025e992a4SHeiner Kallweit static void rtl8169sce_hw_phy_config(struct rtl8169_private *tp) 248125e992a4SHeiner Kallweit { 248225e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 248325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 248425e992a4SHeiner Kallweit { 0x04, 0x0000 }, 248525e992a4SHeiner Kallweit { 0x03, 0x00a1 }, 248625e992a4SHeiner Kallweit { 0x02, 0x0008 }, 248725e992a4SHeiner Kallweit { 0x01, 0x0120 }, 248825e992a4SHeiner Kallweit { 0x00, 0x1000 }, 248925e992a4SHeiner Kallweit { 0x04, 0x0800 }, 249025e992a4SHeiner Kallweit { 0x04, 0x9000 }, 249125e992a4SHeiner Kallweit { 0x03, 0x802f }, 249225e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 249325e992a4SHeiner Kallweit { 0x01, 0x0409 }, 249425e992a4SHeiner Kallweit { 0x00, 0xf099 }, 249525e992a4SHeiner Kallweit { 0x04, 0x9800 }, 249625e992a4SHeiner Kallweit { 0x04, 0xa000 }, 249725e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 249825e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 249925e992a4SHeiner Kallweit { 0x01, 0xff95 }, 250025e992a4SHeiner Kallweit { 0x00, 0xba00 }, 250125e992a4SHeiner Kallweit { 0x04, 0xa800 }, 250225e992a4SHeiner Kallweit { 0x04, 0xf000 }, 250325e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 250425e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 250525e992a4SHeiner Kallweit { 0x01, 0x101a }, 250625e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 250725e992a4SHeiner Kallweit { 0x04, 0xf800 }, 250825e992a4SHeiner Kallweit { 0x04, 0x0000 }, 250925e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 251025e992a4SHeiner Kallweit 251125e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 251225e992a4SHeiner Kallweit { 0x0b, 0x8480 }, 251325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 251425e992a4SHeiner Kallweit 251525e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 251625e992a4SHeiner Kallweit { 0x18, 0x67c7 }, 251725e992a4SHeiner Kallweit { 0x04, 0x2000 }, 251825e992a4SHeiner Kallweit { 0x03, 0x002f }, 251925e992a4SHeiner Kallweit { 0x02, 0x4360 }, 252025e992a4SHeiner Kallweit { 0x01, 0x0109 }, 252125e992a4SHeiner Kallweit { 0x00, 0x3022 }, 252225e992a4SHeiner Kallweit { 0x04, 0x2800 }, 252325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 252425e992a4SHeiner Kallweit 252525e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 252625e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 252725e992a4SHeiner Kallweit { 0x1f, 0x0000 } 252825e992a4SHeiner Kallweit }; 252925e992a4SHeiner Kallweit 253025e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 253125e992a4SHeiner Kallweit } 253225e992a4SHeiner Kallweit 253325e992a4SHeiner Kallweit static void rtl8168bb_hw_phy_config(struct rtl8169_private *tp) 253425e992a4SHeiner Kallweit { 253525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0001); 253625e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 25373a129e3fSHeiner Kallweit rtl_writephy(tp, 0x10, 0xf41b); 25383a129e3fSHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 253925e992a4SHeiner Kallweit } 254025e992a4SHeiner Kallweit 254125e992a4SHeiner Kallweit static void rtl8168bef_hw_phy_config(struct rtl8169_private *tp) 254225e992a4SHeiner Kallweit { 25433a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0001, 0x10, 0xf41b); 254425e992a4SHeiner Kallweit } 254525e992a4SHeiner Kallweit 254625e992a4SHeiner Kallweit static void rtl8168cp_1_hw_phy_config(struct rtl8169_private *tp) 254725e992a4SHeiner Kallweit { 25483a129e3fSHeiner Kallweit phy_write(tp->phydev, 0x1d, 0x0f00); 25493a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0002, 0x0c, 0x1ec8); 255025e992a4SHeiner Kallweit } 255125e992a4SHeiner Kallweit 255225e992a4SHeiner Kallweit static void rtl8168cp_2_hw_phy_config(struct rtl8169_private *tp) 255325e992a4SHeiner Kallweit { 25543a129e3fSHeiner Kallweit phy_set_bits(tp->phydev, 0x14, BIT(5)); 25553a129e3fSHeiner Kallweit phy_set_bits(tp->phydev, 0x0d, BIT(5)); 25563a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0001, 0x1d, 0x3d98); 255725e992a4SHeiner Kallweit } 255825e992a4SHeiner Kallweit 255925e992a4SHeiner Kallweit static void rtl8168c_1_hw_phy_config(struct rtl8169_private *tp) 256025e992a4SHeiner Kallweit { 256125e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 256225e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 256325e992a4SHeiner Kallweit { 0x12, 0x2300 }, 256425e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 256525e992a4SHeiner Kallweit { 0x00, 0x88d4 }, 256625e992a4SHeiner Kallweit { 0x01, 0x82b1 }, 256725e992a4SHeiner Kallweit { 0x03, 0x7002 }, 256825e992a4SHeiner Kallweit { 0x08, 0x9e30 }, 256925e992a4SHeiner Kallweit { 0x09, 0x01f0 }, 257025e992a4SHeiner Kallweit { 0x0a, 0x5500 }, 257125e992a4SHeiner Kallweit { 0x0c, 0x00c8 }, 257225e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 257325e992a4SHeiner Kallweit { 0x12, 0xc096 }, 257425e992a4SHeiner Kallweit { 0x16, 0x000a }, 257525e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 257625e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 257725e992a4SHeiner Kallweit { 0x09, 0x2000 }, 257825e992a4SHeiner Kallweit { 0x09, 0x0000 } 257925e992a4SHeiner Kallweit }; 258025e992a4SHeiner Kallweit 258125e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 258225e992a4SHeiner Kallweit 258325e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 258425e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 258525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 258625e992a4SHeiner Kallweit } 258725e992a4SHeiner Kallweit 258825e992a4SHeiner Kallweit static void rtl8168c_2_hw_phy_config(struct rtl8169_private *tp) 258925e992a4SHeiner Kallweit { 259025e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 259125e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 259225e992a4SHeiner Kallweit { 0x12, 0x2300 }, 259325e992a4SHeiner Kallweit { 0x03, 0x802f }, 259425e992a4SHeiner Kallweit { 0x02, 0x4f02 }, 259525e992a4SHeiner Kallweit { 0x01, 0x0409 }, 259625e992a4SHeiner Kallweit { 0x00, 0xf099 }, 259725e992a4SHeiner Kallweit { 0x04, 0x9800 }, 259825e992a4SHeiner Kallweit { 0x04, 0x9000 }, 259925e992a4SHeiner Kallweit { 0x1d, 0x3d98 }, 260025e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 260125e992a4SHeiner Kallweit { 0x0c, 0x7eb8 }, 260225e992a4SHeiner Kallweit { 0x06, 0x0761 }, 260325e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 260425e992a4SHeiner Kallweit { 0x16, 0x0f0a }, 260525e992a4SHeiner Kallweit { 0x1f, 0x0000 } 260625e992a4SHeiner Kallweit }; 260725e992a4SHeiner Kallweit 260825e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 260925e992a4SHeiner Kallweit 261025e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 261125e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 261225e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 261325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 261425e992a4SHeiner Kallweit } 261525e992a4SHeiner Kallweit 261625e992a4SHeiner Kallweit static void rtl8168c_3_hw_phy_config(struct rtl8169_private *tp) 261725e992a4SHeiner Kallweit { 261825e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 261925e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 262025e992a4SHeiner Kallweit { 0x12, 0x2300 }, 262125e992a4SHeiner Kallweit { 0x1d, 0x3d98 }, 262225e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 262325e992a4SHeiner Kallweit { 0x0c, 0x7eb8 }, 262425e992a4SHeiner Kallweit { 0x06, 0x5461 }, 262525e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 262625e992a4SHeiner Kallweit { 0x16, 0x0f0a }, 262725e992a4SHeiner Kallweit { 0x1f, 0x0000 } 262825e992a4SHeiner Kallweit }; 262925e992a4SHeiner Kallweit 263025e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 263125e992a4SHeiner Kallweit 263225e992a4SHeiner Kallweit rtl_patchphy(tp, 0x16, 1 << 0); 263325e992a4SHeiner Kallweit rtl_patchphy(tp, 0x14, 1 << 5); 263425e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 1 << 5); 263525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 263625e992a4SHeiner Kallweit } 263725e992a4SHeiner Kallweit 263825e992a4SHeiner Kallweit static void rtl8168c_4_hw_phy_config(struct rtl8169_private *tp) 263925e992a4SHeiner Kallweit { 264025e992a4SHeiner Kallweit rtl8168c_3_hw_phy_config(tp); 264125e992a4SHeiner Kallweit } 264225e992a4SHeiner Kallweit 264325e992a4SHeiner Kallweit static const struct phy_reg rtl8168d_1_phy_reg_init_0[] = { 264425e992a4SHeiner Kallweit /* Channel Estimation */ 264525e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 264625e992a4SHeiner Kallweit { 0x06, 0x4064 }, 264725e992a4SHeiner Kallweit { 0x07, 0x2863 }, 264825e992a4SHeiner Kallweit { 0x08, 0x059c }, 264925e992a4SHeiner Kallweit { 0x09, 0x26b4 }, 265025e992a4SHeiner Kallweit { 0x0a, 0x6a19 }, 265125e992a4SHeiner Kallweit { 0x0b, 0xdcc8 }, 265225e992a4SHeiner Kallweit { 0x10, 0xf06d }, 265325e992a4SHeiner Kallweit { 0x14, 0x7f68 }, 265425e992a4SHeiner Kallweit { 0x18, 0x7fd9 }, 265525e992a4SHeiner Kallweit { 0x1c, 0xf0ff }, 265625e992a4SHeiner Kallweit { 0x1d, 0x3d9c }, 265725e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 265825e992a4SHeiner Kallweit { 0x12, 0xf49f }, 265925e992a4SHeiner Kallweit { 0x13, 0x070b }, 266025e992a4SHeiner Kallweit { 0x1a, 0x05ad }, 266125e992a4SHeiner Kallweit { 0x14, 0x94c0 }, 266225e992a4SHeiner Kallweit 266325e992a4SHeiner Kallweit /* 266425e992a4SHeiner Kallweit * Tx Error Issue 266525e992a4SHeiner Kallweit * Enhance line driver power 266625e992a4SHeiner Kallweit */ 266725e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 266825e992a4SHeiner Kallweit { 0x06, 0x5561 }, 266925e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 267025e992a4SHeiner Kallweit { 0x05, 0x8332 }, 267125e992a4SHeiner Kallweit { 0x06, 0x5561 }, 267225e992a4SHeiner Kallweit 267325e992a4SHeiner Kallweit /* 267425e992a4SHeiner Kallweit * Can not link to 1Gbps with bad cable 267525e992a4SHeiner Kallweit * Decrease SNR threshold form 21.07dB to 19.04dB 267625e992a4SHeiner Kallweit */ 267725e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 267825e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 267925e992a4SHeiner Kallweit 268025e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 268125e992a4SHeiner Kallweit { 0x0d, 0xf880 } 268225e992a4SHeiner Kallweit }; 268325e992a4SHeiner Kallweit 268425e992a4SHeiner Kallweit static const struct phy_reg rtl8168d_1_phy_reg_init_1[] = { 268525e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 268625e992a4SHeiner Kallweit { 0x05, 0x669a }, 268725e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 268825e992a4SHeiner Kallweit { 0x05, 0x8330 }, 268925e992a4SHeiner Kallweit { 0x06, 0x669a }, 269025e992a4SHeiner Kallweit { 0x1f, 0x0002 } 269125e992a4SHeiner Kallweit }; 269225e992a4SHeiner Kallweit 269325e992a4SHeiner Kallweit static void rtl8168d_1_hw_phy_config(struct rtl8169_private *tp) 269425e992a4SHeiner Kallweit { 269525e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_0); 269625e992a4SHeiner Kallweit 269725e992a4SHeiner Kallweit /* 269825e992a4SHeiner Kallweit * Rx Error Issue 269925e992a4SHeiner Kallweit * Fine Tune Switching regulator parameter 270025e992a4SHeiner Kallweit */ 270125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 270225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x0b, 0x0010, 0x00ef); 270325e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x0c, 0xa200, 0x5d00); 270425e992a4SHeiner Kallweit 270525e992a4SHeiner Kallweit if (rtl8168d_efuse_read(tp, 0x01) == 0xb1) { 270625e992a4SHeiner Kallweit int val; 270725e992a4SHeiner Kallweit 270825e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_1); 270925e992a4SHeiner Kallweit 271025e992a4SHeiner Kallweit val = rtl_readphy(tp, 0x0d); 271125e992a4SHeiner Kallweit 271225e992a4SHeiner Kallweit if ((val & 0x00ff) != 0x006c) { 271325e992a4SHeiner Kallweit static const u32 set[] = { 271425e992a4SHeiner Kallweit 0x0065, 0x0066, 0x0067, 0x0068, 271525e992a4SHeiner Kallweit 0x0069, 0x006a, 0x006b, 0x006c 271625e992a4SHeiner Kallweit }; 271725e992a4SHeiner Kallweit int i; 271825e992a4SHeiner Kallweit 271925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 272025e992a4SHeiner Kallweit 272125e992a4SHeiner Kallweit val &= 0xff00; 272225e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(set); i++) 272325e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, val | set[i]); 272425e992a4SHeiner Kallweit } 272525e992a4SHeiner Kallweit } else { 2726b5e189b4SHeiner Kallweit phy_write_paged(tp->phydev, 0x0002, 0x05, 0x6662); 2727b5e189b4SHeiner Kallweit r8168d_phy_param(tp->phydev, 0x8330, 0xffff, 0x6662); 272825e992a4SHeiner Kallweit } 272925e992a4SHeiner Kallweit 273025e992a4SHeiner Kallweit /* RSET couple improve */ 273125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 273225e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0d, 0x0300); 273325e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0f, 0x0010); 273425e992a4SHeiner Kallweit 273525e992a4SHeiner Kallweit /* Fine tune PLL performance */ 273625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 273725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x02, 0x0100, 0x0600); 273825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x03, 0x0000, 0xe000); 273925e992a4SHeiner Kallweit 274025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 274125e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x001b); 274225e992a4SHeiner Kallweit 274325e992a4SHeiner Kallweit rtl_apply_firmware_cond(tp, MII_EXPANSION, 0xbf00); 274425e992a4SHeiner Kallweit 274525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 274625e992a4SHeiner Kallweit } 274725e992a4SHeiner Kallweit 274825e992a4SHeiner Kallweit static void rtl8168d_2_hw_phy_config(struct rtl8169_private *tp) 274925e992a4SHeiner Kallweit { 275025e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_0); 275125e992a4SHeiner Kallweit 275225e992a4SHeiner Kallweit if (rtl8168d_efuse_read(tp, 0x01) == 0xb1) { 275325e992a4SHeiner Kallweit int val; 275425e992a4SHeiner Kallweit 275525e992a4SHeiner Kallweit rtl_writephy_batch(tp, rtl8168d_1_phy_reg_init_1); 275625e992a4SHeiner Kallweit 275725e992a4SHeiner Kallweit val = rtl_readphy(tp, 0x0d); 275825e992a4SHeiner Kallweit if ((val & 0x00ff) != 0x006c) { 275925e992a4SHeiner Kallweit static const u32 set[] = { 276025e992a4SHeiner Kallweit 0x0065, 0x0066, 0x0067, 0x0068, 276125e992a4SHeiner Kallweit 0x0069, 0x006a, 0x006b, 0x006c 276225e992a4SHeiner Kallweit }; 276325e992a4SHeiner Kallweit int i; 276425e992a4SHeiner Kallweit 276525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 276625e992a4SHeiner Kallweit 276725e992a4SHeiner Kallweit val &= 0xff00; 276825e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(set); i++) 276925e992a4SHeiner Kallweit rtl_writephy(tp, 0x0d, val | set[i]); 277025e992a4SHeiner Kallweit } 277125e992a4SHeiner Kallweit } else { 2772b5e189b4SHeiner Kallweit phy_write_paged(tp->phydev, 0x0002, 0x05, 0x2642); 2773b5e189b4SHeiner Kallweit r8168d_phy_param(tp->phydev, 0x8330, 0xffff, 0x2642); 277425e992a4SHeiner Kallweit } 277525e992a4SHeiner Kallweit 277625e992a4SHeiner Kallweit /* Fine tune PLL performance */ 277725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 277825e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x02, 0x0100, 0x0600); 277925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x03, 0x0000, 0xe000); 278025e992a4SHeiner Kallweit 278125e992a4SHeiner Kallweit /* Switching regulator Slew rate */ 278225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0002); 278325e992a4SHeiner Kallweit rtl_patchphy(tp, 0x0f, 0x0017); 278425e992a4SHeiner Kallweit 278525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 278625e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x001b); 278725e992a4SHeiner Kallweit 278825e992a4SHeiner Kallweit rtl_apply_firmware_cond(tp, MII_EXPANSION, 0xb300); 278925e992a4SHeiner Kallweit 279025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 279125e992a4SHeiner Kallweit } 279225e992a4SHeiner Kallweit 279325e992a4SHeiner Kallweit static void rtl8168d_3_hw_phy_config(struct rtl8169_private *tp) 279425e992a4SHeiner Kallweit { 279525e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 279625e992a4SHeiner Kallweit { 0x1f, 0x0002 }, 279725e992a4SHeiner Kallweit { 0x10, 0x0008 }, 279825e992a4SHeiner Kallweit { 0x0d, 0x006c }, 279925e992a4SHeiner Kallweit 280025e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 280125e992a4SHeiner Kallweit { 0x0d, 0xf880 }, 280225e992a4SHeiner Kallweit 280325e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 280425e992a4SHeiner Kallweit { 0x17, 0x0cc0 }, 280525e992a4SHeiner Kallweit 280625e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 280725e992a4SHeiner Kallweit { 0x0b, 0xa4d8 }, 280825e992a4SHeiner Kallweit { 0x09, 0x281c }, 280925e992a4SHeiner Kallweit { 0x07, 0x2883 }, 281025e992a4SHeiner Kallweit { 0x0a, 0x6b35 }, 281125e992a4SHeiner Kallweit { 0x1d, 0x3da4 }, 281225e992a4SHeiner Kallweit { 0x1c, 0xeffd }, 281325e992a4SHeiner Kallweit { 0x14, 0x7f52 }, 281425e992a4SHeiner Kallweit { 0x18, 0x7fc6 }, 281525e992a4SHeiner Kallweit { 0x08, 0x0601 }, 281625e992a4SHeiner Kallweit { 0x06, 0x4063 }, 281725e992a4SHeiner Kallweit { 0x10, 0xf074 }, 281825e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 281925e992a4SHeiner Kallweit { 0x13, 0x0789 }, 282025e992a4SHeiner Kallweit { 0x12, 0xf4bd }, 282125e992a4SHeiner Kallweit { 0x1a, 0x04fd }, 282225e992a4SHeiner Kallweit { 0x14, 0x84b0 }, 282325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 282425e992a4SHeiner Kallweit { 0x00, 0x9200 }, 282525e992a4SHeiner Kallweit 282625e992a4SHeiner Kallweit { 0x1f, 0x0005 }, 282725e992a4SHeiner Kallweit { 0x01, 0x0340 }, 282825e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 282925e992a4SHeiner Kallweit { 0x04, 0x4000 }, 283025e992a4SHeiner Kallweit { 0x03, 0x1d21 }, 283125e992a4SHeiner Kallweit { 0x02, 0x0c32 }, 283225e992a4SHeiner Kallweit { 0x01, 0x0200 }, 283325e992a4SHeiner Kallweit { 0x00, 0x5554 }, 283425e992a4SHeiner Kallweit { 0x04, 0x4800 }, 283525e992a4SHeiner Kallweit { 0x04, 0x4000 }, 283625e992a4SHeiner Kallweit { 0x04, 0xf000 }, 283725e992a4SHeiner Kallweit { 0x03, 0xdf01 }, 283825e992a4SHeiner Kallweit { 0x02, 0xdf20 }, 283925e992a4SHeiner Kallweit { 0x01, 0x101a }, 284025e992a4SHeiner Kallweit { 0x00, 0xa0ff }, 284125e992a4SHeiner Kallweit { 0x04, 0xf800 }, 284225e992a4SHeiner Kallweit { 0x04, 0xf000 }, 284325e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 284425e992a4SHeiner Kallweit }; 284525e992a4SHeiner Kallweit 284625e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 28470721914aSHeiner Kallweit 28480721914aSHeiner Kallweit r8168d_modify_extpage(tp->phydev, 0x0023, 0x16, 0xffff, 0x0000); 284925e992a4SHeiner Kallweit } 285025e992a4SHeiner Kallweit 285125e992a4SHeiner Kallweit static void rtl8168d_4_hw_phy_config(struct rtl8169_private *tp) 285225e992a4SHeiner Kallweit { 28530721914aSHeiner Kallweit phy_write_paged(tp->phydev, 0x0001, 0x17, 0x0cc0); 28540721914aSHeiner Kallweit r8168d_modify_extpage(tp->phydev, 0x002d, 0x18, 0xffff, 0x0040); 28550721914aSHeiner Kallweit phy_set_bits(tp->phydev, 0x0d, BIT(5)); 285625e992a4SHeiner Kallweit } 285725e992a4SHeiner Kallweit 285825e992a4SHeiner Kallweit static void rtl8168e_1_hw_phy_config(struct rtl8169_private *tp) 285925e992a4SHeiner Kallweit { 286025e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 286125e992a4SHeiner Kallweit /* Channel estimation fine tune */ 286225e992a4SHeiner Kallweit { 0x1f, 0x0001 }, 286325e992a4SHeiner Kallweit { 0x0b, 0x6c20 }, 286425e992a4SHeiner Kallweit { 0x07, 0x2872 }, 286525e992a4SHeiner Kallweit { 0x1c, 0xefff }, 286625e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 286725e992a4SHeiner Kallweit { 0x14, 0x6420 }, 286825e992a4SHeiner Kallweit { 0x1f, 0x0000 }, 286925e992a4SHeiner Kallweit }; 2870b5e189b4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 287125e992a4SHeiner Kallweit 287225e992a4SHeiner Kallweit rtl_apply_firmware(tp); 287325e992a4SHeiner Kallweit 2874b5e189b4SHeiner Kallweit /* Enable Delay cap */ 2875b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b80, 0xffff, 0xc896); 2876b5e189b4SHeiner Kallweit 287725e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 287825e992a4SHeiner Kallweit 28790721914aSHeiner Kallweit /* Update PFM & 10M TX idle timer */ 28800721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002f, 0x15, 0xffff, 0x1919); 28810721914aSHeiner Kallweit 28820721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x00ac, 0x18, 0xffff, 0x0006); 28830721914aSHeiner Kallweit 288425e992a4SHeiner Kallweit /* DCO enable for 10M IDLE Power */ 28850721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0023, 0x17, 0x0000, 0x0006); 288625e992a4SHeiner Kallweit 288725e992a4SHeiner Kallweit /* For impedance matching */ 28883a129e3fSHeiner Kallweit phy_modify_paged(phydev, 0x0002, 0x08, 0x7f00, 0x8000); 288925e992a4SHeiner Kallweit 289025e992a4SHeiner Kallweit /* PHY auto speed down */ 28910721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002d, 0x18, 0x0000, 0x0050); 28920721914aSHeiner Kallweit phy_set_bits(phydev, 0x14, BIT(15)); 289325e992a4SHeiner Kallweit 2894b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b86, 0x0000, 0x0001); 2895b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x2000, 0x0000); 289625e992a4SHeiner Kallweit 28970721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0020, 0x15, 0x1100, 0x0000); 28980721914aSHeiner Kallweit phy_write_paged(phydev, 0x0006, 0x00, 0x5a00); 2899b5e189b4SHeiner Kallweit 2900b5e189b4SHeiner Kallweit phy_write_mmd(phydev, MDIO_MMD_AN, MDIO_AN_EEE_ADV, 0x0000); 290125e992a4SHeiner Kallweit } 290225e992a4SHeiner Kallweit 290325e992a4SHeiner Kallweit static void rtl_rar_exgmac_set(struct rtl8169_private *tp, u8 *addr) 290425e992a4SHeiner Kallweit { 290525e992a4SHeiner Kallweit const u16 w[] = { 290625e992a4SHeiner Kallweit addr[0] | (addr[1] << 8), 290725e992a4SHeiner Kallweit addr[2] | (addr[3] << 8), 290825e992a4SHeiner Kallweit addr[4] | (addr[5] << 8) 290925e992a4SHeiner Kallweit }; 291025e992a4SHeiner Kallweit 291125e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe0, ERIAR_MASK_1111, w[0] | (w[1] << 16)); 291225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe4, ERIAR_MASK_1111, w[2]); 291325e992a4SHeiner Kallweit rtl_eri_write(tp, 0xf0, ERIAR_MASK_1111, w[0] << 16); 291425e992a4SHeiner Kallweit rtl_eri_write(tp, 0xf4, ERIAR_MASK_1111, w[1] | (w[2] << 16)); 291525e992a4SHeiner Kallweit } 291625e992a4SHeiner Kallweit 291725e992a4SHeiner Kallweit static void rtl8168e_2_hw_phy_config(struct rtl8169_private *tp) 291825e992a4SHeiner Kallweit { 2919b5e189b4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 292025e992a4SHeiner Kallweit 292125e992a4SHeiner Kallweit rtl_apply_firmware(tp); 292225e992a4SHeiner Kallweit 29230721914aSHeiner Kallweit /* Enable Delay cap */ 29240721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x00ac, 0x18, 0xffff, 0x0006); 29250721914aSHeiner Kallweit 29260721914aSHeiner Kallweit /* Channel estimation fine tune */ 29270721914aSHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x09, 0xa20f); 292825e992a4SHeiner Kallweit 2929b5e189b4SHeiner Kallweit /* Green Setting */ 2930b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b5b, 0xffff, 0x9222); 2931b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b6d, 0xffff, 0x8000); 2932b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b76, 0xffff, 0x8000); 2933b5e189b4SHeiner Kallweit 293425e992a4SHeiner Kallweit /* For 4-corner performance improve */ 293525e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 293625e992a4SHeiner Kallweit rtl_writephy(tp, 0x05, 0x8b80); 293725e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x17, 0x0006, 0x0000); 293825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 293925e992a4SHeiner Kallweit 294025e992a4SHeiner Kallweit /* PHY auto speed down */ 29410721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002d, 0x18, 0x0000, 0x0010); 29420721914aSHeiner Kallweit phy_set_bits(phydev, 0x14, BIT(15)); 294325e992a4SHeiner Kallweit 294425e992a4SHeiner Kallweit /* improve 10M EEE waveform */ 2945b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b86, 0x0000, 0x0001); 294625e992a4SHeiner Kallweit 294725e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 2948b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x0000, 0x4000); 294925e992a4SHeiner Kallweit 295025e992a4SHeiner Kallweit rtl8168f_config_eee_phy(tp); 295125e992a4SHeiner Kallweit rtl_enable_eee(tp); 295225e992a4SHeiner Kallweit 295325e992a4SHeiner Kallweit /* Green feature */ 295425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0003); 295525e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x19, 0x0001, 0x0000); 295625e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x10, 0x0400, 0x0000); 295725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 295825e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0005); 295925e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x01, 0x0100, 0x0000); 296025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 296125e992a4SHeiner Kallweit 296225e992a4SHeiner Kallweit /* Broken BIOS workaround: feed GigaMAC registers with MAC address. */ 296325e992a4SHeiner Kallweit rtl_rar_exgmac_set(tp, tp->dev->dev_addr); 296425e992a4SHeiner Kallweit } 296525e992a4SHeiner Kallweit 296625e992a4SHeiner Kallweit static void rtl8168f_hw_phy_config(struct rtl8169_private *tp) 296725e992a4SHeiner Kallweit { 2968b5e189b4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 2969b5e189b4SHeiner Kallweit 297025e992a4SHeiner Kallweit /* For 4-corner performance improve */ 2971b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b80, 0x0000, 0x0006); 297225e992a4SHeiner Kallweit 297325e992a4SHeiner Kallweit /* PHY auto speed down */ 29740721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x002d, 0x18, 0x0000, 0x0010); 29750721914aSHeiner Kallweit phy_set_bits(phydev, 0x14, BIT(15)); 297625e992a4SHeiner Kallweit 297725e992a4SHeiner Kallweit /* Improve 10M EEE waveform */ 2978b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b86, 0x0000, 0x0001); 297925e992a4SHeiner Kallweit 298025e992a4SHeiner Kallweit rtl8168f_config_eee_phy(tp); 298125e992a4SHeiner Kallweit rtl_enable_eee(tp); 298225e992a4SHeiner Kallweit } 298325e992a4SHeiner Kallweit 298425e992a4SHeiner Kallweit static void rtl8168f_1_hw_phy_config(struct rtl8169_private *tp) 298525e992a4SHeiner Kallweit { 2986b5e189b4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 298725e992a4SHeiner Kallweit 298825e992a4SHeiner Kallweit rtl_apply_firmware(tp); 298925e992a4SHeiner Kallweit 2990b5e189b4SHeiner Kallweit /* Channel estimation fine tune */ 2991b5e189b4SHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x09, 0xa20f); 2992b5e189b4SHeiner Kallweit 2993b5e189b4SHeiner Kallweit /* Modify green table for giga & fnet */ 2994b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b55, 0xffff, 0x0000); 2995b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b5e, 0xffff, 0x0000); 2996b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b67, 0xffff, 0x0000); 2997b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b70, 0xffff, 0x0000); 29980721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0078, 0x17, 0xffff, 0x0000); 29990721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0078, 0x19, 0xffff, 0x00fb); 3000b5e189b4SHeiner Kallweit 3001b5e189b4SHeiner Kallweit /* Modify green table for 10M */ 3002b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b79, 0xffff, 0xaa00); 3003b5e189b4SHeiner Kallweit 3004b5e189b4SHeiner Kallweit /* Disable hiimpedance detection (RTCT) */ 3005b5e189b4SHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x01, 0x328a); 300625e992a4SHeiner Kallweit 300725e992a4SHeiner Kallweit rtl8168f_hw_phy_config(tp); 300825e992a4SHeiner Kallweit 300925e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 3010b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x0000, 0x4000); 301125e992a4SHeiner Kallweit } 301225e992a4SHeiner Kallweit 301325e992a4SHeiner Kallweit static void rtl8168f_2_hw_phy_config(struct rtl8169_private *tp) 301425e992a4SHeiner Kallweit { 301525e992a4SHeiner Kallweit rtl_apply_firmware(tp); 301625e992a4SHeiner Kallweit 301725e992a4SHeiner Kallweit rtl8168f_hw_phy_config(tp); 301825e992a4SHeiner Kallweit } 301925e992a4SHeiner Kallweit 302025e992a4SHeiner Kallweit static void rtl8411_hw_phy_config(struct rtl8169_private *tp) 302125e992a4SHeiner Kallweit { 3022b5e189b4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 302325e992a4SHeiner Kallweit 302425e992a4SHeiner Kallweit rtl_apply_firmware(tp); 302525e992a4SHeiner Kallweit 302625e992a4SHeiner Kallweit rtl8168f_hw_phy_config(tp); 302725e992a4SHeiner Kallweit 302825e992a4SHeiner Kallweit /* Improve 2-pair detection performance */ 3029b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x0000, 0x4000); 303025e992a4SHeiner Kallweit 3031b5e189b4SHeiner Kallweit /* Channel estimation fine tune */ 3032b5e189b4SHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x09, 0xa20f); 3033b5e189b4SHeiner Kallweit 3034b5e189b4SHeiner Kallweit /* Modify green table for giga & fnet */ 3035b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b55, 0xffff, 0x0000); 3036b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b5e, 0xffff, 0x0000); 3037b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b67, 0xffff, 0x0000); 3038b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b70, 0xffff, 0x0000); 30390721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0078, 0x17, 0xffff, 0x0000); 30400721914aSHeiner Kallweit r8168d_modify_extpage(phydev, 0x0078, 0x19, 0xffff, 0x00aa); 3041b5e189b4SHeiner Kallweit 3042b5e189b4SHeiner Kallweit /* Modify green table for 10M */ 3043b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b79, 0xffff, 0xaa00); 3044b5e189b4SHeiner Kallweit 3045b5e189b4SHeiner Kallweit /* Disable hiimpedance detection (RTCT) */ 3046b5e189b4SHeiner Kallweit phy_write_paged(phydev, 0x0003, 0x01, 0x328a); 304725e992a4SHeiner Kallweit 304825e992a4SHeiner Kallweit /* Modify green table for giga */ 3049b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b54, 0x0800, 0x0000); 3050b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b5d, 0x0800, 0x0000); 3051b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a7c, 0x0100, 0x0000); 3052b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a7f, 0x0000, 0x0100); 3053b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a82, 0x0100, 0x0000); 3054b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a85, 0x0100, 0x0000); 3055b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8a88, 0x0100, 0x0000); 305625e992a4SHeiner Kallweit 305725e992a4SHeiner Kallweit /* uc same-seed solution */ 3058b5e189b4SHeiner Kallweit r8168d_phy_param(phydev, 0x8b85, 0x0000, 0x8000); 305925e992a4SHeiner Kallweit 306025e992a4SHeiner Kallweit /* Green feature */ 306125e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0003); 306225e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x19, 0x0000, 0x0001); 306325e992a4SHeiner Kallweit rtl_w0w1_phy(tp, 0x10, 0x0000, 0x0400); 306425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 306525e992a4SHeiner Kallweit } 306625e992a4SHeiner Kallweit 306725e992a4SHeiner Kallweit static void rtl8168g_disable_aldps(struct rtl8169_private *tp) 306825e992a4SHeiner Kallweit { 306925e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a43, 0x10, BIT(2), 0); 307025e992a4SHeiner Kallweit } 307125e992a4SHeiner Kallweit 307225e992a4SHeiner Kallweit static void rtl8168g_phy_adjust_10m_aldps(struct rtl8169_private *tp) 307325e992a4SHeiner Kallweit { 307425e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 307525e992a4SHeiner Kallweit 307625e992a4SHeiner Kallweit phy_modify_paged(phydev, 0x0bcc, 0x14, BIT(8), 0); 307725e992a4SHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(7) | BIT(6)); 30788bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8084, 0x6000, 0x0000); 30798bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a43, 0x10, 0x0000, 0x1003); 308025e992a4SHeiner Kallweit } 308125e992a4SHeiner Kallweit 308225e992a4SHeiner Kallweit static void rtl8168g_1_hw_phy_config(struct rtl8169_private *tp) 308325e992a4SHeiner Kallweit { 308425e992a4SHeiner Kallweit int ret; 308525e992a4SHeiner Kallweit 308625e992a4SHeiner Kallweit rtl_apply_firmware(tp); 308725e992a4SHeiner Kallweit 308825e992a4SHeiner Kallweit ret = phy_read_paged(tp->phydev, 0x0a46, 0x10); 308925e992a4SHeiner Kallweit if (ret & BIT(8)) 309025e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0bcc, 0x12, BIT(15), 0); 309125e992a4SHeiner Kallweit else 309225e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0bcc, 0x12, 0, BIT(15)); 309325e992a4SHeiner Kallweit 309425e992a4SHeiner Kallweit ret = phy_read_paged(tp->phydev, 0x0a46, 0x13); 309525e992a4SHeiner Kallweit if (ret & BIT(8)) 30961a03bb53SThomas Voegtle phy_modify_paged(tp->phydev, 0x0c41, 0x15, 0, BIT(1)); 309725e992a4SHeiner Kallweit else 30981a03bb53SThomas Voegtle phy_modify_paged(tp->phydev, 0x0c41, 0x15, BIT(1), 0); 309925e992a4SHeiner Kallweit 310025e992a4SHeiner Kallweit /* Enable PHY auto speed down */ 310125e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, 0, BIT(3) | BIT(2)); 310225e992a4SHeiner Kallweit 310325e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 310425e992a4SHeiner Kallweit 310525e992a4SHeiner Kallweit /* EEE auto-fallback function */ 310625e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a4b, 0x11, 0, BIT(2)); 310725e992a4SHeiner Kallweit 310825e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 31098bfdce1dSHeiner Kallweit r8168g_phy_param(tp->phydev, 0x8012, 0x0000, 0x8000); 311025e992a4SHeiner Kallweit 311125e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 311225e992a4SHeiner Kallweit 311325e992a4SHeiner Kallweit /* Improve SWR Efficiency */ 311425e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 311525e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x5065); 311625e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0xd065); 311725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bc8); 311825e992a4SHeiner Kallweit rtl_writephy(tp, 0x11, 0x5655); 311925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 312025e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 312125e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x9065); 312225e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 312325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 312425e992a4SHeiner Kallweit 312525e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 312625e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 312725e992a4SHeiner Kallweit rtl_enable_eee(tp); 312825e992a4SHeiner Kallweit } 312925e992a4SHeiner Kallweit 313025e992a4SHeiner Kallweit static void rtl8168g_2_hw_phy_config(struct rtl8169_private *tp) 313125e992a4SHeiner Kallweit { 313225e992a4SHeiner Kallweit rtl_apply_firmware(tp); 313325e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 313425e992a4SHeiner Kallweit rtl_enable_eee(tp); 313525e992a4SHeiner Kallweit } 313625e992a4SHeiner Kallweit 313725e992a4SHeiner Kallweit static void rtl8168h_1_hw_phy_config(struct rtl8169_private *tp) 313825e992a4SHeiner Kallweit { 31398bfdce1dSHeiner Kallweit struct phy_device *phydev = tp->phydev; 314025e992a4SHeiner Kallweit u16 dout_tapbin; 314125e992a4SHeiner Kallweit u32 data; 314225e992a4SHeiner Kallweit 314325e992a4SHeiner Kallweit rtl_apply_firmware(tp); 314425e992a4SHeiner Kallweit 314525e992a4SHeiner Kallweit /* CHN EST parameters adjust - giga master */ 31468bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x809b, 0xf800, 0x8000); 31478bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80a2, 0xff00, 0x8000); 31488bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80a4, 0xff00, 0x8500); 31498bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x809c, 0xff00, 0xbd00); 315025e992a4SHeiner Kallweit 315125e992a4SHeiner Kallweit /* CHN EST parameters adjust - giga slave */ 31528bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ad, 0xf800, 0x7000); 31538bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80b4, 0xff00, 0x5000); 31548bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ac, 0xff00, 0x4000); 315525e992a4SHeiner Kallweit 315625e992a4SHeiner Kallweit /* CHN EST parameters adjust - fnet */ 31578bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x808e, 0xff00, 0x1200); 31588bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8090, 0xff00, 0xe500); 31598bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8092, 0xff00, 0x9f00); 316025e992a4SHeiner Kallweit 316125e992a4SHeiner Kallweit /* enable R-tune & PGA-retune function */ 316225e992a4SHeiner Kallweit dout_tapbin = 0; 31638bfdce1dSHeiner Kallweit data = phy_read_paged(phydev, 0x0a46, 0x13); 316425e992a4SHeiner Kallweit data &= 3; 316525e992a4SHeiner Kallweit data <<= 2; 316625e992a4SHeiner Kallweit dout_tapbin |= data; 31678bfdce1dSHeiner Kallweit data = phy_read_paged(phydev, 0x0a46, 0x12); 316825e992a4SHeiner Kallweit data &= 0xc000; 316925e992a4SHeiner Kallweit data >>= 14; 317025e992a4SHeiner Kallweit dout_tapbin |= data; 317125e992a4SHeiner Kallweit dout_tapbin = ~(dout_tapbin^0x08); 317225e992a4SHeiner Kallweit dout_tapbin <<= 12; 317325e992a4SHeiner Kallweit dout_tapbin &= 0xf000; 317425e992a4SHeiner Kallweit 31758bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x827a, 0xf000, dout_tapbin); 31768bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x827b, 0xf000, dout_tapbin); 31778bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x827c, 0xf000, dout_tapbin); 31788bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x827d, 0xf000, dout_tapbin); 31798bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x0811, 0x0000, 0x0800); 31808bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a42, 0x16, 0x0000, 0x0002); 318125e992a4SHeiner Kallweit 318225e992a4SHeiner Kallweit /* enable GPHY 10M */ 318325e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, 0, BIT(11)); 318425e992a4SHeiner Kallweit 318525e992a4SHeiner Kallweit /* SAR ADC performance */ 318625e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0bca, 0x17, BIT(12) | BIT(13), BIT(14)); 318725e992a4SHeiner Kallweit 31888bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x803f, 0x3000, 0x0000); 31898bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8047, 0x3000, 0x0000); 31908bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x804f, 0x3000, 0x0000); 31918bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8057, 0x3000, 0x0000); 31928bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x805f, 0x3000, 0x0000); 31938bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8067, 0x3000, 0x0000); 31948bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x806f, 0x3000, 0x0000); 319525e992a4SHeiner Kallweit 319625e992a4SHeiner Kallweit /* disable phy pfm mode */ 319725e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, BIT(7), 0); 319825e992a4SHeiner Kallweit 319925e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 3200b6cef26fSHeiner Kallweit rtl8168h_config_eee_phy(tp); 320125e992a4SHeiner Kallweit rtl_enable_eee(tp); 320225e992a4SHeiner Kallweit } 320325e992a4SHeiner Kallweit 320425e992a4SHeiner Kallweit static void rtl8168h_2_hw_phy_config(struct rtl8169_private *tp) 320525e992a4SHeiner Kallweit { 320625e992a4SHeiner Kallweit u16 ioffset_p3, ioffset_p2, ioffset_p1, ioffset_p0; 32078bfdce1dSHeiner Kallweit struct phy_device *phydev = tp->phydev; 320825e992a4SHeiner Kallweit u16 rlen; 320925e992a4SHeiner Kallweit u32 data; 321025e992a4SHeiner Kallweit 321125e992a4SHeiner Kallweit rtl_apply_firmware(tp); 321225e992a4SHeiner Kallweit 321325e992a4SHeiner Kallweit /* CHIN EST parameter update */ 32148bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x808a, 0x003f, 0x000a); 321525e992a4SHeiner Kallweit 321625e992a4SHeiner Kallweit /* enable R-tune & PGA-retune function */ 32178bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x0811, 0x0000, 0x0800); 32188bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a42, 0x16, 0x0000, 0x0002); 321925e992a4SHeiner Kallweit 322025e992a4SHeiner Kallweit /* enable GPHY 10M */ 322125e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0a44, 0x11, 0, BIT(11)); 322225e992a4SHeiner Kallweit 322325e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xdd02, 0x807d); 322425e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xdd02); 322525e992a4SHeiner Kallweit ioffset_p3 = ((data & 0x80)>>7); 322625e992a4SHeiner Kallweit ioffset_p3 <<= 3; 322725e992a4SHeiner Kallweit 322825e992a4SHeiner Kallweit data = r8168_mac_ocp_read(tp, 0xdd00); 322925e992a4SHeiner Kallweit ioffset_p3 |= ((data & (0xe000))>>13); 323025e992a4SHeiner Kallweit ioffset_p2 = ((data & (0x1e00))>>9); 323125e992a4SHeiner Kallweit ioffset_p1 = ((data & (0x01e0))>>5); 323225e992a4SHeiner Kallweit ioffset_p0 = ((data & 0x0010)>>4); 323325e992a4SHeiner Kallweit ioffset_p0 <<= 3; 323425e992a4SHeiner Kallweit ioffset_p0 |= (data & (0x07)); 323525e992a4SHeiner Kallweit data = (ioffset_p3<<12)|(ioffset_p2<<8)|(ioffset_p1<<4)|(ioffset_p0); 323625e992a4SHeiner Kallweit 323725e992a4SHeiner Kallweit if ((ioffset_p3 != 0x0f) || (ioffset_p2 != 0x0f) || 32388bfdce1dSHeiner Kallweit (ioffset_p1 != 0x0f) || (ioffset_p0 != 0x0f)) 32398bfdce1dSHeiner Kallweit phy_write_paged(phydev, 0x0bcf, 0x16, data); 324025e992a4SHeiner Kallweit 324125e992a4SHeiner Kallweit /* Modify rlen (TX LPF corner frequency) level */ 32428bfdce1dSHeiner Kallweit data = phy_read_paged(phydev, 0x0bcd, 0x16); 324325e992a4SHeiner Kallweit data &= 0x000f; 324425e992a4SHeiner Kallweit rlen = 0; 324525e992a4SHeiner Kallweit if (data > 3) 324625e992a4SHeiner Kallweit rlen = data - 3; 324725e992a4SHeiner Kallweit data = rlen | (rlen<<4) | (rlen<<8) | (rlen<<12); 32488bfdce1dSHeiner Kallweit phy_write_paged(phydev, 0x0bcd, 0x17, data); 324925e992a4SHeiner Kallweit 325025e992a4SHeiner Kallweit /* disable phy pfm mode */ 32518bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, BIT(7), 0); 325225e992a4SHeiner Kallweit 325325e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 325425e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 325525e992a4SHeiner Kallweit rtl_enable_eee(tp); 325625e992a4SHeiner Kallweit } 325725e992a4SHeiner Kallweit 325825e992a4SHeiner Kallweit static void rtl8168ep_1_hw_phy_config(struct rtl8169_private *tp) 325925e992a4SHeiner Kallweit { 32608bfdce1dSHeiner Kallweit struct phy_device *phydev = tp->phydev; 32618bfdce1dSHeiner Kallweit 326225e992a4SHeiner Kallweit /* Enable PHY auto speed down */ 32638bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a44, 0x11, 0, BIT(3) | BIT(2)); 326425e992a4SHeiner Kallweit 326525e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 326625e992a4SHeiner Kallweit 326725e992a4SHeiner Kallweit /* Enable EEE auto-fallback function */ 32688bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0a4b, 0x11, 0, BIT(2)); 326925e992a4SHeiner Kallweit 327025e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 32718bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8012, 0x0000, 0x8000); 327225e992a4SHeiner Kallweit 327325e992a4SHeiner Kallweit /* set rg_sel_sdm_rate */ 32748bfdce1dSHeiner Kallweit phy_modify_paged(phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 327525e992a4SHeiner Kallweit 327625e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 327725e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 327825e992a4SHeiner Kallweit rtl_enable_eee(tp); 327925e992a4SHeiner Kallweit } 328025e992a4SHeiner Kallweit 328125e992a4SHeiner Kallweit static void rtl8168ep_2_hw_phy_config(struct rtl8169_private *tp) 328225e992a4SHeiner Kallweit { 32838bfdce1dSHeiner Kallweit struct phy_device *phydev = tp->phydev; 32848bfdce1dSHeiner Kallweit 328525e992a4SHeiner Kallweit rtl8168g_phy_adjust_10m_aldps(tp); 328625e992a4SHeiner Kallweit 328725e992a4SHeiner Kallweit /* Enable UC LPF tune function */ 32888bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8012, 0x0000, 0x8000); 328925e992a4SHeiner Kallweit 329025e992a4SHeiner Kallweit /* Set rg_sel_sdm_rate */ 329125e992a4SHeiner Kallweit phy_modify_paged(tp->phydev, 0x0c42, 0x11, BIT(13), BIT(14)); 329225e992a4SHeiner Kallweit 329325e992a4SHeiner Kallweit /* Channel estimation parameters */ 32948bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f3, 0xff00, 0x8b00); 32958bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f0, 0xff00, 0x3a00); 32968bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ef, 0xff00, 0x0500); 32978bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f6, 0xff00, 0x6e00); 32988bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ec, 0xff00, 0x6800); 32998bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ed, 0xff00, 0x7c00); 33008bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f2, 0xff00, 0xf400); 33018bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f4, 0xff00, 0x8500); 33028bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8110, 0xff00, 0xa800); 33038bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x810f, 0xff00, 0x1d00); 33048bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8111, 0xff00, 0xf500); 33058bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8113, 0xff00, 0x6100); 33068bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8115, 0xff00, 0x9200); 33078bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x810e, 0xff00, 0x0400); 33088bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x810c, 0xff00, 0x7c00); 33098bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x810b, 0xff00, 0x5a00); 33108bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80d1, 0xff00, 0xff00); 33118bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80cd, 0xff00, 0x9e00); 33128bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80d3, 0xff00, 0x0e00); 33138bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80d5, 0xff00, 0xca00); 33148bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80d7, 0xff00, 0x8400); 331525e992a4SHeiner Kallweit 331625e992a4SHeiner Kallweit /* Force PWM-mode */ 331725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 331825e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x5065); 331925e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0xd065); 332025e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bc8); 332125e992a4SHeiner Kallweit rtl_writephy(tp, 0x12, 0x00ed); 332225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0bcd); 332325e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 332425e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x9065); 332525e992a4SHeiner Kallweit rtl_writephy(tp, 0x14, 0x1065); 332625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 332725e992a4SHeiner Kallweit 332825e992a4SHeiner Kallweit rtl8168g_disable_aldps(tp); 332925e992a4SHeiner Kallweit rtl8168g_config_eee_phy(tp); 333025e992a4SHeiner Kallweit rtl_enable_eee(tp); 333125e992a4SHeiner Kallweit } 333225e992a4SHeiner Kallweit 333325e992a4SHeiner Kallweit static void rtl8102e_hw_phy_config(struct rtl8169_private *tp) 333425e992a4SHeiner Kallweit { 333525e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 333625e992a4SHeiner Kallweit { 0x1f, 0x0003 }, 333725e992a4SHeiner Kallweit { 0x08, 0x441d }, 333825e992a4SHeiner Kallweit { 0x01, 0x9100 }, 333925e992a4SHeiner Kallweit { 0x1f, 0x0000 } 334025e992a4SHeiner Kallweit }; 334125e992a4SHeiner Kallweit 334225e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 334325e992a4SHeiner Kallweit rtl_patchphy(tp, 0x11, 1 << 12); 334425e992a4SHeiner Kallweit rtl_patchphy(tp, 0x19, 1 << 13); 334525e992a4SHeiner Kallweit rtl_patchphy(tp, 0x10, 1 << 15); 334625e992a4SHeiner Kallweit 334725e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 334825e992a4SHeiner Kallweit } 334925e992a4SHeiner Kallweit 335025e992a4SHeiner Kallweit static void rtl8105e_hw_phy_config(struct rtl8169_private *tp) 335125e992a4SHeiner Kallweit { 335225e992a4SHeiner Kallweit /* Disable ALDPS before ram code */ 33533a129e3fSHeiner Kallweit phy_write(tp->phydev, 0x18, 0x0310); 335425e992a4SHeiner Kallweit msleep(100); 335525e992a4SHeiner Kallweit 335625e992a4SHeiner Kallweit rtl_apply_firmware(tp); 335725e992a4SHeiner Kallweit 33583a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0005, 0x1a, 0x0000); 33593a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0004, 0x1c, 0x0000); 33603a129e3fSHeiner Kallweit phy_write_paged(tp->phydev, 0x0001, 0x15, 0x7701); 336125e992a4SHeiner Kallweit } 336225e992a4SHeiner Kallweit 336325e992a4SHeiner Kallweit static void rtl8402_hw_phy_config(struct rtl8169_private *tp) 336425e992a4SHeiner Kallweit { 336525e992a4SHeiner Kallweit /* Disable ALDPS before setting firmware */ 33663a129e3fSHeiner Kallweit phy_write(tp->phydev, 0x18, 0x0310); 336725e992a4SHeiner Kallweit msleep(20); 336825e992a4SHeiner Kallweit 336925e992a4SHeiner Kallweit rtl_apply_firmware(tp); 337025e992a4SHeiner Kallweit 337125e992a4SHeiner Kallweit /* EEE setting */ 337225e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1b0, ERIAR_MASK_0011, 0x0000); 337325e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0004); 337425e992a4SHeiner Kallweit rtl_writephy(tp, 0x10, 0x401f); 337525e992a4SHeiner Kallweit rtl_writephy(tp, 0x19, 0x7030); 337625e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 337725e992a4SHeiner Kallweit } 337825e992a4SHeiner Kallweit 337925e992a4SHeiner Kallweit static void rtl8106e_hw_phy_config(struct rtl8169_private *tp) 338025e992a4SHeiner Kallweit { 338125e992a4SHeiner Kallweit static const struct phy_reg phy_reg_init[] = { 338225e992a4SHeiner Kallweit { 0x1f, 0x0004 }, 338325e992a4SHeiner Kallweit { 0x10, 0xc07f }, 338425e992a4SHeiner Kallweit { 0x19, 0x7030 }, 338525e992a4SHeiner Kallweit { 0x1f, 0x0000 } 338625e992a4SHeiner Kallweit }; 338725e992a4SHeiner Kallweit 338825e992a4SHeiner Kallweit /* Disable ALDPS before ram code */ 33893a129e3fSHeiner Kallweit phy_write(tp->phydev, 0x18, 0x0310); 339025e992a4SHeiner Kallweit msleep(100); 339125e992a4SHeiner Kallweit 339225e992a4SHeiner Kallweit rtl_apply_firmware(tp); 339325e992a4SHeiner Kallweit 339425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1b0, ERIAR_MASK_0011, 0x0000); 339525e992a4SHeiner Kallweit rtl_writephy_batch(tp, phy_reg_init); 339625e992a4SHeiner Kallweit 339725e992a4SHeiner Kallweit rtl_eri_write(tp, 0x1d0, ERIAR_MASK_0011, 0x0000); 339825e992a4SHeiner Kallweit } 339925e992a4SHeiner Kallweit 340002bf642bSHeiner Kallweit static void rtl8125_1_hw_phy_config(struct rtl8169_private *tp) 340102bf642bSHeiner Kallweit { 340202bf642bSHeiner Kallweit struct phy_device *phydev = tp->phydev; 340302bf642bSHeiner Kallweit 340402bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x10, 0x03ff, 0x0084); 340502bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x17, 0x0000, 0x0010); 340602bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x13, 0x03ff, 0x0006); 340702bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad3, 0x11, 0x003f, 0x0006); 340802bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac0, 0x14, 0x0000, 0x1100); 340902bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac8, 0x15, 0xf000, 0x7000); 341002bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x14, 0x0000, 0x0400); 341102bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x15, 0x0000, 0x03ff); 341202bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x16, 0x0000, 0x03ff); 341302bf642bSHeiner Kallweit 34148bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ea, 0xff00, 0xc400); 34158bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80eb, 0x0700, 0x0300); 34168bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f8, 0xff00, 0x1c00); 34178bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80f1, 0xff00, 0x3000); 34188bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80fe, 0xff00, 0xa500); 34198bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8102, 0xff00, 0x5000); 34208bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8105, 0xff00, 0x3300); 34218bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8100, 0xff00, 0x7000); 34228bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8104, 0xff00, 0xf000); 34238bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8106, 0xff00, 0x6500); 34248bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80dc, 0xff00, 0xed00); 34258bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80df, 0x0000, 0x0100); 34268bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80e1, 0x0100, 0x0000); 342702bf642bSHeiner Kallweit 342802bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xbf0, 0x13, 0x003f, 0x0038); 34298bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x819f, 0xffff, 0xd0b6); 343002bf642bSHeiner Kallweit 343102bf642bSHeiner Kallweit phy_write_paged(phydev, 0xbc3, 0x12, 0x5555); 343202bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xbf0, 0x15, 0x0e00, 0x0a00); 343302bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa5c, 0x10, 0x0400, 0x0000); 343402bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa44, 0x11, 0x0000, 0x0800); 3435b3a42e3aSHeiner Kallweit 3436b3a42e3aSHeiner Kallweit rtl8125_config_eee_phy(tp); 3437b3a42e3aSHeiner Kallweit rtl_enable_eee(tp); 343802bf642bSHeiner Kallweit } 343902bf642bSHeiner Kallweit 344002bf642bSHeiner Kallweit static void rtl8125_2_hw_phy_config(struct rtl8169_private *tp) 344102bf642bSHeiner Kallweit { 344202bf642bSHeiner Kallweit struct phy_device *phydev = tp->phydev; 344302bf642bSHeiner Kallweit int i; 344402bf642bSHeiner Kallweit 344502bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x17, 0x0000, 0x0010); 344602bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad1, 0x13, 0x03ff, 0x03ff); 344702bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad3, 0x11, 0x003f, 0x0006); 344802bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac0, 0x14, 0x1100, 0x0000); 344902bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xacc, 0x10, 0x0003, 0x0002); 345002bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x10, 0x00e7, 0x0044); 345102bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac1, 0x12, 0x0080, 0x0000); 345202bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac8, 0x10, 0x0300, 0x0000); 345302bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac5, 0x17, 0x0007, 0x0002); 345402bf642bSHeiner Kallweit phy_write_paged(phydev, 0xad4, 0x16, 0x00a8); 345502bf642bSHeiner Kallweit phy_write_paged(phydev, 0xac5, 0x16, 0x01ff); 345602bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xac8, 0x15, 0x00f0, 0x0030); 345702bf642bSHeiner Kallweit 345802bf642bSHeiner Kallweit phy_write(phydev, 0x1f, 0x0b87); 345902bf642bSHeiner Kallweit phy_write(phydev, 0x16, 0x80a2); 346002bf642bSHeiner Kallweit phy_write(phydev, 0x17, 0x0153); 346102bf642bSHeiner Kallweit phy_write(phydev, 0x16, 0x809c); 346202bf642bSHeiner Kallweit phy_write(phydev, 0x17, 0x0153); 346302bf642bSHeiner Kallweit phy_write(phydev, 0x1f, 0x0000); 346402bf642bSHeiner Kallweit 346502bf642bSHeiner Kallweit phy_write(phydev, 0x1f, 0x0a43); 346602bf642bSHeiner Kallweit phy_write(phydev, 0x13, 0x81B3); 346702bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0043); 346802bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00A7); 346902bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00D6); 347002bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00EC); 347102bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00F6); 347202bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00FB); 347302bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00FD); 347402bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00FF); 347502bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x00BB); 347602bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0058); 347702bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0029); 347802bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0013); 347902bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0009); 348002bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0004); 348102bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0002); 348202bf642bSHeiner Kallweit for (i = 0; i < 25; i++) 348302bf642bSHeiner Kallweit phy_write(phydev, 0x14, 0x0000); 348402bf642bSHeiner Kallweit phy_write(phydev, 0x1f, 0x0000); 348502bf642bSHeiner Kallweit 34868bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x8257, 0xffff, 0x020F); 34878bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x80ea, 0xffff, 0x7843); 34888bfdce1dSHeiner Kallweit 348902bf642bSHeiner Kallweit rtl_apply_firmware(tp); 349002bf642bSHeiner Kallweit 349102bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xd06, 0x14, 0x0000, 0x2000); 349202bf642bSHeiner Kallweit 34938bfdce1dSHeiner Kallweit r8168g_phy_param(phydev, 0x81a2, 0x0000, 0x0100); 349402bf642bSHeiner Kallweit 349502bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xb54, 0x16, 0xff00, 0xdb00); 349602bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa45, 0x12, 0x0001, 0x0000); 349702bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa5d, 0x12, 0x0000, 0x0020); 349802bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xad4, 0x17, 0x0010, 0x0000); 349902bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa86, 0x15, 0x0001, 0x0000); 350002bf642bSHeiner Kallweit phy_modify_paged(phydev, 0xa44, 0x11, 0x0000, 0x0800); 3501b3a42e3aSHeiner Kallweit 3502b3a42e3aSHeiner Kallweit rtl8125_config_eee_phy(tp); 3503b3a42e3aSHeiner Kallweit rtl_enable_eee(tp); 350402bf642bSHeiner Kallweit } 350502bf642bSHeiner Kallweit 350625e992a4SHeiner Kallweit static void rtl_hw_phy_config(struct net_device *dev) 350725e992a4SHeiner Kallweit { 350825e992a4SHeiner Kallweit static const rtl_generic_fct phy_configs[] = { 350925e992a4SHeiner Kallweit /* PCI devices. */ 351025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_02] = rtl8169s_hw_phy_config, 351125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_03] = rtl8169s_hw_phy_config, 351225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_04] = rtl8169sb_hw_phy_config, 351325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_05] = rtl8169scd_hw_phy_config, 351425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_06] = rtl8169sce_hw_phy_config, 351525e992a4SHeiner Kallweit /* PCI-E devices. */ 351625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = rtl8102e_hw_phy_config, 351725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = rtl8102e_hw_phy_config, 351825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = rtl8102e_hw_phy_config, 351925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = NULL, 352025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = rtl8168bb_hw_phy_config, 352125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = rtl8168bef_hw_phy_config, 352225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = NULL, 352325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = NULL, 352425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = NULL, 352525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = NULL, 352625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = rtl8168bef_hw_phy_config, 352725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = rtl8168cp_1_hw_phy_config, 352825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = rtl8168c_1_hw_phy_config, 352925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = rtl8168c_2_hw_phy_config, 353025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = rtl8168c_3_hw_phy_config, 353125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = rtl8168c_4_hw_phy_config, 353225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = rtl8168cp_2_hw_phy_config, 353325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = rtl8168cp_2_hw_phy_config, 353425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = rtl8168d_1_hw_phy_config, 353525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = rtl8168d_2_hw_phy_config, 353625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = rtl8168d_3_hw_phy_config, 353725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = rtl8168d_4_hw_phy_config, 353825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = rtl8105e_hw_phy_config, 353925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = rtl8105e_hw_phy_config, 354025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_31] = NULL, 354125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = rtl8168e_1_hw_phy_config, 354225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = rtl8168e_1_hw_phy_config, 354325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = rtl8168e_2_hw_phy_config, 354425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = rtl8168f_1_hw_phy_config, 354525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = rtl8168f_2_hw_phy_config, 354625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = rtl8402_hw_phy_config, 354725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = rtl8411_hw_phy_config, 354825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = rtl8106e_hw_phy_config, 354925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = rtl8168g_1_hw_phy_config, 355025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = NULL, 355125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = rtl8168g_2_hw_phy_config, 355225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = rtl8168g_2_hw_phy_config, 355325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = rtl8168g_2_hw_phy_config, 355425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = rtl8168h_1_hw_phy_config, 355525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = rtl8168h_2_hw_phy_config, 355625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = rtl8168h_1_hw_phy_config, 355725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = rtl8168h_2_hw_phy_config, 355825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = rtl8168ep_1_hw_phy_config, 355925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = rtl8168ep_2_hw_phy_config, 356025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = rtl8168ep_2_hw_phy_config, 356102bf642bSHeiner Kallweit [RTL_GIGA_MAC_VER_60] = rtl8125_1_hw_phy_config, 356202bf642bSHeiner Kallweit [RTL_GIGA_MAC_VER_61] = rtl8125_2_hw_phy_config, 356325e992a4SHeiner Kallweit }; 356425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 356525e992a4SHeiner Kallweit 356625e992a4SHeiner Kallweit if (phy_configs[tp->mac_version]) 356725e992a4SHeiner Kallweit phy_configs[tp->mac_version](tp); 356825e992a4SHeiner Kallweit } 356925e992a4SHeiner Kallweit 357025e992a4SHeiner Kallweit static void rtl_schedule_task(struct rtl8169_private *tp, enum rtl_flag flag) 357125e992a4SHeiner Kallweit { 357225e992a4SHeiner Kallweit if (!test_and_set_bit(flag, tp->wk.flags)) 357325e992a4SHeiner Kallweit schedule_work(&tp->wk.work); 357425e992a4SHeiner Kallweit } 357525e992a4SHeiner Kallweit 357625e992a4SHeiner Kallweit static void rtl8169_init_phy(struct net_device *dev, struct rtl8169_private *tp) 357725e992a4SHeiner Kallweit { 357825e992a4SHeiner Kallweit rtl_hw_phy_config(dev); 357925e992a4SHeiner Kallweit 358025e992a4SHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) { 358125e992a4SHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_LATENCY_TIMER, 0x40); 358225e992a4SHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_CACHE_LINE_SIZE, 0x08); 358325e992a4SHeiner Kallweit netif_dbg(tp, drv, dev, 358425e992a4SHeiner Kallweit "Set MAC Reg C+CR Offset 0x82h = 0x01h\n"); 358525e992a4SHeiner Kallweit RTL_W8(tp, 0x82, 0x01); 358625e992a4SHeiner Kallweit } 358725e992a4SHeiner Kallweit 358825e992a4SHeiner Kallweit /* We may have called phy_speed_down before */ 358925e992a4SHeiner Kallweit phy_speed_up(tp->phydev); 359025e992a4SHeiner Kallweit 359125e992a4SHeiner Kallweit genphy_soft_reset(tp->phydev); 359225e992a4SHeiner Kallweit } 359325e992a4SHeiner Kallweit 359425e992a4SHeiner Kallweit static void rtl_rar_set(struct rtl8169_private *tp, u8 *addr) 359525e992a4SHeiner Kallweit { 359625e992a4SHeiner Kallweit rtl_lock_work(tp); 359725e992a4SHeiner Kallweit 359825e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 359925e992a4SHeiner Kallweit 360025e992a4SHeiner Kallweit RTL_W32(tp, MAC4, addr[4] | addr[5] << 8); 360125e992a4SHeiner Kallweit RTL_R32(tp, MAC4); 360225e992a4SHeiner Kallweit 360325e992a4SHeiner Kallweit RTL_W32(tp, MAC0, addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24); 360425e992a4SHeiner Kallweit RTL_R32(tp, MAC0); 360525e992a4SHeiner Kallweit 360625e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_34) 360725e992a4SHeiner Kallweit rtl_rar_exgmac_set(tp, addr); 360825e992a4SHeiner Kallweit 360925e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 361025e992a4SHeiner Kallweit 361125e992a4SHeiner Kallweit rtl_unlock_work(tp); 361225e992a4SHeiner Kallweit } 361325e992a4SHeiner Kallweit 361425e992a4SHeiner Kallweit static int rtl_set_mac_address(struct net_device *dev, void *p) 361525e992a4SHeiner Kallweit { 361625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 361725e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 361825e992a4SHeiner Kallweit int ret; 361925e992a4SHeiner Kallweit 362025e992a4SHeiner Kallweit ret = eth_mac_addr(dev, p); 362125e992a4SHeiner Kallweit if (ret) 362225e992a4SHeiner Kallweit return ret; 362325e992a4SHeiner Kallweit 362425e992a4SHeiner Kallweit pm_runtime_get_noresume(d); 362525e992a4SHeiner Kallweit 362625e992a4SHeiner Kallweit if (pm_runtime_active(d)) 362725e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 362825e992a4SHeiner Kallweit 362925e992a4SHeiner Kallweit pm_runtime_put_noidle(d); 363025e992a4SHeiner Kallweit 363125e992a4SHeiner Kallweit return 0; 363225e992a4SHeiner Kallweit } 363325e992a4SHeiner Kallweit 363425e992a4SHeiner Kallweit static int rtl8169_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 363525e992a4SHeiner Kallweit { 363625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 363725e992a4SHeiner Kallweit 363825e992a4SHeiner Kallweit if (!netif_running(dev)) 363925e992a4SHeiner Kallweit return -ENODEV; 364025e992a4SHeiner Kallweit 364125e992a4SHeiner Kallweit return phy_mii_ioctl(tp->phydev, ifr, cmd); 364225e992a4SHeiner Kallweit } 364325e992a4SHeiner Kallweit 364425e992a4SHeiner Kallweit static void rtl_wol_suspend_quirk(struct rtl8169_private *tp) 364525e992a4SHeiner Kallweit { 364625e992a4SHeiner Kallweit switch (tp->mac_version) { 364725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25: 364825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_26: 364925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_29: 365025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_30: 365125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_32: 365225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_33: 365325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 365425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_37 ... RTL_GIGA_MAC_VER_51: 365525e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RTL_R32(tp, RxConfig) | 365625e992a4SHeiner Kallweit AcceptBroadcast | AcceptMulticast | AcceptMyPhys); 365725e992a4SHeiner Kallweit break; 365825e992a4SHeiner Kallweit default: 365925e992a4SHeiner Kallweit break; 366025e992a4SHeiner Kallweit } 366125e992a4SHeiner Kallweit } 366225e992a4SHeiner Kallweit 366325e992a4SHeiner Kallweit static void rtl_pll_power_down(struct rtl8169_private *tp) 366425e992a4SHeiner Kallweit { 366525e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 366625e992a4SHeiner Kallweit return; 366725e992a4SHeiner Kallweit 366825e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_32 || 366925e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_33) 367025e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x19, 0xff64); 367125e992a4SHeiner Kallweit 367225e992a4SHeiner Kallweit if (device_may_wakeup(tp_to_dev(tp))) { 367325e992a4SHeiner Kallweit phy_speed_down(tp->phydev, false); 367425e992a4SHeiner Kallweit rtl_wol_suspend_quirk(tp); 367525e992a4SHeiner Kallweit return; 367625e992a4SHeiner Kallweit } 367725e992a4SHeiner Kallweit 367825e992a4SHeiner Kallweit switch (tp->mac_version) { 367925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33: 368025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_37: 368125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_39: 368225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_43: 368325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_44: 368425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_45: 368525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_46: 368625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_47: 368725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_48: 368825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 368925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 3690f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_60: 3691f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_61: 369225e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) & ~0x80); 369325e992a4SHeiner Kallweit break; 369425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40: 369525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_41: 369625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 369725e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1a8, ERIAR_MASK_1111, 0xfc000000); 369825e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) & ~0x80); 369925e992a4SHeiner Kallweit break; 370025e992a4SHeiner Kallweit default: 370125e992a4SHeiner Kallweit break; 370225e992a4SHeiner Kallweit } 370325e992a4SHeiner Kallweit } 370425e992a4SHeiner Kallweit 370525e992a4SHeiner Kallweit static void rtl_pll_power_up(struct rtl8169_private *tp) 370625e992a4SHeiner Kallweit { 370725e992a4SHeiner Kallweit switch (tp->mac_version) { 370825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_33: 370925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_37: 371025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_39: 371125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_43: 371225e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0x80); 371325e992a4SHeiner Kallweit break; 371425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_44: 371525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_45: 371625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_46: 371725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_47: 371825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_48: 371925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_50: 372025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_51: 3721f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_60: 3722f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_61: 372325e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0xc0); 372425e992a4SHeiner Kallweit break; 372525e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40: 372625e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_41: 372725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49: 372825e992a4SHeiner Kallweit RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) | 0xc0); 372925e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1a8, ERIAR_MASK_1111, 0xfc000000); 373025e992a4SHeiner Kallweit break; 373125e992a4SHeiner Kallweit default: 373225e992a4SHeiner Kallweit break; 373325e992a4SHeiner Kallweit } 373425e992a4SHeiner Kallweit 373525e992a4SHeiner Kallweit phy_resume(tp->phydev); 373625e992a4SHeiner Kallweit /* give MAC/PHY some time to resume */ 373725e992a4SHeiner Kallweit msleep(20); 373825e992a4SHeiner Kallweit } 373925e992a4SHeiner Kallweit 374025e992a4SHeiner Kallweit static void rtl_init_rxcfg(struct rtl8169_private *tp) 374125e992a4SHeiner Kallweit { 374225e992a4SHeiner Kallweit switch (tp->mac_version) { 374325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 374425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_10 ... RTL_GIGA_MAC_VER_17: 374525e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX_FIFO_THRESH | RX_DMA_BURST); 374625e992a4SHeiner Kallweit break; 374725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_24: 374825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34 ... RTL_GIGA_MAC_VER_36: 374925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_38: 375025e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_MULTI_EN | RX_DMA_BURST); 375125e992a4SHeiner Kallweit break; 375225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 375325e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_MULTI_EN | RX_DMA_BURST | RX_EARLY_OFF); 375425e992a4SHeiner Kallweit break; 3755f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_60 ... RTL_GIGA_MAC_VER_61: 3756f1bce4adSHeiner Kallweit RTL_W32(tp, RxConfig, RX_FETCH_DFLT_8125 | RX_VLAN_8125 | 3757f1bce4adSHeiner Kallweit RX_DMA_BURST); 3758f1bce4adSHeiner Kallweit break; 375925e992a4SHeiner Kallweit default: 376025e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RX128_INT_EN | RX_DMA_BURST); 376125e992a4SHeiner Kallweit break; 376225e992a4SHeiner Kallweit } 376325e992a4SHeiner Kallweit } 376425e992a4SHeiner Kallweit 376525e992a4SHeiner Kallweit static void rtl8169_init_ring_indexes(struct rtl8169_private *tp) 376625e992a4SHeiner Kallweit { 376725e992a4SHeiner Kallweit tp->dirty_tx = tp->cur_tx = tp->cur_rx = 0; 376825e992a4SHeiner Kallweit } 376925e992a4SHeiner Kallweit 377025e992a4SHeiner Kallweit static void r8168c_hw_jumbo_enable(struct rtl8169_private *tp) 377125e992a4SHeiner Kallweit { 377225e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 377325e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | Jumbo_En1); 377425e992a4SHeiner Kallweit } 377525e992a4SHeiner Kallweit 377625e992a4SHeiner Kallweit static void r8168c_hw_jumbo_disable(struct rtl8169_private *tp) 377725e992a4SHeiner Kallweit { 377825e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 377925e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~Jumbo_En1); 378025e992a4SHeiner Kallweit } 378125e992a4SHeiner Kallweit 378225e992a4SHeiner Kallweit static void r8168dp_hw_jumbo_enable(struct rtl8169_private *tp) 378325e992a4SHeiner Kallweit { 378425e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 378525e992a4SHeiner Kallweit } 378625e992a4SHeiner Kallweit 378725e992a4SHeiner Kallweit static void r8168dp_hw_jumbo_disable(struct rtl8169_private *tp) 378825e992a4SHeiner Kallweit { 378925e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 379025e992a4SHeiner Kallweit } 379125e992a4SHeiner Kallweit 379225e992a4SHeiner Kallweit static void r8168e_hw_jumbo_enable(struct rtl8169_private *tp) 379325e992a4SHeiner Kallweit { 379425e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, 0x3f); 379525e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) | Jumbo_En0); 379625e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | 0x01); 379725e992a4SHeiner Kallweit } 379825e992a4SHeiner Kallweit 379925e992a4SHeiner Kallweit static void r8168e_hw_jumbo_disable(struct rtl8169_private *tp) 380025e992a4SHeiner Kallweit { 380125e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, 0x0c); 380225e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Jumbo_En0); 380325e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~0x01); 380425e992a4SHeiner Kallweit } 380525e992a4SHeiner Kallweit 380625e992a4SHeiner Kallweit static void r8168b_1_hw_jumbo_enable(struct rtl8169_private *tp) 380725e992a4SHeiner Kallweit { 380825e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) | (1 << 0)); 380925e992a4SHeiner Kallweit } 381025e992a4SHeiner Kallweit 381125e992a4SHeiner Kallweit static void r8168b_1_hw_jumbo_disable(struct rtl8169_private *tp) 381225e992a4SHeiner Kallweit { 381325e992a4SHeiner Kallweit RTL_W8(tp, Config4, RTL_R8(tp, Config4) & ~(1 << 0)); 381425e992a4SHeiner Kallweit } 381525e992a4SHeiner Kallweit 381625e992a4SHeiner Kallweit static void rtl_hw_jumbo_enable(struct rtl8169_private *tp) 381725e992a4SHeiner Kallweit { 381825e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 381925e992a4SHeiner Kallweit switch (tp->mac_version) { 382025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 382125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 382225e992a4SHeiner Kallweit r8168b_1_hw_jumbo_enable(tp); 382325e992a4SHeiner Kallweit break; 382425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_26: 382525e992a4SHeiner Kallweit r8168c_hw_jumbo_enable(tp); 382625e992a4SHeiner Kallweit break; 382725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27 ... RTL_GIGA_MAC_VER_28: 382825e992a4SHeiner Kallweit r8168dp_hw_jumbo_enable(tp); 382925e992a4SHeiner Kallweit break; 383025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31 ... RTL_GIGA_MAC_VER_34: 383125e992a4SHeiner Kallweit r8168e_hw_jumbo_enable(tp); 383225e992a4SHeiner Kallweit break; 383325e992a4SHeiner Kallweit default: 383425e992a4SHeiner Kallweit break; 383525e992a4SHeiner Kallweit } 383625e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 383725e992a4SHeiner Kallweit } 383825e992a4SHeiner Kallweit 383925e992a4SHeiner Kallweit static void rtl_hw_jumbo_disable(struct rtl8169_private *tp) 384025e992a4SHeiner Kallweit { 384125e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 384225e992a4SHeiner Kallweit switch (tp->mac_version) { 384325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 384425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 384525e992a4SHeiner Kallweit r8168b_1_hw_jumbo_disable(tp); 384625e992a4SHeiner Kallweit break; 384725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_26: 384825e992a4SHeiner Kallweit r8168c_hw_jumbo_disable(tp); 384925e992a4SHeiner Kallweit break; 385025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27 ... RTL_GIGA_MAC_VER_28: 385125e992a4SHeiner Kallweit r8168dp_hw_jumbo_disable(tp); 385225e992a4SHeiner Kallweit break; 385325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31 ... RTL_GIGA_MAC_VER_34: 385425e992a4SHeiner Kallweit r8168e_hw_jumbo_disable(tp); 385525e992a4SHeiner Kallweit break; 385625e992a4SHeiner Kallweit default: 385725e992a4SHeiner Kallweit break; 385825e992a4SHeiner Kallweit } 385925e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 386025e992a4SHeiner Kallweit } 386125e992a4SHeiner Kallweit 38624ebcb113SHeiner Kallweit static void rtl_jumbo_config(struct rtl8169_private *tp, int mtu) 38634ebcb113SHeiner Kallweit { 38644ebcb113SHeiner Kallweit if (mtu > ETH_DATA_LEN) 38654ebcb113SHeiner Kallweit rtl_hw_jumbo_enable(tp); 38664ebcb113SHeiner Kallweit else 38674ebcb113SHeiner Kallweit rtl_hw_jumbo_disable(tp); 38684ebcb113SHeiner Kallweit } 38694ebcb113SHeiner Kallweit 387025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_chipcmd_cond) 387125e992a4SHeiner Kallweit { 387225e992a4SHeiner Kallweit return RTL_R8(tp, ChipCmd) & CmdReset; 387325e992a4SHeiner Kallweit } 387425e992a4SHeiner Kallweit 387525e992a4SHeiner Kallweit static void rtl_hw_reset(struct rtl8169_private *tp) 387625e992a4SHeiner Kallweit { 387725e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, CmdReset); 387825e992a4SHeiner Kallweit 387925e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_chipcmd_cond, 100, 100); 388025e992a4SHeiner Kallweit } 388125e992a4SHeiner Kallweit 388225e992a4SHeiner Kallweit static void rtl_request_firmware(struct rtl8169_private *tp) 388325e992a4SHeiner Kallweit { 388425e992a4SHeiner Kallweit struct rtl_fw *rtl_fw; 388525e992a4SHeiner Kallweit 388625e992a4SHeiner Kallweit /* firmware loaded already or no firmware available */ 388725e992a4SHeiner Kallweit if (tp->rtl_fw || !tp->fw_name) 388825e992a4SHeiner Kallweit return; 388925e992a4SHeiner Kallweit 389025e992a4SHeiner Kallweit rtl_fw = kzalloc(sizeof(*rtl_fw), GFP_KERNEL); 389125e992a4SHeiner Kallweit if (!rtl_fw) { 389225e992a4SHeiner Kallweit netif_warn(tp, ifup, tp->dev, "Unable to load firmware, out of memory\n"); 389325e992a4SHeiner Kallweit return; 389425e992a4SHeiner Kallweit } 389525e992a4SHeiner Kallweit 389625e992a4SHeiner Kallweit rtl_fw->phy_write = rtl_writephy; 389725e992a4SHeiner Kallweit rtl_fw->phy_read = rtl_readphy; 389825e992a4SHeiner Kallweit rtl_fw->mac_mcu_write = mac_mcu_write; 389925e992a4SHeiner Kallweit rtl_fw->mac_mcu_read = mac_mcu_read; 390025e992a4SHeiner Kallweit rtl_fw->fw_name = tp->fw_name; 390125e992a4SHeiner Kallweit rtl_fw->dev = tp_to_dev(tp); 390225e992a4SHeiner Kallweit 390325e992a4SHeiner Kallweit if (rtl_fw_request_firmware(rtl_fw)) 390425e992a4SHeiner Kallweit kfree(rtl_fw); 390525e992a4SHeiner Kallweit else 390625e992a4SHeiner Kallweit tp->rtl_fw = rtl_fw; 390725e992a4SHeiner Kallweit } 390825e992a4SHeiner Kallweit 390925e992a4SHeiner Kallweit static void rtl_rx_close(struct rtl8169_private *tp) 391025e992a4SHeiner Kallweit { 391125e992a4SHeiner Kallweit RTL_W32(tp, RxConfig, RTL_R32(tp, RxConfig) & ~RX_CONFIG_ACCEPT_MASK); 391225e992a4SHeiner Kallweit } 391325e992a4SHeiner Kallweit 391425e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_npq_cond) 391525e992a4SHeiner Kallweit { 391625e992a4SHeiner Kallweit return RTL_R8(tp, TxPoll) & NPQ; 391725e992a4SHeiner Kallweit } 391825e992a4SHeiner Kallweit 391925e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_txcfg_empty_cond) 392025e992a4SHeiner Kallweit { 392125e992a4SHeiner Kallweit return RTL_R32(tp, TxConfig) & TXCFG_EMPTY; 392225e992a4SHeiner Kallweit } 392325e992a4SHeiner Kallweit 392425e992a4SHeiner Kallweit static void rtl8169_hw_reset(struct rtl8169_private *tp) 392525e992a4SHeiner Kallweit { 392625e992a4SHeiner Kallweit /* Disable interrupts */ 392725e992a4SHeiner Kallweit rtl8169_irq_mask_and_ack(tp); 392825e992a4SHeiner Kallweit 392925e992a4SHeiner Kallweit rtl_rx_close(tp); 393025e992a4SHeiner Kallweit 393125e992a4SHeiner Kallweit switch (tp->mac_version) { 393225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_27: 393325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_28: 393425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_31: 393525e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_npq_cond, 20, 42*42); 393625e992a4SHeiner Kallweit break; 393725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_34 ... RTL_GIGA_MAC_VER_38: 393825e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_51: 393925e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) | StopReq); 394025e992a4SHeiner Kallweit rtl_udelay_loop_wait_high(tp, &rtl_txcfg_empty_cond, 100, 666); 394125e992a4SHeiner Kallweit break; 394225e992a4SHeiner Kallweit default: 394325e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) | StopReq); 394425e992a4SHeiner Kallweit udelay(100); 394525e992a4SHeiner Kallweit break; 394625e992a4SHeiner Kallweit } 394725e992a4SHeiner Kallweit 394825e992a4SHeiner Kallweit rtl_hw_reset(tp); 394925e992a4SHeiner Kallweit } 395025e992a4SHeiner Kallweit 395125e992a4SHeiner Kallweit static void rtl_set_tx_config_registers(struct rtl8169_private *tp) 395225e992a4SHeiner Kallweit { 395325e992a4SHeiner Kallweit u32 val = TX_DMA_BURST << TxDMAShift | 395425e992a4SHeiner Kallweit InterFrameGap << TxInterFrameGapShift; 395525e992a4SHeiner Kallweit 39569e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp)) 395725e992a4SHeiner Kallweit val |= TXCFG_AUTO_FIFO; 395825e992a4SHeiner Kallweit 395925e992a4SHeiner Kallweit RTL_W32(tp, TxConfig, val); 396025e992a4SHeiner Kallweit } 396125e992a4SHeiner Kallweit 396225e992a4SHeiner Kallweit static void rtl_set_rx_max_size(struct rtl8169_private *tp) 396325e992a4SHeiner Kallweit { 396425e992a4SHeiner Kallweit /* Low hurts. Let's disable the filtering. */ 396525e992a4SHeiner Kallweit RTL_W16(tp, RxMaxSize, R8169_RX_BUF_SIZE + 1); 396625e992a4SHeiner Kallweit } 396725e992a4SHeiner Kallweit 396825e992a4SHeiner Kallweit static void rtl_set_rx_tx_desc_registers(struct rtl8169_private *tp) 396925e992a4SHeiner Kallweit { 397025e992a4SHeiner Kallweit /* 397125e992a4SHeiner Kallweit * Magic spell: some iop3xx ARM board needs the TxDescAddrHigh 397225e992a4SHeiner Kallweit * register to be written before TxDescAddrLow to work. 397325e992a4SHeiner Kallweit * Switching from MMIO to I/O access fixes the issue as well. 397425e992a4SHeiner Kallweit */ 397525e992a4SHeiner Kallweit RTL_W32(tp, TxDescStartAddrHigh, ((u64) tp->TxPhyAddr) >> 32); 397625e992a4SHeiner Kallweit RTL_W32(tp, TxDescStartAddrLow, ((u64) tp->TxPhyAddr) & DMA_BIT_MASK(32)); 397725e992a4SHeiner Kallweit RTL_W32(tp, RxDescAddrHigh, ((u64) tp->RxPhyAddr) >> 32); 397825e992a4SHeiner Kallweit RTL_W32(tp, RxDescAddrLow, ((u64) tp->RxPhyAddr) & DMA_BIT_MASK(32)); 397925e992a4SHeiner Kallweit } 398025e992a4SHeiner Kallweit 398125e992a4SHeiner Kallweit static void rtl8169_set_magic_reg(struct rtl8169_private *tp, unsigned mac_version) 398225e992a4SHeiner Kallweit { 398325e992a4SHeiner Kallweit u32 val; 398425e992a4SHeiner Kallweit 398525e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 398625e992a4SHeiner Kallweit val = 0x000fff00; 398725e992a4SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_06) 398825e992a4SHeiner Kallweit val = 0x00ffff00; 398925e992a4SHeiner Kallweit else 399025e992a4SHeiner Kallweit return; 399125e992a4SHeiner Kallweit 399225e992a4SHeiner Kallweit if (RTL_R8(tp, Config2) & PCI_Clock_66MHz) 399325e992a4SHeiner Kallweit val |= 0xff; 399425e992a4SHeiner Kallweit 399525e992a4SHeiner Kallweit RTL_W32(tp, 0x7c, val); 399625e992a4SHeiner Kallweit } 399725e992a4SHeiner Kallweit 399825e992a4SHeiner Kallweit static void rtl_set_rx_mode(struct net_device *dev) 399925e992a4SHeiner Kallweit { 400081cd17a4SHeiner Kallweit u32 rx_mode = AcceptBroadcast | AcceptMyPhys | AcceptMulticast; 400181cd17a4SHeiner Kallweit /* Multicast hash filter */ 400281cd17a4SHeiner Kallweit u32 mc_filter[2] = { 0xffffffff, 0xffffffff }; 400325e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 400481cd17a4SHeiner Kallweit u32 tmp; 400525e992a4SHeiner Kallweit 400625e992a4SHeiner Kallweit if (dev->flags & IFF_PROMISC) { 400725e992a4SHeiner Kallweit /* Unconditionally log net taps. */ 400825e992a4SHeiner Kallweit netif_notice(tp, link, dev, "Promiscuous mode enabled\n"); 400981cd17a4SHeiner Kallweit rx_mode |= AcceptAllPhys; 401081cd17a4SHeiner Kallweit } else if (netdev_mc_count(dev) > MC_FILTER_LIMIT || 401181cd17a4SHeiner Kallweit dev->flags & IFF_ALLMULTI || 401281cd17a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_35) { 401381cd17a4SHeiner Kallweit /* accept all multicasts */ 401481cd17a4SHeiner Kallweit } else if (netdev_mc_empty(dev)) { 401581cd17a4SHeiner Kallweit rx_mode &= ~AcceptMulticast; 401625e992a4SHeiner Kallweit } else { 401725e992a4SHeiner Kallweit struct netdev_hw_addr *ha; 401825e992a4SHeiner Kallweit 401925e992a4SHeiner Kallweit mc_filter[1] = mc_filter[0] = 0; 402025e992a4SHeiner Kallweit netdev_for_each_mc_addr(ha, dev) { 402181cd17a4SHeiner Kallweit u32 bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26; 402281cd17a4SHeiner Kallweit mc_filter[bit_nr >> 5] |= BIT(bit_nr & 31); 402381cd17a4SHeiner Kallweit } 402481cd17a4SHeiner Kallweit 402581cd17a4SHeiner Kallweit if (tp->mac_version > RTL_GIGA_MAC_VER_06) { 402681cd17a4SHeiner Kallweit tmp = mc_filter[0]; 402781cd17a4SHeiner Kallweit mc_filter[0] = swab32(mc_filter[1]); 402881cd17a4SHeiner Kallweit mc_filter[1] = swab32(tmp); 402925e992a4SHeiner Kallweit } 403025e992a4SHeiner Kallweit } 403125e992a4SHeiner Kallweit 403225e992a4SHeiner Kallweit if (dev->features & NETIF_F_RXALL) 403325e992a4SHeiner Kallweit rx_mode |= (AcceptErr | AcceptRunt); 403425e992a4SHeiner Kallweit 403525e992a4SHeiner Kallweit RTL_W32(tp, MAR0 + 4, mc_filter[1]); 403625e992a4SHeiner Kallweit RTL_W32(tp, MAR0 + 0, mc_filter[0]); 403725e992a4SHeiner Kallweit 403881cd17a4SHeiner Kallweit tmp = RTL_R32(tp, RxConfig); 403981cd17a4SHeiner Kallweit RTL_W32(tp, RxConfig, (tmp & ~RX_CONFIG_ACCEPT_MASK) | rx_mode); 404025e992a4SHeiner Kallweit } 404125e992a4SHeiner Kallweit 404225e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_csiar_cond) 404325e992a4SHeiner Kallweit { 404425e992a4SHeiner Kallweit return RTL_R32(tp, CSIAR) & CSIAR_FLAG; 404525e992a4SHeiner Kallweit } 404625e992a4SHeiner Kallweit 404725e992a4SHeiner Kallweit static void rtl_csi_write(struct rtl8169_private *tp, int addr, int value) 404825e992a4SHeiner Kallweit { 404925e992a4SHeiner Kallweit u32 func = PCI_FUNC(tp->pci_dev->devfn); 405025e992a4SHeiner Kallweit 405125e992a4SHeiner Kallweit RTL_W32(tp, CSIDR, value); 405225e992a4SHeiner Kallweit RTL_W32(tp, CSIAR, CSIAR_WRITE_CMD | (addr & CSIAR_ADDR_MASK) | 405325e992a4SHeiner Kallweit CSIAR_BYTE_ENABLE | func << 16); 405425e992a4SHeiner Kallweit 405525e992a4SHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_csiar_cond, 10, 100); 405625e992a4SHeiner Kallweit } 405725e992a4SHeiner Kallweit 405825e992a4SHeiner Kallweit static u32 rtl_csi_read(struct rtl8169_private *tp, int addr) 405925e992a4SHeiner Kallweit { 406025e992a4SHeiner Kallweit u32 func = PCI_FUNC(tp->pci_dev->devfn); 406125e992a4SHeiner Kallweit 406225e992a4SHeiner Kallweit RTL_W32(tp, CSIAR, (addr & CSIAR_ADDR_MASK) | func << 16 | 406325e992a4SHeiner Kallweit CSIAR_BYTE_ENABLE); 406425e992a4SHeiner Kallweit 406525e992a4SHeiner Kallweit return rtl_udelay_loop_wait_high(tp, &rtl_csiar_cond, 10, 100) ? 406625e992a4SHeiner Kallweit RTL_R32(tp, CSIDR) : ~0; 406725e992a4SHeiner Kallweit } 406825e992a4SHeiner Kallweit 406925e992a4SHeiner Kallweit static void rtl_csi_access_enable(struct rtl8169_private *tp, u8 val) 407025e992a4SHeiner Kallweit { 407125e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 407225e992a4SHeiner Kallweit u32 csi; 407325e992a4SHeiner Kallweit 407425e992a4SHeiner Kallweit /* According to Realtek the value at config space address 0x070f 407525e992a4SHeiner Kallweit * controls the L0s/L1 entrance latency. We try standard ECAM access 407625e992a4SHeiner Kallweit * first and if it fails fall back to CSI. 407725e992a4SHeiner Kallweit */ 407825e992a4SHeiner Kallweit if (pdev->cfg_size > 0x070f && 407925e992a4SHeiner Kallweit pci_write_config_byte(pdev, 0x070f, val) == PCIBIOS_SUCCESSFUL) 408025e992a4SHeiner Kallweit return; 408125e992a4SHeiner Kallweit 408225e992a4SHeiner Kallweit netdev_notice_once(tp->dev, 408325e992a4SHeiner Kallweit "No native access to PCI extended config space, falling back to CSI\n"); 408425e992a4SHeiner Kallweit csi = rtl_csi_read(tp, 0x070c) & 0x00ffffff; 408525e992a4SHeiner Kallweit rtl_csi_write(tp, 0x070c, csi | val << 24); 408625e992a4SHeiner Kallweit } 408725e992a4SHeiner Kallweit 408825e992a4SHeiner Kallweit static void rtl_set_def_aspm_entry_latency(struct rtl8169_private *tp) 408925e992a4SHeiner Kallweit { 409025e992a4SHeiner Kallweit rtl_csi_access_enable(tp, 0x27); 409125e992a4SHeiner Kallweit } 409225e992a4SHeiner Kallweit 409325e992a4SHeiner Kallweit struct ephy_info { 409425e992a4SHeiner Kallweit unsigned int offset; 409525e992a4SHeiner Kallweit u16 mask; 409625e992a4SHeiner Kallweit u16 bits; 409725e992a4SHeiner Kallweit }; 409825e992a4SHeiner Kallweit 409925e992a4SHeiner Kallweit static void __rtl_ephy_init(struct rtl8169_private *tp, 410025e992a4SHeiner Kallweit const struct ephy_info *e, int len) 410125e992a4SHeiner Kallweit { 410225e992a4SHeiner Kallweit u16 w; 410325e992a4SHeiner Kallweit 410425e992a4SHeiner Kallweit while (len-- > 0) { 410525e992a4SHeiner Kallweit w = (rtl_ephy_read(tp, e->offset) & ~e->mask) | e->bits; 410625e992a4SHeiner Kallweit rtl_ephy_write(tp, e->offset, w); 410725e992a4SHeiner Kallweit e++; 410825e992a4SHeiner Kallweit } 410925e992a4SHeiner Kallweit } 411025e992a4SHeiner Kallweit 411125e992a4SHeiner Kallweit #define rtl_ephy_init(tp, a) __rtl_ephy_init(tp, a, ARRAY_SIZE(a)) 411225e992a4SHeiner Kallweit 411325e992a4SHeiner Kallweit static void rtl_disable_clock_request(struct rtl8169_private *tp) 411425e992a4SHeiner Kallweit { 411525e992a4SHeiner Kallweit pcie_capability_clear_word(tp->pci_dev, PCI_EXP_LNKCTL, 411625e992a4SHeiner Kallweit PCI_EXP_LNKCTL_CLKREQ_EN); 411725e992a4SHeiner Kallweit } 411825e992a4SHeiner Kallweit 411925e992a4SHeiner Kallweit static void rtl_enable_clock_request(struct rtl8169_private *tp) 412025e992a4SHeiner Kallweit { 412125e992a4SHeiner Kallweit pcie_capability_set_word(tp->pci_dev, PCI_EXP_LNKCTL, 412225e992a4SHeiner Kallweit PCI_EXP_LNKCTL_CLKREQ_EN); 412325e992a4SHeiner Kallweit } 412425e992a4SHeiner Kallweit 412525e992a4SHeiner Kallweit static void rtl_pcie_state_l2l3_disable(struct rtl8169_private *tp) 412625e992a4SHeiner Kallweit { 412725e992a4SHeiner Kallweit /* work around an issue when PCI reset occurs during L2/L3 state */ 412825e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Rdy_to_L23); 412925e992a4SHeiner Kallweit } 413025e992a4SHeiner Kallweit 413125e992a4SHeiner Kallweit static void rtl_hw_aspm_clkreq_enable(struct rtl8169_private *tp, bool enable) 413225e992a4SHeiner Kallweit { 413362b1b3b3SHeiner Kallweit /* Don't enable ASPM in the chip if OS can't control ASPM */ 413462b1b3b3SHeiner Kallweit if (enable && tp->aspm_manageable) { 413525e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) | ASPM_en); 413625e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) | ClkReqEn); 413725e992a4SHeiner Kallweit } else { 413825e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~ClkReqEn); 413925e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~ASPM_en); 414025e992a4SHeiner Kallweit } 414125e992a4SHeiner Kallweit 414225e992a4SHeiner Kallweit udelay(10); 414325e992a4SHeiner Kallweit } 414425e992a4SHeiner Kallweit 414525e992a4SHeiner Kallweit static void rtl_set_fifo_size(struct rtl8169_private *tp, u16 rx_stat, 414625e992a4SHeiner Kallweit u16 tx_stat, u16 rx_dyn, u16 tx_dyn) 414725e992a4SHeiner Kallweit { 414825e992a4SHeiner Kallweit /* Usage of dynamic vs. static FIFO is controlled by bit 414925e992a4SHeiner Kallweit * TXCFG_AUTO_FIFO. Exact meaning of FIFO values isn't known. 415025e992a4SHeiner Kallweit */ 415125e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc8, ERIAR_MASK_1111, (rx_stat << 16) | rx_dyn); 415225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xe8, ERIAR_MASK_1111, (tx_stat << 16) | tx_dyn); 415325e992a4SHeiner Kallweit } 415425e992a4SHeiner Kallweit 415525e992a4SHeiner Kallweit static void rtl8168g_set_pause_thresholds(struct rtl8169_private *tp, 415625e992a4SHeiner Kallweit u8 low, u8 high) 415725e992a4SHeiner Kallweit { 415825e992a4SHeiner Kallweit /* FIFO thresholds for pause flow control */ 415925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_0001, low); 416025e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_0001, high); 416125e992a4SHeiner Kallweit } 416225e992a4SHeiner Kallweit 416394b5ff74SHeiner Kallweit static void rtl_hw_start_8168b(struct rtl8169_private *tp) 416425e992a4SHeiner Kallweit { 416525e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 416625e992a4SHeiner Kallweit } 416725e992a4SHeiner Kallweit 416825e992a4SHeiner Kallweit static void __rtl_hw_start_8168cp(struct rtl8169_private *tp) 416925e992a4SHeiner Kallweit { 417025e992a4SHeiner Kallweit RTL_W8(tp, Config1, RTL_R8(tp, Config1) | Speed_down); 417125e992a4SHeiner Kallweit 417225e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 417325e992a4SHeiner Kallweit 417425e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 417525e992a4SHeiner Kallweit } 417625e992a4SHeiner Kallweit 417725e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_1(struct rtl8169_private *tp) 417825e992a4SHeiner Kallweit { 417925e992a4SHeiner Kallweit static const struct ephy_info e_info_8168cp[] = { 418025e992a4SHeiner Kallweit { 0x01, 0, 0x0001 }, 418125e992a4SHeiner Kallweit { 0x02, 0x0800, 0x1000 }, 418225e992a4SHeiner Kallweit { 0x03, 0, 0x0042 }, 418325e992a4SHeiner Kallweit { 0x06, 0x0080, 0x0000 }, 418425e992a4SHeiner Kallweit { 0x07, 0, 0x2000 } 418525e992a4SHeiner Kallweit }; 418625e992a4SHeiner Kallweit 418725e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 418825e992a4SHeiner Kallweit 418925e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168cp); 419025e992a4SHeiner Kallweit 419125e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 419225e992a4SHeiner Kallweit } 419325e992a4SHeiner Kallweit 419425e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_2(struct rtl8169_private *tp) 419525e992a4SHeiner Kallweit { 419625e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 419725e992a4SHeiner Kallweit 419825e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 419925e992a4SHeiner Kallweit } 420025e992a4SHeiner Kallweit 420125e992a4SHeiner Kallweit static void rtl_hw_start_8168cp_3(struct rtl8169_private *tp) 420225e992a4SHeiner Kallweit { 420325e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 420425e992a4SHeiner Kallweit 420525e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 420625e992a4SHeiner Kallweit 420725e992a4SHeiner Kallweit /* Magic. */ 420825e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, 0x20); 420925e992a4SHeiner Kallweit } 421025e992a4SHeiner Kallweit 421125e992a4SHeiner Kallweit static void rtl_hw_start_8168c_1(struct rtl8169_private *tp) 421225e992a4SHeiner Kallweit { 421325e992a4SHeiner Kallweit static const struct ephy_info e_info_8168c_1[] = { 421425e992a4SHeiner Kallweit { 0x02, 0x0800, 0x1000 }, 421525e992a4SHeiner Kallweit { 0x03, 0, 0x0002 }, 421625e992a4SHeiner Kallweit { 0x06, 0x0080, 0x0000 } 421725e992a4SHeiner Kallweit }; 421825e992a4SHeiner Kallweit 421925e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 422025e992a4SHeiner Kallweit 422125e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, 0x06 | FIX_NAK_1 | FIX_NAK_2); 422225e992a4SHeiner Kallweit 422325e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168c_1); 422425e992a4SHeiner Kallweit 422525e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 422625e992a4SHeiner Kallweit } 422725e992a4SHeiner Kallweit 422825e992a4SHeiner Kallweit static void rtl_hw_start_8168c_2(struct rtl8169_private *tp) 422925e992a4SHeiner Kallweit { 423025e992a4SHeiner Kallweit static const struct ephy_info e_info_8168c_2[] = { 423125e992a4SHeiner Kallweit { 0x01, 0, 0x0001 }, 4232a7a92cf8SHeiner Kallweit { 0x03, 0x0400, 0x0020 } 423325e992a4SHeiner Kallweit }; 423425e992a4SHeiner Kallweit 423525e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 423625e992a4SHeiner Kallweit 423725e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168c_2); 423825e992a4SHeiner Kallweit 423925e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 424025e992a4SHeiner Kallweit } 424125e992a4SHeiner Kallweit 424225e992a4SHeiner Kallweit static void rtl_hw_start_8168c_3(struct rtl8169_private *tp) 424325e992a4SHeiner Kallweit { 424425e992a4SHeiner Kallweit rtl_hw_start_8168c_2(tp); 424525e992a4SHeiner Kallweit } 424625e992a4SHeiner Kallweit 424725e992a4SHeiner Kallweit static void rtl_hw_start_8168c_4(struct rtl8169_private *tp) 424825e992a4SHeiner Kallweit { 424925e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 425025e992a4SHeiner Kallweit 425125e992a4SHeiner Kallweit __rtl_hw_start_8168cp(tp); 425225e992a4SHeiner Kallweit } 425325e992a4SHeiner Kallweit 425425e992a4SHeiner Kallweit static void rtl_hw_start_8168d(struct rtl8169_private *tp) 425525e992a4SHeiner Kallweit { 425625e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 425725e992a4SHeiner Kallweit 425825e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 425925e992a4SHeiner Kallweit } 426025e992a4SHeiner Kallweit 426125e992a4SHeiner Kallweit static void rtl_hw_start_8168d_4(struct rtl8169_private *tp) 426225e992a4SHeiner Kallweit { 426325e992a4SHeiner Kallweit static const struct ephy_info e_info_8168d_4[] = { 426425e992a4SHeiner Kallweit { 0x0b, 0x0000, 0x0048 }, 426525e992a4SHeiner Kallweit { 0x19, 0x0020, 0x0050 }, 4266a7a92cf8SHeiner Kallweit { 0x0c, 0x0100, 0x0020 }, 4267a7a92cf8SHeiner Kallweit { 0x10, 0x0004, 0x0000 }, 426825e992a4SHeiner Kallweit }; 426925e992a4SHeiner Kallweit 427025e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 427125e992a4SHeiner Kallweit 427225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168d_4); 427325e992a4SHeiner Kallweit 427425e992a4SHeiner Kallweit rtl_enable_clock_request(tp); 427525e992a4SHeiner Kallweit } 427625e992a4SHeiner Kallweit 427725e992a4SHeiner Kallweit static void rtl_hw_start_8168e_1(struct rtl8169_private *tp) 427825e992a4SHeiner Kallweit { 427925e992a4SHeiner Kallweit static const struct ephy_info e_info_8168e_1[] = { 428025e992a4SHeiner Kallweit { 0x00, 0x0200, 0x0100 }, 428125e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 428225e992a4SHeiner Kallweit { 0x06, 0x0002, 0x0001 }, 428325e992a4SHeiner Kallweit { 0x06, 0x0000, 0x0030 }, 428425e992a4SHeiner Kallweit { 0x07, 0x0000, 0x2000 }, 428525e992a4SHeiner Kallweit { 0x00, 0x0000, 0x0020 }, 428625e992a4SHeiner Kallweit { 0x03, 0x5800, 0x2000 }, 428725e992a4SHeiner Kallweit { 0x03, 0x0000, 0x0001 }, 428825e992a4SHeiner Kallweit { 0x01, 0x0800, 0x1000 }, 428925e992a4SHeiner Kallweit { 0x07, 0x0000, 0x4000 }, 429025e992a4SHeiner Kallweit { 0x1e, 0x0000, 0x2000 }, 429125e992a4SHeiner Kallweit { 0x19, 0xffff, 0xfe6c }, 429225e992a4SHeiner Kallweit { 0x0a, 0x0000, 0x0040 } 429325e992a4SHeiner Kallweit }; 429425e992a4SHeiner Kallweit 429525e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 429625e992a4SHeiner Kallweit 429725e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168e_1); 429825e992a4SHeiner Kallweit 429925e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 430025e992a4SHeiner Kallweit 430125e992a4SHeiner Kallweit /* Reset tx FIFO pointer */ 430225e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | TXPLA_RST); 430325e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~TXPLA_RST); 430425e992a4SHeiner Kallweit 430525e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 430625e992a4SHeiner Kallweit } 430725e992a4SHeiner Kallweit 430825e992a4SHeiner Kallweit static void rtl_hw_start_8168e_2(struct rtl8169_private *tp) 430925e992a4SHeiner Kallweit { 431025e992a4SHeiner Kallweit static const struct ephy_info e_info_8168e_2[] = { 431125e992a4SHeiner Kallweit { 0x09, 0x0000, 0x0080 }, 4312a7a92cf8SHeiner Kallweit { 0x19, 0x0000, 0x0224 }, 4313a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 4314a7a92cf8SHeiner Kallweit { 0x0c, 0x3df0, 0x0200 }, 431525e992a4SHeiner Kallweit }; 431625e992a4SHeiner Kallweit 431725e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 431825e992a4SHeiner Kallweit 431925e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168e_2); 432025e992a4SHeiner Kallweit 432125e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 432225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 432325e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x10, 0x10, 0x02, 0x06); 432425e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_1111, 0x00000050); 432525e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_1111, 0x07ff0060); 432625e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_0001, BIT(4)); 432725e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00, 0xff00); 432825e992a4SHeiner Kallweit 432925e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 433025e992a4SHeiner Kallweit 433125e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 433225e992a4SHeiner Kallweit 433325e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 433425e992a4SHeiner Kallweit 433525e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 433625e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | PWM_EN); 433725e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 433825e992a4SHeiner Kallweit 433925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 434025e992a4SHeiner Kallweit } 434125e992a4SHeiner Kallweit 434225e992a4SHeiner Kallweit static void rtl_hw_start_8168f(struct rtl8169_private *tp) 434325e992a4SHeiner Kallweit { 434425e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 434525e992a4SHeiner Kallweit 434625e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 434725e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 434825e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x10, 0x10, 0x02, 0x06); 434925e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 435025e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1b0, ERIAR_MASK_0001, BIT(4)); 435125e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x1d0, ERIAR_MASK_0001, BIT(4)); 435225e992a4SHeiner Kallweit rtl_eri_write(tp, 0xcc, ERIAR_MASK_1111, 0x00000050); 435325e992a4SHeiner Kallweit rtl_eri_write(tp, 0xd0, ERIAR_MASK_1111, 0x00000060); 435425e992a4SHeiner Kallweit 435525e992a4SHeiner Kallweit rtl_disable_clock_request(tp); 435625e992a4SHeiner Kallweit 435725e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 435825e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 435925e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | PWM_EN); 436025e992a4SHeiner Kallweit RTL_W8(tp, Config5, RTL_R8(tp, Config5) & ~Spi_en); 436125e992a4SHeiner Kallweit 436225e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 436325e992a4SHeiner Kallweit } 436425e992a4SHeiner Kallweit 436525e992a4SHeiner Kallweit static void rtl_hw_start_8168f_1(struct rtl8169_private *tp) 436625e992a4SHeiner Kallweit { 436725e992a4SHeiner Kallweit static const struct ephy_info e_info_8168f_1[] = { 436825e992a4SHeiner Kallweit { 0x06, 0x00c0, 0x0020 }, 436925e992a4SHeiner Kallweit { 0x08, 0x0001, 0x0002 }, 437025e992a4SHeiner Kallweit { 0x09, 0x0000, 0x0080 }, 4371a7a92cf8SHeiner Kallweit { 0x19, 0x0000, 0x0224 }, 4372a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 4373a7a92cf8SHeiner Kallweit { 0x0c, 0x3df0, 0x0200 }, 437425e992a4SHeiner Kallweit }; 437525e992a4SHeiner Kallweit 437625e992a4SHeiner Kallweit rtl_hw_start_8168f(tp); 437725e992a4SHeiner Kallweit 437825e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168f_1); 437925e992a4SHeiner Kallweit 438025e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00, 0xff00); 438125e992a4SHeiner Kallweit } 438225e992a4SHeiner Kallweit 438325e992a4SHeiner Kallweit static void rtl_hw_start_8411(struct rtl8169_private *tp) 438425e992a4SHeiner Kallweit { 438525e992a4SHeiner Kallweit static const struct ephy_info e_info_8168f_1[] = { 438625e992a4SHeiner Kallweit { 0x06, 0x00c0, 0x0020 }, 438725e992a4SHeiner Kallweit { 0x0f, 0xffff, 0x5200 }, 4388a7a92cf8SHeiner Kallweit { 0x19, 0x0000, 0x0224 }, 4389a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0004 }, 4390a7a92cf8SHeiner Kallweit { 0x0c, 0x3df0, 0x0200 }, 439125e992a4SHeiner Kallweit }; 439225e992a4SHeiner Kallweit 439325e992a4SHeiner Kallweit rtl_hw_start_8168f(tp); 439425e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 439525e992a4SHeiner Kallweit 439625e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168f_1); 439725e992a4SHeiner Kallweit 439825e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0x0d4, ERIAR_MASK_0011, 0x0c00); 439925e992a4SHeiner Kallweit } 440025e992a4SHeiner Kallweit 440125e992a4SHeiner Kallweit static void rtl_hw_start_8168g(struct rtl8169_private *tp) 440225e992a4SHeiner Kallweit { 440325e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 440425e992a4SHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x38, 0x48); 440525e992a4SHeiner Kallweit 440625e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 440725e992a4SHeiner Kallweit 440825e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 440925e992a4SHeiner Kallweit rtl_eri_write(tp, 0x2f8, ERIAR_MASK_0011, 0x1d8f); 441025e992a4SHeiner Kallweit 441125e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 441225e992a4SHeiner Kallweit 441325e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 441425e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 441525e992a4SHeiner Kallweit 441625e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 441725e992a4SHeiner Kallweit 441825e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x2fc, ERIAR_MASK_0001, 0x01, 0x06); 441925e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1b0, ERIAR_MASK_0011, BIT(12)); 442025e992a4SHeiner Kallweit 442125e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 442225e992a4SHeiner Kallweit } 442325e992a4SHeiner Kallweit 442425e992a4SHeiner Kallweit static void rtl_hw_start_8168g_1(struct rtl8169_private *tp) 442525e992a4SHeiner Kallweit { 442625e992a4SHeiner Kallweit static const struct ephy_info e_info_8168g_1[] = { 4427a7a92cf8SHeiner Kallweit { 0x00, 0x0008, 0x0000 }, 4428a7a92cf8SHeiner Kallweit { 0x0c, 0x3ff0, 0x0820 }, 442925e992a4SHeiner Kallweit { 0x1e, 0x0000, 0x0001 }, 443025e992a4SHeiner Kallweit { 0x19, 0x8000, 0x0000 } 443125e992a4SHeiner Kallweit }; 443225e992a4SHeiner Kallweit 443325e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 443425e992a4SHeiner Kallweit 443525e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 443625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 443725e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168g_1); 443825e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 443925e992a4SHeiner Kallweit } 444025e992a4SHeiner Kallweit 444125e992a4SHeiner Kallweit static void rtl_hw_start_8168g_2(struct rtl8169_private *tp) 444225e992a4SHeiner Kallweit { 444325e992a4SHeiner Kallweit static const struct ephy_info e_info_8168g_2[] = { 4444a7a92cf8SHeiner Kallweit { 0x00, 0x0008, 0x0000 }, 4445a7a92cf8SHeiner Kallweit { 0x0c, 0x3ff0, 0x0820 }, 4446a7a92cf8SHeiner Kallweit { 0x19, 0xffff, 0x7c00 }, 4447a7a92cf8SHeiner Kallweit { 0x1e, 0xffff, 0x20eb }, 4448a7a92cf8SHeiner Kallweit { 0x0d, 0xffff, 0x1666 }, 4449a7a92cf8SHeiner Kallweit { 0x00, 0xffff, 0x10a3 }, 4450a7a92cf8SHeiner Kallweit { 0x06, 0xffff, 0xf050 }, 4451a7a92cf8SHeiner Kallweit { 0x04, 0x0000, 0x0010 }, 4452a7a92cf8SHeiner Kallweit { 0x1d, 0x4000, 0x0000 }, 445325e992a4SHeiner Kallweit }; 445425e992a4SHeiner Kallweit 445525e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 445625e992a4SHeiner Kallweit 445725e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 4458ebdcebcbSHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 445925e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168g_2); 446025e992a4SHeiner Kallweit } 446125e992a4SHeiner Kallweit 446225e992a4SHeiner Kallweit static void rtl_hw_start_8411_2(struct rtl8169_private *tp) 446325e992a4SHeiner Kallweit { 446425e992a4SHeiner Kallweit static const struct ephy_info e_info_8411_2[] = { 4465a7a92cf8SHeiner Kallweit { 0x00, 0x0008, 0x0000 }, 4466a7a92cf8SHeiner Kallweit { 0x0c, 0x37d0, 0x0820 }, 4467a7a92cf8SHeiner Kallweit { 0x1e, 0x0000, 0x0001 }, 4468a7a92cf8SHeiner Kallweit { 0x19, 0x8021, 0x0000 }, 4469a7a92cf8SHeiner Kallweit { 0x1e, 0x0000, 0x2000 }, 4470a7a92cf8SHeiner Kallweit { 0x0d, 0x0100, 0x0200 }, 4471a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0080 }, 4472a7a92cf8SHeiner Kallweit { 0x06, 0x0000, 0x0010 }, 4473a7a92cf8SHeiner Kallweit { 0x04, 0x0000, 0x0010 }, 4474a7a92cf8SHeiner Kallweit { 0x1d, 0x0000, 0x4000 }, 447525e992a4SHeiner Kallweit }; 447625e992a4SHeiner Kallweit 447725e992a4SHeiner Kallweit rtl_hw_start_8168g(tp); 447825e992a4SHeiner Kallweit 447925e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 448025e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 448125e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8411_2); 4482fe4e8db0SHeiner Kallweit 4483fe4e8db0SHeiner Kallweit /* The following Realtek-provided magic fixes an issue with the RX unit 4484fe4e8db0SHeiner Kallweit * getting confused after the PHY having been powered-down. 4485fe4e8db0SHeiner Kallweit */ 4486fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC28, 0x0000); 4487fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2A, 0x0000); 4488fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2C, 0x0000); 4489fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2E, 0x0000); 4490fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC30, 0x0000); 4491fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC32, 0x0000); 4492fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC34, 0x0000); 4493fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC36, 0x0000); 4494fe4e8db0SHeiner Kallweit mdelay(3); 4495fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC26, 0x0000); 4496fe4e8db0SHeiner Kallweit 4497fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF800, 0xE008); 4498fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF802, 0xE00A); 4499fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF804, 0xE00C); 4500fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF806, 0xE00E); 4501fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF808, 0xE027); 4502fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF80A, 0xE04F); 4503fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF80C, 0xE05E); 4504fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF80E, 0xE065); 4505fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF810, 0xC602); 4506fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF812, 0xBE00); 4507fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF814, 0x0000); 4508fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF816, 0xC502); 4509fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF818, 0xBD00); 4510fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF81A, 0x074C); 4511fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF81C, 0xC302); 4512fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF81E, 0xBB00); 4513fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF820, 0x080A); 4514fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF822, 0x6420); 4515fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF824, 0x48C2); 4516fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF826, 0x8C20); 4517fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF828, 0xC516); 4518fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF82A, 0x64A4); 4519fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF82C, 0x49C0); 4520fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF82E, 0xF009); 4521fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF830, 0x74A2); 4522fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF832, 0x8CA5); 4523fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF834, 0x74A0); 4524fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF836, 0xC50E); 4525fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF838, 0x9CA2); 4526fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF83A, 0x1C11); 4527fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF83C, 0x9CA0); 4528fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF83E, 0xE006); 4529fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF840, 0x74F8); 4530fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF842, 0x48C4); 4531fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF844, 0x8CF8); 4532fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF846, 0xC404); 4533fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF848, 0xBC00); 4534fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF84A, 0xC403); 4535fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF84C, 0xBC00); 4536fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF84E, 0x0BF2); 4537fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF850, 0x0C0A); 4538fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF852, 0xE434); 4539fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF854, 0xD3C0); 4540fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF856, 0x49D9); 4541fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF858, 0xF01F); 4542fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF85A, 0xC526); 4543fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF85C, 0x64A5); 4544fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF85E, 0x1400); 4545fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF860, 0xF007); 4546fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF862, 0x0C01); 4547fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF864, 0x8CA5); 4548fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF866, 0x1C15); 4549fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF868, 0xC51B); 4550fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF86A, 0x9CA0); 4551fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF86C, 0xE013); 4552fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF86E, 0xC519); 4553fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF870, 0x74A0); 4554fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF872, 0x48C4); 4555fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF874, 0x8CA0); 4556fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF876, 0xC516); 4557fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF878, 0x74A4); 4558fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF87A, 0x48C8); 4559fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF87C, 0x48CA); 4560fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF87E, 0x9CA4); 4561fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF880, 0xC512); 4562fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF882, 0x1B00); 4563fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF884, 0x9BA0); 4564fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF886, 0x1B1C); 4565fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF888, 0x483F); 4566fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF88A, 0x9BA2); 4567fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF88C, 0x1B04); 4568fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF88E, 0xC508); 4569fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF890, 0x9BA0); 4570fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF892, 0xC505); 4571fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF894, 0xBD00); 4572fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF896, 0xC502); 4573fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF898, 0xBD00); 4574fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF89A, 0x0300); 4575fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF89C, 0x051E); 4576fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF89E, 0xE434); 4577fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A0, 0xE018); 4578fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A2, 0xE092); 4579fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A4, 0xDE20); 4580fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A6, 0xD3C0); 4581fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8A8, 0xC50F); 4582fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8AA, 0x76A4); 4583fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8AC, 0x49E3); 4584fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8AE, 0xF007); 4585fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B0, 0x49C0); 4586fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B2, 0xF103); 4587fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B4, 0xC607); 4588fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B6, 0xBE00); 4589fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8B8, 0xC606); 4590fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8BA, 0xBE00); 4591fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8BC, 0xC602); 4592fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8BE, 0xBE00); 4593fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C0, 0x0C4C); 4594fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C2, 0x0C28); 4595fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C4, 0x0C2C); 4596fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C6, 0xDC00); 4597fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8C8, 0xC707); 4598fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8CA, 0x1D00); 4599fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8CC, 0x8DE2); 4600fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8CE, 0x48C1); 4601fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D0, 0xC502); 4602fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D2, 0xBD00); 4603fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D4, 0x00AA); 4604fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D6, 0xE0C0); 4605fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8D8, 0xC502); 4606fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8DA, 0xBD00); 4607fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xF8DC, 0x0132); 4608fe4e8db0SHeiner Kallweit 4609fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC26, 0x8000); 4610fe4e8db0SHeiner Kallweit 4611fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2A, 0x0743); 4612fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2C, 0x0801); 4613fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC2E, 0x0BE9); 4614fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC30, 0x02FD); 4615fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC32, 0x0C25); 4616fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC34, 0x00A9); 4617fe4e8db0SHeiner Kallweit r8168_mac_ocp_write(tp, 0xFC36, 0x012D); 4618fe4e8db0SHeiner Kallweit 461925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 462025e992a4SHeiner Kallweit } 462125e992a4SHeiner Kallweit 462225e992a4SHeiner Kallweit static void rtl_hw_start_8168h_1(struct rtl8169_private *tp) 462325e992a4SHeiner Kallweit { 462425e992a4SHeiner Kallweit static const struct ephy_info e_info_8168h_1[] = { 462525e992a4SHeiner Kallweit { 0x1e, 0x0800, 0x0001 }, 462625e992a4SHeiner Kallweit { 0x1d, 0x0000, 0x0800 }, 462725e992a4SHeiner Kallweit { 0x05, 0xffff, 0x2089 }, 462825e992a4SHeiner Kallweit { 0x06, 0xffff, 0x5881 }, 4629a7a92cf8SHeiner Kallweit { 0x04, 0xffff, 0x854a }, 463025e992a4SHeiner Kallweit { 0x01, 0xffff, 0x068b } 463125e992a4SHeiner Kallweit }; 4632ef712edeSHeiner Kallweit int rg_saw_cnt; 463325e992a4SHeiner Kallweit 463425e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 463525e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 463625e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168h_1); 463725e992a4SHeiner Kallweit 463825e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 463925e992a4SHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x38, 0x48); 464025e992a4SHeiner Kallweit 464125e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 464225e992a4SHeiner Kallweit 464325e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 464425e992a4SHeiner Kallweit 464525e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xdc, ERIAR_MASK_1111, BIT(4)); 464625e992a4SHeiner Kallweit 464725e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xd4, ERIAR_MASK_1111, 0x1f00); 464825e992a4SHeiner Kallweit 464925e992a4SHeiner Kallweit rtl_eri_write(tp, 0x5f0, ERIAR_MASK_0011, 0x4f87); 465025e992a4SHeiner Kallweit 465125e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 465225e992a4SHeiner Kallweit 465325e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 465425e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 465525e992a4SHeiner Kallweit 465625e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 465725e992a4SHeiner Kallweit 465825e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 465925e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 466025e992a4SHeiner Kallweit 466125e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~TX_10M_PS_EN); 466225e992a4SHeiner Kallweit 466325e992a4SHeiner Kallweit rtl_eri_clear_bits(tp, 0x1b0, ERIAR_MASK_0011, BIT(12)); 466425e992a4SHeiner Kallweit 466525e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 466625e992a4SHeiner Kallweit 466725e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0c42); 466825e992a4SHeiner Kallweit rg_saw_cnt = (rtl_readphy(tp, 0x13) & 0x3fff); 466925e992a4SHeiner Kallweit rtl_writephy(tp, 0x1f, 0x0000); 467025e992a4SHeiner Kallweit if (rg_saw_cnt > 0) { 467125e992a4SHeiner Kallweit u16 sw_cnt_1ms_ini; 467225e992a4SHeiner Kallweit 467325e992a4SHeiner Kallweit sw_cnt_1ms_ini = 16000000/rg_saw_cnt; 467425e992a4SHeiner Kallweit sw_cnt_1ms_ini &= 0x0fff; 4675ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd412, 0x0fff, sw_cnt_1ms_ini); 467625e992a4SHeiner Kallweit } 467725e992a4SHeiner Kallweit 4678ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe056, 0x00f0, 0x0070); 4679ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe052, 0x6000, 0x8008); 4680ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe0d6, 0x01ff, 0x017f); 4681ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd420, 0x0fff, 0x047f); 468225e992a4SHeiner Kallweit 468325e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe63e, 0x0001); 468425e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xe63e, 0x0000); 468525e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xc094, 0x0000); 468625e992a4SHeiner Kallweit r8168_mac_ocp_write(tp, 0xc09e, 0x0000); 468725e992a4SHeiner Kallweit 468825e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 468925e992a4SHeiner Kallweit } 469025e992a4SHeiner Kallweit 469125e992a4SHeiner Kallweit static void rtl_hw_start_8168ep(struct rtl8169_private *tp) 469225e992a4SHeiner Kallweit { 469325e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 469425e992a4SHeiner Kallweit 469525e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x08, 0x10, 0x02, 0x06); 469625e992a4SHeiner Kallweit rtl8168g_set_pause_thresholds(tp, 0x2f, 0x5f); 469725e992a4SHeiner Kallweit 469825e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 469925e992a4SHeiner Kallweit 470025e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 470125e992a4SHeiner Kallweit 470225e992a4SHeiner Kallweit rtl_eri_set_bits(tp, 0xd4, ERIAR_MASK_1111, 0x1f80); 470325e992a4SHeiner Kallweit 470425e992a4SHeiner Kallweit rtl_eri_write(tp, 0x5f0, ERIAR_MASK_0011, 0x4f87); 470525e992a4SHeiner Kallweit 470625e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 470725e992a4SHeiner Kallweit 470825e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 470925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 471025e992a4SHeiner Kallweit 471125e992a4SHeiner Kallweit rtl8168_config_eee_mac(tp); 471225e992a4SHeiner Kallweit 471325e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x2fc, ERIAR_MASK_0001, 0x01, 0x06); 471425e992a4SHeiner Kallweit 471525e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~TX_10M_PS_EN); 471625e992a4SHeiner Kallweit 471725e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 471825e992a4SHeiner Kallweit } 471925e992a4SHeiner Kallweit 472025e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_1(struct rtl8169_private *tp) 472125e992a4SHeiner Kallweit { 472225e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_1[] = { 472325e992a4SHeiner Kallweit { 0x00, 0xffff, 0x10ab }, 472425e992a4SHeiner Kallweit { 0x06, 0xffff, 0xf030 }, 472525e992a4SHeiner Kallweit { 0x08, 0xffff, 0x2006 }, 472625e992a4SHeiner Kallweit { 0x0d, 0xffff, 0x1666 }, 472725e992a4SHeiner Kallweit { 0x0c, 0x3ff0, 0x0000 } 472825e992a4SHeiner Kallweit }; 472925e992a4SHeiner Kallweit 473025e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 473125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 473225e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_1); 473325e992a4SHeiner Kallweit 473425e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 473525e992a4SHeiner Kallweit 473625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 473725e992a4SHeiner Kallweit } 473825e992a4SHeiner Kallweit 473925e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_2(struct rtl8169_private *tp) 474025e992a4SHeiner Kallweit { 474125e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_2[] = { 474225e992a4SHeiner Kallweit { 0x00, 0xffff, 0x10a3 }, 474325e992a4SHeiner Kallweit { 0x19, 0xffff, 0xfc00 }, 474425e992a4SHeiner Kallweit { 0x1e, 0xffff, 0x20ea } 474525e992a4SHeiner Kallweit }; 474625e992a4SHeiner Kallweit 474725e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 474825e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 474925e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_2); 475025e992a4SHeiner Kallweit 475125e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 475225e992a4SHeiner Kallweit 475325e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 475425e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 475525e992a4SHeiner Kallweit 475625e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 475725e992a4SHeiner Kallweit } 475825e992a4SHeiner Kallweit 475925e992a4SHeiner Kallweit static void rtl_hw_start_8168ep_3(struct rtl8169_private *tp) 476025e992a4SHeiner Kallweit { 476125e992a4SHeiner Kallweit static const struct ephy_info e_info_8168ep_3[] = { 4762a7a92cf8SHeiner Kallweit { 0x00, 0x0000, 0x0080 }, 4763a7a92cf8SHeiner Kallweit { 0x0d, 0x0100, 0x0200 }, 4764a7a92cf8SHeiner Kallweit { 0x19, 0x8021, 0x0000 }, 4765a7a92cf8SHeiner Kallweit { 0x1e, 0x0000, 0x2000 }, 476625e992a4SHeiner Kallweit }; 476725e992a4SHeiner Kallweit 476825e992a4SHeiner Kallweit /* disable aspm and clock request before access ephy */ 476925e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 477025e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8168ep_3); 477125e992a4SHeiner Kallweit 477225e992a4SHeiner Kallweit rtl_hw_start_8168ep(tp); 477325e992a4SHeiner Kallweit 477425e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 477525e992a4SHeiner Kallweit RTL_W8(tp, MISC_1, RTL_R8(tp, MISC_1) & ~PFM_D3COLD_EN); 477625e992a4SHeiner Kallweit 4777ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd3e2, 0x0fff, 0x0271); 4778ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd3e4, 0x00ff, 0x0000); 4779ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe860, 0x0000, 0x0080); 478025e992a4SHeiner Kallweit 478125e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 478225e992a4SHeiner Kallweit } 478325e992a4SHeiner Kallweit 478425e992a4SHeiner Kallweit static void rtl_hw_start_8102e_1(struct rtl8169_private *tp) 478525e992a4SHeiner Kallweit { 478625e992a4SHeiner Kallweit static const struct ephy_info e_info_8102e_1[] = { 478725e992a4SHeiner Kallweit { 0x01, 0, 0x6e65 }, 478825e992a4SHeiner Kallweit { 0x02, 0, 0x091f }, 478925e992a4SHeiner Kallweit { 0x03, 0, 0xc2f9 }, 479025e992a4SHeiner Kallweit { 0x06, 0, 0xafb5 }, 479125e992a4SHeiner Kallweit { 0x07, 0, 0x0e00 }, 479225e992a4SHeiner Kallweit { 0x19, 0, 0xec80 }, 479325e992a4SHeiner Kallweit { 0x01, 0, 0x2e65 }, 479425e992a4SHeiner Kallweit { 0x01, 0, 0x6e65 } 479525e992a4SHeiner Kallweit }; 479625e992a4SHeiner Kallweit u8 cfg1; 479725e992a4SHeiner Kallweit 479825e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 479925e992a4SHeiner Kallweit 480025e992a4SHeiner Kallweit RTL_W8(tp, DBG_REG, FIX_NAK_1); 480125e992a4SHeiner Kallweit 480225e992a4SHeiner Kallweit RTL_W8(tp, Config1, 480325e992a4SHeiner Kallweit LEDS1 | LEDS0 | Speed_down | MEMMAP | IOMAP | VPD | PMEnable); 480425e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 480525e992a4SHeiner Kallweit 480625e992a4SHeiner Kallweit cfg1 = RTL_R8(tp, Config1); 480725e992a4SHeiner Kallweit if ((cfg1 & LEDS0) && (cfg1 & LEDS1)) 480825e992a4SHeiner Kallweit RTL_W8(tp, Config1, cfg1 & ~LEDS0); 480925e992a4SHeiner Kallweit 481025e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8102e_1); 481125e992a4SHeiner Kallweit } 481225e992a4SHeiner Kallweit 481325e992a4SHeiner Kallweit static void rtl_hw_start_8102e_2(struct rtl8169_private *tp) 481425e992a4SHeiner Kallweit { 481525e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 481625e992a4SHeiner Kallweit 481725e992a4SHeiner Kallweit RTL_W8(tp, Config1, MEMMAP | IOMAP | VPD | PMEnable); 481825e992a4SHeiner Kallweit RTL_W8(tp, Config3, RTL_R8(tp, Config3) & ~Beacon_en); 481925e992a4SHeiner Kallweit } 482025e992a4SHeiner Kallweit 482125e992a4SHeiner Kallweit static void rtl_hw_start_8102e_3(struct rtl8169_private *tp) 482225e992a4SHeiner Kallweit { 482325e992a4SHeiner Kallweit rtl_hw_start_8102e_2(tp); 482425e992a4SHeiner Kallweit 482525e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x03, 0xc2f9); 482625e992a4SHeiner Kallweit } 482725e992a4SHeiner Kallweit 482825e992a4SHeiner Kallweit static void rtl_hw_start_8105e_1(struct rtl8169_private *tp) 482925e992a4SHeiner Kallweit { 483025e992a4SHeiner Kallweit static const struct ephy_info e_info_8105e_1[] = { 483125e992a4SHeiner Kallweit { 0x07, 0, 0x4000 }, 483225e992a4SHeiner Kallweit { 0x19, 0, 0x0200 }, 483325e992a4SHeiner Kallweit { 0x19, 0, 0x0020 }, 483425e992a4SHeiner Kallweit { 0x1e, 0, 0x2000 }, 483525e992a4SHeiner Kallweit { 0x03, 0, 0x0001 }, 483625e992a4SHeiner Kallweit { 0x19, 0, 0x0100 }, 483725e992a4SHeiner Kallweit { 0x19, 0, 0x0004 }, 483825e992a4SHeiner Kallweit { 0x0a, 0, 0x0020 } 483925e992a4SHeiner Kallweit }; 484025e992a4SHeiner Kallweit 484125e992a4SHeiner Kallweit /* Force LAN exit from ASPM if Rx/Tx are not idle */ 484225e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) | 0x002800); 484325e992a4SHeiner Kallweit 484425e992a4SHeiner Kallweit /* Disable Early Tally Counter */ 484525e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) & ~0x010000); 484625e992a4SHeiner Kallweit 484725e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) | EN_NDP | EN_OOB_RESET); 484825e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) | PFM_EN); 484925e992a4SHeiner Kallweit 485025e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8105e_1); 485125e992a4SHeiner Kallweit 485225e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 485325e992a4SHeiner Kallweit } 485425e992a4SHeiner Kallweit 485525e992a4SHeiner Kallweit static void rtl_hw_start_8105e_2(struct rtl8169_private *tp) 485625e992a4SHeiner Kallweit { 485725e992a4SHeiner Kallweit rtl_hw_start_8105e_1(tp); 485825e992a4SHeiner Kallweit rtl_ephy_write(tp, 0x1e, rtl_ephy_read(tp, 0x1e) | 0x8000); 485925e992a4SHeiner Kallweit } 486025e992a4SHeiner Kallweit 486125e992a4SHeiner Kallweit static void rtl_hw_start_8402(struct rtl8169_private *tp) 486225e992a4SHeiner Kallweit { 486325e992a4SHeiner Kallweit static const struct ephy_info e_info_8402[] = { 486425e992a4SHeiner Kallweit { 0x19, 0xffff, 0xff64 }, 486525e992a4SHeiner Kallweit { 0x1e, 0, 0x4000 } 486625e992a4SHeiner Kallweit }; 486725e992a4SHeiner Kallweit 486825e992a4SHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 486925e992a4SHeiner Kallweit 487025e992a4SHeiner Kallweit /* Force LAN exit from ASPM if Rx/Tx are not idle */ 487125e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) | 0x002800); 487225e992a4SHeiner Kallweit 487325e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 487425e992a4SHeiner Kallweit 487525e992a4SHeiner Kallweit rtl_ephy_init(tp, e_info_8402); 487625e992a4SHeiner Kallweit 487725e992a4SHeiner Kallweit rtl_set_fifo_size(tp, 0x00, 0x00, 0x02, 0x06); 487825e992a4SHeiner Kallweit rtl_reset_packet_filter(tp); 487925e992a4SHeiner Kallweit rtl_eri_write(tp, 0xc0, ERIAR_MASK_0011, 0x0000); 488025e992a4SHeiner Kallweit rtl_eri_write(tp, 0xb8, ERIAR_MASK_0011, 0x0000); 488125e992a4SHeiner Kallweit rtl_w0w1_eri(tp, 0x0d4, ERIAR_MASK_0011, 0x0e00, 0xff00); 488225e992a4SHeiner Kallweit 488325e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 488425e992a4SHeiner Kallweit } 488525e992a4SHeiner Kallweit 488625e992a4SHeiner Kallweit static void rtl_hw_start_8106(struct rtl8169_private *tp) 488725e992a4SHeiner Kallweit { 488825e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 488925e992a4SHeiner Kallweit 489025e992a4SHeiner Kallweit /* Force LAN exit from ASPM if Rx/Tx are not idle */ 489125e992a4SHeiner Kallweit RTL_W32(tp, FuncEvent, RTL_R32(tp, FuncEvent) | 0x002800); 489225e992a4SHeiner Kallweit 489325e992a4SHeiner Kallweit RTL_W32(tp, MISC, (RTL_R32(tp, MISC) | DISABLE_LAN_EN) & ~EARLY_TALLY_EN); 489425e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) | EN_NDP | EN_OOB_RESET); 489525e992a4SHeiner Kallweit RTL_W8(tp, DLLPR, RTL_R8(tp, DLLPR) & ~PFM_EN); 489625e992a4SHeiner Kallweit 489725e992a4SHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 489825e992a4SHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, true); 489925e992a4SHeiner Kallweit } 490025e992a4SHeiner Kallweit 4901f1bce4adSHeiner Kallweit DECLARE_RTL_COND(rtl_mac_ocp_e00e_cond) 4902f1bce4adSHeiner Kallweit { 4903f1bce4adSHeiner Kallweit return r8168_mac_ocp_read(tp, 0xe00e) & BIT(13); 4904f1bce4adSHeiner Kallweit } 4905f1bce4adSHeiner Kallweit 4906f1bce4adSHeiner Kallweit static void rtl_hw_start_8125_common(struct rtl8169_private *tp) 4907f1bce4adSHeiner Kallweit { 4908f1bce4adSHeiner Kallweit rtl_pcie_state_l2l3_disable(tp); 4909f1bce4adSHeiner Kallweit 4910f1bce4adSHeiner Kallweit RTL_W16(tp, 0x382, 0x221b); 4911f1bce4adSHeiner Kallweit RTL_W8(tp, 0x4500, 0); 4912f1bce4adSHeiner Kallweit RTL_W16(tp, 0x4800, 0); 4913f1bce4adSHeiner Kallweit 4914f1bce4adSHeiner Kallweit /* disable UPS */ 4915f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd40a, 0x0010, 0x0000); 4916f1bce4adSHeiner Kallweit 4917f1bce4adSHeiner Kallweit RTL_W8(tp, Config1, RTL_R8(tp, Config1) & ~0x10); 4918f1bce4adSHeiner Kallweit 4919f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc140, 0xffff); 4920f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc142, 0xffff); 4921f1bce4adSHeiner Kallweit 4922f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd3e2, 0x0fff, 0x03a9); 4923f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd3e4, 0x00ff, 0x0000); 4924f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe860, 0x0000, 0x0080); 4925f1bce4adSHeiner Kallweit 4926f1bce4adSHeiner Kallweit /* disable new tx descriptor format */ 4927f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb58, 0x0001, 0x0000); 4928f1bce4adSHeiner Kallweit 4929f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe614, 0x0700, 0x0400); 4930f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe63e, 0x0c30, 0x0020); 4931f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xc0b4, 0x0000, 0x000c); 4932f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb6a, 0x00ff, 0x0033); 4933f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb50, 0x03e0, 0x0040); 4934f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe056, 0x00f0, 0x0030); 4935f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe040, 0x1000, 0x0000); 4936f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe0c0, 0x4f0f, 0x4403); 4937f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe052, 0x0080, 0x0067); 4938f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xc0ac, 0x0080, 0x1f00); 4939f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xd430, 0x0fff, 0x047f); 4940f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe84c, 0x0000, 0x00c0); 4941f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xea1c, 0x0004, 0x0000); 4942f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb54, 0x0000, 0x0001); 4943f1bce4adSHeiner Kallweit udelay(1); 4944f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xeb54, 0x0001, 0x0000); 4945f1bce4adSHeiner Kallweit RTL_W16(tp, 0x1880, RTL_R16(tp, 0x1880) & ~0x0030); 4946f1bce4adSHeiner Kallweit 4947f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xe098, 0xc302); 4948f1bce4adSHeiner Kallweit 4949f1bce4adSHeiner Kallweit rtl_udelay_loop_wait_low(tp, &rtl_mac_ocp_e00e_cond, 1000, 10); 4950f1bce4adSHeiner Kallweit 4951b3a42e3aSHeiner Kallweit rtl8125_config_eee_mac(tp); 4952b3a42e3aSHeiner Kallweit 4953f1bce4adSHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) & ~RXDV_GATED_EN); 4954f1bce4adSHeiner Kallweit udelay(10); 4955f1bce4adSHeiner Kallweit } 4956f1bce4adSHeiner Kallweit 4957f1bce4adSHeiner Kallweit static void rtl_hw_start_8125_1(struct rtl8169_private *tp) 4958f1bce4adSHeiner Kallweit { 4959f1bce4adSHeiner Kallweit static const struct ephy_info e_info_8125_1[] = { 4960f1bce4adSHeiner Kallweit { 0x01, 0xffff, 0xa812 }, 4961f1bce4adSHeiner Kallweit { 0x09, 0xffff, 0x520c }, 4962f1bce4adSHeiner Kallweit { 0x04, 0xffff, 0xd000 }, 4963f1bce4adSHeiner Kallweit { 0x0d, 0xffff, 0xf702 }, 4964f1bce4adSHeiner Kallweit { 0x0a, 0xffff, 0x8653 }, 4965f1bce4adSHeiner Kallweit { 0x06, 0xffff, 0x001e }, 4966f1bce4adSHeiner Kallweit { 0x08, 0xffff, 0x3595 }, 4967f1bce4adSHeiner Kallweit { 0x20, 0xffff, 0x9455 }, 4968f1bce4adSHeiner Kallweit { 0x21, 0xffff, 0x99ff }, 4969f1bce4adSHeiner Kallweit { 0x02, 0xffff, 0x6046 }, 4970f1bce4adSHeiner Kallweit { 0x29, 0xffff, 0xfe00 }, 4971f1bce4adSHeiner Kallweit { 0x23, 0xffff, 0xab62 }, 4972f1bce4adSHeiner Kallweit 4973f1bce4adSHeiner Kallweit { 0x41, 0xffff, 0xa80c }, 4974f1bce4adSHeiner Kallweit { 0x49, 0xffff, 0x520c }, 4975f1bce4adSHeiner Kallweit { 0x44, 0xffff, 0xd000 }, 4976f1bce4adSHeiner Kallweit { 0x4d, 0xffff, 0xf702 }, 4977f1bce4adSHeiner Kallweit { 0x4a, 0xffff, 0x8653 }, 4978f1bce4adSHeiner Kallweit { 0x46, 0xffff, 0x001e }, 4979f1bce4adSHeiner Kallweit { 0x48, 0xffff, 0x3595 }, 4980f1bce4adSHeiner Kallweit { 0x60, 0xffff, 0x9455 }, 4981f1bce4adSHeiner Kallweit { 0x61, 0xffff, 0x99ff }, 4982f1bce4adSHeiner Kallweit { 0x42, 0xffff, 0x6046 }, 4983f1bce4adSHeiner Kallweit { 0x69, 0xffff, 0xfe00 }, 4984f1bce4adSHeiner Kallweit { 0x63, 0xffff, 0xab62 }, 4985f1bce4adSHeiner Kallweit }; 4986f1bce4adSHeiner Kallweit 4987f1bce4adSHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 4988f1bce4adSHeiner Kallweit 4989f1bce4adSHeiner Kallweit /* disable aspm and clock request before access ephy */ 4990f1bce4adSHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 4991f1bce4adSHeiner Kallweit rtl_ephy_init(tp, e_info_8125_1); 4992f1bce4adSHeiner Kallweit 4993f1bce4adSHeiner Kallweit rtl_hw_start_8125_common(tp); 4994f1bce4adSHeiner Kallweit } 4995f1bce4adSHeiner Kallweit 4996f1bce4adSHeiner Kallweit static void rtl_hw_start_8125_2(struct rtl8169_private *tp) 4997f1bce4adSHeiner Kallweit { 4998f1bce4adSHeiner Kallweit static const struct ephy_info e_info_8125_2[] = { 4999f1bce4adSHeiner Kallweit { 0x04, 0xffff, 0xd000 }, 5000f1bce4adSHeiner Kallweit { 0x0a, 0xffff, 0x8653 }, 5001f1bce4adSHeiner Kallweit { 0x23, 0xffff, 0xab66 }, 5002f1bce4adSHeiner Kallweit { 0x20, 0xffff, 0x9455 }, 5003f1bce4adSHeiner Kallweit { 0x21, 0xffff, 0x99ff }, 5004f1bce4adSHeiner Kallweit { 0x29, 0xffff, 0xfe04 }, 5005f1bce4adSHeiner Kallweit 5006f1bce4adSHeiner Kallweit { 0x44, 0xffff, 0xd000 }, 5007f1bce4adSHeiner Kallweit { 0x4a, 0xffff, 0x8653 }, 5008f1bce4adSHeiner Kallweit { 0x63, 0xffff, 0xab66 }, 5009f1bce4adSHeiner Kallweit { 0x60, 0xffff, 0x9455 }, 5010f1bce4adSHeiner Kallweit { 0x61, 0xffff, 0x99ff }, 5011f1bce4adSHeiner Kallweit { 0x69, 0xffff, 0xfe04 }, 5012f1bce4adSHeiner Kallweit }; 5013f1bce4adSHeiner Kallweit 5014f1bce4adSHeiner Kallweit rtl_set_def_aspm_entry_latency(tp); 5015f1bce4adSHeiner Kallweit 5016f1bce4adSHeiner Kallweit /* disable aspm and clock request before access ephy */ 5017f1bce4adSHeiner Kallweit rtl_hw_aspm_clkreq_enable(tp, false); 5018f1bce4adSHeiner Kallweit rtl_ephy_init(tp, e_info_8125_2); 5019f1bce4adSHeiner Kallweit 5020f1bce4adSHeiner Kallweit rtl_hw_start_8125_common(tp); 5021f1bce4adSHeiner Kallweit } 5022f1bce4adSHeiner Kallweit 502325e992a4SHeiner Kallweit static void rtl_hw_config(struct rtl8169_private *tp) 502425e992a4SHeiner Kallweit { 502525e992a4SHeiner Kallweit static const rtl_generic_fct hw_configs[] = { 502625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_07] = rtl_hw_start_8102e_1, 502725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_08] = rtl_hw_start_8102e_3, 502825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_09] = rtl_hw_start_8102e_2, 502925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_10] = NULL, 503094b5ff74SHeiner Kallweit [RTL_GIGA_MAC_VER_11] = rtl_hw_start_8168b, 503194b5ff74SHeiner Kallweit [RTL_GIGA_MAC_VER_12] = rtl_hw_start_8168b, 503225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_13] = NULL, 503325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_14] = NULL, 503425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_15] = NULL, 503525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_16] = NULL, 503694b5ff74SHeiner Kallweit [RTL_GIGA_MAC_VER_17] = rtl_hw_start_8168b, 503725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_18] = rtl_hw_start_8168cp_1, 503825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_19] = rtl_hw_start_8168c_1, 503925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_20] = rtl_hw_start_8168c_2, 504025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_21] = rtl_hw_start_8168c_3, 504125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_22] = rtl_hw_start_8168c_4, 504225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_23] = rtl_hw_start_8168cp_2, 504325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_24] = rtl_hw_start_8168cp_3, 504425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_25] = rtl_hw_start_8168d, 504525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_26] = rtl_hw_start_8168d, 504625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_27] = rtl_hw_start_8168d, 504725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_28] = rtl_hw_start_8168d_4, 504825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_29] = rtl_hw_start_8105e_1, 504925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_30] = rtl_hw_start_8105e_2, 50500a413e6bSHeiner Kallweit [RTL_GIGA_MAC_VER_31] = rtl_hw_start_8168d, 505125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_32] = rtl_hw_start_8168e_1, 505225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_33] = rtl_hw_start_8168e_1, 505325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_34] = rtl_hw_start_8168e_2, 505425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_35] = rtl_hw_start_8168f_1, 505525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_36] = rtl_hw_start_8168f_1, 505625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_37] = rtl_hw_start_8402, 505725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_38] = rtl_hw_start_8411, 505825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_39] = rtl_hw_start_8106, 505925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_40] = rtl_hw_start_8168g_1, 506025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_41] = rtl_hw_start_8168g_1, 506125e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_42] = rtl_hw_start_8168g_2, 506225e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_43] = rtl_hw_start_8168g_2, 506325e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_44] = rtl_hw_start_8411_2, 506425e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_45] = rtl_hw_start_8168h_1, 506525e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_46] = rtl_hw_start_8168h_1, 506625e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_47] = rtl_hw_start_8168h_1, 506725e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_48] = rtl_hw_start_8168h_1, 506825e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_49] = rtl_hw_start_8168ep_1, 506925e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_50] = rtl_hw_start_8168ep_2, 507025e992a4SHeiner Kallweit [RTL_GIGA_MAC_VER_51] = rtl_hw_start_8168ep_3, 5071f1bce4adSHeiner Kallweit [RTL_GIGA_MAC_VER_60] = rtl_hw_start_8125_1, 5072f1bce4adSHeiner Kallweit [RTL_GIGA_MAC_VER_61] = rtl_hw_start_8125_2, 507325e992a4SHeiner Kallweit }; 507425e992a4SHeiner Kallweit 507525e992a4SHeiner Kallweit if (hw_configs[tp->mac_version]) 507625e992a4SHeiner Kallweit hw_configs[tp->mac_version](tp); 507725e992a4SHeiner Kallweit } 507825e992a4SHeiner Kallweit 5079f1bce4adSHeiner Kallweit static void rtl_hw_start_8125(struct rtl8169_private *tp) 5080f1bce4adSHeiner Kallweit { 5081f1bce4adSHeiner Kallweit int i; 5082f1bce4adSHeiner Kallweit 5083f1bce4adSHeiner Kallweit /* disable interrupt coalescing */ 5084f1bce4adSHeiner Kallweit for (i = 0xa00; i < 0xb00; i += 4) 5085f1bce4adSHeiner Kallweit RTL_W32(tp, i, 0); 5086f1bce4adSHeiner Kallweit 5087f1bce4adSHeiner Kallweit rtl_hw_config(tp); 5088f1bce4adSHeiner Kallweit } 5089f1bce4adSHeiner Kallweit 509025e992a4SHeiner Kallweit static void rtl_hw_start_8168(struct rtl8169_private *tp) 509125e992a4SHeiner Kallweit { 5092272b2265SHeiner Kallweit if (rtl_is_8168evl_up(tp)) 5093272b2265SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, EarlySize); 5094272b2265SHeiner Kallweit else 509525e992a4SHeiner Kallweit RTL_W8(tp, MaxTxPacketSize, TxPacketMax); 509625e992a4SHeiner Kallweit 509725e992a4SHeiner Kallweit rtl_hw_config(tp); 5098bcf2b868SHeiner Kallweit 5099bcf2b868SHeiner Kallweit /* disable interrupt coalescing */ 5100bcf2b868SHeiner Kallweit RTL_W16(tp, IntrMitigate, 0x0000); 510125e992a4SHeiner Kallweit } 510225e992a4SHeiner Kallweit 51036c19156eSHeiner Kallweit static void rtl_hw_start_8169(struct rtl8169_private *tp) 51046c19156eSHeiner Kallweit { 51056c19156eSHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 51066c19156eSHeiner Kallweit pci_write_config_byte(tp->pci_dev, PCI_CACHE_LINE_SIZE, 0x08); 51076c19156eSHeiner Kallweit 51086c19156eSHeiner Kallweit RTL_W8(tp, EarlyTxThres, NoEarlyTx); 51096c19156eSHeiner Kallweit 51106c19156eSHeiner Kallweit tp->cp_cmd |= PCIMulRW; 51116c19156eSHeiner Kallweit 51126c19156eSHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_02 || 51136c19156eSHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_03) { 51146c19156eSHeiner Kallweit netif_dbg(tp, drv, tp->dev, 51156c19156eSHeiner Kallweit "Set MAC Reg C+CR Offset 0xe0. Bit 3 and Bit 14 MUST be 1\n"); 51166c19156eSHeiner Kallweit tp->cp_cmd |= (1 << 14); 51176c19156eSHeiner Kallweit } 51186c19156eSHeiner Kallweit 51196c19156eSHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 51206c19156eSHeiner Kallweit 51216c19156eSHeiner Kallweit rtl8169_set_magic_reg(tp, tp->mac_version); 51226c19156eSHeiner Kallweit 51236c19156eSHeiner Kallweit RTL_W32(tp, RxMissed, 0); 5124bcf2b868SHeiner Kallweit 5125bcf2b868SHeiner Kallweit /* disable interrupt coalescing */ 5126bcf2b868SHeiner Kallweit RTL_W16(tp, IntrMitigate, 0x0000); 51276c19156eSHeiner Kallweit } 51286c19156eSHeiner Kallweit 51296c19156eSHeiner Kallweit static void rtl_hw_start(struct rtl8169_private *tp) 51306c19156eSHeiner Kallweit { 51316c19156eSHeiner Kallweit rtl_unlock_config_regs(tp); 51326c19156eSHeiner Kallweit 51336c19156eSHeiner Kallweit tp->cp_cmd &= CPCMD_MASK; 51346c19156eSHeiner Kallweit RTL_W16(tp, CPlusCmd, tp->cp_cmd); 51356c19156eSHeiner Kallweit 51366c19156eSHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 51376c19156eSHeiner Kallweit rtl_hw_start_8169(tp); 5138f1bce4adSHeiner Kallweit else if (rtl_is_8125(tp)) 5139f1bce4adSHeiner Kallweit rtl_hw_start_8125(tp); 51406c19156eSHeiner Kallweit else 51416c19156eSHeiner Kallweit rtl_hw_start_8168(tp); 51426c19156eSHeiner Kallweit 51436c19156eSHeiner Kallweit rtl_set_rx_max_size(tp); 51446c19156eSHeiner Kallweit rtl_set_rx_tx_desc_registers(tp); 51456c19156eSHeiner Kallweit rtl_lock_config_regs(tp); 51466c19156eSHeiner Kallweit 51474ebcb113SHeiner Kallweit rtl_jumbo_config(tp, tp->dev->mtu); 51484ebcb113SHeiner Kallweit 51496c19156eSHeiner Kallweit /* Initially a 10 us delay. Turned it into a PCI commit. - FR */ 51507366016dSHeiner Kallweit RTL_R16(tp, CPlusCmd); 51516c19156eSHeiner Kallweit RTL_W8(tp, ChipCmd, CmdTxEnb | CmdRxEnb); 51526c19156eSHeiner Kallweit rtl_init_rxcfg(tp); 51536c19156eSHeiner Kallweit rtl_set_tx_config_registers(tp); 51546c19156eSHeiner Kallweit rtl_set_rx_mode(tp->dev); 51556c19156eSHeiner Kallweit rtl_irq_enable(tp); 51566c19156eSHeiner Kallweit } 51576c19156eSHeiner Kallweit 515825e992a4SHeiner Kallweit static int rtl8169_change_mtu(struct net_device *dev, int new_mtu) 515925e992a4SHeiner Kallweit { 516025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 516125e992a4SHeiner Kallweit 51624ebcb113SHeiner Kallweit rtl_jumbo_config(tp, new_mtu); 516325e992a4SHeiner Kallweit 516425e992a4SHeiner Kallweit dev->mtu = new_mtu; 516525e992a4SHeiner Kallweit netdev_update_features(dev); 516625e992a4SHeiner Kallweit 516725e992a4SHeiner Kallweit return 0; 516825e992a4SHeiner Kallweit } 516925e992a4SHeiner Kallweit 517025e992a4SHeiner Kallweit static inline void rtl8169_make_unusable_by_asic(struct RxDesc *desc) 517125e992a4SHeiner Kallweit { 517225e992a4SHeiner Kallweit desc->addr = cpu_to_le64(0x0badbadbadbadbadull); 517325e992a4SHeiner Kallweit desc->opts1 &= ~cpu_to_le32(DescOwn | RsvdMask); 517425e992a4SHeiner Kallweit } 517525e992a4SHeiner Kallweit 517625e992a4SHeiner Kallweit static inline void rtl8169_mark_to_asic(struct RxDesc *desc) 517725e992a4SHeiner Kallweit { 517825e992a4SHeiner Kallweit u32 eor = le32_to_cpu(desc->opts1) & RingEnd; 517925e992a4SHeiner Kallweit 518025e992a4SHeiner Kallweit /* Force memory writes to complete before releasing descriptor */ 518125e992a4SHeiner Kallweit dma_wmb(); 518225e992a4SHeiner Kallweit 518325e992a4SHeiner Kallweit desc->opts1 = cpu_to_le32(DescOwn | eor | R8169_RX_BUF_SIZE); 518425e992a4SHeiner Kallweit } 518525e992a4SHeiner Kallweit 518632879f00SHeiner Kallweit static struct page *rtl8169_alloc_rx_data(struct rtl8169_private *tp, 518725e992a4SHeiner Kallweit struct RxDesc *desc) 518825e992a4SHeiner Kallweit { 518925e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 519025e992a4SHeiner Kallweit int node = dev_to_node(d); 519132879f00SHeiner Kallweit dma_addr_t mapping; 519232879f00SHeiner Kallweit struct page *data; 519325e992a4SHeiner Kallweit 519432879f00SHeiner Kallweit data = alloc_pages_node(node, GFP_KERNEL, get_order(R8169_RX_BUF_SIZE)); 519525e992a4SHeiner Kallweit if (!data) 519625e992a4SHeiner Kallweit return NULL; 519725e992a4SHeiner Kallweit 519832879f00SHeiner Kallweit mapping = dma_map_page(d, data, 0, R8169_RX_BUF_SIZE, DMA_FROM_DEVICE); 519925e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 520025e992a4SHeiner Kallweit if (net_ratelimit()) 520125e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, "Failed to map RX DMA!\n"); 520232879f00SHeiner Kallweit __free_pages(data, get_order(R8169_RX_BUF_SIZE)); 520332879f00SHeiner Kallweit return NULL; 520425e992a4SHeiner Kallweit } 520525e992a4SHeiner Kallweit 520625e992a4SHeiner Kallweit desc->addr = cpu_to_le64(mapping); 520725e992a4SHeiner Kallweit rtl8169_mark_to_asic(desc); 520825e992a4SHeiner Kallweit 520932879f00SHeiner Kallweit return data; 521025e992a4SHeiner Kallweit } 521125e992a4SHeiner Kallweit 521225e992a4SHeiner Kallweit static void rtl8169_rx_clear(struct rtl8169_private *tp) 521325e992a4SHeiner Kallweit { 521425e992a4SHeiner Kallweit unsigned int i; 521525e992a4SHeiner Kallweit 5216eb2e7f09SHeiner Kallweit for (i = 0; i < NUM_RX_DESC && tp->Rx_databuff[i]; i++) { 5217eb2e7f09SHeiner Kallweit dma_unmap_page(tp_to_dev(tp), 5218eb2e7f09SHeiner Kallweit le64_to_cpu(tp->RxDescArray[i].addr), 5219eb2e7f09SHeiner Kallweit R8169_RX_BUF_SIZE, DMA_FROM_DEVICE); 5220eb2e7f09SHeiner Kallweit __free_pages(tp->Rx_databuff[i], get_order(R8169_RX_BUF_SIZE)); 5221eb2e7f09SHeiner Kallweit tp->Rx_databuff[i] = NULL; 5222eb2e7f09SHeiner Kallweit rtl8169_make_unusable_by_asic(tp->RxDescArray + i); 522325e992a4SHeiner Kallweit } 522425e992a4SHeiner Kallweit } 522525e992a4SHeiner Kallweit 522625e992a4SHeiner Kallweit static inline void rtl8169_mark_as_last_descriptor(struct RxDesc *desc) 522725e992a4SHeiner Kallweit { 522825e992a4SHeiner Kallweit desc->opts1 |= cpu_to_le32(RingEnd); 522925e992a4SHeiner Kallweit } 523025e992a4SHeiner Kallweit 523125e992a4SHeiner Kallweit static int rtl8169_rx_fill(struct rtl8169_private *tp) 523225e992a4SHeiner Kallweit { 523325e992a4SHeiner Kallweit unsigned int i; 523425e992a4SHeiner Kallweit 523525e992a4SHeiner Kallweit for (i = 0; i < NUM_RX_DESC; i++) { 523632879f00SHeiner Kallweit struct page *data; 523725e992a4SHeiner Kallweit 523825e992a4SHeiner Kallweit data = rtl8169_alloc_rx_data(tp, tp->RxDescArray + i); 523925e992a4SHeiner Kallweit if (!data) { 5240e4b5c7a5SHeiner Kallweit rtl8169_rx_clear(tp); 5241e4b5c7a5SHeiner Kallweit return -ENOMEM; 524225e992a4SHeiner Kallweit } 524325e992a4SHeiner Kallweit tp->Rx_databuff[i] = data; 524425e992a4SHeiner Kallweit } 524525e992a4SHeiner Kallweit 524625e992a4SHeiner Kallweit rtl8169_mark_as_last_descriptor(tp->RxDescArray + NUM_RX_DESC - 1); 524725e992a4SHeiner Kallweit 5248e4b5c7a5SHeiner Kallweit return 0; 524925e992a4SHeiner Kallweit } 525025e992a4SHeiner Kallweit 525125e992a4SHeiner Kallweit static int rtl8169_init_ring(struct rtl8169_private *tp) 525225e992a4SHeiner Kallweit { 525325e992a4SHeiner Kallweit rtl8169_init_ring_indexes(tp); 525425e992a4SHeiner Kallweit 525525e992a4SHeiner Kallweit memset(tp->tx_skb, 0, sizeof(tp->tx_skb)); 525625e992a4SHeiner Kallweit memset(tp->Rx_databuff, 0, sizeof(tp->Rx_databuff)); 525725e992a4SHeiner Kallweit 525825e992a4SHeiner Kallweit return rtl8169_rx_fill(tp); 525925e992a4SHeiner Kallweit } 526025e992a4SHeiner Kallweit 526125e992a4SHeiner Kallweit static void rtl8169_unmap_tx_skb(struct device *d, struct ring_info *tx_skb, 526225e992a4SHeiner Kallweit struct TxDesc *desc) 526325e992a4SHeiner Kallweit { 526425e992a4SHeiner Kallweit unsigned int len = tx_skb->len; 526525e992a4SHeiner Kallweit 526625e992a4SHeiner Kallweit dma_unmap_single(d, le64_to_cpu(desc->addr), len, DMA_TO_DEVICE); 526725e992a4SHeiner Kallweit 526825e992a4SHeiner Kallweit desc->opts1 = 0x00; 526925e992a4SHeiner Kallweit desc->opts2 = 0x00; 527025e992a4SHeiner Kallweit desc->addr = 0x00; 527125e992a4SHeiner Kallweit tx_skb->len = 0; 527225e992a4SHeiner Kallweit } 527325e992a4SHeiner Kallweit 527425e992a4SHeiner Kallweit static void rtl8169_tx_clear_range(struct rtl8169_private *tp, u32 start, 527525e992a4SHeiner Kallweit unsigned int n) 527625e992a4SHeiner Kallweit { 527725e992a4SHeiner Kallweit unsigned int i; 527825e992a4SHeiner Kallweit 527925e992a4SHeiner Kallweit for (i = 0; i < n; i++) { 528025e992a4SHeiner Kallweit unsigned int entry = (start + i) % NUM_TX_DESC; 528125e992a4SHeiner Kallweit struct ring_info *tx_skb = tp->tx_skb + entry; 528225e992a4SHeiner Kallweit unsigned int len = tx_skb->len; 528325e992a4SHeiner Kallweit 528425e992a4SHeiner Kallweit if (len) { 528525e992a4SHeiner Kallweit struct sk_buff *skb = tx_skb->skb; 528625e992a4SHeiner Kallweit 528725e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(tp_to_dev(tp), tx_skb, 528825e992a4SHeiner Kallweit tp->TxDescArray + entry); 528925e992a4SHeiner Kallweit if (skb) { 529025e992a4SHeiner Kallweit dev_consume_skb_any(skb); 529125e992a4SHeiner Kallweit tx_skb->skb = NULL; 529225e992a4SHeiner Kallweit } 529325e992a4SHeiner Kallweit } 529425e992a4SHeiner Kallweit } 529525e992a4SHeiner Kallweit } 529625e992a4SHeiner Kallweit 529725e992a4SHeiner Kallweit static void rtl8169_tx_clear(struct rtl8169_private *tp) 529825e992a4SHeiner Kallweit { 529925e992a4SHeiner Kallweit rtl8169_tx_clear_range(tp, tp->dirty_tx, NUM_TX_DESC); 530025e992a4SHeiner Kallweit tp->cur_tx = tp->dirty_tx = 0; 530125e992a4SHeiner Kallweit netdev_reset_queue(tp->dev); 530225e992a4SHeiner Kallweit } 530325e992a4SHeiner Kallweit 530425e992a4SHeiner Kallweit static void rtl_reset_work(struct rtl8169_private *tp) 530525e992a4SHeiner Kallweit { 530625e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 530725e992a4SHeiner Kallweit int i; 530825e992a4SHeiner Kallweit 530925e992a4SHeiner Kallweit napi_disable(&tp->napi); 531025e992a4SHeiner Kallweit netif_stop_queue(dev); 531125e992a4SHeiner Kallweit synchronize_rcu(); 531225e992a4SHeiner Kallweit 531325e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 531425e992a4SHeiner Kallweit 531525e992a4SHeiner Kallweit for (i = 0; i < NUM_RX_DESC; i++) 531625e992a4SHeiner Kallweit rtl8169_mark_to_asic(tp->RxDescArray + i); 531725e992a4SHeiner Kallweit 531825e992a4SHeiner Kallweit rtl8169_tx_clear(tp); 531925e992a4SHeiner Kallweit rtl8169_init_ring_indexes(tp); 532025e992a4SHeiner Kallweit 532125e992a4SHeiner Kallweit napi_enable(&tp->napi); 532225e992a4SHeiner Kallweit rtl_hw_start(tp); 532325e992a4SHeiner Kallweit netif_wake_queue(dev); 532425e992a4SHeiner Kallweit } 532525e992a4SHeiner Kallweit 532625e992a4SHeiner Kallweit static void rtl8169_tx_timeout(struct net_device *dev) 532725e992a4SHeiner Kallweit { 532825e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 532925e992a4SHeiner Kallweit 533025e992a4SHeiner Kallweit rtl_schedule_task(tp, RTL_FLAG_TASK_RESET_PENDING); 533125e992a4SHeiner Kallweit } 533225e992a4SHeiner Kallweit 533325e992a4SHeiner Kallweit static __le32 rtl8169_get_txd_opts1(u32 opts0, u32 len, unsigned int entry) 533425e992a4SHeiner Kallweit { 533525e992a4SHeiner Kallweit u32 status = opts0 | len; 533625e992a4SHeiner Kallweit 533725e992a4SHeiner Kallweit if (entry == NUM_TX_DESC - 1) 533825e992a4SHeiner Kallweit status |= RingEnd; 533925e992a4SHeiner Kallweit 534025e992a4SHeiner Kallweit return cpu_to_le32(status); 534125e992a4SHeiner Kallweit } 534225e992a4SHeiner Kallweit 534325e992a4SHeiner Kallweit static int rtl8169_xmit_frags(struct rtl8169_private *tp, struct sk_buff *skb, 534425e992a4SHeiner Kallweit u32 *opts) 534525e992a4SHeiner Kallweit { 534625e992a4SHeiner Kallweit struct skb_shared_info *info = skb_shinfo(skb); 534725e992a4SHeiner Kallweit unsigned int cur_frag, entry; 534825e992a4SHeiner Kallweit struct TxDesc *uninitialized_var(txd); 534925e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 535025e992a4SHeiner Kallweit 535125e992a4SHeiner Kallweit entry = tp->cur_tx; 535225e992a4SHeiner Kallweit for (cur_frag = 0; cur_frag < info->nr_frags; cur_frag++) { 535325e992a4SHeiner Kallweit const skb_frag_t *frag = info->frags + cur_frag; 535425e992a4SHeiner Kallweit dma_addr_t mapping; 535525e992a4SHeiner Kallweit u32 len; 535625e992a4SHeiner Kallweit void *addr; 535725e992a4SHeiner Kallweit 535825e992a4SHeiner Kallweit entry = (entry + 1) % NUM_TX_DESC; 535925e992a4SHeiner Kallweit 536025e992a4SHeiner Kallweit txd = tp->TxDescArray + entry; 536125e992a4SHeiner Kallweit len = skb_frag_size(frag); 536225e992a4SHeiner Kallweit addr = skb_frag_address(frag); 536325e992a4SHeiner Kallweit mapping = dma_map_single(d, addr, len, DMA_TO_DEVICE); 536425e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 536525e992a4SHeiner Kallweit if (net_ratelimit()) 536625e992a4SHeiner Kallweit netif_err(tp, drv, tp->dev, 536725e992a4SHeiner Kallweit "Failed to map TX fragments DMA!\n"); 536825e992a4SHeiner Kallweit goto err_out; 536925e992a4SHeiner Kallweit } 537025e992a4SHeiner Kallweit 537125e992a4SHeiner Kallweit txd->opts1 = rtl8169_get_txd_opts1(opts[0], len, entry); 537225e992a4SHeiner Kallweit txd->opts2 = cpu_to_le32(opts[1]); 537325e992a4SHeiner Kallweit txd->addr = cpu_to_le64(mapping); 537425e992a4SHeiner Kallweit 537525e992a4SHeiner Kallweit tp->tx_skb[entry].len = len; 537625e992a4SHeiner Kallweit } 537725e992a4SHeiner Kallweit 537825e992a4SHeiner Kallweit if (cur_frag) { 537925e992a4SHeiner Kallweit tp->tx_skb[entry].skb = skb; 538025e992a4SHeiner Kallweit txd->opts1 |= cpu_to_le32(LastFrag); 538125e992a4SHeiner Kallweit } 538225e992a4SHeiner Kallweit 538325e992a4SHeiner Kallweit return cur_frag; 538425e992a4SHeiner Kallweit 538525e992a4SHeiner Kallweit err_out: 538625e992a4SHeiner Kallweit rtl8169_tx_clear_range(tp, tp->cur_tx + 1, cur_frag); 538725e992a4SHeiner Kallweit return -EIO; 538825e992a4SHeiner Kallweit } 538925e992a4SHeiner Kallweit 539025e992a4SHeiner Kallweit static bool rtl_test_hw_pad_bug(struct rtl8169_private *tp, struct sk_buff *skb) 539125e992a4SHeiner Kallweit { 539225e992a4SHeiner Kallweit return skb->len < ETH_ZLEN && tp->mac_version == RTL_GIGA_MAC_VER_34; 539325e992a4SHeiner Kallweit } 539425e992a4SHeiner Kallweit 539525e992a4SHeiner Kallweit /* msdn_giant_send_check() 539625e992a4SHeiner Kallweit * According to the document of microsoft, the TCP Pseudo Header excludes the 539725e992a4SHeiner Kallweit * packet length for IPv6 TCP large packets. 539825e992a4SHeiner Kallweit */ 539925e992a4SHeiner Kallweit static int msdn_giant_send_check(struct sk_buff *skb) 540025e992a4SHeiner Kallweit { 540125e992a4SHeiner Kallweit const struct ipv6hdr *ipv6h; 540225e992a4SHeiner Kallweit struct tcphdr *th; 540325e992a4SHeiner Kallweit int ret; 540425e992a4SHeiner Kallweit 540525e992a4SHeiner Kallweit ret = skb_cow_head(skb, 0); 540625e992a4SHeiner Kallweit if (ret) 540725e992a4SHeiner Kallweit return ret; 540825e992a4SHeiner Kallweit 540925e992a4SHeiner Kallweit ipv6h = ipv6_hdr(skb); 541025e992a4SHeiner Kallweit th = tcp_hdr(skb); 541125e992a4SHeiner Kallweit 541225e992a4SHeiner Kallweit th->check = 0; 541325e992a4SHeiner Kallweit th->check = ~tcp_v6_check(0, &ipv6h->saddr, &ipv6h->daddr, 0); 541425e992a4SHeiner Kallweit 541525e992a4SHeiner Kallweit return ret; 541625e992a4SHeiner Kallweit } 541725e992a4SHeiner Kallweit 541825e992a4SHeiner Kallweit static void rtl8169_tso_csum_v1(struct sk_buff *skb, u32 *opts) 541925e992a4SHeiner Kallweit { 542025e992a4SHeiner Kallweit u32 mss = skb_shinfo(skb)->gso_size; 542125e992a4SHeiner Kallweit 542225e992a4SHeiner Kallweit if (mss) { 542325e992a4SHeiner Kallweit opts[0] |= TD_LSO; 542425e992a4SHeiner Kallweit opts[0] |= min(mss, TD_MSS_MAX) << TD0_MSS_SHIFT; 542525e992a4SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 542625e992a4SHeiner Kallweit const struct iphdr *ip = ip_hdr(skb); 542725e992a4SHeiner Kallweit 542825e992a4SHeiner Kallweit if (ip->protocol == IPPROTO_TCP) 542925e992a4SHeiner Kallweit opts[0] |= TD0_IP_CS | TD0_TCP_CS; 543025e992a4SHeiner Kallweit else if (ip->protocol == IPPROTO_UDP) 543125e992a4SHeiner Kallweit opts[0] |= TD0_IP_CS | TD0_UDP_CS; 543225e992a4SHeiner Kallweit else 543325e992a4SHeiner Kallweit WARN_ON_ONCE(1); 543425e992a4SHeiner Kallweit } 543525e992a4SHeiner Kallweit } 543625e992a4SHeiner Kallweit 543725e992a4SHeiner Kallweit static bool rtl8169_tso_csum_v2(struct rtl8169_private *tp, 543825e992a4SHeiner Kallweit struct sk_buff *skb, u32 *opts) 543925e992a4SHeiner Kallweit { 544025e992a4SHeiner Kallweit u32 transport_offset = (u32)skb_transport_offset(skb); 544125e992a4SHeiner Kallweit u32 mss = skb_shinfo(skb)->gso_size; 544225e992a4SHeiner Kallweit 544325e992a4SHeiner Kallweit if (mss) { 544425e992a4SHeiner Kallweit switch (vlan_get_protocol(skb)) { 544525e992a4SHeiner Kallweit case htons(ETH_P_IP): 544625e992a4SHeiner Kallweit opts[0] |= TD1_GTSENV4; 544725e992a4SHeiner Kallweit break; 544825e992a4SHeiner Kallweit 544925e992a4SHeiner Kallweit case htons(ETH_P_IPV6): 545025e992a4SHeiner Kallweit if (msdn_giant_send_check(skb)) 545125e992a4SHeiner Kallweit return false; 545225e992a4SHeiner Kallweit 545325e992a4SHeiner Kallweit opts[0] |= TD1_GTSENV6; 545425e992a4SHeiner Kallweit break; 545525e992a4SHeiner Kallweit 545625e992a4SHeiner Kallweit default: 545725e992a4SHeiner Kallweit WARN_ON_ONCE(1); 545825e992a4SHeiner Kallweit break; 545925e992a4SHeiner Kallweit } 546025e992a4SHeiner Kallweit 546125e992a4SHeiner Kallweit opts[0] |= transport_offset << GTTCPHO_SHIFT; 546225e992a4SHeiner Kallweit opts[1] |= min(mss, TD_MSS_MAX) << TD1_MSS_SHIFT; 546325e992a4SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 546425e992a4SHeiner Kallweit u8 ip_protocol; 546525e992a4SHeiner Kallweit 546625e992a4SHeiner Kallweit switch (vlan_get_protocol(skb)) { 546725e992a4SHeiner Kallweit case htons(ETH_P_IP): 546825e992a4SHeiner Kallweit opts[1] |= TD1_IPv4_CS; 546925e992a4SHeiner Kallweit ip_protocol = ip_hdr(skb)->protocol; 547025e992a4SHeiner Kallweit break; 547125e992a4SHeiner Kallweit 547225e992a4SHeiner Kallweit case htons(ETH_P_IPV6): 547325e992a4SHeiner Kallweit opts[1] |= TD1_IPv6_CS; 547425e992a4SHeiner Kallweit ip_protocol = ipv6_hdr(skb)->nexthdr; 547525e992a4SHeiner Kallweit break; 547625e992a4SHeiner Kallweit 547725e992a4SHeiner Kallweit default: 547825e992a4SHeiner Kallweit ip_protocol = IPPROTO_RAW; 547925e992a4SHeiner Kallweit break; 548025e992a4SHeiner Kallweit } 548125e992a4SHeiner Kallweit 548225e992a4SHeiner Kallweit if (ip_protocol == IPPROTO_TCP) 548325e992a4SHeiner Kallweit opts[1] |= TD1_TCP_CS; 548425e992a4SHeiner Kallweit else if (ip_protocol == IPPROTO_UDP) 548525e992a4SHeiner Kallweit opts[1] |= TD1_UDP_CS; 548625e992a4SHeiner Kallweit else 548725e992a4SHeiner Kallweit WARN_ON_ONCE(1); 548825e992a4SHeiner Kallweit 548925e992a4SHeiner Kallweit opts[1] |= transport_offset << TCPHO_SHIFT; 549025e992a4SHeiner Kallweit } else { 549125e992a4SHeiner Kallweit if (unlikely(rtl_test_hw_pad_bug(tp, skb))) 549225e992a4SHeiner Kallweit return !eth_skb_pad(skb); 549325e992a4SHeiner Kallweit } 549425e992a4SHeiner Kallweit 549525e992a4SHeiner Kallweit return true; 549625e992a4SHeiner Kallweit } 549725e992a4SHeiner Kallweit 549825e992a4SHeiner Kallweit static bool rtl_tx_slots_avail(struct rtl8169_private *tp, 549925e992a4SHeiner Kallweit unsigned int nr_frags) 550025e992a4SHeiner Kallweit { 550125e992a4SHeiner Kallweit unsigned int slots_avail = tp->dirty_tx + NUM_TX_DESC - tp->cur_tx; 550225e992a4SHeiner Kallweit 550325e992a4SHeiner Kallweit /* A skbuff with nr_frags needs nr_frags+1 entries in the tx queue */ 550425e992a4SHeiner Kallweit return slots_avail > nr_frags; 550525e992a4SHeiner Kallweit } 550625e992a4SHeiner Kallweit 550725e992a4SHeiner Kallweit /* Versions RTL8102e and from RTL8168c onwards support csum_v2 */ 550825e992a4SHeiner Kallweit static bool rtl_chip_supports_csum_v2(struct rtl8169_private *tp) 550925e992a4SHeiner Kallweit { 551025e992a4SHeiner Kallweit switch (tp->mac_version) { 551125e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 551225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_10 ... RTL_GIGA_MAC_VER_17: 551325e992a4SHeiner Kallweit return false; 551425e992a4SHeiner Kallweit default: 551525e992a4SHeiner Kallweit return true; 551625e992a4SHeiner Kallweit } 551725e992a4SHeiner Kallweit } 551825e992a4SHeiner Kallweit 5519f1bce4adSHeiner Kallweit static void rtl8169_doorbell(struct rtl8169_private *tp) 5520f1bce4adSHeiner Kallweit { 5521f1bce4adSHeiner Kallweit if (rtl_is_8125(tp)) 5522f1bce4adSHeiner Kallweit RTL_W16(tp, TxPoll_8125, BIT(0)); 5523f1bce4adSHeiner Kallweit else 5524f1bce4adSHeiner Kallweit RTL_W8(tp, TxPoll, NPQ); 5525f1bce4adSHeiner Kallweit } 5526f1bce4adSHeiner Kallweit 552725e992a4SHeiner Kallweit static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb, 552825e992a4SHeiner Kallweit struct net_device *dev) 552925e992a4SHeiner Kallweit { 553025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 553125e992a4SHeiner Kallweit unsigned int entry = tp->cur_tx % NUM_TX_DESC; 553225e992a4SHeiner Kallweit struct TxDesc *txd = tp->TxDescArray + entry; 553325e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 553425e992a4SHeiner Kallweit dma_addr_t mapping; 553525e992a4SHeiner Kallweit u32 opts[2], len; 5536ef143585SHeiner Kallweit bool stop_queue; 5537ef143585SHeiner Kallweit bool door_bell; 553825e992a4SHeiner Kallweit int frags; 553925e992a4SHeiner Kallweit 554025e992a4SHeiner Kallweit if (unlikely(!rtl_tx_slots_avail(tp, skb_shinfo(skb)->nr_frags))) { 554125e992a4SHeiner Kallweit netif_err(tp, drv, dev, "BUG! Tx Ring full when queue awake!\n"); 554225e992a4SHeiner Kallweit goto err_stop_0; 554325e992a4SHeiner Kallweit } 554425e992a4SHeiner Kallweit 554525e992a4SHeiner Kallweit if (unlikely(le32_to_cpu(txd->opts1) & DescOwn)) 554625e992a4SHeiner Kallweit goto err_stop_0; 554725e992a4SHeiner Kallweit 5548355f948aSHeiner Kallweit opts[1] = rtl8169_tx_vlan_tag(skb); 554925e992a4SHeiner Kallweit opts[0] = DescOwn; 555025e992a4SHeiner Kallweit 555125e992a4SHeiner Kallweit if (rtl_chip_supports_csum_v2(tp)) { 555296ea772eSHeiner Kallweit if (!rtl8169_tso_csum_v2(tp, skb, opts)) 555396ea772eSHeiner Kallweit goto err_dma_0; 555425e992a4SHeiner Kallweit } else { 555525e992a4SHeiner Kallweit rtl8169_tso_csum_v1(skb, opts); 555625e992a4SHeiner Kallweit } 555725e992a4SHeiner Kallweit 555825e992a4SHeiner Kallweit len = skb_headlen(skb); 555925e992a4SHeiner Kallweit mapping = dma_map_single(d, skb->data, len, DMA_TO_DEVICE); 556025e992a4SHeiner Kallweit if (unlikely(dma_mapping_error(d, mapping))) { 556125e992a4SHeiner Kallweit if (net_ratelimit()) 556225e992a4SHeiner Kallweit netif_err(tp, drv, dev, "Failed to map TX DMA!\n"); 556325e992a4SHeiner Kallweit goto err_dma_0; 556425e992a4SHeiner Kallweit } 556525e992a4SHeiner Kallweit 556625e992a4SHeiner Kallweit tp->tx_skb[entry].len = len; 556725e992a4SHeiner Kallweit txd->addr = cpu_to_le64(mapping); 556825e992a4SHeiner Kallweit 556925e992a4SHeiner Kallweit frags = rtl8169_xmit_frags(tp, skb, opts); 557025e992a4SHeiner Kallweit if (frags < 0) 557125e992a4SHeiner Kallweit goto err_dma_1; 557225e992a4SHeiner Kallweit else if (frags) 557325e992a4SHeiner Kallweit opts[0] |= FirstFrag; 557425e992a4SHeiner Kallweit else { 557525e992a4SHeiner Kallweit opts[0] |= FirstFrag | LastFrag; 557625e992a4SHeiner Kallweit tp->tx_skb[entry].skb = skb; 557725e992a4SHeiner Kallweit } 557825e992a4SHeiner Kallweit 557925e992a4SHeiner Kallweit txd->opts2 = cpu_to_le32(opts[1]); 558025e992a4SHeiner Kallweit 558125e992a4SHeiner Kallweit skb_tx_timestamp(skb); 558225e992a4SHeiner Kallweit 558325e992a4SHeiner Kallweit /* Force memory writes to complete before releasing descriptor */ 558425e992a4SHeiner Kallweit dma_wmb(); 558525e992a4SHeiner Kallweit 5586ef143585SHeiner Kallweit door_bell = __netdev_sent_queue(dev, skb->len, netdev_xmit_more()); 5587ef143585SHeiner Kallweit 558825e992a4SHeiner Kallweit txd->opts1 = rtl8169_get_txd_opts1(opts[0], len, entry); 558925e992a4SHeiner Kallweit 559025e992a4SHeiner Kallweit /* Force all memory writes to complete before notifying device */ 559125e992a4SHeiner Kallweit wmb(); 559225e992a4SHeiner Kallweit 559325e992a4SHeiner Kallweit tp->cur_tx += frags + 1; 559425e992a4SHeiner Kallweit 5595ef143585SHeiner Kallweit stop_queue = !rtl_tx_slots_avail(tp, MAX_SKB_FRAGS); 5596ef143585SHeiner Kallweit if (unlikely(stop_queue)) { 559725e992a4SHeiner Kallweit /* Avoid wrongly optimistic queue wake-up: rtl_tx thread must 559825e992a4SHeiner Kallweit * not miss a ring update when it notices a stopped queue. 559925e992a4SHeiner Kallweit */ 560025e992a4SHeiner Kallweit smp_wmb(); 560125e992a4SHeiner Kallweit netif_stop_queue(dev); 56024773f9bdSHeiner Kallweit door_bell = true; 5603ef143585SHeiner Kallweit } 5604ef143585SHeiner Kallweit 5605ef143585SHeiner Kallweit if (door_bell) 5606f1bce4adSHeiner Kallweit rtl8169_doorbell(tp); 5607ef143585SHeiner Kallweit 5608ef143585SHeiner Kallweit if (unlikely(stop_queue)) { 560925e992a4SHeiner Kallweit /* Sync with rtl_tx: 561025e992a4SHeiner Kallweit * - publish queue status and cur_tx ring index (write barrier) 561125e992a4SHeiner Kallweit * - refresh dirty_tx ring index (read barrier). 561225e992a4SHeiner Kallweit * May the current thread have a pessimistic view of the ring 561325e992a4SHeiner Kallweit * status and forget to wake up queue, a racing rtl_tx thread 561425e992a4SHeiner Kallweit * can't. 561525e992a4SHeiner Kallweit */ 561625e992a4SHeiner Kallweit smp_mb(); 561725e992a4SHeiner Kallweit if (rtl_tx_slots_avail(tp, MAX_SKB_FRAGS)) 561825e992a4SHeiner Kallweit netif_start_queue(dev); 561925e992a4SHeiner Kallweit } 562025e992a4SHeiner Kallweit 562125e992a4SHeiner Kallweit return NETDEV_TX_OK; 562225e992a4SHeiner Kallweit 562325e992a4SHeiner Kallweit err_dma_1: 562425e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(d, tp->tx_skb + entry, txd); 562525e992a4SHeiner Kallweit err_dma_0: 562625e992a4SHeiner Kallweit dev_kfree_skb_any(skb); 562725e992a4SHeiner Kallweit dev->stats.tx_dropped++; 562825e992a4SHeiner Kallweit return NETDEV_TX_OK; 562925e992a4SHeiner Kallweit 563025e992a4SHeiner Kallweit err_stop_0: 563125e992a4SHeiner Kallweit netif_stop_queue(dev); 563225e992a4SHeiner Kallweit dev->stats.tx_dropped++; 563325e992a4SHeiner Kallweit return NETDEV_TX_BUSY; 563425e992a4SHeiner Kallweit } 563525e992a4SHeiner Kallweit 5636e64e0c89SHeiner Kallweit static netdev_features_t rtl8169_features_check(struct sk_buff *skb, 5637e64e0c89SHeiner Kallweit struct net_device *dev, 5638e64e0c89SHeiner Kallweit netdev_features_t features) 5639e64e0c89SHeiner Kallweit { 5640e64e0c89SHeiner Kallweit int transport_offset = skb_transport_offset(skb); 5641e64e0c89SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 5642e64e0c89SHeiner Kallweit 5643e64e0c89SHeiner Kallweit if (skb_is_gso(skb)) { 5644e64e0c89SHeiner Kallweit if (transport_offset > GTTCPHO_MAX && 5645e64e0c89SHeiner Kallweit rtl_chip_supports_csum_v2(tp)) 5646e64e0c89SHeiner Kallweit features &= ~NETIF_F_ALL_TSO; 5647e64e0c89SHeiner Kallweit } else if (skb->ip_summed == CHECKSUM_PARTIAL) { 5648e64e0c89SHeiner Kallweit if (skb->len < ETH_ZLEN) { 5649e64e0c89SHeiner Kallweit switch (tp->mac_version) { 5650e64e0c89SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 5651e64e0c89SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 5652e64e0c89SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 5653e64e0c89SHeiner Kallweit case RTL_GIGA_MAC_VER_34: 5654e64e0c89SHeiner Kallweit features &= ~NETIF_F_CSUM_MASK; 5655e64e0c89SHeiner Kallweit break; 5656e64e0c89SHeiner Kallweit default: 5657e64e0c89SHeiner Kallweit break; 5658e64e0c89SHeiner Kallweit } 5659e64e0c89SHeiner Kallweit } 5660e64e0c89SHeiner Kallweit 5661e64e0c89SHeiner Kallweit if (transport_offset > TCPHO_MAX && 5662e64e0c89SHeiner Kallweit rtl_chip_supports_csum_v2(tp)) 5663e64e0c89SHeiner Kallweit features &= ~NETIF_F_CSUM_MASK; 5664e64e0c89SHeiner Kallweit } 5665e64e0c89SHeiner Kallweit 5666e64e0c89SHeiner Kallweit return vlan_features_check(skb, features); 5667e64e0c89SHeiner Kallweit } 5668e64e0c89SHeiner Kallweit 566925e992a4SHeiner Kallweit static void rtl8169_pcierr_interrupt(struct net_device *dev) 567025e992a4SHeiner Kallweit { 567125e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 567225e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 567325e992a4SHeiner Kallweit u16 pci_status, pci_cmd; 567425e992a4SHeiner Kallweit 567525e992a4SHeiner Kallweit pci_read_config_word(pdev, PCI_COMMAND, &pci_cmd); 567625e992a4SHeiner Kallweit pci_read_config_word(pdev, PCI_STATUS, &pci_status); 567725e992a4SHeiner Kallweit 567825e992a4SHeiner Kallweit netif_err(tp, intr, dev, "PCI error (cmd = 0x%04x, status = 0x%04x)\n", 567925e992a4SHeiner Kallweit pci_cmd, pci_status); 568025e992a4SHeiner Kallweit 568125e992a4SHeiner Kallweit /* 568225e992a4SHeiner Kallweit * The recovery sequence below admits a very elaborated explanation: 568325e992a4SHeiner Kallweit * - it seems to work; 568425e992a4SHeiner Kallweit * - I did not see what else could be done; 568525e992a4SHeiner Kallweit * - it makes iop3xx happy. 568625e992a4SHeiner Kallweit * 568725e992a4SHeiner Kallweit * Feel free to adjust to your needs. 568825e992a4SHeiner Kallweit */ 568925e992a4SHeiner Kallweit if (pdev->broken_parity_status) 569025e992a4SHeiner Kallweit pci_cmd &= ~PCI_COMMAND_PARITY; 569125e992a4SHeiner Kallweit else 569225e992a4SHeiner Kallweit pci_cmd |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY; 569325e992a4SHeiner Kallweit 569425e992a4SHeiner Kallweit pci_write_config_word(pdev, PCI_COMMAND, pci_cmd); 569525e992a4SHeiner Kallweit 569625e992a4SHeiner Kallweit pci_write_config_word(pdev, PCI_STATUS, 569725e992a4SHeiner Kallweit pci_status & (PCI_STATUS_DETECTED_PARITY | 569825e992a4SHeiner Kallweit PCI_STATUS_SIG_SYSTEM_ERROR | PCI_STATUS_REC_MASTER_ABORT | 569925e992a4SHeiner Kallweit PCI_STATUS_REC_TARGET_ABORT | PCI_STATUS_SIG_TARGET_ABORT)); 570025e992a4SHeiner Kallweit 570125e992a4SHeiner Kallweit rtl_schedule_task(tp, RTL_FLAG_TASK_RESET_PENDING); 570225e992a4SHeiner Kallweit } 570325e992a4SHeiner Kallweit 570425e992a4SHeiner Kallweit static void rtl_tx(struct net_device *dev, struct rtl8169_private *tp, 570525e992a4SHeiner Kallweit int budget) 570625e992a4SHeiner Kallweit { 570725e992a4SHeiner Kallweit unsigned int dirty_tx, tx_left, bytes_compl = 0, pkts_compl = 0; 570825e992a4SHeiner Kallweit 570925e992a4SHeiner Kallweit dirty_tx = tp->dirty_tx; 571025e992a4SHeiner Kallweit smp_rmb(); 571125e992a4SHeiner Kallweit tx_left = tp->cur_tx - dirty_tx; 571225e992a4SHeiner Kallweit 571325e992a4SHeiner Kallweit while (tx_left > 0) { 571425e992a4SHeiner Kallweit unsigned int entry = dirty_tx % NUM_TX_DESC; 571525e992a4SHeiner Kallweit struct ring_info *tx_skb = tp->tx_skb + entry; 571625e992a4SHeiner Kallweit u32 status; 571725e992a4SHeiner Kallweit 571825e992a4SHeiner Kallweit status = le32_to_cpu(tp->TxDescArray[entry].opts1); 571925e992a4SHeiner Kallweit if (status & DescOwn) 572025e992a4SHeiner Kallweit break; 572125e992a4SHeiner Kallweit 572225e992a4SHeiner Kallweit /* This barrier is needed to keep us from reading 572325e992a4SHeiner Kallweit * any other fields out of the Tx descriptor until 572425e992a4SHeiner Kallweit * we know the status of DescOwn 572525e992a4SHeiner Kallweit */ 572625e992a4SHeiner Kallweit dma_rmb(); 572725e992a4SHeiner Kallweit 572825e992a4SHeiner Kallweit rtl8169_unmap_tx_skb(tp_to_dev(tp), tx_skb, 572925e992a4SHeiner Kallweit tp->TxDescArray + entry); 5730ae84bc18SHeiner Kallweit if (tx_skb->skb) { 573125e992a4SHeiner Kallweit pkts_compl++; 573225e992a4SHeiner Kallweit bytes_compl += tx_skb->skb->len; 573325e992a4SHeiner Kallweit napi_consume_skb(tx_skb->skb, budget); 573425e992a4SHeiner Kallweit tx_skb->skb = NULL; 573525e992a4SHeiner Kallweit } 573625e992a4SHeiner Kallweit dirty_tx++; 573725e992a4SHeiner Kallweit tx_left--; 573825e992a4SHeiner Kallweit } 573925e992a4SHeiner Kallweit 574025e992a4SHeiner Kallweit if (tp->dirty_tx != dirty_tx) { 574125e992a4SHeiner Kallweit netdev_completed_queue(dev, pkts_compl, bytes_compl); 574225e992a4SHeiner Kallweit 574325e992a4SHeiner Kallweit u64_stats_update_begin(&tp->tx_stats.syncp); 574425e992a4SHeiner Kallweit tp->tx_stats.packets += pkts_compl; 574525e992a4SHeiner Kallweit tp->tx_stats.bytes += bytes_compl; 574625e992a4SHeiner Kallweit u64_stats_update_end(&tp->tx_stats.syncp); 574725e992a4SHeiner Kallweit 574825e992a4SHeiner Kallweit tp->dirty_tx = dirty_tx; 574925e992a4SHeiner Kallweit /* Sync with rtl8169_start_xmit: 575025e992a4SHeiner Kallweit * - publish dirty_tx ring index (write barrier) 575125e992a4SHeiner Kallweit * - refresh cur_tx ring index and queue status (read barrier) 575225e992a4SHeiner Kallweit * May the current thread miss the stopped queue condition, 575325e992a4SHeiner Kallweit * a racing xmit thread can only have a right view of the 575425e992a4SHeiner Kallweit * ring status. 575525e992a4SHeiner Kallweit */ 575625e992a4SHeiner Kallweit smp_mb(); 575725e992a4SHeiner Kallweit if (netif_queue_stopped(dev) && 575825e992a4SHeiner Kallweit rtl_tx_slots_avail(tp, MAX_SKB_FRAGS)) { 575925e992a4SHeiner Kallweit netif_wake_queue(dev); 576025e992a4SHeiner Kallweit } 576125e992a4SHeiner Kallweit /* 576225e992a4SHeiner Kallweit * 8168 hack: TxPoll requests are lost when the Tx packets are 576325e992a4SHeiner Kallweit * too close. Let's kick an extra TxPoll request when a burst 576425e992a4SHeiner Kallweit * of start_xmit activity is detected (if it is not detected, 576525e992a4SHeiner Kallweit * it is slow enough). -- FR 576625e992a4SHeiner Kallweit */ 576725e992a4SHeiner Kallweit if (tp->cur_tx != dirty_tx) 5768f1bce4adSHeiner Kallweit rtl8169_doorbell(tp); 576925e992a4SHeiner Kallweit } 577025e992a4SHeiner Kallweit } 577125e992a4SHeiner Kallweit 577225e992a4SHeiner Kallweit static inline int rtl8169_fragmented_frame(u32 status) 577325e992a4SHeiner Kallweit { 577425e992a4SHeiner Kallweit return (status & (FirstFrag | LastFrag)) != (FirstFrag | LastFrag); 577525e992a4SHeiner Kallweit } 577625e992a4SHeiner Kallweit 577725e992a4SHeiner Kallweit static inline void rtl8169_rx_csum(struct sk_buff *skb, u32 opts1) 577825e992a4SHeiner Kallweit { 577925e992a4SHeiner Kallweit u32 status = opts1 & RxProtoMask; 578025e992a4SHeiner Kallweit 578125e992a4SHeiner Kallweit if (((status == RxProtoTCP) && !(opts1 & TCPFail)) || 578225e992a4SHeiner Kallweit ((status == RxProtoUDP) && !(opts1 & UDPFail))) 578325e992a4SHeiner Kallweit skb->ip_summed = CHECKSUM_UNNECESSARY; 578425e992a4SHeiner Kallweit else 578525e992a4SHeiner Kallweit skb_checksum_none_assert(skb); 578625e992a4SHeiner Kallweit } 578725e992a4SHeiner Kallweit 578825e992a4SHeiner Kallweit static int rtl_rx(struct net_device *dev, struct rtl8169_private *tp, u32 budget) 578925e992a4SHeiner Kallweit { 579025e992a4SHeiner Kallweit unsigned int cur_rx, rx_left; 579125e992a4SHeiner Kallweit unsigned int count; 579225e992a4SHeiner Kallweit 579325e992a4SHeiner Kallweit cur_rx = tp->cur_rx; 579425e992a4SHeiner Kallweit 579525e992a4SHeiner Kallweit for (rx_left = min(budget, NUM_RX_DESC); rx_left > 0; rx_left--, cur_rx++) { 579625e992a4SHeiner Kallweit unsigned int entry = cur_rx % NUM_RX_DESC; 579732879f00SHeiner Kallweit const void *rx_buf = page_address(tp->Rx_databuff[entry]); 579825e992a4SHeiner Kallweit struct RxDesc *desc = tp->RxDescArray + entry; 579925e992a4SHeiner Kallweit u32 status; 580025e992a4SHeiner Kallweit 580125e992a4SHeiner Kallweit status = le32_to_cpu(desc->opts1); 580225e992a4SHeiner Kallweit if (status & DescOwn) 580325e992a4SHeiner Kallweit break; 580425e992a4SHeiner Kallweit 580525e992a4SHeiner Kallweit /* This barrier is needed to keep us from reading 580625e992a4SHeiner Kallweit * any other fields out of the Rx descriptor until 580725e992a4SHeiner Kallweit * we know the status of DescOwn 580825e992a4SHeiner Kallweit */ 580925e992a4SHeiner Kallweit dma_rmb(); 581025e992a4SHeiner Kallweit 581125e992a4SHeiner Kallweit if (unlikely(status & RxRES)) { 581225e992a4SHeiner Kallweit netif_info(tp, rx_err, dev, "Rx ERROR. status = %08x\n", 581325e992a4SHeiner Kallweit status); 581425e992a4SHeiner Kallweit dev->stats.rx_errors++; 581525e992a4SHeiner Kallweit if (status & (RxRWT | RxRUNT)) 581625e992a4SHeiner Kallweit dev->stats.rx_length_errors++; 581725e992a4SHeiner Kallweit if (status & RxCRC) 581825e992a4SHeiner Kallweit dev->stats.rx_crc_errors++; 581925e992a4SHeiner Kallweit if (status & (RxRUNT | RxCRC) && !(status & RxRWT) && 582025e992a4SHeiner Kallweit dev->features & NETIF_F_RXALL) { 582125e992a4SHeiner Kallweit goto process_pkt; 582225e992a4SHeiner Kallweit } 582325e992a4SHeiner Kallweit } else { 5824fcd4e608SHeiner Kallweit unsigned int pkt_size; 582525e992a4SHeiner Kallweit struct sk_buff *skb; 582625e992a4SHeiner Kallweit 582725e992a4SHeiner Kallweit process_pkt: 5828fcd4e608SHeiner Kallweit pkt_size = status & GENMASK(13, 0); 582925e992a4SHeiner Kallweit if (likely(!(dev->features & NETIF_F_RXFCS))) 5830fcd4e608SHeiner Kallweit pkt_size -= ETH_FCS_LEN; 583125e992a4SHeiner Kallweit /* 583225e992a4SHeiner Kallweit * The driver does not support incoming fragmented 583325e992a4SHeiner Kallweit * frames. They are seen as a symptom of over-mtu 583425e992a4SHeiner Kallweit * sized frames. 583525e992a4SHeiner Kallweit */ 583625e992a4SHeiner Kallweit if (unlikely(rtl8169_fragmented_frame(status))) { 583725e992a4SHeiner Kallweit dev->stats.rx_dropped++; 583825e992a4SHeiner Kallweit dev->stats.rx_length_errors++; 583925e992a4SHeiner Kallweit goto release_descriptor; 584025e992a4SHeiner Kallweit } 584125e992a4SHeiner Kallweit 5842fcd4e608SHeiner Kallweit skb = napi_alloc_skb(&tp->napi, pkt_size); 5843fcd4e608SHeiner Kallweit if (unlikely(!skb)) { 584425e992a4SHeiner Kallweit dev->stats.rx_dropped++; 584525e992a4SHeiner Kallweit goto release_descriptor; 584625e992a4SHeiner Kallweit } 584725e992a4SHeiner Kallweit 58483c95e501SHeiner Kallweit dma_sync_single_for_cpu(tp_to_dev(tp), 58493c95e501SHeiner Kallweit le64_to_cpu(desc->addr), 58503c95e501SHeiner Kallweit pkt_size, DMA_FROM_DEVICE); 585132879f00SHeiner Kallweit prefetch(rx_buf); 585232879f00SHeiner Kallweit skb_copy_to_linear_data(skb, rx_buf, pkt_size); 5853fcd4e608SHeiner Kallweit skb->tail += pkt_size; 5854fcd4e608SHeiner Kallweit skb->len = pkt_size; 5855fcd4e608SHeiner Kallweit 5856d4ed7463SHeiner Kallweit dma_sync_single_for_device(tp_to_dev(tp), 5857d4ed7463SHeiner Kallweit le64_to_cpu(desc->addr), 5858d4ed7463SHeiner Kallweit pkt_size, DMA_FROM_DEVICE); 5859d4ed7463SHeiner Kallweit 586025e992a4SHeiner Kallweit rtl8169_rx_csum(skb, status); 586125e992a4SHeiner Kallweit skb->protocol = eth_type_trans(skb, dev); 586225e992a4SHeiner Kallweit 586325e992a4SHeiner Kallweit rtl8169_rx_vlan_tag(desc, skb); 586425e992a4SHeiner Kallweit 586525e992a4SHeiner Kallweit if (skb->pkt_type == PACKET_MULTICAST) 586625e992a4SHeiner Kallweit dev->stats.multicast++; 586725e992a4SHeiner Kallweit 586825e992a4SHeiner Kallweit napi_gro_receive(&tp->napi, skb); 586925e992a4SHeiner Kallweit 587025e992a4SHeiner Kallweit u64_stats_update_begin(&tp->rx_stats.syncp); 587125e992a4SHeiner Kallweit tp->rx_stats.packets++; 587225e992a4SHeiner Kallweit tp->rx_stats.bytes += pkt_size; 587325e992a4SHeiner Kallweit u64_stats_update_end(&tp->rx_stats.syncp); 587425e992a4SHeiner Kallweit } 587525e992a4SHeiner Kallweit release_descriptor: 587625e992a4SHeiner Kallweit desc->opts2 = 0; 587725e992a4SHeiner Kallweit rtl8169_mark_to_asic(desc); 587825e992a4SHeiner Kallweit } 587925e992a4SHeiner Kallweit 588025e992a4SHeiner Kallweit count = cur_rx - tp->cur_rx; 588125e992a4SHeiner Kallweit tp->cur_rx = cur_rx; 588225e992a4SHeiner Kallweit 588325e992a4SHeiner Kallweit return count; 588425e992a4SHeiner Kallweit } 588525e992a4SHeiner Kallweit 588625e992a4SHeiner Kallweit static irqreturn_t rtl8169_interrupt(int irq, void *dev_instance) 588725e992a4SHeiner Kallweit { 588825e992a4SHeiner Kallweit struct rtl8169_private *tp = dev_instance; 5889c1d532d2SHeiner Kallweit u32 status = rtl_get_events(tp); 589025e992a4SHeiner Kallweit 5891c1d532d2SHeiner Kallweit if (!tp->irq_enabled || (status & 0xffff) == 0xffff || 5892c1d532d2SHeiner Kallweit !(status & tp->irq_mask)) 589325e992a4SHeiner Kallweit return IRQ_NONE; 589425e992a4SHeiner Kallweit 589525e992a4SHeiner Kallweit if (unlikely(status & SYSErr)) { 589625e992a4SHeiner Kallweit rtl8169_pcierr_interrupt(tp->dev); 589725e992a4SHeiner Kallweit goto out; 589825e992a4SHeiner Kallweit } 589925e992a4SHeiner Kallweit 590025e992a4SHeiner Kallweit if (status & LinkChg) 590125e992a4SHeiner Kallweit phy_mac_interrupt(tp->phydev); 590225e992a4SHeiner Kallweit 590325e992a4SHeiner Kallweit if (unlikely(status & RxFIFOOver && 590425e992a4SHeiner Kallweit tp->mac_version == RTL_GIGA_MAC_VER_11)) { 590525e992a4SHeiner Kallweit netif_stop_queue(tp->dev); 590625e992a4SHeiner Kallweit /* XXX - Hack alert. See rtl_task(). */ 590725e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_RESET_PENDING, tp->wk.flags); 590825e992a4SHeiner Kallweit } 590925e992a4SHeiner Kallweit 591025e992a4SHeiner Kallweit rtl_irq_disable(tp); 591125e992a4SHeiner Kallweit napi_schedule_irqoff(&tp->napi); 591225e992a4SHeiner Kallweit out: 591325e992a4SHeiner Kallweit rtl_ack_events(tp, status); 591425e992a4SHeiner Kallweit 591525e992a4SHeiner Kallweit return IRQ_HANDLED; 591625e992a4SHeiner Kallweit } 591725e992a4SHeiner Kallweit 591825e992a4SHeiner Kallweit static void rtl_task(struct work_struct *work) 591925e992a4SHeiner Kallweit { 592025e992a4SHeiner Kallweit static const struct { 592125e992a4SHeiner Kallweit int bitnr; 592225e992a4SHeiner Kallweit void (*action)(struct rtl8169_private *); 592325e992a4SHeiner Kallweit } rtl_work[] = { 592425e992a4SHeiner Kallweit { RTL_FLAG_TASK_RESET_PENDING, rtl_reset_work }, 592525e992a4SHeiner Kallweit }; 592625e992a4SHeiner Kallweit struct rtl8169_private *tp = 592725e992a4SHeiner Kallweit container_of(work, struct rtl8169_private, wk.work); 592825e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 592925e992a4SHeiner Kallweit int i; 593025e992a4SHeiner Kallweit 593125e992a4SHeiner Kallweit rtl_lock_work(tp); 593225e992a4SHeiner Kallweit 593325e992a4SHeiner Kallweit if (!netif_running(dev) || 593425e992a4SHeiner Kallweit !test_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags)) 593525e992a4SHeiner Kallweit goto out_unlock; 593625e992a4SHeiner Kallweit 593725e992a4SHeiner Kallweit for (i = 0; i < ARRAY_SIZE(rtl_work); i++) { 593825e992a4SHeiner Kallweit bool pending; 593925e992a4SHeiner Kallweit 594025e992a4SHeiner Kallweit pending = test_and_clear_bit(rtl_work[i].bitnr, tp->wk.flags); 594125e992a4SHeiner Kallweit if (pending) 594225e992a4SHeiner Kallweit rtl_work[i].action(tp); 594325e992a4SHeiner Kallweit } 594425e992a4SHeiner Kallweit 594525e992a4SHeiner Kallweit out_unlock: 594625e992a4SHeiner Kallweit rtl_unlock_work(tp); 594725e992a4SHeiner Kallweit } 594825e992a4SHeiner Kallweit 594925e992a4SHeiner Kallweit static int rtl8169_poll(struct napi_struct *napi, int budget) 595025e992a4SHeiner Kallweit { 595125e992a4SHeiner Kallweit struct rtl8169_private *tp = container_of(napi, struct rtl8169_private, napi); 595225e992a4SHeiner Kallweit struct net_device *dev = tp->dev; 595325e992a4SHeiner Kallweit int work_done; 595425e992a4SHeiner Kallweit 595525e992a4SHeiner Kallweit work_done = rtl_rx(dev, tp, (u32) budget); 595625e992a4SHeiner Kallweit 595725e992a4SHeiner Kallweit rtl_tx(dev, tp, budget); 595825e992a4SHeiner Kallweit 595925e992a4SHeiner Kallweit if (work_done < budget) { 596025e992a4SHeiner Kallweit napi_complete_done(napi, work_done); 596125e992a4SHeiner Kallweit rtl_irq_enable(tp); 596225e992a4SHeiner Kallweit } 596325e992a4SHeiner Kallweit 596425e992a4SHeiner Kallweit return work_done; 596525e992a4SHeiner Kallweit } 596625e992a4SHeiner Kallweit 596725e992a4SHeiner Kallweit static void rtl8169_rx_missed(struct net_device *dev) 596825e992a4SHeiner Kallweit { 596925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 597025e992a4SHeiner Kallweit 597125e992a4SHeiner Kallweit if (tp->mac_version > RTL_GIGA_MAC_VER_06) 597225e992a4SHeiner Kallweit return; 597325e992a4SHeiner Kallweit 597425e992a4SHeiner Kallweit dev->stats.rx_missed_errors += RTL_R32(tp, RxMissed) & 0xffffff; 597525e992a4SHeiner Kallweit RTL_W32(tp, RxMissed, 0); 597625e992a4SHeiner Kallweit } 597725e992a4SHeiner Kallweit 597825e992a4SHeiner Kallweit static void r8169_phylink_handler(struct net_device *ndev) 597925e992a4SHeiner Kallweit { 598025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(ndev); 598125e992a4SHeiner Kallweit 598225e992a4SHeiner Kallweit if (netif_carrier_ok(ndev)) { 598325e992a4SHeiner Kallweit rtl_link_chg_patch(tp); 598425e992a4SHeiner Kallweit pm_request_resume(&tp->pci_dev->dev); 598525e992a4SHeiner Kallweit } else { 598625e992a4SHeiner Kallweit pm_runtime_idle(&tp->pci_dev->dev); 598725e992a4SHeiner Kallweit } 598825e992a4SHeiner Kallweit 598925e992a4SHeiner Kallweit if (net_ratelimit()) 599025e992a4SHeiner Kallweit phy_print_status(tp->phydev); 599125e992a4SHeiner Kallweit } 599225e992a4SHeiner Kallweit 599325e992a4SHeiner Kallweit static int r8169_phy_connect(struct rtl8169_private *tp) 599425e992a4SHeiner Kallweit { 599525e992a4SHeiner Kallweit struct phy_device *phydev = tp->phydev; 599625e992a4SHeiner Kallweit phy_interface_t phy_mode; 599725e992a4SHeiner Kallweit int ret; 599825e992a4SHeiner Kallweit 599925e992a4SHeiner Kallweit phy_mode = tp->supports_gmii ? PHY_INTERFACE_MODE_GMII : 600025e992a4SHeiner Kallweit PHY_INTERFACE_MODE_MII; 600125e992a4SHeiner Kallweit 600225e992a4SHeiner Kallweit ret = phy_connect_direct(tp->dev, phydev, r8169_phylink_handler, 600325e992a4SHeiner Kallweit phy_mode); 600425e992a4SHeiner Kallweit if (ret) 600525e992a4SHeiner Kallweit return ret; 600625e992a4SHeiner Kallweit 600766058b1cSHeiner Kallweit if (!tp->supports_gmii) 600825e992a4SHeiner Kallweit phy_set_max_speed(phydev, SPEED_100); 600925e992a4SHeiner Kallweit 601025e992a4SHeiner Kallweit phy_support_asym_pause(phydev); 601125e992a4SHeiner Kallweit 601225e992a4SHeiner Kallweit phy_attached_info(phydev); 601325e992a4SHeiner Kallweit 601425e992a4SHeiner Kallweit return 0; 601525e992a4SHeiner Kallweit } 601625e992a4SHeiner Kallweit 601725e992a4SHeiner Kallweit static void rtl8169_down(struct net_device *dev) 601825e992a4SHeiner Kallweit { 601925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 602025e992a4SHeiner Kallweit 602125e992a4SHeiner Kallweit phy_stop(tp->phydev); 602225e992a4SHeiner Kallweit 602325e992a4SHeiner Kallweit napi_disable(&tp->napi); 602425e992a4SHeiner Kallweit netif_stop_queue(dev); 602525e992a4SHeiner Kallweit 602625e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 602725e992a4SHeiner Kallweit /* 602825e992a4SHeiner Kallweit * At this point device interrupts can not be enabled in any function, 602925e992a4SHeiner Kallweit * as netif_running is not true (rtl8169_interrupt, rtl8169_reset_task) 603025e992a4SHeiner Kallweit * and napi is disabled (rtl8169_poll). 603125e992a4SHeiner Kallweit */ 603225e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 603325e992a4SHeiner Kallweit 603425e992a4SHeiner Kallweit /* Give a racing hard_start_xmit a few cycles to complete. */ 603525e992a4SHeiner Kallweit synchronize_rcu(); 603625e992a4SHeiner Kallweit 603725e992a4SHeiner Kallweit rtl8169_tx_clear(tp); 603825e992a4SHeiner Kallweit 603925e992a4SHeiner Kallweit rtl8169_rx_clear(tp); 604025e992a4SHeiner Kallweit 604125e992a4SHeiner Kallweit rtl_pll_power_down(tp); 604225e992a4SHeiner Kallweit } 604325e992a4SHeiner Kallweit 604425e992a4SHeiner Kallweit static int rtl8169_close(struct net_device *dev) 604525e992a4SHeiner Kallweit { 604625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 604725e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 604825e992a4SHeiner Kallweit 604925e992a4SHeiner Kallweit pm_runtime_get_sync(&pdev->dev); 605025e992a4SHeiner Kallweit 605125e992a4SHeiner Kallweit /* Update counters before going down */ 605225e992a4SHeiner Kallweit rtl8169_update_counters(tp); 605325e992a4SHeiner Kallweit 605425e992a4SHeiner Kallweit rtl_lock_work(tp); 605525e992a4SHeiner Kallweit /* Clear all task flags */ 605625e992a4SHeiner Kallweit bitmap_zero(tp->wk.flags, RTL_FLAG_MAX); 605725e992a4SHeiner Kallweit 605825e992a4SHeiner Kallweit rtl8169_down(dev); 605925e992a4SHeiner Kallweit rtl_unlock_work(tp); 606025e992a4SHeiner Kallweit 606125e992a4SHeiner Kallweit cancel_work_sync(&tp->wk.work); 606225e992a4SHeiner Kallweit 606325e992a4SHeiner Kallweit phy_disconnect(tp->phydev); 606425e992a4SHeiner Kallweit 606525e992a4SHeiner Kallweit pci_free_irq(pdev, 0, tp); 606625e992a4SHeiner Kallweit 606725e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray, 606825e992a4SHeiner Kallweit tp->RxPhyAddr); 606925e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray, 607025e992a4SHeiner Kallweit tp->TxPhyAddr); 607125e992a4SHeiner Kallweit tp->TxDescArray = NULL; 607225e992a4SHeiner Kallweit tp->RxDescArray = NULL; 607325e992a4SHeiner Kallweit 607425e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 607525e992a4SHeiner Kallweit 607625e992a4SHeiner Kallweit return 0; 607725e992a4SHeiner Kallweit } 607825e992a4SHeiner Kallweit 607925e992a4SHeiner Kallweit #ifdef CONFIG_NET_POLL_CONTROLLER 608025e992a4SHeiner Kallweit static void rtl8169_netpoll(struct net_device *dev) 608125e992a4SHeiner Kallweit { 608225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 608325e992a4SHeiner Kallweit 608425e992a4SHeiner Kallweit rtl8169_interrupt(pci_irq_vector(tp->pci_dev, 0), tp); 608525e992a4SHeiner Kallweit } 608625e992a4SHeiner Kallweit #endif 608725e992a4SHeiner Kallweit 608825e992a4SHeiner Kallweit static int rtl_open(struct net_device *dev) 608925e992a4SHeiner Kallweit { 609025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 609125e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 609225e992a4SHeiner Kallweit int retval = -ENOMEM; 609325e992a4SHeiner Kallweit 609425e992a4SHeiner Kallweit pm_runtime_get_sync(&pdev->dev); 609525e992a4SHeiner Kallweit 609625e992a4SHeiner Kallweit /* 609725e992a4SHeiner Kallweit * Rx and Tx descriptors needs 256 bytes alignment. 609825e992a4SHeiner Kallweit * dma_alloc_coherent provides more. 609925e992a4SHeiner Kallweit */ 610025e992a4SHeiner Kallweit tp->TxDescArray = dma_alloc_coherent(&pdev->dev, R8169_TX_RING_BYTES, 610125e992a4SHeiner Kallweit &tp->TxPhyAddr, GFP_KERNEL); 610225e992a4SHeiner Kallweit if (!tp->TxDescArray) 610325e992a4SHeiner Kallweit goto err_pm_runtime_put; 610425e992a4SHeiner Kallweit 610525e992a4SHeiner Kallweit tp->RxDescArray = dma_alloc_coherent(&pdev->dev, R8169_RX_RING_BYTES, 610625e992a4SHeiner Kallweit &tp->RxPhyAddr, GFP_KERNEL); 610725e992a4SHeiner Kallweit if (!tp->RxDescArray) 610825e992a4SHeiner Kallweit goto err_free_tx_0; 610925e992a4SHeiner Kallweit 611025e992a4SHeiner Kallweit retval = rtl8169_init_ring(tp); 611125e992a4SHeiner Kallweit if (retval < 0) 611225e992a4SHeiner Kallweit goto err_free_rx_1; 611325e992a4SHeiner Kallweit 611425e992a4SHeiner Kallweit rtl_request_firmware(tp); 611525e992a4SHeiner Kallweit 611625e992a4SHeiner Kallweit retval = pci_request_irq(pdev, 0, rtl8169_interrupt, NULL, tp, 611725e992a4SHeiner Kallweit dev->name); 611825e992a4SHeiner Kallweit if (retval < 0) 611925e992a4SHeiner Kallweit goto err_release_fw_2; 612025e992a4SHeiner Kallweit 612125e992a4SHeiner Kallweit retval = r8169_phy_connect(tp); 612225e992a4SHeiner Kallweit if (retval) 612325e992a4SHeiner Kallweit goto err_free_irq; 612425e992a4SHeiner Kallweit 612525e992a4SHeiner Kallweit rtl_lock_work(tp); 612625e992a4SHeiner Kallweit 612725e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags); 612825e992a4SHeiner Kallweit 612925e992a4SHeiner Kallweit napi_enable(&tp->napi); 613025e992a4SHeiner Kallweit 613125e992a4SHeiner Kallweit rtl8169_init_phy(dev, tp); 613225e992a4SHeiner Kallweit 613325e992a4SHeiner Kallweit rtl_pll_power_up(tp); 613425e992a4SHeiner Kallweit 613525e992a4SHeiner Kallweit rtl_hw_start(tp); 613625e992a4SHeiner Kallweit 613725e992a4SHeiner Kallweit if (!rtl8169_init_counter_offsets(tp)) 613825e992a4SHeiner Kallweit netif_warn(tp, hw, dev, "counter reset/update failed\n"); 613925e992a4SHeiner Kallweit 614025e992a4SHeiner Kallweit phy_start(tp->phydev); 614125e992a4SHeiner Kallweit netif_start_queue(dev); 614225e992a4SHeiner Kallweit 614325e992a4SHeiner Kallweit rtl_unlock_work(tp); 614425e992a4SHeiner Kallweit 614525e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 614625e992a4SHeiner Kallweit out: 614725e992a4SHeiner Kallweit return retval; 614825e992a4SHeiner Kallweit 614925e992a4SHeiner Kallweit err_free_irq: 615025e992a4SHeiner Kallweit pci_free_irq(pdev, 0, tp); 615125e992a4SHeiner Kallweit err_release_fw_2: 615225e992a4SHeiner Kallweit rtl_release_firmware(tp); 615325e992a4SHeiner Kallweit rtl8169_rx_clear(tp); 615425e992a4SHeiner Kallweit err_free_rx_1: 615525e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray, 615625e992a4SHeiner Kallweit tp->RxPhyAddr); 615725e992a4SHeiner Kallweit tp->RxDescArray = NULL; 615825e992a4SHeiner Kallweit err_free_tx_0: 615925e992a4SHeiner Kallweit dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray, 616025e992a4SHeiner Kallweit tp->TxPhyAddr); 616125e992a4SHeiner Kallweit tp->TxDescArray = NULL; 616225e992a4SHeiner Kallweit err_pm_runtime_put: 616325e992a4SHeiner Kallweit pm_runtime_put_noidle(&pdev->dev); 616425e992a4SHeiner Kallweit goto out; 616525e992a4SHeiner Kallweit } 616625e992a4SHeiner Kallweit 616725e992a4SHeiner Kallweit static void 616825e992a4SHeiner Kallweit rtl8169_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats) 616925e992a4SHeiner Kallweit { 617025e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 617125e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 617225e992a4SHeiner Kallweit struct rtl8169_counters *counters = tp->counters; 617325e992a4SHeiner Kallweit unsigned int start; 617425e992a4SHeiner Kallweit 617525e992a4SHeiner Kallweit pm_runtime_get_noresume(&pdev->dev); 617625e992a4SHeiner Kallweit 617725e992a4SHeiner Kallweit if (netif_running(dev) && pm_runtime_active(&pdev->dev)) 617825e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 617925e992a4SHeiner Kallweit 618025e992a4SHeiner Kallweit do { 618125e992a4SHeiner Kallweit start = u64_stats_fetch_begin_irq(&tp->rx_stats.syncp); 618225e992a4SHeiner Kallweit stats->rx_packets = tp->rx_stats.packets; 618325e992a4SHeiner Kallweit stats->rx_bytes = tp->rx_stats.bytes; 618425e992a4SHeiner Kallweit } while (u64_stats_fetch_retry_irq(&tp->rx_stats.syncp, start)); 618525e992a4SHeiner Kallweit 618625e992a4SHeiner Kallweit do { 618725e992a4SHeiner Kallweit start = u64_stats_fetch_begin_irq(&tp->tx_stats.syncp); 618825e992a4SHeiner Kallweit stats->tx_packets = tp->tx_stats.packets; 618925e992a4SHeiner Kallweit stats->tx_bytes = tp->tx_stats.bytes; 619025e992a4SHeiner Kallweit } while (u64_stats_fetch_retry_irq(&tp->tx_stats.syncp, start)); 619125e992a4SHeiner Kallweit 619225e992a4SHeiner Kallweit stats->rx_dropped = dev->stats.rx_dropped; 619325e992a4SHeiner Kallweit stats->tx_dropped = dev->stats.tx_dropped; 619425e992a4SHeiner Kallweit stats->rx_length_errors = dev->stats.rx_length_errors; 619525e992a4SHeiner Kallweit stats->rx_errors = dev->stats.rx_errors; 619625e992a4SHeiner Kallweit stats->rx_crc_errors = dev->stats.rx_crc_errors; 619725e992a4SHeiner Kallweit stats->rx_fifo_errors = dev->stats.rx_fifo_errors; 619825e992a4SHeiner Kallweit stats->rx_missed_errors = dev->stats.rx_missed_errors; 619925e992a4SHeiner Kallweit stats->multicast = dev->stats.multicast; 620025e992a4SHeiner Kallweit 620125e992a4SHeiner Kallweit /* 6202ed72a9bbSCorentin Musard * Fetch additional counter values missing in stats collected by driver 620325e992a4SHeiner Kallweit * from tally counters. 620425e992a4SHeiner Kallweit */ 620525e992a4SHeiner Kallweit if (pm_runtime_active(&pdev->dev)) 620625e992a4SHeiner Kallweit rtl8169_update_counters(tp); 620725e992a4SHeiner Kallweit 620825e992a4SHeiner Kallweit /* 620925e992a4SHeiner Kallweit * Subtract values fetched during initalization. 621025e992a4SHeiner Kallweit * See rtl8169_init_counter_offsets for a description why we do that. 621125e992a4SHeiner Kallweit */ 621225e992a4SHeiner Kallweit stats->tx_errors = le64_to_cpu(counters->tx_errors) - 621325e992a4SHeiner Kallweit le64_to_cpu(tp->tc_offset.tx_errors); 621425e992a4SHeiner Kallweit stats->collisions = le32_to_cpu(counters->tx_multi_collision) - 621525e992a4SHeiner Kallweit le32_to_cpu(tp->tc_offset.tx_multi_collision); 621625e992a4SHeiner Kallweit stats->tx_aborted_errors = le16_to_cpu(counters->tx_aborted) - 621725e992a4SHeiner Kallweit le16_to_cpu(tp->tc_offset.tx_aborted); 621825e992a4SHeiner Kallweit 621925e992a4SHeiner Kallweit pm_runtime_put_noidle(&pdev->dev); 622025e992a4SHeiner Kallweit } 622125e992a4SHeiner Kallweit 622225e992a4SHeiner Kallweit static void rtl8169_net_suspend(struct net_device *dev) 622325e992a4SHeiner Kallweit { 622425e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 622525e992a4SHeiner Kallweit 622625e992a4SHeiner Kallweit if (!netif_running(dev)) 622725e992a4SHeiner Kallweit return; 622825e992a4SHeiner Kallweit 622925e992a4SHeiner Kallweit phy_stop(tp->phydev); 623025e992a4SHeiner Kallweit netif_device_detach(dev); 623125e992a4SHeiner Kallweit 623225e992a4SHeiner Kallweit rtl_lock_work(tp); 623325e992a4SHeiner Kallweit napi_disable(&tp->napi); 623425e992a4SHeiner Kallweit /* Clear all task flags */ 623525e992a4SHeiner Kallweit bitmap_zero(tp->wk.flags, RTL_FLAG_MAX); 623625e992a4SHeiner Kallweit 623725e992a4SHeiner Kallweit rtl_unlock_work(tp); 623825e992a4SHeiner Kallweit 623925e992a4SHeiner Kallweit rtl_pll_power_down(tp); 624025e992a4SHeiner Kallweit } 624125e992a4SHeiner Kallweit 624225e992a4SHeiner Kallweit #ifdef CONFIG_PM 624325e992a4SHeiner Kallweit 624425e992a4SHeiner Kallweit static int rtl8169_suspend(struct device *device) 624525e992a4SHeiner Kallweit { 624625e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 624725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 624825e992a4SHeiner Kallweit 624925e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 625025e992a4SHeiner Kallweit clk_disable_unprepare(tp->clk); 625125e992a4SHeiner Kallweit 625225e992a4SHeiner Kallweit return 0; 625325e992a4SHeiner Kallweit } 625425e992a4SHeiner Kallweit 625525e992a4SHeiner Kallweit static void __rtl8169_resume(struct net_device *dev) 625625e992a4SHeiner Kallweit { 625725e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 625825e992a4SHeiner Kallweit 625925e992a4SHeiner Kallweit netif_device_attach(dev); 626025e992a4SHeiner Kallweit 626125e992a4SHeiner Kallweit rtl_pll_power_up(tp); 626225e992a4SHeiner Kallweit rtl8169_init_phy(dev, tp); 626325e992a4SHeiner Kallweit 626425e992a4SHeiner Kallweit phy_start(tp->phydev); 626525e992a4SHeiner Kallweit 626625e992a4SHeiner Kallweit rtl_lock_work(tp); 626725e992a4SHeiner Kallweit napi_enable(&tp->napi); 626825e992a4SHeiner Kallweit set_bit(RTL_FLAG_TASK_ENABLED, tp->wk.flags); 626925e992a4SHeiner Kallweit rtl_reset_work(tp); 627025e992a4SHeiner Kallweit rtl_unlock_work(tp); 627125e992a4SHeiner Kallweit } 627225e992a4SHeiner Kallweit 627325e992a4SHeiner Kallweit static int rtl8169_resume(struct device *device) 627425e992a4SHeiner Kallweit { 627525e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 627625e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 627725e992a4SHeiner Kallweit 627825e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 627925e992a4SHeiner Kallweit 628025e992a4SHeiner Kallweit clk_prepare_enable(tp->clk); 628125e992a4SHeiner Kallweit 628225e992a4SHeiner Kallweit if (netif_running(dev)) 628325e992a4SHeiner Kallweit __rtl8169_resume(dev); 628425e992a4SHeiner Kallweit 628525e992a4SHeiner Kallweit return 0; 628625e992a4SHeiner Kallweit } 628725e992a4SHeiner Kallweit 628825e992a4SHeiner Kallweit static int rtl8169_runtime_suspend(struct device *device) 628925e992a4SHeiner Kallweit { 629025e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 629125e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 629225e992a4SHeiner Kallweit 629325e992a4SHeiner Kallweit if (!tp->TxDescArray) 629425e992a4SHeiner Kallweit return 0; 629525e992a4SHeiner Kallweit 629625e992a4SHeiner Kallweit rtl_lock_work(tp); 629725e992a4SHeiner Kallweit __rtl8169_set_wol(tp, WAKE_ANY); 629825e992a4SHeiner Kallweit rtl_unlock_work(tp); 629925e992a4SHeiner Kallweit 630025e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 630125e992a4SHeiner Kallweit 630225e992a4SHeiner Kallweit /* Update counters before going runtime suspend */ 630325e992a4SHeiner Kallweit rtl8169_rx_missed(dev); 630425e992a4SHeiner Kallweit rtl8169_update_counters(tp); 630525e992a4SHeiner Kallweit 630625e992a4SHeiner Kallweit return 0; 630725e992a4SHeiner Kallweit } 630825e992a4SHeiner Kallweit 630925e992a4SHeiner Kallweit static int rtl8169_runtime_resume(struct device *device) 631025e992a4SHeiner Kallweit { 631125e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 631225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 631325e992a4SHeiner Kallweit 631425e992a4SHeiner Kallweit rtl_rar_set(tp, dev->dev_addr); 631525e992a4SHeiner Kallweit 631625e992a4SHeiner Kallweit if (!tp->TxDescArray) 631725e992a4SHeiner Kallweit return 0; 631825e992a4SHeiner Kallweit 631925e992a4SHeiner Kallweit rtl_lock_work(tp); 632025e992a4SHeiner Kallweit __rtl8169_set_wol(tp, tp->saved_wolopts); 632125e992a4SHeiner Kallweit rtl_unlock_work(tp); 632225e992a4SHeiner Kallweit 632325e992a4SHeiner Kallweit __rtl8169_resume(dev); 632425e992a4SHeiner Kallweit 632525e992a4SHeiner Kallweit return 0; 632625e992a4SHeiner Kallweit } 632725e992a4SHeiner Kallweit 632825e992a4SHeiner Kallweit static int rtl8169_runtime_idle(struct device *device) 632925e992a4SHeiner Kallweit { 633025e992a4SHeiner Kallweit struct net_device *dev = dev_get_drvdata(device); 633125e992a4SHeiner Kallweit 633225e992a4SHeiner Kallweit if (!netif_running(dev) || !netif_carrier_ok(dev)) 633325e992a4SHeiner Kallweit pm_schedule_suspend(device, 10000); 633425e992a4SHeiner Kallweit 633525e992a4SHeiner Kallweit return -EBUSY; 633625e992a4SHeiner Kallweit } 633725e992a4SHeiner Kallweit 633825e992a4SHeiner Kallweit static const struct dev_pm_ops rtl8169_pm_ops = { 633925e992a4SHeiner Kallweit .suspend = rtl8169_suspend, 634025e992a4SHeiner Kallweit .resume = rtl8169_resume, 634125e992a4SHeiner Kallweit .freeze = rtl8169_suspend, 634225e992a4SHeiner Kallweit .thaw = rtl8169_resume, 634325e992a4SHeiner Kallweit .poweroff = rtl8169_suspend, 634425e992a4SHeiner Kallweit .restore = rtl8169_resume, 634525e992a4SHeiner Kallweit .runtime_suspend = rtl8169_runtime_suspend, 634625e992a4SHeiner Kallweit .runtime_resume = rtl8169_runtime_resume, 634725e992a4SHeiner Kallweit .runtime_idle = rtl8169_runtime_idle, 634825e992a4SHeiner Kallweit }; 634925e992a4SHeiner Kallweit 635025e992a4SHeiner Kallweit #define RTL8169_PM_OPS (&rtl8169_pm_ops) 635125e992a4SHeiner Kallweit 635225e992a4SHeiner Kallweit #else /* !CONFIG_PM */ 635325e992a4SHeiner Kallweit 635425e992a4SHeiner Kallweit #define RTL8169_PM_OPS NULL 635525e992a4SHeiner Kallweit 635625e992a4SHeiner Kallweit #endif /* !CONFIG_PM */ 635725e992a4SHeiner Kallweit 635825e992a4SHeiner Kallweit static void rtl_wol_shutdown_quirk(struct rtl8169_private *tp) 635925e992a4SHeiner Kallweit { 636025e992a4SHeiner Kallweit /* WoL fails with 8168b when the receiver is disabled. */ 636125e992a4SHeiner Kallweit switch (tp->mac_version) { 636225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 636325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 636425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 636525e992a4SHeiner Kallweit pci_clear_master(tp->pci_dev); 636625e992a4SHeiner Kallweit 636725e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, CmdRxEnb); 636825e992a4SHeiner Kallweit /* PCI commit */ 636925e992a4SHeiner Kallweit RTL_R8(tp, ChipCmd); 637025e992a4SHeiner Kallweit break; 637125e992a4SHeiner Kallweit default: 637225e992a4SHeiner Kallweit break; 637325e992a4SHeiner Kallweit } 637425e992a4SHeiner Kallweit } 637525e992a4SHeiner Kallweit 637625e992a4SHeiner Kallweit static void rtl_shutdown(struct pci_dev *pdev) 637725e992a4SHeiner Kallweit { 637825e992a4SHeiner Kallweit struct net_device *dev = pci_get_drvdata(pdev); 637925e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 638025e992a4SHeiner Kallweit 638125e992a4SHeiner Kallweit rtl8169_net_suspend(dev); 638225e992a4SHeiner Kallweit 638325e992a4SHeiner Kallweit /* Restore original MAC address */ 638425e992a4SHeiner Kallweit rtl_rar_set(tp, dev->perm_addr); 638525e992a4SHeiner Kallweit 638625e992a4SHeiner Kallweit rtl8169_hw_reset(tp); 638725e992a4SHeiner Kallweit 638825e992a4SHeiner Kallweit if (system_state == SYSTEM_POWER_OFF) { 638925e992a4SHeiner Kallweit if (tp->saved_wolopts) { 639025e992a4SHeiner Kallweit rtl_wol_suspend_quirk(tp); 639125e992a4SHeiner Kallweit rtl_wol_shutdown_quirk(tp); 639225e992a4SHeiner Kallweit } 639325e992a4SHeiner Kallweit 639425e992a4SHeiner Kallweit pci_wake_from_d3(pdev, true); 639525e992a4SHeiner Kallweit pci_set_power_state(pdev, PCI_D3hot); 639625e992a4SHeiner Kallweit } 639725e992a4SHeiner Kallweit } 639825e992a4SHeiner Kallweit 639925e992a4SHeiner Kallweit static void rtl_remove_one(struct pci_dev *pdev) 640025e992a4SHeiner Kallweit { 640125e992a4SHeiner Kallweit struct net_device *dev = pci_get_drvdata(pdev); 640225e992a4SHeiner Kallweit struct rtl8169_private *tp = netdev_priv(dev); 640325e992a4SHeiner Kallweit 640425e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 640525e992a4SHeiner Kallweit rtl8168_driver_stop(tp); 640625e992a4SHeiner Kallweit 640725e992a4SHeiner Kallweit netif_napi_del(&tp->napi); 640825e992a4SHeiner Kallweit 640925e992a4SHeiner Kallweit unregister_netdev(dev); 641025e992a4SHeiner Kallweit mdiobus_unregister(tp->phydev->mdio.bus); 641125e992a4SHeiner Kallweit 641225e992a4SHeiner Kallweit rtl_release_firmware(tp); 641325e992a4SHeiner Kallweit 641425e992a4SHeiner Kallweit if (pci_dev_run_wake(pdev)) 641525e992a4SHeiner Kallweit pm_runtime_get_noresume(&pdev->dev); 641625e992a4SHeiner Kallweit 641725e992a4SHeiner Kallweit /* restore original MAC address */ 641825e992a4SHeiner Kallweit rtl_rar_set(tp, dev->perm_addr); 641925e992a4SHeiner Kallweit } 642025e992a4SHeiner Kallweit 642125e992a4SHeiner Kallweit static const struct net_device_ops rtl_netdev_ops = { 642225e992a4SHeiner Kallweit .ndo_open = rtl_open, 642325e992a4SHeiner Kallweit .ndo_stop = rtl8169_close, 642425e992a4SHeiner Kallweit .ndo_get_stats64 = rtl8169_get_stats64, 642525e992a4SHeiner Kallweit .ndo_start_xmit = rtl8169_start_xmit, 6426e64e0c89SHeiner Kallweit .ndo_features_check = rtl8169_features_check, 642725e992a4SHeiner Kallweit .ndo_tx_timeout = rtl8169_tx_timeout, 642825e992a4SHeiner Kallweit .ndo_validate_addr = eth_validate_addr, 642925e992a4SHeiner Kallweit .ndo_change_mtu = rtl8169_change_mtu, 643025e992a4SHeiner Kallweit .ndo_fix_features = rtl8169_fix_features, 643125e992a4SHeiner Kallweit .ndo_set_features = rtl8169_set_features, 643225e992a4SHeiner Kallweit .ndo_set_mac_address = rtl_set_mac_address, 643325e992a4SHeiner Kallweit .ndo_do_ioctl = rtl8169_ioctl, 643425e992a4SHeiner Kallweit .ndo_set_rx_mode = rtl_set_rx_mode, 643525e992a4SHeiner Kallweit #ifdef CONFIG_NET_POLL_CONTROLLER 643625e992a4SHeiner Kallweit .ndo_poll_controller = rtl8169_netpoll, 643725e992a4SHeiner Kallweit #endif 643825e992a4SHeiner Kallweit 643925e992a4SHeiner Kallweit }; 644025e992a4SHeiner Kallweit 6441ec9a4088SHeiner Kallweit static void rtl_set_irq_mask(struct rtl8169_private *tp) 6442ec9a4088SHeiner Kallweit { 6443ec9a4088SHeiner Kallweit tp->irq_mask = RTL_EVENT_NAPI | LinkChg; 6444ec9a4088SHeiner Kallweit 6445ec9a4088SHeiner Kallweit if (tp->mac_version <= RTL_GIGA_MAC_VER_06) 6446ec9a4088SHeiner Kallweit tp->irq_mask |= SYSErr | RxOverflow | RxFIFOOver; 6447ec9a4088SHeiner Kallweit else if (tp->mac_version == RTL_GIGA_MAC_VER_11) 6448ec9a4088SHeiner Kallweit /* special workaround needed */ 6449ec9a4088SHeiner Kallweit tp->irq_mask |= RxFIFOOver; 6450ec9a4088SHeiner Kallweit else 6451ec9a4088SHeiner Kallweit tp->irq_mask |= RxOverflow; 6452ec9a4088SHeiner Kallweit } 6453ec9a4088SHeiner Kallweit 645425e992a4SHeiner Kallweit static int rtl_alloc_irq(struct rtl8169_private *tp) 645525e992a4SHeiner Kallweit { 645625e992a4SHeiner Kallweit unsigned int flags; 645725e992a4SHeiner Kallweit 6458003bd5b4SHeiner Kallweit switch (tp->mac_version) { 6459003bd5b4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 646025e992a4SHeiner Kallweit rtl_unlock_config_regs(tp); 646125e992a4SHeiner Kallweit RTL_W8(tp, Config2, RTL_R8(tp, Config2) & ~MSIEnable); 646225e992a4SHeiner Kallweit rtl_lock_config_regs(tp); 6463003bd5b4SHeiner Kallweit /* fall through */ 6464003bd5b4SHeiner Kallweit case RTL_GIGA_MAC_VER_07 ... RTL_GIGA_MAC_VER_24: 646525e992a4SHeiner Kallweit flags = PCI_IRQ_LEGACY; 6466003bd5b4SHeiner Kallweit break; 6467003bd5b4SHeiner Kallweit default: 646825e992a4SHeiner Kallweit flags = PCI_IRQ_ALL_TYPES; 6469003bd5b4SHeiner Kallweit break; 647025e992a4SHeiner Kallweit } 647125e992a4SHeiner Kallweit 647225e992a4SHeiner Kallweit return pci_alloc_irq_vectors(tp->pci_dev, 1, 1, flags); 647325e992a4SHeiner Kallweit } 647425e992a4SHeiner Kallweit 647525e992a4SHeiner Kallweit static void rtl_read_mac_address(struct rtl8169_private *tp, 647625e992a4SHeiner Kallweit u8 mac_addr[ETH_ALEN]) 647725e992a4SHeiner Kallweit { 647825e992a4SHeiner Kallweit /* Get MAC address */ 64799e9f33baSHeiner Kallweit if (rtl_is_8168evl_up(tp) && tp->mac_version != RTL_GIGA_MAC_VER_34) { 64809e9f33baSHeiner Kallweit u32 value = rtl_eri_read(tp, 0xe0); 64819e9f33baSHeiner Kallweit 648225e992a4SHeiner Kallweit mac_addr[0] = (value >> 0) & 0xff; 648325e992a4SHeiner Kallweit mac_addr[1] = (value >> 8) & 0xff; 648425e992a4SHeiner Kallweit mac_addr[2] = (value >> 16) & 0xff; 648525e992a4SHeiner Kallweit mac_addr[3] = (value >> 24) & 0xff; 648625e992a4SHeiner Kallweit 648725e992a4SHeiner Kallweit value = rtl_eri_read(tp, 0xe4); 648825e992a4SHeiner Kallweit mac_addr[4] = (value >> 0) & 0xff; 648925e992a4SHeiner Kallweit mac_addr[5] = (value >> 8) & 0xff; 6490f1bce4adSHeiner Kallweit } else if (rtl_is_8125(tp)) { 6491f1bce4adSHeiner Kallweit rtl_read_mac_from_reg(tp, mac_addr, MAC0_BKP); 649225e992a4SHeiner Kallweit } 649325e992a4SHeiner Kallweit } 649425e992a4SHeiner Kallweit 649525e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_link_list_ready_cond) 649625e992a4SHeiner Kallweit { 649725e992a4SHeiner Kallweit return RTL_R8(tp, MCU) & LINK_LIST_RDY; 649825e992a4SHeiner Kallweit } 649925e992a4SHeiner Kallweit 650025e992a4SHeiner Kallweit DECLARE_RTL_COND(rtl_rxtx_empty_cond) 650125e992a4SHeiner Kallweit { 650225e992a4SHeiner Kallweit return (RTL_R8(tp, MCU) & RXTX_EMPTY) == RXTX_EMPTY; 650325e992a4SHeiner Kallweit } 650425e992a4SHeiner Kallweit 650525e992a4SHeiner Kallweit static int r8169_mdio_read_reg(struct mii_bus *mii_bus, int phyaddr, int phyreg) 650625e992a4SHeiner Kallweit { 650725e992a4SHeiner Kallweit struct rtl8169_private *tp = mii_bus->priv; 650825e992a4SHeiner Kallweit 650925e992a4SHeiner Kallweit if (phyaddr > 0) 651025e992a4SHeiner Kallweit return -ENODEV; 651125e992a4SHeiner Kallweit 651225e992a4SHeiner Kallweit return rtl_readphy(tp, phyreg); 651325e992a4SHeiner Kallweit } 651425e992a4SHeiner Kallweit 651525e992a4SHeiner Kallweit static int r8169_mdio_write_reg(struct mii_bus *mii_bus, int phyaddr, 651625e992a4SHeiner Kallweit int phyreg, u16 val) 651725e992a4SHeiner Kallweit { 651825e992a4SHeiner Kallweit struct rtl8169_private *tp = mii_bus->priv; 651925e992a4SHeiner Kallweit 652025e992a4SHeiner Kallweit if (phyaddr > 0) 652125e992a4SHeiner Kallweit return -ENODEV; 652225e992a4SHeiner Kallweit 652325e992a4SHeiner Kallweit rtl_writephy(tp, phyreg, val); 652425e992a4SHeiner Kallweit 652525e992a4SHeiner Kallweit return 0; 652625e992a4SHeiner Kallweit } 652725e992a4SHeiner Kallweit 652825e992a4SHeiner Kallweit static int r8169_mdio_register(struct rtl8169_private *tp) 652925e992a4SHeiner Kallweit { 653025e992a4SHeiner Kallweit struct pci_dev *pdev = tp->pci_dev; 653125e992a4SHeiner Kallweit struct mii_bus *new_bus; 653225e992a4SHeiner Kallweit int ret; 653325e992a4SHeiner Kallweit 653425e992a4SHeiner Kallweit new_bus = devm_mdiobus_alloc(&pdev->dev); 653525e992a4SHeiner Kallweit if (!new_bus) 653625e992a4SHeiner Kallweit return -ENOMEM; 653725e992a4SHeiner Kallweit 653825e992a4SHeiner Kallweit new_bus->name = "r8169"; 653925e992a4SHeiner Kallweit new_bus->priv = tp; 654025e992a4SHeiner Kallweit new_bus->parent = &pdev->dev; 654125e992a4SHeiner Kallweit new_bus->irq[0] = PHY_IGNORE_INTERRUPT; 654225e992a4SHeiner Kallweit snprintf(new_bus->id, MII_BUS_ID_SIZE, "r8169-%x", pci_dev_id(pdev)); 654325e992a4SHeiner Kallweit 654425e992a4SHeiner Kallweit new_bus->read = r8169_mdio_read_reg; 654525e992a4SHeiner Kallweit new_bus->write = r8169_mdio_write_reg; 654625e992a4SHeiner Kallweit 654725e992a4SHeiner Kallweit ret = mdiobus_register(new_bus); 654825e992a4SHeiner Kallweit if (ret) 654925e992a4SHeiner Kallweit return ret; 655025e992a4SHeiner Kallweit 655125e992a4SHeiner Kallweit tp->phydev = mdiobus_get_phy(new_bus, 0); 655225e992a4SHeiner Kallweit if (!tp->phydev) { 655325e992a4SHeiner Kallweit mdiobus_unregister(new_bus); 655425e992a4SHeiner Kallweit return -ENODEV; 655525e992a4SHeiner Kallweit } 655625e992a4SHeiner Kallweit 655725e992a4SHeiner Kallweit /* PHY will be woken up in rtl_open() */ 655825e992a4SHeiner Kallweit phy_suspend(tp->phydev); 655925e992a4SHeiner Kallweit 656025e992a4SHeiner Kallweit return 0; 656125e992a4SHeiner Kallweit } 656225e992a4SHeiner Kallweit 656325e992a4SHeiner Kallweit static void rtl_hw_init_8168g(struct rtl8169_private *tp) 656425e992a4SHeiner Kallweit { 656525e992a4SHeiner Kallweit tp->ocp_base = OCP_STD_PHY_BASE; 656625e992a4SHeiner Kallweit 656725e992a4SHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | RXDV_GATED_EN); 656825e992a4SHeiner Kallweit 656925e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_txcfg_empty_cond, 100, 42)) 657025e992a4SHeiner Kallweit return; 657125e992a4SHeiner Kallweit 657225e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_rxtx_empty_cond, 100, 42)) 657325e992a4SHeiner Kallweit return; 657425e992a4SHeiner Kallweit 657525e992a4SHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) & ~(CmdTxEnb | CmdRxEnb)); 657625e992a4SHeiner Kallweit msleep(1); 657725e992a4SHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 657825e992a4SHeiner Kallweit 6579ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe8de, BIT(14), 0); 658025e992a4SHeiner Kallweit 658125e992a4SHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42)) 658225e992a4SHeiner Kallweit return; 658325e992a4SHeiner Kallweit 6584ef712edeSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe8de, 0, BIT(15)); 658525e992a4SHeiner Kallweit 658625e992a4SHeiner Kallweit rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42); 658725e992a4SHeiner Kallweit } 658825e992a4SHeiner Kallweit 6589f1bce4adSHeiner Kallweit static void rtl_hw_init_8125(struct rtl8169_private *tp) 6590f1bce4adSHeiner Kallweit { 6591f1bce4adSHeiner Kallweit tp->ocp_base = OCP_STD_PHY_BASE; 6592f1bce4adSHeiner Kallweit 6593f1bce4adSHeiner Kallweit RTL_W32(tp, MISC, RTL_R32(tp, MISC) | RXDV_GATED_EN); 6594f1bce4adSHeiner Kallweit 6595f1bce4adSHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_rxtx_empty_cond, 100, 42)) 6596f1bce4adSHeiner Kallweit return; 6597f1bce4adSHeiner Kallweit 6598f1bce4adSHeiner Kallweit RTL_W8(tp, ChipCmd, RTL_R8(tp, ChipCmd) & ~(CmdTxEnb | CmdRxEnb)); 6599f1bce4adSHeiner Kallweit msleep(1); 6600f1bce4adSHeiner Kallweit RTL_W8(tp, MCU, RTL_R8(tp, MCU) & ~NOW_IS_OOB); 6601f1bce4adSHeiner Kallweit 6602f1bce4adSHeiner Kallweit r8168_mac_ocp_modify(tp, 0xe8de, BIT(14), 0); 6603f1bce4adSHeiner Kallweit 6604f1bce4adSHeiner Kallweit if (!rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42)) 6605f1bce4adSHeiner Kallweit return; 6606f1bce4adSHeiner Kallweit 6607f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc0aa, 0x07d0); 6608f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc0a6, 0x0150); 6609f1bce4adSHeiner Kallweit r8168_mac_ocp_write(tp, 0xc01e, 0x5555); 6610f1bce4adSHeiner Kallweit 6611f1bce4adSHeiner Kallweit rtl_udelay_loop_wait_high(tp, &rtl_link_list_ready_cond, 100, 42); 6612f1bce4adSHeiner Kallweit } 6613f1bce4adSHeiner Kallweit 661425e992a4SHeiner Kallweit static void rtl_hw_initialize(struct rtl8169_private *tp) 661525e992a4SHeiner Kallweit { 661625e992a4SHeiner Kallweit switch (tp->mac_version) { 661725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_49 ... RTL_GIGA_MAC_VER_51: 661825e992a4SHeiner Kallweit rtl8168ep_stop_cmac(tp); 661925e992a4SHeiner Kallweit /* fall through */ 662025e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_40 ... RTL_GIGA_MAC_VER_48: 662125e992a4SHeiner Kallweit rtl_hw_init_8168g(tp); 662225e992a4SHeiner Kallweit break; 6623f1bce4adSHeiner Kallweit case RTL_GIGA_MAC_VER_60 ... RTL_GIGA_MAC_VER_61: 6624f1bce4adSHeiner Kallweit rtl_hw_init_8125(tp); 6625f1bce4adSHeiner Kallweit break; 662625e992a4SHeiner Kallweit default: 662725e992a4SHeiner Kallweit break; 662825e992a4SHeiner Kallweit } 662925e992a4SHeiner Kallweit } 663025e992a4SHeiner Kallweit 663125e992a4SHeiner Kallweit static int rtl_jumbo_max(struct rtl8169_private *tp) 663225e992a4SHeiner Kallweit { 663325e992a4SHeiner Kallweit /* Non-GBit versions don't support jumbo frames */ 663425e992a4SHeiner Kallweit if (!tp->supports_gmii) 663525e992a4SHeiner Kallweit return JUMBO_1K; 663625e992a4SHeiner Kallweit 663725e992a4SHeiner Kallweit switch (tp->mac_version) { 663825e992a4SHeiner Kallweit /* RTL8169 */ 663925e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_02 ... RTL_GIGA_MAC_VER_06: 664025e992a4SHeiner Kallweit return JUMBO_7K; 664125e992a4SHeiner Kallweit /* RTL8168b */ 664225e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_11: 664325e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_12: 664425e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_17: 664525e992a4SHeiner Kallweit return JUMBO_4K; 664625e992a4SHeiner Kallweit /* RTL8168c */ 664725e992a4SHeiner Kallweit case RTL_GIGA_MAC_VER_18 ... RTL_GIGA_MAC_VER_24: 664825e992a4SHeiner Kallweit return JUMBO_6K; 664925e992a4SHeiner Kallweit default: 665025e992a4SHeiner Kallweit return JUMBO_9K; 665125e992a4SHeiner Kallweit } 665225e992a4SHeiner Kallweit } 665325e992a4SHeiner Kallweit 665425e992a4SHeiner Kallweit static void rtl_disable_clk(void *data) 665525e992a4SHeiner Kallweit { 665625e992a4SHeiner Kallweit clk_disable_unprepare(data); 665725e992a4SHeiner Kallweit } 665825e992a4SHeiner Kallweit 665925e992a4SHeiner Kallweit static int rtl_get_ether_clk(struct rtl8169_private *tp) 666025e992a4SHeiner Kallweit { 666125e992a4SHeiner Kallweit struct device *d = tp_to_dev(tp); 666225e992a4SHeiner Kallweit struct clk *clk; 666325e992a4SHeiner Kallweit int rc; 666425e992a4SHeiner Kallweit 666525e992a4SHeiner Kallweit clk = devm_clk_get(d, "ether_clk"); 666625e992a4SHeiner Kallweit if (IS_ERR(clk)) { 666725e992a4SHeiner Kallweit rc = PTR_ERR(clk); 666825e992a4SHeiner Kallweit if (rc == -ENOENT) 666925e992a4SHeiner Kallweit /* clk-core allows NULL (for suspend / resume) */ 667025e992a4SHeiner Kallweit rc = 0; 667125e992a4SHeiner Kallweit else if (rc != -EPROBE_DEFER) 667225e992a4SHeiner Kallweit dev_err(d, "failed to get clk: %d\n", rc); 667325e992a4SHeiner Kallweit } else { 667425e992a4SHeiner Kallweit tp->clk = clk; 667525e992a4SHeiner Kallweit rc = clk_prepare_enable(clk); 667625e992a4SHeiner Kallweit if (rc) 667725e992a4SHeiner Kallweit dev_err(d, "failed to enable clk: %d\n", rc); 667825e992a4SHeiner Kallweit else 667925e992a4SHeiner Kallweit rc = devm_add_action_or_reset(d, rtl_disable_clk, clk); 668025e992a4SHeiner Kallweit } 668125e992a4SHeiner Kallweit 668225e992a4SHeiner Kallweit return rc; 668325e992a4SHeiner Kallweit } 668425e992a4SHeiner Kallweit 6685c782e204SHeiner Kallweit static void rtl_init_mac_address(struct rtl8169_private *tp) 6686c782e204SHeiner Kallweit { 6687c782e204SHeiner Kallweit struct net_device *dev = tp->dev; 6688c782e204SHeiner Kallweit u8 *mac_addr = dev->dev_addr; 6689ce37115eSHeiner Kallweit int rc; 6690c782e204SHeiner Kallweit 6691c782e204SHeiner Kallweit rc = eth_platform_get_mac_address(tp_to_dev(tp), mac_addr); 6692c782e204SHeiner Kallweit if (!rc) 6693c782e204SHeiner Kallweit goto done; 6694c782e204SHeiner Kallweit 6695c782e204SHeiner Kallweit rtl_read_mac_address(tp, mac_addr); 6696c782e204SHeiner Kallweit if (is_valid_ether_addr(mac_addr)) 6697c782e204SHeiner Kallweit goto done; 6698c782e204SHeiner Kallweit 6699ce37115eSHeiner Kallweit rtl_read_mac_from_reg(tp, mac_addr, MAC0); 6700c782e204SHeiner Kallweit if (is_valid_ether_addr(mac_addr)) 6701c782e204SHeiner Kallweit goto done; 6702c782e204SHeiner Kallweit 6703c782e204SHeiner Kallweit eth_hw_addr_random(dev); 6704c782e204SHeiner Kallweit dev_warn(tp_to_dev(tp), "can't read MAC address, setting random one\n"); 6705c782e204SHeiner Kallweit done: 6706c782e204SHeiner Kallweit rtl_rar_set(tp, mac_addr); 6707c782e204SHeiner Kallweit } 6708c782e204SHeiner Kallweit 670925e992a4SHeiner Kallweit static int rtl_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 671025e992a4SHeiner Kallweit { 671125e992a4SHeiner Kallweit struct rtl8169_private *tp; 671225e992a4SHeiner Kallweit struct net_device *dev; 6713c782e204SHeiner Kallweit int chipset, region; 671425e992a4SHeiner Kallweit int jumbo_max, rc; 671525e992a4SHeiner Kallweit 671625e992a4SHeiner Kallweit dev = devm_alloc_etherdev(&pdev->dev, sizeof (*tp)); 671725e992a4SHeiner Kallweit if (!dev) 671825e992a4SHeiner Kallweit return -ENOMEM; 671925e992a4SHeiner Kallweit 672025e992a4SHeiner Kallweit SET_NETDEV_DEV(dev, &pdev->dev); 672125e992a4SHeiner Kallweit dev->netdev_ops = &rtl_netdev_ops; 672225e992a4SHeiner Kallweit tp = netdev_priv(dev); 672325e992a4SHeiner Kallweit tp->dev = dev; 672425e992a4SHeiner Kallweit tp->pci_dev = pdev; 672525e992a4SHeiner Kallweit tp->msg_enable = netif_msg_init(debug.msg_enable, R8169_MSG_DEFAULT); 6726145a40e8SHeiner Kallweit tp->supports_gmii = ent->driver_data == RTL_CFG_NO_GBIT ? 0 : 1; 672725e992a4SHeiner Kallweit 672825e992a4SHeiner Kallweit /* Get the *optional* external "ether_clk" used on some boards */ 672925e992a4SHeiner Kallweit rc = rtl_get_ether_clk(tp); 673025e992a4SHeiner Kallweit if (rc) 673125e992a4SHeiner Kallweit return rc; 673225e992a4SHeiner Kallweit 673325e992a4SHeiner Kallweit /* Disable ASPM completely as that cause random device stop working 673425e992a4SHeiner Kallweit * problems as well as full system hangs for some PCIe devices users. 673525e992a4SHeiner Kallweit */ 673662b1b3b3SHeiner Kallweit rc = pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | 673762b1b3b3SHeiner Kallweit PCIE_LINK_STATE_L1); 673862b1b3b3SHeiner Kallweit tp->aspm_manageable = !rc; 673925e992a4SHeiner Kallweit 674025e992a4SHeiner Kallweit /* enable device (incl. PCI PM wakeup and hotplug setup) */ 674125e992a4SHeiner Kallweit rc = pcim_enable_device(pdev); 674225e992a4SHeiner Kallweit if (rc < 0) { 674325e992a4SHeiner Kallweit dev_err(&pdev->dev, "enable failure\n"); 674425e992a4SHeiner Kallweit return rc; 674525e992a4SHeiner Kallweit } 674625e992a4SHeiner Kallweit 674725e992a4SHeiner Kallweit if (pcim_set_mwi(pdev) < 0) 674825e992a4SHeiner Kallweit dev_info(&pdev->dev, "Mem-Wr-Inval unavailable\n"); 674925e992a4SHeiner Kallweit 675025e992a4SHeiner Kallweit /* use first MMIO region */ 675125e992a4SHeiner Kallweit region = ffs(pci_select_bars(pdev, IORESOURCE_MEM)) - 1; 675225e992a4SHeiner Kallweit if (region < 0) { 675325e992a4SHeiner Kallweit dev_err(&pdev->dev, "no MMIO resource found\n"); 675425e992a4SHeiner Kallweit return -ENODEV; 675525e992a4SHeiner Kallweit } 675625e992a4SHeiner Kallweit 675725e992a4SHeiner Kallweit /* check for weird/broken PCI region reporting */ 675825e992a4SHeiner Kallweit if (pci_resource_len(pdev, region) < R8169_REGS_SIZE) { 675925e992a4SHeiner Kallweit dev_err(&pdev->dev, "Invalid PCI region size(s), aborting\n"); 676025e992a4SHeiner Kallweit return -ENODEV; 676125e992a4SHeiner Kallweit } 676225e992a4SHeiner Kallweit 676325e992a4SHeiner Kallweit rc = pcim_iomap_regions(pdev, BIT(region), MODULENAME); 676425e992a4SHeiner Kallweit if (rc < 0) { 676525e992a4SHeiner Kallweit dev_err(&pdev->dev, "cannot remap MMIO, aborting\n"); 676625e992a4SHeiner Kallweit return rc; 676725e992a4SHeiner Kallweit } 676825e992a4SHeiner Kallweit 676925e992a4SHeiner Kallweit tp->mmio_addr = pcim_iomap_table(pdev)[region]; 677025e992a4SHeiner Kallweit 677125e992a4SHeiner Kallweit /* Identify chip attached to board */ 677225e992a4SHeiner Kallweit rtl8169_get_mac_version(tp); 677325e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_NONE) 677425e992a4SHeiner Kallweit return -ENODEV; 677525e992a4SHeiner Kallweit 677625e992a4SHeiner Kallweit tp->cp_cmd = RTL_R16(tp, CPlusCmd); 677725e992a4SHeiner Kallweit 677825e992a4SHeiner Kallweit if (sizeof(dma_addr_t) > 4 && tp->mac_version >= RTL_GIGA_MAC_VER_18 && 67793c18cbe3SHeiner Kallweit !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) 678025e992a4SHeiner Kallweit dev->features |= NETIF_F_HIGHDMA; 678125e992a4SHeiner Kallweit 678225e992a4SHeiner Kallweit rtl_init_rxcfg(tp); 678325e992a4SHeiner Kallweit 678425e992a4SHeiner Kallweit rtl8169_irq_mask_and_ack(tp); 678525e992a4SHeiner Kallweit 678625e992a4SHeiner Kallweit rtl_hw_initialize(tp); 678725e992a4SHeiner Kallweit 678825e992a4SHeiner Kallweit rtl_hw_reset(tp); 678925e992a4SHeiner Kallweit 679025e992a4SHeiner Kallweit pci_set_master(pdev); 679125e992a4SHeiner Kallweit 679225e992a4SHeiner Kallweit chipset = tp->mac_version; 679325e992a4SHeiner Kallweit 679425e992a4SHeiner Kallweit rc = rtl_alloc_irq(tp); 679525e992a4SHeiner Kallweit if (rc < 0) { 679625e992a4SHeiner Kallweit dev_err(&pdev->dev, "Can't allocate interrupt\n"); 679725e992a4SHeiner Kallweit return rc; 679825e992a4SHeiner Kallweit } 679925e992a4SHeiner Kallweit 680025e992a4SHeiner Kallweit mutex_init(&tp->wk.mutex); 680125e992a4SHeiner Kallweit INIT_WORK(&tp->wk.work, rtl_task); 680225e992a4SHeiner Kallweit u64_stats_init(&tp->rx_stats.syncp); 680325e992a4SHeiner Kallweit u64_stats_init(&tp->tx_stats.syncp); 680425e992a4SHeiner Kallweit 6805c782e204SHeiner Kallweit rtl_init_mac_address(tp); 680625e992a4SHeiner Kallweit 680725e992a4SHeiner Kallweit dev->ethtool_ops = &rtl8169_ethtool_ops; 680825e992a4SHeiner Kallweit 680925e992a4SHeiner Kallweit netif_napi_add(dev, &tp->napi, rtl8169_poll, NAPI_POLL_WEIGHT); 681025e992a4SHeiner Kallweit 681193681cd7SHeiner Kallweit dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | 681293681cd7SHeiner Kallweit NETIF_F_RXCSUM | NETIF_F_HW_VLAN_CTAG_TX | 681393681cd7SHeiner Kallweit NETIF_F_HW_VLAN_CTAG_RX; 681425e992a4SHeiner Kallweit dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | 681525e992a4SHeiner Kallweit NETIF_F_RXCSUM | NETIF_F_HW_VLAN_CTAG_TX | 681625e992a4SHeiner Kallweit NETIF_F_HW_VLAN_CTAG_RX; 681725e992a4SHeiner Kallweit dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO | 681825e992a4SHeiner Kallweit NETIF_F_HIGHDMA; 681925e992a4SHeiner Kallweit dev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 682025e992a4SHeiner Kallweit 6821dc161162SHeiner Kallweit tp->cp_cmd |= RxChkSum; 6822dc161162SHeiner Kallweit /* RTL8125 uses register RxConfig for VLAN offloading config */ 6823dc161162SHeiner Kallweit if (!rtl_is_8125(tp)) 6824dc161162SHeiner Kallweit tp->cp_cmd |= RxVlan; 682525e992a4SHeiner Kallweit /* 682625e992a4SHeiner Kallweit * Pretend we are using VLANs; This bypasses a nasty bug where 682725e992a4SHeiner Kallweit * Interrupts stop flowing on high load on 8110SCd controllers. 682825e992a4SHeiner Kallweit */ 682925e992a4SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_05) 683025e992a4SHeiner Kallweit /* Disallow toggling */ 683125e992a4SHeiner Kallweit dev->hw_features &= ~NETIF_F_HW_VLAN_CTAG_RX; 683225e992a4SHeiner Kallweit 68330170d594SHeiner Kallweit if (rtl_chip_supports_csum_v2(tp)) { 683425e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6; 683593681cd7SHeiner Kallweit dev->features |= NETIF_F_IPV6_CSUM | NETIF_F_TSO6; 68360170d594SHeiner Kallweit dev->gso_max_size = RTL_GSO_MAX_SIZE_V2; 68370170d594SHeiner Kallweit dev->gso_max_segs = RTL_GSO_MAX_SEGS_V2; 68380170d594SHeiner Kallweit } else { 68390170d594SHeiner Kallweit dev->gso_max_size = RTL_GSO_MAX_SIZE_V1; 68400170d594SHeiner Kallweit dev->gso_max_segs = RTL_GSO_MAX_SEGS_V1; 68410170d594SHeiner Kallweit } 684225e992a4SHeiner Kallweit 684393681cd7SHeiner Kallweit /* RTL8168e-vl has a HW issue with TSO */ 684493681cd7SHeiner Kallweit if (tp->mac_version == RTL_GIGA_MAC_VER_34) { 6845a7eb6a4fSHolger Hoffstätte dev->vlan_features &= ~(NETIF_F_ALL_TSO | NETIF_F_SG); 6846a7eb6a4fSHolger Hoffstätte dev->hw_features &= ~(NETIF_F_ALL_TSO | NETIF_F_SG); 6847a7eb6a4fSHolger Hoffstätte dev->features &= ~(NETIF_F_ALL_TSO | NETIF_F_SG); 684893681cd7SHeiner Kallweit } 684993681cd7SHeiner Kallweit 685025e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_RXALL; 685125e992a4SHeiner Kallweit dev->hw_features |= NETIF_F_RXFCS; 685225e992a4SHeiner Kallweit 685325e992a4SHeiner Kallweit /* MTU range: 60 - hw-specific max */ 685425e992a4SHeiner Kallweit dev->min_mtu = ETH_ZLEN; 685525e992a4SHeiner Kallweit jumbo_max = rtl_jumbo_max(tp); 685625e992a4SHeiner Kallweit dev->max_mtu = jumbo_max; 685725e992a4SHeiner Kallweit 6858ec9a4088SHeiner Kallweit rtl_set_irq_mask(tp); 68599fa0a8e1SHeiner Kallweit 686025e992a4SHeiner Kallweit tp->fw_name = rtl_chip_infos[chipset].fw_name; 686125e992a4SHeiner Kallweit 686225e992a4SHeiner Kallweit tp->counters = dmam_alloc_coherent (&pdev->dev, sizeof(*tp->counters), 686325e992a4SHeiner Kallweit &tp->counters_phys_addr, 686425e992a4SHeiner Kallweit GFP_KERNEL); 686525e992a4SHeiner Kallweit if (!tp->counters) 686625e992a4SHeiner Kallweit return -ENOMEM; 686725e992a4SHeiner Kallweit 686825e992a4SHeiner Kallweit pci_set_drvdata(pdev, dev); 686925e992a4SHeiner Kallweit 687025e992a4SHeiner Kallweit rc = r8169_mdio_register(tp); 687125e992a4SHeiner Kallweit if (rc) 687225e992a4SHeiner Kallweit return rc; 687325e992a4SHeiner Kallweit 687425e992a4SHeiner Kallweit /* chip gets powered up in rtl_open() */ 687525e992a4SHeiner Kallweit rtl_pll_power_down(tp); 687625e992a4SHeiner Kallweit 687725e992a4SHeiner Kallweit rc = register_netdev(dev); 687825e992a4SHeiner Kallweit if (rc) 687925e992a4SHeiner Kallweit goto err_mdio_unregister; 688025e992a4SHeiner Kallweit 688125e992a4SHeiner Kallweit netif_info(tp, probe, dev, "%s, %pM, XID %03x, IRQ %d\n", 688225e992a4SHeiner Kallweit rtl_chip_infos[chipset].name, dev->dev_addr, 688325e992a4SHeiner Kallweit (RTL_R32(tp, TxConfig) >> 20) & 0xfcf, 688425e992a4SHeiner Kallweit pci_irq_vector(pdev, 0)); 688525e992a4SHeiner Kallweit 688625e992a4SHeiner Kallweit if (jumbo_max > JUMBO_1K) 688725e992a4SHeiner Kallweit netif_info(tp, probe, dev, 688825e992a4SHeiner Kallweit "jumbo features [frames: %d bytes, tx checksumming: %s]\n", 688925e992a4SHeiner Kallweit jumbo_max, tp->mac_version <= RTL_GIGA_MAC_VER_06 ? 689025e992a4SHeiner Kallweit "ok" : "ko"); 689125e992a4SHeiner Kallweit 689225e992a4SHeiner Kallweit if (r8168_check_dash(tp)) 689325e992a4SHeiner Kallweit rtl8168_driver_start(tp); 689425e992a4SHeiner Kallweit 689525e992a4SHeiner Kallweit if (pci_dev_run_wake(pdev)) 689625e992a4SHeiner Kallweit pm_runtime_put_sync(&pdev->dev); 689725e992a4SHeiner Kallweit 689825e992a4SHeiner Kallweit return 0; 689925e992a4SHeiner Kallweit 690025e992a4SHeiner Kallweit err_mdio_unregister: 690125e992a4SHeiner Kallweit mdiobus_unregister(tp->phydev->mdio.bus); 690225e992a4SHeiner Kallweit return rc; 690325e992a4SHeiner Kallweit } 690425e992a4SHeiner Kallweit 690525e992a4SHeiner Kallweit static struct pci_driver rtl8169_pci_driver = { 690625e992a4SHeiner Kallweit .name = MODULENAME, 690725e992a4SHeiner Kallweit .id_table = rtl8169_pci_tbl, 690825e992a4SHeiner Kallweit .probe = rtl_init_one, 690925e992a4SHeiner Kallweit .remove = rtl_remove_one, 691025e992a4SHeiner Kallweit .shutdown = rtl_shutdown, 691125e992a4SHeiner Kallweit .driver.pm = RTL8169_PM_OPS, 691225e992a4SHeiner Kallweit }; 691325e992a4SHeiner Kallweit 691425e992a4SHeiner Kallweit module_pci_driver(rtl8169_pci_driver); 6915