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