// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2015 Realtek Semiconductor Corp. All rights reserved.
 *
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <log.h>
#include <malloc.h>
#include <memalign.h>
#include <net.h>
#include <usb.h>
#include <linux/delay.h>
#include <linux/mii.h>
#include <linux/bitops.h>
#include "usb_ether.h"
#include "r8152.h"

#ifndef CONFIG_DM_ETH
/* local vars */
static int curr_eth_dev; /* index for name of next device detected */

struct r8152_dongle {
        unsigned short vendor;
        unsigned short product;
};

static const struct r8152_dongle r8152_dongles[] = {
        /* Realtek */
        { 0x0bda, 0x8050 },
        { 0x0bda, 0x8152 },
        { 0x0bda, 0x8153 },

        /* Samsung */
        { 0x04e8, 0xa101 },

        /* Lenovo */
        { 0x17ef, 0x304f },
        { 0x17ef, 0x3052 },
        { 0x17ef, 0x3054 },
        { 0x17ef, 0x3057 },
        { 0x17ef, 0x7205 },
        { 0x17ef, 0x720a },
        { 0x17ef, 0x720b },
        { 0x17ef, 0x720c },

        /* TP-LINK */
        { 0x2357, 0x0601 },

        /* Nvidia */
        { 0x0955, 0x09ff },
};
#endif

struct r8152_version {
        unsigned short tcr;
        unsigned short version;
        bool           gmii;
};

static const struct r8152_version r8152_versions[] = {
        { 0x4c00, RTL_VER_01, 0 },
        { 0x4c10, RTL_VER_02, 0 },
        { 0x5c00, RTL_VER_03, 1 },
        { 0x5c10, RTL_VER_04, 1 },
        { 0x5c20, RTL_VER_05, 1 },
        { 0x5c30, RTL_VER_06, 1 },
        { 0x4800, RTL_VER_07, 0 },
        { 0x6000, RTL_VER_08, 1 },
        { 0x6010, RTL_VER_09, 1 },
};

static
int get_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data)
{
        ALLOC_CACHE_ALIGN_BUFFER(void *, tmp, size);
        int ret;

        ret = usb_control_msg(tp->udev, usb_rcvctrlpipe(tp->udev, 0),
                RTL8152_REQ_GET_REGS, RTL8152_REQT_READ,
                value, index, tmp, size, 500);
        memcpy(data, tmp, size);
        return ret;
}

static
int set_registers(struct r8152 *tp, u16 value, u16 index, u16 size, void *data)
{
        ALLOC_CACHE_ALIGN_BUFFER(void *, tmp, size);

        memcpy(tmp, data, size);
        return usb_control_msg(tp->udev, usb_sndctrlpipe(tp->udev, 0),
                               RTL8152_REQ_SET_REGS, RTL8152_REQT_WRITE,
                               value, index, tmp, size, 500);
}

int generic_ocp_read(struct r8152 *tp, u16 index, u16 size,
                     void *data, u16 type)
{
        u16 burst_size = 64;
        int ret;
        int txsize;

        /* both size and index must be 4 bytes align */
        if ((size & 3) || !size || (index & 3) || !data)
                return -EINVAL;

        if (index + size > 0xffff)
                return -EINVAL;

        while (size) {
                txsize = min(size, burst_size);
                ret = get_registers(tp, index, type, txsize, data);
                if (ret < 0)
                        break;

                index += txsize;
                data += txsize;
                size -= txsize;
        }

        return ret;
}

int generic_ocp_write(struct r8152 *tp, u16 index, u16 byteen,
                      u16 size, void *data, u16 type)
{
        int ret;
        u16 byteen_start, byteen_end, byte_en_to_hw;
        u16 burst_size = 512;
        int txsize;

        /* both size and index must be 4 bytes align */
        if ((size & 3) || !size || (index & 3) || !data)
                return -EINVAL;

        if (index + size > 0xffff)
                return -EINVAL;

        byteen_start = byteen & BYTE_EN_START_MASK;
        byteen_end = byteen & BYTE_EN_END_MASK;

        byte_en_to_hw = byteen_start | (byteen_start << 4);
        ret = set_registers(tp, index, type | byte_en_to_hw, 4, data);
        if (ret < 0)
                return ret;

        index += 4;
        data += 4;
        size -= 4;

        if (size) {
                size -= 4;

                while (size) {
                        txsize = min(size, burst_size);

                        ret = set_registers(tp, index,
                                            type | BYTE_EN_DWORD,
                                            txsize, data);
                        if (ret < 0)
                                return ret;

                        index += txsize;
                        data += txsize;
                        size -= txsize;
                }

                byte_en_to_hw = byteen_end | (byteen_end >> 4);
                ret = set_registers(tp, index, type | byte_en_to_hw, 4, data);
                if (ret < 0)
                        return ret;
        }

        return ret;
}

int pla_ocp_read(struct r8152 *tp, u16 index, u16 size, void *data)
{
        return generic_ocp_read(tp, index, size, data, MCU_TYPE_PLA);
}

int pla_ocp_write(struct r8152 *tp, u16 index, u16 byteen, u16 size, void *data)
{
        return generic_ocp_write(tp, index, byteen, size, data, MCU_TYPE_PLA);
}

int usb_ocp_read(struct r8152 *tp, u16 index, u16 size, void *data)
{
        return generic_ocp_read(tp, index, size, data, MCU_TYPE_USB);
}

int usb_ocp_write(struct r8152 *tp, u16 index, u16 byteen, u16 size, void *data)
{
        return generic_ocp_write(tp, index, byteen, size, data, MCU_TYPE_USB);
}

u32 ocp_read_dword(struct r8152 *tp, u16 type, u16 index)
{
        __le32 data;

        generic_ocp_read(tp, index, sizeof(data), &data, type);

        return __le32_to_cpu(data);
}

void ocp_write_dword(struct r8152 *tp, u16 type, u16 index, u32 data)
{
        __le32 tmp = __cpu_to_le32(data);

        generic_ocp_write(tp, index, BYTE_EN_DWORD, sizeof(tmp), &tmp, type);
}

u16 ocp_read_word(struct r8152 *tp, u16 type, u16 index)
{
        u32 data;
        __le32 tmp;
        u8 shift = index & 2;

        index &= ~3;

        generic_ocp_read(tp, index, sizeof(tmp), &tmp, type);

        data = __le32_to_cpu(tmp);
        data >>= (shift * 8);
        data &= 0xffff;

        return data;
}

void ocp_write_word(struct r8152 *tp, u16 type, u16 index, u32 data)
{
        u32 mask = 0xffff;
        __le32 tmp;
        u16 byen = BYTE_EN_WORD;
        u8 shift = index & 2;

        data &= mask;

        if (index & 2) {
                byen <<= shift;
                mask <<= (shift * 8);
                data <<= (shift * 8);
                index &= ~3;
        }

        tmp = __cpu_to_le32(data);

        generic_ocp_write(tp, index, byen, sizeof(tmp), &tmp, type);
}

u8 ocp_read_byte(struct r8152 *tp, u16 type, u16 index)
{
        u32 data;
        __le32 tmp;
        u8 shift = index & 3;

        index &= ~3;

        generic_ocp_read(tp, index, sizeof(tmp), &tmp, type);

        data = __le32_to_cpu(tmp);
        data >>= (shift * 8);
        data &= 0xff;

        return data;
}

void ocp_write_byte(struct r8152 *tp, u16 type, u16 index, u32 data)
{
        u32 mask = 0xff;
        __le32 tmp;
        u16 byen = BYTE_EN_BYTE;
        u8 shift = index & 3;

        data &= mask;

        if (index & 3) {
                byen <<= shift;
                mask <<= (shift * 8);
                data <<= (shift * 8);
                index &= ~3;
        }

        tmp = __cpu_to_le32(data);

        generic_ocp_write(tp, index, byen, sizeof(tmp), &tmp, type);
}

