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