u16 ocp_reg_read(struct r8152 *tp, u16 addr)
{
        u16 ocp_base, ocp_index;

        ocp_base = addr & 0xf000;
        if (ocp_base != tp->ocp_base) {
                ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, ocp_base);
                tp->ocp_base = ocp_base;
        }

        ocp_index = (addr & 0x0fff) | 0xb000;
        return ocp_read_word(tp, MCU_TYPE_PLA, ocp_index);
}

void ocp_reg_write(struct r8152 *tp, u16 addr, u16 data)
{
        u16 ocp_base, ocp_index;

        ocp_base = addr & 0xf000;
        if (ocp_base != tp->ocp_base) {
                ocp_write_word(tp, MCU_TYPE_PLA, PLA_OCP_GPHY_BASE, ocp_base);
                tp->ocp_base = ocp_base;
        }

        ocp_index = (addr & 0x0fff) | 0xb000;
        ocp_write_word(tp, MCU_TYPE_PLA, ocp_index, data);
}

static void r8152_mdio_write(struct r8152 *tp, u32 reg_addr, u32 value)
{
        ocp_reg_write(tp, OCP_BASE_MII + reg_addr * 2, value);
}

static int r8152_mdio_read(struct r8152 *tp, u32 reg_addr)
{
        return ocp_reg_read(tp, OCP_BASE_MII + reg_addr * 2);
}

void sram_write(struct r8152 *tp, u16 addr, u16 data)
{
        ocp_reg_write(tp, OCP_SRAM_ADDR, addr);
        ocp_reg_write(tp, OCP_SRAM_DATA, data);
}

static u16 sram_read(struct r8152 *tp, u16 addr)
{
        ocp_reg_write(tp, OCP_SRAM_ADDR, addr);
        return ocp_reg_read(tp, OCP_SRAM_DATA);
}

int r8152_wait_for_bit(struct r8152 *tp, bool ocp_reg, u16 type, u16 index,
                       const u32 mask, bool set, unsigned int timeout)
{
        u32 val;

        while (--timeout) {
                if (ocp_reg)
                        val = ocp_reg_read(tp, index);
                else
                        val = ocp_read_dword(tp, type, index);

                if (!set)
                        val = ~val;

                if ((val & mask) == mask)
                        return 0;

                mdelay(1);
        }

        debug("%s: Timeout (index=%04x mask=%08x timeout=%d)\n",
              __func__, index, mask, timeout);

        return -ETIMEDOUT;
}

static void r8152b_reset_packet_filter(struct r8152 *tp)
{
        u32 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_FMC);
        ocp_data &= ~FMC_FCR_MCU_EN;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_FMC, ocp_data);
        ocp_data |= FMC_FCR_MCU_EN;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_FMC, ocp_data);
}

static void rtl8152_wait_fifo_empty(struct r8152 *tp)
{
        int ret;

        ret = r8152_wait_for_bit(tp, 0, MCU_TYPE_PLA, PLA_PHY_PWR,
                                 PLA_PHY_PWR_TXEMP, 1, R8152_WAIT_TIMEOUT);
        if (ret)
                debug("Timeout waiting for FIFO empty\n");

        ret = r8152_wait_for_bit(tp, 0, MCU_TYPE_PLA, PLA_TCR0,
                                 TCR0_TX_EMPTY, 1, R8152_WAIT_TIMEOUT);
        if (ret)
                debug("Timeout waiting for TX empty\n");
}

static void rtl8152_nic_reset(struct r8152 *tp)
{
        int ret;
        u32 ocp_data;

        ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, BIST_CTRL);
        ocp_data |= BIST_CTRL_SW_RESET;
        ocp_write_dword(tp, MCU_TYPE_PLA, BIST_CTRL, ocp_data);

        ret = r8152_wait_for_bit(tp, 0, MCU_TYPE_PLA, BIST_CTRL,
                                 BIST_CTRL_SW_RESET, 0, R8152_WAIT_TIMEOUT);
        if (ret)
                debug("Timeout waiting for NIC reset\n");
}

static u8 rtl8152_get_speed(struct r8152 *tp)
{
        return ocp_read_byte(tp, MCU_TYPE_PLA, PLA_PHYSTATUS);
}

static void rtl_set_eee_plus(struct r8152 *tp)
{
        u32 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR);
        ocp_data &= ~EEEP_CR_EEEP_TX;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_EEEP_CR, ocp_data);
}

static void rxdy_gated_en(struct r8152 *tp, bool enable)
{
        u32 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MISC_1);
        if (enable)
                ocp_data |= RXDY_GATED_EN;
        else
                ocp_data &= ~RXDY_GATED_EN;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MISC_1, ocp_data);
}

static void rtl8152_set_rx_mode(struct r8152 *tp)
{
        u32 ocp_data;
        __le32 tmp[2];

        tmp[0] = 0xffffffff;
        tmp[1] = 0xffffffff;

        pla_ocp_write(tp, PLA_MAR, BYTE_EN_DWORD, sizeof(tmp), tmp);

        ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
        ocp_data |= RCR_APM | RCR_AM | RCR_AB;
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
}

static inline void r8153b_rx_agg_chg_indicate(struct r8152 *tp)
{
        ocp_write_byte(tp, MCU_TYPE_USB, USB_UPT_RXDMA_OWN,
                       OWN_UPDATE | OWN_CLEAR);
}

static int rtl_enable(struct r8152 *tp)
{
        u32 ocp_data;

        r8152b_reset_packet_filter(tp);

        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_CR);
        ocp_data |= PLA_CR_RE | PLA_CR_TE;
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, ocp_data);

        switch (tp->version) {
        case RTL_VER_08:
        case RTL_VER_09:
                r8153b_rx_agg_chg_indicate(tp);
                break;
        default:
                break;
        }

        rxdy_gated_en(tp, false);

        rtl8152_set_rx_mode(tp);

        return 0;
}

static int rtl8152_enable(struct r8152 *tp)
{
        rtl_set_eee_plus(tp);

        return rtl_enable(tp);
}

static void r8153_set_rx_early_timeout(struct r8152 *tp)
{
        u32 ocp_data = tp->coalesce / 8;

        switch (tp->version) {
        case RTL_VER_03:
        case RTL_VER_04:
        case RTL_VER_05:
        case RTL_VER_06:
                ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_TIMEOUT,
                               ocp_data);
                break;

        case RTL_VER_08:
        case RTL_VER_09:
                /* The RTL8153B uses USB_RX_EXTRA_AGGR_TMR for rx timeout
                 * primarily. For USB_RX_EARLY_TIMEOUT, we fix it to 1264ns.
                 */
                ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_TIMEOUT,
                               RX_AUXILIARY_TIMER / 8);
                ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EXTRA_AGGR_TMR,
                               ocp_data);
                break;

        default:
                debug("** %s Invalid Device\n", __func__);
                break;
        }
}

static void r8153_set_rx_early_size(struct r8152 *tp)
{
        u32 ocp_data = (RTL8152_AGG_BUF_SZ - RTL8153_RMS -
                        sizeof(struct rx_desc));

        switch (tp->version) {
        case RTL_VER_03:
        case RTL_VER_04:
        case RTL_VER_05:
        case RTL_VER_06:
                ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_SIZE,
                               ocp_data / 4);
                break;

        case RTL_VER_08:
        case RTL_VER_09:
                ocp_write_word(tp, MCU_TYPE_USB, USB_RX_EARLY_SIZE,
                               ocp_data / 8);
                break;

        default:
                debug("** %s Invalid Device\n", __func__);
                break;
        }
}

static int rtl8153_enable(struct r8152 *tp)
{
        rtl_set_eee_plus(tp);
        r8153_set_rx_early_timeout(tp);
        r8153_set_rx_early_size(tp);

        return rtl_enable(tp);
}

static void rtl_disable(struct r8152 *tp)
{
        u32 ocp_data;

        ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
        ocp_data &= ~RCR_ACPT_ALL;
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);

        rxdy_gated_en(tp, true);

        rtl8152_wait_fifo_empty(tp);
        rtl8152_nic_reset(tp);
}

static void r8152_power_cut_en(struct r8152 *tp, bool enable)
{
        u32 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_UPS_CTRL);
        if (enable)
                ocp_data |= POWER_CUT;
        else
                ocp_data &= ~POWER_CUT;
        ocp_write_word(tp, MCU_TYPE_USB, USB_UPS_CTRL, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_PM_CTRL_STATUS);
        ocp_data &= ~RESUME_INDICATE;
        ocp_write_word(tp, MCU_TYPE_USB, USB_PM_CTRL_STATUS, ocp_data);
}

static void rtl_rx_vlan_en(struct r8152 *tp, bool enable)
{
        u32 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_CPCR);
        if (enable)
                ocp_data |= CPCR_RX_VLAN;
        else
                ocp_data &= ~CPCR_RX_VLAN;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_CPCR, ocp_data);
}

static void r8153_u1u2en(struct r8152 *tp, bool enable)
{
        u8 u1u2[8];

        if (enable)
                memset(u1u2, 0xff, sizeof(u1u2));
        else
                memset(u1u2, 0x00, sizeof(u1u2));

        usb_ocp_write(tp, USB_TOLERANCE, BYTE_EN_SIX_BYTES, sizeof(u1u2), u1u2);
}

static void r8153b_u1u2en(struct r8152 *tp, bool enable)
{
        u16 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_LPM_CONFIG);
        if (enable)
                ocp_data |= LPM_U1U2_EN;
        else
                ocp_data &= ~LPM_U1U2_EN;

        ocp_write_word(tp, MCU_TYPE_USB, USB_LPM_CONFIG, ocp_data);
}

static void r8153_u2p3en(struct r8152 *tp, bool enable)
{
        u32 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL);
        if (enable && tp->version != RTL_VER_03 && tp->version != RTL_VER_04)
                ocp_data |= U2P3_ENABLE;
        else
                ocp_data &= ~U2P3_ENABLE;
        ocp_write_word(tp, MCU_TYPE_USB, USB_U2P3_CTRL, ocp_data);
}

static void r8153_power_cut_en(struct r8152 *tp, bool enable)
{
        u32 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_POWER_CUT);
        if (enable)
                ocp_data |= PWR_EN | PHASE2_EN;
        else
                ocp_data &= ~(PWR_EN | PHASE2_EN);
        ocp_write_word(tp, MCU_TYPE_USB, USB_POWER_CUT, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_MISC_0);
        ocp_data &= ~PCUT_STATUS;
        ocp_write_word(tp, MCU_TYPE_USB, USB_MISC_0, ocp_data);
}

static void rtl_reset_bmu(struct r8152 *tp)
{
        u8 ocp_data;

        ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_BMU_RESET);
        ocp_data &= ~(BMU_RESET_EP_IN | BMU_RESET_EP_OUT);
        ocp_write_byte(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data);
        ocp_data |= BMU_RESET_EP_IN | BMU_RESET_EP_OUT;
        ocp_write_byte(tp, MCU_TYPE_USB, USB_BMU_RESET, ocp_data);
}

static int r8152_read_mac(struct r8152 *tp, unsigned char *macaddr)
{
        int ret;
        unsigned char enetaddr[8] = {0};

        ret = pla_ocp_read(tp, PLA_IDR, 8, enetaddr);
        if (ret < 0)
                return ret;

        memcpy(macaddr, enetaddr, ETH_ALEN);
        return 0;
}

static void r8152b_disable_aldps(struct r8152 *tp)
{
        ocp_reg_write(tp, OCP_ALDPS_CONFIG, ENPDNPS | LINKENA | DIS_SDSAVE);
        mdelay(20);
}

static void r8152b_enable_aldps(struct r8152 *tp)
{
        ocp_reg_write(tp, OCP_ALDPS_CONFIG, ENPWRSAVE | ENPDNPS |
                LINKENA | DIS_SDSAVE);
}

static void rtl8152_disable(struct r8152 *tp)
{
        r8152b_disable_aldps(tp);
        rtl_disable(tp);
        r8152b_enable_aldps(tp);
}

static void r8152b_hw_phy_cfg(struct r8152 *tp)
{
        u16 data;

        data = r8152_mdio_read(tp, MII_BMCR);
        if (data & BMCR_PDOWN) {
                data &= ~BMCR_PDOWN;
                r8152_mdio_write(tp, MII_BMCR, data);
        }

        r8152b_firmware(tp);
}

static void rtl8152_reinit_ll(struct r8152 *tp)
{
        u32 ocp_data;
        int ret;

        ret = r8152_wait_for_bit(tp, 0, MCU_TYPE_PLA, PLA_PHY_PWR,
                                 PLA_PHY_PWR_LLR, 1, R8152_WAIT_TIMEOUT);
        if (ret)
                debug("Timeout waiting for link list ready\n");

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
        ocp_data |= RE_INIT_LL;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);

        ret = r8152_wait_for_bit(tp, 0, MCU_TYPE_PLA, PLA_PHY_PWR,
                                 PLA_PHY_PWR_LLR, 1, R8152_WAIT_TIMEOUT);
        if (ret)
                debug("Timeout waiting for link list ready\n");
}

static void r8152b_exit_oob(struct r8152 *tp)
{
        u32 ocp_data;

        ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
        ocp_data &= ~RCR_ACPT_ALL;
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);

        rxdy_gated_en(tp, true);
        r8152b_hw_phy_cfg(tp);

        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CR, 0x00);

        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
        ocp_data &= ~NOW_IS_OOB;
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
        ocp_data &= ~MCU_BORW_EN;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);

        rtl8152_reinit_ll(tp);
        rtl8152_nic_reset(tp);

        /* rx share fifo credit full threshold */
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_NORMAL);

        if (tp->udev->speed == USB_SPEED_FULL ||
            tp->udev->speed == USB_SPEED_LOW) {
                /* rx share fifo credit near full threshold */
                ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1,
                                RXFIFO_THR2_FULL);
                ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2,
                                RXFIFO_THR3_FULL);
        } else {
                /* rx share fifo credit near full threshold */
                ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1,
                                RXFIFO_THR2_HIGH);
                ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2,
                                RXFIFO_THR3_HIGH);
        }

        /* TX share fifo free credit full threshold */
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, TXFIFO_THR_NORMAL);

        ocp_write_byte(tp, MCU_TYPE_USB, USB_TX_AGG, TX_AGG_MAX_THRESHOLD);
        ocp_write_dword(tp, MCU_TYPE_USB, USB_RX_BUF_TH, RX_THR_HIGH);
        ocp_write_dword(tp, MCU_TYPE_USB, USB_TX_DMA,
                        TEST_MODE_DISABLE | TX_SIZE_ADJUST1);

        ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8152_RMS);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0);
        ocp_data |= TCR0_AUTO_FIFO;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_TCR0, ocp_data);
}

static void r8152b_enter_oob(struct r8152 *tp)
{
        u32 ocp_data;

        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
        ocp_data &= ~NOW_IS_OOB;
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);

        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_OOB);
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_OOB);
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_OOB);

        rtl_disable(tp);

        rtl8152_reinit_ll(tp);

        ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, RTL8152_RMS);

        rtl_rx_vlan_en(tp, false);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_BDC_CR);
        ocp_data |= ALDPS_PROXY_MODE;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_BDC_CR, ocp_data);

        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
        ocp_data |= NOW_IS_OOB | DIS_MCU_CLROOB;
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);

        rxdy_gated_en(tp, false);

        ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
        ocp_data |= RCR_APM | RCR_AM | RCR_AB;
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
}

static void r8153_hw_phy_cfg(struct r8152 *tp)
{
        u32 ocp_data;
        u16 data;

        if (tp->version == RTL_VER_03 || tp->version == RTL_VER_04 ||
            tp->version == RTL_VER_05)
                ocp_reg_write(tp, OCP_ADC_CFG, CKADSEL_L | ADC_EN | EN_EMI_L);

        data = r8152_mdio_read(tp, MII_BMCR);
        if (data & BMCR_PDOWN) {
                data &= ~BMCR_PDOWN;
                r8152_mdio_write(tp, MII_BMCR, data);
        }

        r8153_firmware(tp);

        if (tp->version == RTL_VER_03) {
                data = ocp_reg_read(tp, OCP_EEE_CFG);
                data &= ~CTAP_SHORT_EN;
                ocp_reg_write(tp, OCP_EEE_CFG, data);
        }

        data = ocp_reg_read(tp, OCP_POWER_CFG);
        data |= EEE_CLKDIV_EN;
        ocp_reg_write(tp, OCP_POWER_CFG, data);

        data = ocp_reg_read(tp, OCP_DOWN_SPEED);
        data |= EN_10M_BGOFF;
        ocp_reg_write(tp, OCP_DOWN_SPEED, data);
        data = ocp_reg_read(tp, OCP_POWER_CFG);
        data |= EN_10M_PLLOFF;
        ocp_reg_write(tp, OCP_POWER_CFG, data);
        sram_write(tp, SRAM_IMPEDANCE, 0x0b13);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
        ocp_data |= PFM_PWM_SWITCH;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);

        /* Enable LPF corner auto tune */
        sram_write(tp, SRAM_LPF_CFG, 0xf70f);

        /* Adjust 10M Amplitude */
        sram_write(tp, SRAM_10M_AMP1, 0x00af);
        sram_write(tp, SRAM_10M_AMP2, 0x0208);
}

static u32 r8152_efuse_read(struct r8152 *tp, u8 addr)
{
        u32 ocp_data;

        ocp_write_word(tp, MCU_TYPE_PLA, PLA_EFUSE_CMD, EFUSE_READ_CMD | addr);
        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_EFUSE_CMD);
        ocp_data = (ocp_data & EFUSE_DATA_BIT16) << 9;  /* data of bit16 */
        ocp_data |= ocp_read_word(tp, MCU_TYPE_PLA, PLA_EFUSE_DATA);

        return ocp_data;
}

static void r8153b_hw_phy_cfg(struct r8152 *tp)
{
        u32 ocp_data;
        u16 data;

        data = r8152_mdio_read(tp, MII_BMCR);
        if (data & BMCR_PDOWN) {
                data &= ~BMCR_PDOWN;
                r8152_mdio_write(tp, MII_BMCR, data);
        }

        /* U1/U2/L1 idle timer. 500 us */
        ocp_write_word(tp, MCU_TYPE_USB, USB_U1U2_TIMER, 500);

        r8153b_firmware(tp);

        data = sram_read(tp, SRAM_GREEN_CFG);
        data |= R_TUNE_EN;
        sram_write(tp, SRAM_GREEN_CFG, data);
        data = ocp_reg_read(tp, OCP_NCTL_CFG);
        data |= PGA_RETURN_EN;
        ocp_reg_write(tp, OCP_NCTL_CFG, data);

        /* ADC Bias Calibration:
         * read efuse offset 0x7d to get a 17-bit data. Remove the dummy/fake
         * bit (bit3) to rebuild the real 16-bit data. Write the data to the
         * ADC ioffset.
         */
        ocp_data = r8152_efuse_read(tp, 0x7d);
        ocp_data = ((ocp_data & 0x1fff0) >> 1) | (ocp_data & 0x7);
        if (ocp_data != 0xffff)
                ocp_reg_write(tp, OCP_ADC_IOFFSET, ocp_data);

        /* ups mode tx-link-pulse timing adjustment:
         * rg_saw_cnt = OCP reg 0xC426 Bit[13:0]
         * swr_cnt_1ms_ini = 16000000 / rg_saw_cnt
         */
        ocp_data = ocp_reg_read(tp, 0xc426);
        ocp_data &= 0x3fff;
        if (ocp_data) {
                u32 swr_cnt_1ms_ini;

                swr_cnt_1ms_ini = (16000000 / ocp_data) & SAW_CNT_1MS_MASK;
                ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_UPS_CFG);
                ocp_data = (ocp_data & ~SAW_CNT_1MS_MASK) | swr_cnt_1ms_ini;
                ocp_write_word(tp, MCU_TYPE_USB, USB_UPS_CFG, ocp_data);
        }

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
        ocp_data |= PFM_PWM_SWITCH;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
}

static void r8153_first_init(struct r8152 *tp)
{
        u32 ocp_data;

        rxdy_gated_en(tp, true);

        ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
        ocp_data &= ~RCR_ACPT_ALL;
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);

        r8153_hw_phy_cfg(tp);

        rtl8152_nic_reset(tp);
        rtl_reset_bmu(tp);

        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
        ocp_data &= ~NOW_IS_OOB;
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7);
        ocp_data &= ~MCU_BORW_EN;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_SFF_STS_7, ocp_data);

        rtl8152_reinit_ll(tp);

        rtl_rx_vlan_en(tp, false);

        ocp_data = RTL8153_RMS;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, ocp_data);
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_MTPS, MTPS_JUMBO);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR0);
        ocp_data |= TCR0_AUTO_FIFO;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_TCR0, ocp_data);

        rtl8152_nic_reset(tp);

        /* rx share fifo credit full threshold */
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL0, RXFIFO_THR1_NORMAL);
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL1, RXFIFO_THR2_NORMAL);
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_RXFIFO_CTRL2, RXFIFO_THR3_NORMAL);
        /* TX share fifo free credit full threshold */
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_TXFIFO_CTRL, TXFIFO_THR_NORMAL2);

        /* rx aggregation */
        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);

        ocp_data &= ~(RX_AGG_DISABLE | RX_ZERO_EN);
        ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
}

static void r8153_enter_oob(struct r8152 *tp)
{
        u32 ocp_data;

        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
        ocp_data &= ~NOW_IS_OOB;
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);

        rtl_disable(tp);
        rtl_reset_bmu(tp);

        rtl8152_reinit_ll(tp);

        ocp_data = RTL8153_RMS;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_RMS, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG);
        ocp_data &= ~TEREDO_WAKE_MASK;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_TEREDO_CFG, ocp_data);

        rtl_rx_vlan_en(tp, false);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_BDC_CR);
        ocp_data |= ALDPS_PROXY_MODE;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_BDC_CR, ocp_data);

        ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL);
        ocp_data |= NOW_IS_OOB | DIS_MCU_CLROOB;
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_OOB_CTRL, ocp_data);

        rxdy_gated_en(tp, false);

        ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_RCR);
        ocp_data |= RCR_APM | RCR_AM | RCR_AB;
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_RCR, ocp_data);
}

static void r8153_disable_aldps(struct r8152 *tp)
{
        u16 data;

        data = ocp_reg_read(tp, OCP_POWER_CFG);
        data &= ~EN_ALDPS;
        ocp_reg_write(tp, OCP_POWER_CFG, data);
        mdelay(20);
}

static void rtl8153_disable(struct r8152 *tp)
{
        r8153_disable_aldps(tp);
        rtl_disable(tp);
        rtl_reset_bmu(tp);
}

static int rtl8152_set_speed(struct r8152 *tp, u8 autoneg, u16 speed, u8 duplex)
{
        u16 bmcr, anar, gbcr;

        anar = r8152_mdio_read(tp, MII_ADVERTISE);
        anar &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL |
                  ADVERTISE_100HALF | ADVERTISE_100FULL);
        if (tp->supports_gmii) {
                gbcr = r8152_mdio_read(tp, MII_CTRL1000);
                gbcr &= ~(ADVERTISE_1000FULL | ADVERTISE_1000HALF);
        } else {
                gbcr = 0;
        }

        if (autoneg == AUTONEG_DISABLE) {
                if (speed == SPEED_10) {
                        bmcr = 0;
                        anar |= ADVERTISE_10HALF | ADVERTISE_10FULL;
                } else if (speed == SPEED_100) {
                        bmcr = BMCR_SPEED100;
                        anar |= ADVERTISE_100HALF | ADVERTISE_100FULL;
                } else if (speed == SPEED_1000 && tp->supports_gmii) {
                        bmcr = BMCR_SPEED1000;
                        gbcr |= ADVERTISE_1000FULL | ADVERTISE_1000HALF;
                } else {
                        return -EINVAL;
                }

                if (duplex == DUPLEX_FULL)
                        bmcr |= BMCR_FULLDPLX;
        } else {
                if (speed == SPEED_10) {
                        if (duplex == DUPLEX_FULL)
                                anar |= ADVERTISE_10HALF | ADVERTISE_10FULL;
                        else
                                anar |= ADVERTISE_10HALF;
                } else if (speed == SPEED_100) {
                        if (duplex == DUPLEX_FULL) {
                                anar |= ADVERTISE_10HALF | ADVERTISE_10FULL;
                                anar |= ADVERTISE_100HALF | ADVERTISE_100FULL;
                        } else {
                                anar |= ADVERTISE_10HALF;
                                anar |= ADVERTISE_100HALF;
                        }
                } else if (speed == SPEED_1000 && tp->supports_gmii) {
                        if (duplex == DUPLEX_FULL) {
                                anar |= ADVERTISE_10HALF | ADVERTISE_10FULL;
                                anar |= ADVERTISE_100HALF | ADVERTISE_100FULL;
                                gbcr |= ADVERTISE_1000FULL | ADVERTISE_1000HALF;
                        } else {
                                anar |= ADVERTISE_10HALF;
                                anar |= ADVERTISE_100HALF;
                                gbcr |= ADVERTISE_1000HALF;
                        }
                } else {
                        return -EINVAL;
                }

                bmcr = BMCR_ANENABLE | BMCR_ANRESTART | BMCR_RESET;
        }

        if (tp->supports_gmii)
                r8152_mdio_write(tp, MII_CTRL1000, gbcr);

        r8152_mdio_write(tp, MII_ADVERTISE, anar);
        r8152_mdio_write(tp, MII_BMCR, bmcr);

        return 0;
}

static void rtl8152_up(struct r8152 *tp)
{
        r8152b_disable_aldps(tp);
        r8152b_exit_oob(tp);
        r8152b_enable_aldps(tp);
}

static void rtl8152_down(struct r8152 *tp)
{
        r8152_power_cut_en(tp, false);
        r8152b_disable_aldps(tp);
        r8152b_enter_oob(tp);
        r8152b_enable_aldps(tp);
}

static void rtl8153_up(struct r8152 *tp)
{
        r8153_u1u2en(tp, false);
        r8153_disable_aldps(tp);
        r8153_first_init(tp);
        r8153_u2p3en(tp, false);
}

static void rtl8153_down(struct r8152 *tp)
{
        r8153_u1u2en(tp, false);
        r8153_u2p3en(tp, false);
        r8153_power_cut_en(tp, false);
        r8153_disable_aldps(tp);
        r8153_enter_oob(tp);
}

static void rtl8153b_up(struct r8152 *tp)
{
        r8153_first_init(tp);
}

static void rtl8153b_down(struct r8152 *tp)
{
        r8153_enter_oob(tp);
}

static void r8152b_get_version(struct r8152 *tp)
{
        u32 ocp_data;
        u16 tcr;
        int i;

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_TCR1);
        tcr = (u16)(ocp_data & VERSION_MASK);

        for (i = 0; i < ARRAY_SIZE(r8152_versions); i++) {
                if (tcr == r8152_versions[i].tcr) {
                        /* Found a supported version */
                        tp->version = r8152_versions[i].version;
                        tp->supports_gmii = r8152_versions[i].gmii;
                        break;
                }
        }

        if (tp->version == RTL_VER_UNKNOWN)
                debug("r8152 Unknown tcr version 0x%04x\n", tcr);
}

static void r8152b_enable_fc(struct r8152 *tp)
{
        u16 anar;
        anar = r8152_mdio_read(tp, MII_ADVERTISE);
        anar |= ADVERTISE_PAUSE_CAP | ADVERTISE_PAUSE_ASYM;
        r8152_mdio_write(tp, MII_ADVERTISE, anar);
}

static void rtl_tally_reset(struct r8152 *tp)
{
        u32 ocp_data;

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_RSTTALLY);
        ocp_data |= TALLY_RESET;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_RSTTALLY, ocp_data);
}

static void r8152b_init(struct r8152 *tp)
{
        u32 ocp_data;

        r8152b_disable_aldps(tp);

        if (tp->version == RTL_VER_01) {
                ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE);
                ocp_data &= ~LED_MODE_MASK;
                ocp_write_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE, ocp_data);
        }

        r8152_power_cut_en(tp, false);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
        ocp_data |= TX_10M_IDLE_EN | PFM_PWM_SWITCH;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
        ocp_data = ocp_read_dword(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL);
        ocp_data &= ~MCU_CLK_RATIO_MASK;
        ocp_data |= MCU_CLK_RATIO | D3_CLK_GATED_EN;
        ocp_write_dword(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL, ocp_data);
        ocp_data = GPHY_STS_MSK | SPEED_DOWN_MSK |
                   SPDWN_RXDV_MSK | SPDWN_LINKCHG_MSK;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_GPHY_INTR_IMR, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_TIMER);
        ocp_data |= BIT(15);
        ocp_write_word(tp, MCU_TYPE_USB, USB_USB_TIMER, ocp_data);
        ocp_write_word(tp, MCU_TYPE_USB, 0xcbfc, 0x03e8);
        ocp_data &= ~BIT(15);
        ocp_write_word(tp, MCU_TYPE_USB, USB_USB_TIMER, ocp_data);

        r8152b_enable_fc(tp);
        rtl_tally_reset(tp);

        /* enable rx aggregation */
        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);

        ocp_data &= ~(RX_AGG_DISABLE | RX_ZERO_EN);
        ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);
}

static void r8153_init(struct r8152 *tp)
{
        int i;
        u32 ocp_data;

        r8153_disable_aldps(tp);
        r8153_u1u2en(tp, false);

        r8152_wait_for_bit(tp, 0, MCU_TYPE_PLA, PLA_BOOT_CTRL,
                           AUTOLOAD_DONE, 1, R8152_WAIT_TIMEOUT);

        for (i = 0; i < R8152_WAIT_TIMEOUT; i++) {
                ocp_data = ocp_reg_read(tp, OCP_PHY_STATUS) & PHY_STAT_MASK;
                if (ocp_data == PHY_STAT_LAN_ON || ocp_data == PHY_STAT_PWRDN)
                        break;

                mdelay(1);
        }

        r8153_u2p3en(tp, false);

        if (tp->version == RTL_VER_04) {
                ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_SSPHYLINK2);
                ocp_data &= ~pwd_dn_scale_mask;
                ocp_data |= pwd_dn_scale(96);
                ocp_write_word(tp, MCU_TYPE_USB, USB_SSPHYLINK2, ocp_data);

                ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_USB2PHY);
                ocp_data |= USB2PHY_L1 | USB2PHY_SUSPEND;
                ocp_write_byte(tp, MCU_TYPE_USB, USB_USB2PHY, ocp_data);
        } else if (tp->version == RTL_VER_05) {
                ocp_data = ocp_read_byte(tp, MCU_TYPE_PLA, PLA_DMY_REG0);
                ocp_data &= ~ECM_ALDPS;
                ocp_write_byte(tp, MCU_TYPE_PLA, PLA_DMY_REG0, ocp_data);

                ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY1);
                if (ocp_read_word(tp, MCU_TYPE_USB, USB_BURST_SIZE) == 0)
                        ocp_data &= ~DYNAMIC_BURST;
                else
                        ocp_data |= DYNAMIC_BURST;
                ocp_write_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY1, ocp_data);
        } else if (tp->version == RTL_VER_06) {
                ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY1);
                if (ocp_read_word(tp, MCU_TYPE_USB, USB_BURST_SIZE) == 0)
                        ocp_data &= ~DYNAMIC_BURST;
                else
                        ocp_data |= DYNAMIC_BURST;
                ocp_write_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY1, ocp_data);
        }

        ocp_data = ocp_read_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY2);
        ocp_data |= EP4_FULL_FC;
        ocp_write_byte(tp, MCU_TYPE_USB, USB_CSR_DUMMY2, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_WDT11_CTRL);
        ocp_data &= ~TIMER11_EN;
        ocp_write_word(tp, MCU_TYPE_USB, USB_WDT11_CTRL, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE);
        ocp_data &= ~LED_MODE_MASK;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_LED_FEATURE, ocp_data);

        ocp_data = FIFO_EMPTY_1FB | ROK_EXIT_LPM;
        if (tp->version == RTL_VER_04 && tp->udev->speed != USB_SPEED_SUPER)
                ocp_data |= LPM_TIMER_500MS;
        else
                ocp_data |= LPM_TIMER_500US;
        ocp_write_byte(tp, MCU_TYPE_USB, USB_LPM_CTRL, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_AFE_CTRL2);
        ocp_data &= ~SEN_VAL_MASK;
        ocp_data |= SEN_VAL_NORMAL | SEL_RXIDLE;
        ocp_write_word(tp, MCU_TYPE_USB, USB_AFE_CTRL2, ocp_data);

        ocp_write_word(tp, MCU_TYPE_USB, USB_CONNECT_TIMER, 0x0001);

        r8153_power_cut_en(tp, false);

        r8152b_enable_fc(tp);
        rtl_tally_reset(tp);
}

static void r8153b_init(struct r8152 *tp)
{
        u32 ocp_data;
        int i;

        r8153_disable_aldps(tp);
        r8153b_u1u2en(tp, false);

        r8152_wait_for_bit(tp, 0, MCU_TYPE_PLA, PLA_BOOT_CTRL,
                           AUTOLOAD_DONE, 1, R8152_WAIT_TIMEOUT);

        for (i = 0; i < R8152_WAIT_TIMEOUT; i++) {
                ocp_data = ocp_reg_read(tp, OCP_PHY_STATUS) & PHY_STAT_MASK;
                if (ocp_data == PHY_STAT_LAN_ON || ocp_data == PHY_STAT_PWRDN)
                        break;

                mdelay(1);
        }

        r8153_u2p3en(tp, false);

        /* MSC timer = 0xfff * 8ms = 32760 ms */
        ocp_write_word(tp, MCU_TYPE_USB, USB_MSC_TIMER, 0x0fff);

        r8153_power_cut_en(tp, false);

        /* MAC clock speed down */
        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2);
        ocp_data |= MAC_CLK_SPDWN_EN;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL2, ocp_data);

        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3);
        ocp_data &= ~PLA_MCU_SPDWN_EN;
        ocp_write_word(tp, MCU_TYPE_PLA, PLA_MAC_PWR_CTRL3, ocp_data);

        if (tp->version == RTL_VER_09) {
                /* Disable Test IO for 32QFN */
                if (ocp_read_byte(tp, MCU_TYPE_PLA, 0xdc00) & BIT(5)) {
                        ocp_data = ocp_read_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR);
                        ocp_data |= TEST_IO_OFF;
                        ocp_write_word(tp, MCU_TYPE_PLA, PLA_PHY_PWR, ocp_data);
                }
        }

        /* rx aggregation */
        ocp_data = ocp_read_word(tp, MCU_TYPE_USB, USB_USB_CTRL);
        ocp_data &= ~(RX_AGG_DISABLE | RX_ZERO_EN);
        ocp_write_word(tp, MCU_TYPE_USB, USB_USB_CTRL, ocp_data);

        rtl_tally_reset(tp);
        r8153b_hw_phy_cfg(tp);
        r8152b_enable_fc(tp);
}

static void rtl8152_unload(struct r8152 *tp)
{
        if (tp->version != RTL_VER_01)
                r8152_power_cut_en(tp, true);
}

static void rtl8153_unload(struct r8152 *tp)
{
        r8153_power_cut_en(tp, false);
}

static int rtl_ops_init(struct r8152 *tp)
{
        struct rtl_ops *ops = &tp->rtl_ops;
        int ret = 0;

        switch (tp->version) {
        case RTL_VER_01:
        case RTL_VER_02:
        case RTL_VER_07:
                ops->init               = r8152b_init;
                ops->enable             = rtl8152_enable;
                ops->disable            = rtl8152_disable;
                ops->up                 = rtl8152_up;
                ops->down               = rtl8152_down;
                ops->unload             = rtl8152_unload;
                break;

        case RTL_VER_03:
        case RTL_VER_04:
        case RTL_VER_05:
        case RTL_VER_06:
                ops->init               = r8153_init;
                ops->enable             = rtl8153_enable;
                ops->disable            = rtl8153_disable;
                ops->up                 = rtl8153_up;
                ops->down               = rtl8153_down;
                ops->unload             = rtl8153_unload;
                break;

        case RTL_VER_08:
        case RTL_VER_09:
                ops->init               = r8153b_init;
                ops->enable             = rtl8153_enable;
                ops->disable            = rtl8153_disable;
                ops->up                 = rtl8153b_up;
                ops->down               = rtl8153b_down;
                break;

        default:
                ret = -ENODEV;
                printf("r8152 Unknown Device\n");
                break;
        }

        return ret;
}

static int r8152_init_common(struct r8152 *tp)
{
        u8 speed;
        int timeout = 0;
        int link_detected;

        debug("** %s()\n", __func__);

        do {
                speed = rtl8152_get_speed(tp);

                link_detected = speed & LINK_STATUS;
                if (!link_detected) {
                        if (timeout == 0)
                                printf("Waiting for Ethernet connection... ");
                        mdelay(TIMEOUT_RESOLUTION);
                        timeout += TIMEOUT_RESOLUTION;
                }
        } while (!link_detected && timeout < PHY_CONNECT_TIMEOUT);
        if (link_detected) {
                tp->rtl_ops.enable(tp);

                if (timeout != 0)
                        printf("done.\n");
        } else {
                printf("unable to connect.\n");
        }

        return 0;
}

static int r8152_send_common(struct ueth_data *ueth, void *packet, int length)
{
        struct usb_device *udev = ueth->pusb_dev;
        u32 opts1, opts2 = 0;
        int err;
        int actual_len;
        ALLOC_CACHE_ALIGN_BUFFER(uint8_t, msg,
                                 PKTSIZE + sizeof(struct tx_desc));
        struct tx_desc *tx_desc = (struct tx_desc *)msg;

        debug("** %s(), len %d\n", __func__, length);

        opts1 = length | TX_FS | TX_LS;

        tx_desc->opts2 = cpu_to_le32(opts2);
        tx_desc->opts1 = cpu_to_le32(opts1);

        memcpy(msg + sizeof(struct tx_desc), (void *)packet, length);

        err = usb_bulk_msg(udev, usb_sndbulkpipe(udev, ueth->ep_out),
                           (void *)msg, length + sizeof(struct tx_desc),
                           &actual_len, USB_BULK_SEND_TIMEOUT);
        debug("Tx: len = %zu, actual = %u, err = %d\n",
              length + sizeof(struct tx_desc), actual_len, err);

        return err;
}

#ifndef CONFIG_DM_ETH
static int r8152_init(struct eth_device *eth, struct bd_info *bd)
{
        struct ueth_data *dev = (struct ueth_data *)eth->priv;
        struct r8152 *tp = (struct r8152 *)dev->dev_priv;

        return r8152_init_common(tp);
}

static int r8152_send(struct eth_device *eth, void *packet, int length)
{
        struct ueth_data *dev = (struct ueth_data *)eth->priv;

        return r8152_send_common(dev, packet, length);
}

static int r8152_recv(struct eth_device *eth)
{
        struct ueth_data *dev = (struct ueth_data *)eth->priv;

        ALLOC_CACHE_ALIGN_BUFFER(uint8_t, recv_buf, RTL8152_AGG_BUF_SZ);
        unsigned char *pkt_ptr;
        int err;
        int actual_len;
        u16 packet_len;

        u32 bytes_process = 0;
        struct rx_desc *rx_desc;

        debug("** %s()\n", __func__);

        err = usb_bulk_msg(dev->pusb_dev,
                                usb_rcvbulkpipe(dev->pusb_dev, dev->ep_in),
                                (void *)recv_buf,
                                RTL8152_AGG_BUF_SZ,
                                &actual_len,
                                USB_BULK_RECV_TIMEOUT);
        debug("Rx: len = %u, actual = %u, err = %d\n", RTL8152_AGG_BUF_SZ,
              actual_len, err);
        if (err != 0) {
                debug("Rx: failed to receive\n");
                return -1;
        }
        if (actual_len > RTL8152_AGG_BUF_SZ) {
                debug("Rx: received too many bytes %d\n", actual_len);
                return -1;
        }

        while (bytes_process < actual_len) {
                rx_desc = (struct rx_desc *)(recv_buf + bytes_process);
                pkt_ptr = recv_buf + sizeof(struct rx_desc) + bytes_process;

                packet_len = le32_to_cpu(rx_desc->opts1) & RX_LEN_MASK;
                packet_len -= CRC_SIZE;

                net_process_received_packet(pkt_ptr, packet_len);

                bytes_process +=
                        (packet_len + sizeof(struct rx_desc) + CRC_SIZE);

                if (bytes_process % 8)
                        bytes_process = bytes_process + 8 - (bytes_process % 8);
        }

        return 0;
}

static void r8152_halt(struct eth_device *eth)
{
        struct ueth_data *dev = (struct ueth_data *)eth->priv;
        struct r8152 *tp = (struct r8152 *)dev->dev_priv;

        debug("** %s()\n", __func__);

        tp->rtl_ops.disable(tp);
}

static int r8152_write_hwaddr(struct eth_device *eth)
{
        struct ueth_data *dev = (struct ueth_data *)eth->priv;
        struct r8152 *tp = (struct r8152 *)dev->dev_priv;

        unsigned char enetaddr[8] = {0};

        memcpy(enetaddr, eth->enetaddr, ETH_ALEN);

        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
        pla_ocp_write(tp, PLA_IDR, BYTE_EN_SIX_BYTES, 8, enetaddr);
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);

        debug("MAC %pM\n", eth->enetaddr);
        return 0;
}

void r8152_eth_before_probe(void)
{
        curr_eth_dev = 0;
}

/* Probe to see if a new device is actually an realtek device */
int r8152_eth_probe(struct usb_device *dev, unsigned int ifnum,
                      struct ueth_data *ss)
{
        struct usb_interface *iface;
        struct usb_interface_descriptor *iface_desc;
        int ep_in_found = 0, ep_out_found = 0;
        struct r8152 *tp;
        int i;

        /* let's examine the device now */
        iface = &dev->config.if_desc[ifnum];
        iface_desc = &dev->config.if_desc[ifnum].desc;

        for (i = 0; i < ARRAY_SIZE(r8152_dongles); i++) {
                if (dev->descriptor.idVendor == r8152_dongles[i].vendor &&
                    dev->descriptor.idProduct == r8152_dongles[i].product)
                        /* Found a supported dongle */
                        break;
        }

        if (i == ARRAY_SIZE(r8152_dongles))
                return 0;

        memset(ss, 0, sizeof(struct ueth_data));

        /* At this point, we know we've got a live one */
        debug("\n\nUSB Ethernet device detected: %#04x:%#04x\n",
              dev->descriptor.idVendor, dev->descriptor.idProduct);

        /* Initialize the ueth_data structure with some useful info */
        ss->ifnum = ifnum;
        ss->pusb_dev = dev;
        ss->subclass = iface_desc->bInterfaceSubClass;
        ss->protocol = iface_desc->bInterfaceProtocol;

        /* alloc driver private */
        ss->dev_priv = calloc(1, sizeof(struct r8152));

        if (!ss->dev_priv)
                return 0;

        /*
         * We are expecting a minimum of 3 endpoints - in, out (bulk), and
         * int. We will ignore any others.
         */
        for (i = 0; i < iface_desc->bNumEndpoints; i++) {
                /* is it an BULK endpoint? */
                if ((iface->ep_desc[i].bmAttributes &
                     USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK) {
                        u8 ep_addr = iface->ep_desc[i].bEndpointAddress;

                        if (ep_addr & USB_DIR_IN) {
                                if (!ep_in_found) {
                                        ss->ep_in = ep_addr &
                                                USB_ENDPOINT_NUMBER_MASK;
                                        ep_in_found = 1;
                                }
                        } else {
                                if (!ep_out_found) {
                                        ss->ep_out = ep_addr &
                                                USB_ENDPOINT_NUMBER_MASK;
                                        ep_out_found = 1;
                                }
                        }
                }

                /* is it an interrupt endpoint? */
                if ((iface->ep_desc[i].bmAttributes &
                    USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT) {
                        ss->ep_int = iface->ep_desc[i].bEndpointAddress &
                                USB_ENDPOINT_NUMBER_MASK;
                        ss->irqinterval = iface->ep_desc[i].bInterval;
                }
        }

        debug("Endpoints In %d Out %d Int %d\n",
              ss->ep_in, ss->ep_out, ss->ep_int);

        /* Do some basic sanity checks, and bail if we find a problem */
        if (usb_set_interface(dev, iface_desc->bInterfaceNumber, 0) ||
            !ss->ep_in || !ss->ep_out || !ss->ep_int) {
                debug("Problems with device\n");
                goto error;
        }

        dev->privptr = (void *)ss;

        tp = ss->dev_priv;
        tp->udev = dev;
        tp->intf = iface;

        r8152b_get_version(tp);

        if (rtl_ops_init(tp))
                goto error;

        tp->rtl_ops.init(tp);
        tp->rtl_ops.up(tp);

        rtl8152_set_speed(tp, AUTONEG_ENABLE,
                          tp->supports_gmii ? SPEED_1000 : SPEED_100,
                          DUPLEX_FULL);

        return 1;

error:
        cfree(ss->dev_priv);
        ss->dev_priv = 0;
        return 0;
}

int r8152_eth_get_info(struct usb_device *dev, struct ueth_data *ss,
                                struct eth_device *eth)
{
        if (!eth) {
                debug("%s: missing parameter.\n", __func__);
                return 0;
        }

        sprintf(eth->name, "%s#%d", R8152_BASE_NAME, curr_eth_dev++);
        eth->init = r8152_init;
        eth->send = r8152_send;
        eth->recv = r8152_recv;
        eth->halt = r8152_halt;
        eth->write_hwaddr = r8152_write_hwaddr;
        eth->priv = ss;

        /* Get the MAC address */
        if (r8152_read_mac(ss->dev_priv, eth->enetaddr) < 0)
                return 0;

        debug("MAC %pM\n", eth->enetaddr);
        return 1;
}
#endif /* !CONFIG_DM_ETH */

#ifdef CONFIG_DM_ETH
static int r8152_eth_start(struct udevice *dev)
{
        struct r8152 *tp = dev_get_priv(dev);

        debug("** %s (%d)\n", __func__, __LINE__);

        return r8152_init_common(tp);
}

void r8152_eth_stop(struct udevice *dev)
{
        struct r8152 *tp = dev_get_priv(dev);

        debug("** %s (%d)\n", __func__, __LINE__);

        tp->rtl_ops.disable(tp);
}

int r8152_eth_send(struct udevice *dev, void *packet, int length)
{
        struct r8152 *tp = dev_get_priv(dev);

        return r8152_send_common(&tp->ueth, packet, length);
}

int r8152_eth_recv(struct udevice *dev, int flags, uchar **packetp)
{
        struct r8152 *tp = dev_get_priv(dev);
        struct ueth_data *ueth = &tp->ueth;
        uint8_t *ptr;
        int ret, len;
        struct rx_desc *rx_desc;
        u16 packet_len;

        len = usb_ether_get_rx_bytes(ueth, &ptr);
        debug("%s: first try, len=%d\n", __func__, len);
        if (!len) {
                if (!(flags & ETH_RECV_CHECK_DEVICE))
                        return -EAGAIN;
                ret = usb_ether_receive(ueth, RTL8152_AGG_BUF_SZ);
                if (ret)
                        return ret;

                len = usb_ether_get_rx_bytes(ueth, &ptr);
                debug("%s: second try, len=%d\n", __func__, len);
        }

        rx_desc = (struct rx_desc *)ptr;
        packet_len = le32_to_cpu(rx_desc->opts1) & RX_LEN_MASK;
        packet_len -= CRC_SIZE;

        if (packet_len > len - (sizeof(struct rx_desc) + CRC_SIZE)) {
                debug("Rx: too large packet: %d\n", packet_len);
                goto err;
        }

        *packetp = ptr + sizeof(struct rx_desc);
        return packet_len;

err:
        usb_ether_advance_rxbuf(ueth, -1);
        return -ENOSPC;
}

static int r8152_free_pkt(struct udevice *dev, uchar *packet, int packet_len)
{
        struct r8152 *tp = dev_get_priv(dev);

        packet_len += sizeof(struct rx_desc) + CRC_SIZE;
        packet_len = ALIGN(packet_len, 8);
        usb_ether_advance_rxbuf(&tp->ueth, packet_len);

        return 0;
}

static int r8152_write_hwaddr(struct udevice *dev)
{
        struct eth_pdata *pdata = dev_get_plat(dev);
        struct r8152 *tp = dev_get_priv(dev);

        unsigned char enetaddr[8] = { 0 };

        debug("** %s (%d)\n", __func__, __LINE__);
        memcpy(enetaddr, pdata->enetaddr, ETH_ALEN);

        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_CONFIG);
        pla_ocp_write(tp, PLA_IDR, BYTE_EN_SIX_BYTES, 8, enetaddr);
        ocp_write_byte(tp, MCU_TYPE_PLA, PLA_CRWECR, CRWECR_NORAML);

        debug("MAC %pM\n", pdata->enetaddr);
        return 0;
}

int r8152_read_rom_hwaddr(struct udevice *dev)
{
        struct eth_pdata *pdata = dev_get_plat(dev);
        struct r8152 *tp = dev_get_priv(dev);

        debug("** %s (%d)\n", __func__, __LINE__);
        r8152_read_mac(tp, pdata->enetaddr);
        return 0;
}

static int r8152_eth_probe(struct udevice *dev)
{
        struct usb_device *udev = dev_get_parent_priv(dev);
        struct eth_pdata *pdata = dev_get_plat(dev);
        struct r8152 *tp = dev_get_priv(dev);
        struct ueth_data *ueth = &tp->ueth;
        int ret;

        tp->udev = udev;
        r8152_read_mac(tp, pdata->enetaddr);

        r8152b_get_version(tp);

        ret = rtl_ops_init(tp);
        if (ret)
                return ret;

        tp->rtl_ops.init(tp);
        tp->rtl_ops.up(tp);

        rtl8152_set_speed(tp, AUTONEG_ENABLE,
                          tp->supports_gmii ? SPEED_1000 : SPEED_100,
                          DUPLEX_FULL);

        return usb_ether_register(dev, ueth, RTL8152_AGG_BUF_SZ);
}

static const struct eth_ops r8152_eth_ops = {
        .start  = r8152_eth_start,
        .send   = r8152_eth_send,
        .recv   = r8152_eth_recv,
        .free_pkt = r8152_free_pkt,
        .stop   = r8152_eth_stop,
        .write_hwaddr = r8152_write_hwaddr,
        .read_rom_hwaddr = r8152_read_rom_hwaddr,
};

U_BOOT_DRIVER(r8152_eth) = {
        .name   = "r8152_eth",
        .id     = UCLASS_ETH,
        .probe = r8152_eth_probe,
        .ops    = &r8152_eth_ops,
        .priv_auto      = sizeof(struct r8152),
        .plat_auto      = sizeof(struct eth_pdata),
};

static const struct usb_device_id r8152_eth_id_table[] = {
        /* Realtek */
        { USB_DEVICE(0x0bda, 0x8050) },
        { USB_DEVICE(0x0bda, 0x8152) },
        { USB_DEVICE(0x0bda, 0x8153) },

        /* Samsung */
        { USB_DEVICE(0x04e8, 0xa101) },

        /* Lenovo */
        { USB_DEVICE(0x17ef, 0x304f) },
        { USB_DEVICE(0x17ef, 0x3052) },
        { USB_DEVICE(0x17ef, 0x3054) },
        { USB_DEVICE(0x17ef, 0x3057) },
        { USB_DEVICE(0x17ef, 0x7205) },
        { USB_DEVICE(0x17ef, 0x720a) },
        { USB_DEVICE(0x17ef, 0x720b) },
        { USB_DEVICE(0x17ef, 0x720c) },

        /* TP-LINK */
        { USB_DEVICE(0x2357, 0x0601) },

        /* Nvidia */
        { USB_DEVICE(0x0955, 0x09ff) },

        { }             /* Terminating entry */
};

U_BOOT_USB_DEVICE(r8152_eth, r8152_eth_id_table);
#endif /* CONFIG_DM_ETH */