Quelle  lan743x_main.c   Sprache: C

/* SPDX-License-Identifier: GPL-2.0+ */
/* Copyright (C) 2018 Microchip Technology Inc. */

#include <linux/module.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/crc32.h>
#include <linux/microchipphy.h>
#include <linux/net_tstamp.h>
#include <linux/of_mdio.h>
#include <linux/of_net.h>
#include <linux/phy.h>
#include <linux/phy_fixed.h>
#include <linux/rtnetlink.h>
#include <linux/iopoll.h>
#include <linux/crc16.h>
#include <linux/phylink.h>
#include "lan743x_main.h"
#include "lan743x_ethtool.h"

#define MMD_ACCESS_ADDRESS 0
#define MMD_ACCESS_WRITE 1
#define MMD_ACCESS_READ  2
#define MMD_ACCESS_READ_INC 3
#define PCS_POWER_STATE_DOWN 0x6
#define PCS_POWER_STATE_UP 0x4

#define RFE_RD_FIFO_TH_3_DWORDS 0x3

static void pci11x1x_strap_get_status(struct lan743x_adapter *adapter)
{
 u32 chip_rev;
 u32 cfg_load;
 u32 hw_cfg;
 u32 strap;
 int ret;

 /* Timeout = 100 (i.e. 1 sec (10 msce * 100)) */
 ret = lan743x_hs_syslock_acquire(adapter, 100);
 if (ret < 0) {
  netif_err(adapter, drv, adapter->netdev,
     "Sys Lock acquire failed ret:%d\n", ret);
  return;
 }

 cfg_load = lan743x_csr_read(adapter, ETH_SYS_CONFIG_LOAD_STARTED_REG);
 lan743x_hs_syslock_release(adapter);
 hw_cfg = lan743x_csr_read(adapter, HW_CFG);

 if (cfg_load & GEN_SYS_LOAD_STARTED_REG_ETH_ ||
     hw_cfg & HW_CFG_RST_PROTECT_) {
  strap = lan743x_csr_read(adapter, STRAP_READ);
  if (strap & STRAP_READ_SGMII_EN_)
   adapter->is_sgmii_en = true;
  else
   adapter->is_sgmii_en = false;
 } else {
  chip_rev = lan743x_csr_read(adapter, FPGA_REV);
  if (chip_rev) {
   if (chip_rev & FPGA_SGMII_OP)
    adapter->is_sgmii_en = true;
   else
    adapter->is_sgmii_en = false;
  } else {
   adapter->is_sgmii_en = false;
  }
 }
 netif_dbg(adapter, drv, adapter->netdev,
    "SGMII I/F %sable\n", adapter->is_sgmii_en ? "En" : "Dis");
}

static bool is_pci11x1x_chip(struct lan743x_adapter *adapter)
{
 struct lan743x_csr *csr = &adapter->csr;
 u32 id_rev = csr->id_rev;

 if (((id_rev & 0xFFFF0000) == ID_REV_ID_A011_) ||
     ((id_rev & 0xFFFF0000) == ID_REV_ID_A041_)) {
  return true;
 }
 return false;
}

static void lan743x_pci_cleanup(struct lan743x_adapter *adapter)
{
 pci_release_selected_regions(adapter->pdev,
         pci_select_bars(adapter->pdev,
           IORESOURCE_MEM));
 pci_disable_device(adapter->pdev);
}

static int lan743x_pci_init(struct lan743x_adapter *adapter,
       struct pci_dev *pdev)
{
 unsigned long bars = 0;
 int ret;

 adapter->pdev = pdev;
 ret = pci_enable_device_mem(pdev);
 if (ret)
  goto return_error;

 netif_info(adapter, probe, adapter->netdev,
     "PCI: Vendor ID = 0x%04X, Device ID = 0x%04X\n",
     pdev->vendor, pdev->device);
 bars = pci_select_bars(pdev, IORESOURCE_MEM);
 if (!test_bit(0, &bars))
  goto disable_device;

 ret = pci_request_selected_regions(pdev, bars, DRIVER_NAME);
 if (ret)
  goto disable_device;

 pci_set_master(pdev);
 return 0;

disable_device:
 pci_disable_device(adapter->pdev);

return_error:
 return ret;
}

u32 lan743x_csr_read(struct lan743x_adapter *adapter, int offset)
{
 return ioread32(&adapter->csr.csr_address[offset]);
}

void lan743x_csr_write(struct lan743x_adapter *adapter, int offset,
         u32 data)
{
 iowrite32(data, &adapter->csr.csr_address[offset]);
}

#define LAN743X_CSR_READ_OP(offset) lan743x_csr_read(adapter, offset)

static int lan743x_csr_light_reset(struct lan743x_adapter *adapter)
{
 u32 data;

 data = lan743x_csr_read(adapter, HW_CFG);
 data |= HW_CFG_LRST_;
 lan743x_csr_write(adapter, HW_CFG, data);

 return readx_poll_timeout(LAN743X_CSR_READ_OP, HW_CFG, data,
      !(data & HW_CFG_LRST_), 100000, 10000000);
}

static int lan743x_csr_wait_for_bit_atomic(struct lan743x_adapter *adapter,
        int offset, u32 bit_mask,
        int target_value, int udelay_min,
        int udelay_max, int count)
{
 u32 data;

 return readx_poll_timeout_atomic(LAN743X_CSR_READ_OP, offset, data,
      target_value == !!(data & bit_mask),
      udelay_max, udelay_min * count);
}

static int lan743x_csr_wait_for_bit(struct lan743x_adapter *adapter,
        int offset, u32 bit_mask,
        int target_value, int usleep_min,
        int usleep_max, int count)
{
 u32 data;

 return readx_poll_timeout(LAN743X_CSR_READ_OP, offset, data,
      target_value == !!(data & bit_mask),
      usleep_max, usleep_min * count);
}

static int lan743x_csr_init(struct lan743x_adapter *adapter)
{
 struct lan743x_csr *csr = &adapter->csr;
 resource_size_t bar_start, bar_length;

 bar_start = pci_resource_start(adapter->pdev, 0);
 bar_length = pci_resource_len(adapter->pdev, 0);
 csr->csr_address = devm_ioremap(&adapter->pdev->dev,
     bar_start, bar_length);
 if (!csr->csr_address)
  return -ENOMEM;

 csr->id_rev = lan743x_csr_read(adapter, ID_REV);
 csr->fpga_rev = lan743x_csr_read(adapter, FPGA_REV);
 netif_info(adapter, probe, adapter->netdev,
     "ID_REV = 0x%08X, FPGA_REV = %d.%d\n",
     csr->id_rev, FPGA_REV_GET_MAJOR_(csr->fpga_rev),
     FPGA_REV_GET_MINOR_(csr->fpga_rev));
 if (!ID_REV_IS_VALID_CHIP_ID_(csr->id_rev))
  return -ENODEV;

 csr->flags = LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR;
 switch (csr->id_rev & ID_REV_CHIP_REV_MASK_) {
 case ID_REV_CHIP_REV_A0_:
  csr->flags |= LAN743X_CSR_FLAG_IS_A0;
  csr->flags &= ~LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR;
  break;
 case ID_REV_CHIP_REV_B0_:
  csr->flags |= LAN743X_CSR_FLAG_IS_B0;
  break;
 }

 return lan743x_csr_light_reset(adapter);
}

static void lan743x_intr_software_isr(struct lan743x_adapter *adapter)
{
 struct lan743x_intr *intr = &adapter->intr;

 /* disable the interrupt to prevent repeated re-triggering */
 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_SW_GP_);
 intr->software_isr_flag = true;
 wake_up(&intr->software_isr_wq);
}

static void lan743x_tx_isr(void *context, u32 int_sts, u32 flags)
{
 struct lan743x_tx *tx = context;
 struct lan743x_adapter *adapter = tx->adapter;
 bool enable_flag = true;

 lan743x_csr_read(adapter, INT_EN_SET);
 if (flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR) {
  lan743x_csr_write(adapter, INT_EN_CLR,
      INT_BIT_DMA_TX_(tx->channel_number));
 }

 if (int_sts & INT_BIT_DMA_TX_(tx->channel_number)) {
  u32 ioc_bit = DMAC_INT_BIT_TX_IOC_(tx->channel_number);
  u32 dmac_int_sts;
  u32 dmac_int_en;

  if (flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ)
   dmac_int_sts = lan743x_csr_read(adapter, DMAC_INT_STS);
  else
   dmac_int_sts = ioc_bit;
  if (flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK)
   dmac_int_en = lan743x_csr_read(adapter,
             DMAC_INT_EN_SET);
  else
   dmac_int_en = ioc_bit;

  dmac_int_en &= ioc_bit;
  dmac_int_sts &= dmac_int_en;
  if (dmac_int_sts & ioc_bit) {
   napi_schedule(&tx->napi);
   enable_flag = false;/* poll func will enable later */
  }
 }

 if (enable_flag)
  /* enable isr */
  lan743x_csr_write(adapter, INT_EN_SET,
      INT_BIT_DMA_TX_(tx->channel_number));
}

static void lan743x_rx_isr(void *context, u32 int_sts, u32 flags)
{
 struct lan743x_rx *rx = context;
 struct lan743x_adapter *adapter = rx->adapter;
 bool enable_flag = true;

 if (flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR) {
  lan743x_csr_write(adapter, INT_EN_CLR,
      INT_BIT_DMA_RX_(rx->channel_number));
 }

 if (int_sts & INT_BIT_DMA_RX_(rx->channel_number)) {
  u32 rx_frame_bit = DMAC_INT_BIT_RXFRM_(rx->channel_number);
  u32 dmac_int_sts;
  u32 dmac_int_en;

  if (flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ)
   dmac_int_sts = lan743x_csr_read(adapter, DMAC_INT_STS);
  else
   dmac_int_sts = rx_frame_bit;
  if (flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK)
   dmac_int_en = lan743x_csr_read(adapter,
             DMAC_INT_EN_SET);
  else
   dmac_int_en = rx_frame_bit;

  dmac_int_en &= rx_frame_bit;
  dmac_int_sts &= dmac_int_en;
  if (dmac_int_sts & rx_frame_bit) {
   napi_schedule(&rx->napi);
   enable_flag = false;/* poll funct will enable later */
  }
 }

 if (enable_flag) {
  /* enable isr */
  lan743x_csr_write(adapter, INT_EN_SET,
      INT_BIT_DMA_RX_(rx->channel_number));
 }
}

static void lan743x_intr_shared_isr(void *context, u32 int_sts, u32 flags)
{
 struct lan743x_adapter *adapter = context;
 unsigned int channel;

 if (int_sts & INT_BIT_ALL_RX_) {
  for (channel = 0; channel < LAN743X_USED_RX_CHANNELS;
   channel++) {
   u32 int_bit = INT_BIT_DMA_RX_(channel);

   if (int_sts & int_bit) {
    lan743x_rx_isr(&adapter->rx[channel],
            int_bit, flags);
    int_sts &= ~int_bit;
   }
  }
 }
 if (int_sts & INT_BIT_ALL_TX_) {
  for (channel = 0; channel < adapter->used_tx_channels;
   channel++) {
   u32 int_bit = INT_BIT_DMA_TX_(channel);

   if (int_sts & int_bit) {
    lan743x_tx_isr(&adapter->tx[channel],
            int_bit, flags);
    int_sts &= ~int_bit;
   }
  }
 }
 if (int_sts & INT_BIT_ALL_OTHER_) {
  if (int_sts & INT_BIT_SW_GP_) {
   lan743x_intr_software_isr(adapter);
   int_sts &= ~INT_BIT_SW_GP_;
  }
  if (int_sts & INT_BIT_1588_) {
   lan743x_ptp_isr(adapter);
   int_sts &= ~INT_BIT_1588_;
  }
 }
 if (int_sts)
  lan743x_csr_write(adapter, INT_EN_CLR, int_sts);
}

static irqreturn_t lan743x_intr_entry_isr(int irq, void *ptr)
{
 struct lan743x_vector *vector = ptr;
 struct lan743x_adapter *adapter = vector->adapter;
 irqreturn_t result = IRQ_NONE;
 u32 int_enables;
 u32 int_sts;

 if (vector->flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ) {
  int_sts = lan743x_csr_read(adapter, INT_STS);
 } else if (vector->flags &
     (LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C |
     LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C)) {
  int_sts = lan743x_csr_read(adapter, INT_STS_R2C);
 } else {
  /* use mask as implied status */
  int_sts = vector->int_mask | INT_BIT_MAS_;
 }

 if (!(int_sts & INT_BIT_MAS_))
  goto irq_done;

 if (vector->flags & LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR)
  /* disable vector interrupt */
  lan743x_csr_write(adapter,
      INT_VEC_EN_CLR,
      INT_VEC_EN_(vector->vector_index));

 if (vector->flags & LAN743X_VECTOR_FLAG_MASTER_ENABLE_CLEAR)
  /* disable master interrupt */
  lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_MAS_);

 if (vector->flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK) {
  int_enables = lan743x_csr_read(adapter, INT_EN_SET);
 } else {
  /*  use vector mask as implied enable mask */
  int_enables = vector->int_mask;
 }

 int_sts &= int_enables;
 int_sts &= vector->int_mask;
 if (int_sts) {
  if (vector->handler) {
   vector->handler(vector->context,
     int_sts, vector->flags);
  } else {
   /* disable interrupts on this vector */
   lan743x_csr_write(adapter, INT_EN_CLR,
       vector->int_mask);
  }
  result = IRQ_HANDLED;
 }

 if (vector->flags & LAN743X_VECTOR_FLAG_MASTER_ENABLE_SET)
  /* enable master interrupt */
  lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_MAS_);

 if (vector->flags & LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET)
  /* enable vector interrupt */
  lan743x_csr_write(adapter,
      INT_VEC_EN_SET,
      INT_VEC_EN_(vector->vector_index));
irq_done:
 return result;
}

static int lan743x_intr_test_isr(struct lan743x_adapter *adapter)
{
 struct lan743x_intr *intr = &adapter->intr;
 int ret;

 intr->software_isr_flag = false;

 /* enable and activate test interrupt */
 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_SW_GP_);
 lan743x_csr_write(adapter, INT_SET, INT_BIT_SW_GP_);

 ret = wait_event_timeout(intr->software_isr_wq,
     intr->software_isr_flag,
     msecs_to_jiffies(200));

 /* disable test interrupt */
 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_SW_GP_);

 return ret > 0 ? 0 : -ENODEV;
}

static int lan743x_intr_register_isr(struct lan743x_adapter *adapter,
         int vector_index, u32 flags,
         u32 int_mask,
         lan743x_vector_handler handler,
         void *context)
{
 struct lan743x_vector *vector = &adapter->intr.vector_list
     [vector_index];
 int ret;

 vector->adapter = adapter;
 vector->flags = flags;
 vector->vector_index = vector_index;
 vector->int_mask = int_mask;
 vector->handler = handler;
 vector->context = context;

 ret = request_irq(vector->irq,
     lan743x_intr_entry_isr,
     (flags & LAN743X_VECTOR_FLAG_IRQ_SHARED) ?
     IRQF_SHARED : 0, DRIVER_NAME, vector);
 if (ret) {
  vector->handler = NULL;
  vector->context = NULL;
  vector->int_mask = 0;
  vector->flags = 0;
 }
 return ret;
}

static void lan743x_intr_unregister_isr(struct lan743x_adapter *adapter,
     int vector_index)
{
 struct lan743x_vector *vector = &adapter->intr.vector_list
     [vector_index];

 free_irq(vector->irq, vector);
 vector->handler = NULL;
 vector->context = NULL;
 vector->int_mask = 0;
 vector->flags = 0;
}

static u32 lan743x_intr_get_vector_flags(struct lan743x_adapter *adapter,
      u32 int_mask)
{
 int index;

 for (index = 0; index < adapter->max_vector_count; index++) {
  if (adapter->intr.vector_list[index].int_mask & int_mask)
   return adapter->intr.vector_list[index].flags;
 }
 return 0;
}

static void lan743x_intr_close(struct lan743x_adapter *adapter)
{
 struct lan743x_intr *intr = &adapter->intr;
 int index = 0;

 lan743x_csr_write(adapter, INT_EN_CLR, INT_BIT_MAS_);
 if (adapter->is_pci11x1x)
  lan743x_csr_write(adapter, INT_VEC_EN_CLR, 0x0000FFFF);
 else
  lan743x_csr_write(adapter, INT_VEC_EN_CLR, 0x000000FF);

 for (index = 0; index < intr->number_of_vectors; index++) {
  if (intr->flags & INTR_FLAG_IRQ_REQUESTED(index)) {
   lan743x_intr_unregister_isr(adapter, index);
   intr->flags &= ~INTR_FLAG_IRQ_REQUESTED(index);
  }
 }

 if (intr->flags & INTR_FLAG_MSI_ENABLED) {
  pci_disable_msi(adapter->pdev);
  intr->flags &= ~INTR_FLAG_MSI_ENABLED;
 }

 if (intr->flags & INTR_FLAG_MSIX_ENABLED) {
  pci_disable_msix(adapter->pdev);
  intr->flags &= ~INTR_FLAG_MSIX_ENABLED;
 }
}

static int lan743x_intr_open(struct lan743x_adapter *adapter)
{
 struct msix_entry msix_entries[PCI11X1X_MAX_VECTOR_COUNT];
 struct lan743x_intr *intr = &adapter->intr;
 unsigned int used_tx_channels;
 u32 int_vec_en_auto_clr = 0;
 u8 max_vector_count;
 u32 int_vec_map0 = 0;
 u32 int_vec_map1 = 0;
 int ret = -ENODEV;
 int index = 0;
 u32 flags = 0;

 intr->number_of_vectors = 0;

 /* Try to set up MSIX interrupts */
 max_vector_count = adapter->max_vector_count;
 memset(&msix_entries[0], 0,
        sizeof(struct msix_entry) * max_vector_count);
 for (index = 0; index < max_vector_count; index++)
  msix_entries[index].entry = index;
 used_tx_channels = adapter->used_tx_channels;
 ret = pci_enable_msix_range(adapter->pdev,
        msix_entries, 1,
        1 + used_tx_channels +
        LAN743X_USED_RX_CHANNELS);

 if (ret > 0) {
  intr->flags |= INTR_FLAG_MSIX_ENABLED;
  intr->number_of_vectors = ret;
  intr->using_vectors = true;
  for (index = 0; index < intr->number_of_vectors; index++)
   intr->vector_list[index].irq = msix_entries
             [index].vector;
  netif_info(adapter, ifup, adapter->netdev,
      "using MSIX interrupts, number of vectors = %d\n",
      intr->number_of_vectors);
 }

 /* If MSIX failed try to setup using MSI interrupts */
 if (!intr->number_of_vectors) {
  if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0)) {
   if (!pci_enable_msi(adapter->pdev)) {
    intr->flags |= INTR_FLAG_MSI_ENABLED;
    intr->number_of_vectors = 1;
    intr->using_vectors = true;
    intr->vector_list[0].irq =
     adapter->pdev->irq;
    netif_info(adapter, ifup, adapter->netdev,
        "using MSI interrupts, number of vectors = %d\n",
        intr->number_of_vectors);
   }
  }
 }

 /* If MSIX, and MSI failed, setup using legacy interrupt */
 if (!intr->number_of_vectors) {
  intr->number_of_vectors = 1;
  intr->using_vectors = false;
  intr->vector_list[0].irq = intr->irq;
  netif_info(adapter, ifup, adapter->netdev,
      "using legacy interrupts\n");
 }

 /* At this point we must have at least one irq */
 lan743x_csr_write(adapter, INT_VEC_EN_CLR, 0xFFFFFFFF);

 /* map all interrupts to vector 0 */
 lan743x_csr_write(adapter, INT_VEC_MAP0, 0x00000000);
 lan743x_csr_write(adapter, INT_VEC_MAP1, 0x00000000);
 lan743x_csr_write(adapter, INT_VEC_MAP2, 0x00000000);
 flags = LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ |
  LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C |
  LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK |
  LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR;

 if (intr->using_vectors) {
  flags |= LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR |
    LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET;
 } else {
  flags |= LAN743X_VECTOR_FLAG_MASTER_ENABLE_CLEAR |
    LAN743X_VECTOR_FLAG_MASTER_ENABLE_SET |
    LAN743X_VECTOR_FLAG_IRQ_SHARED;
 }

 if (adapter->csr.flags & LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR) {
  flags &= ~LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ;
  flags &= ~LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C;
  flags &= ~LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR;
  flags &= ~LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK;
  flags |= LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C;
  flags |= LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C;
 }

 init_waitqueue_head(&intr->software_isr_wq);

 ret = lan743x_intr_register_isr(adapter, 0, flags,
     INT_BIT_ALL_RX_ | INT_BIT_ALL_TX_ |
     INT_BIT_ALL_OTHER_,
     lan743x_intr_shared_isr, adapter);
 if (ret)
  goto clean_up;
 intr->flags |= INTR_FLAG_IRQ_REQUESTED(0);

 if (intr->using_vectors)
  lan743x_csr_write(adapter, INT_VEC_EN_SET,
      INT_VEC_EN_(0));

 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0)) {
  lan743x_csr_write(adapter, INT_MOD_CFG0, LAN743X_INT_MOD);
  lan743x_csr_write(adapter, INT_MOD_CFG1, LAN743X_INT_MOD);
  lan743x_csr_write(adapter, INT_MOD_CFG2, LAN743X_INT_MOD);
  lan743x_csr_write(adapter, INT_MOD_CFG3, LAN743X_INT_MOD);
  lan743x_csr_write(adapter, INT_MOD_CFG4, LAN743X_INT_MOD);
  lan743x_csr_write(adapter, INT_MOD_CFG5, LAN743X_INT_MOD);
  lan743x_csr_write(adapter, INT_MOD_CFG6, LAN743X_INT_MOD);
  lan743x_csr_write(adapter, INT_MOD_CFG7, LAN743X_INT_MOD);
  if (adapter->is_pci11x1x) {
   lan743x_csr_write(adapter, INT_MOD_CFG8, LAN743X_INT_MOD);
   lan743x_csr_write(adapter, INT_MOD_CFG9, LAN743X_INT_MOD);
   lan743x_csr_write(adapter, INT_MOD_MAP0, 0x00007654);
   lan743x_csr_write(adapter, INT_MOD_MAP1, 0x00003210);
  } else {
   lan743x_csr_write(adapter, INT_MOD_MAP0, 0x00005432);
   lan743x_csr_write(adapter, INT_MOD_MAP1, 0x00000001);
  }
  lan743x_csr_write(adapter, INT_MOD_MAP2, 0x00FFFFFF);
 }

 /* enable interrupts */
 lan743x_csr_write(adapter, INT_EN_SET, INT_BIT_MAS_);
 ret = lan743x_intr_test_isr(adapter);
 if (ret)
  goto clean_up;

 if (intr->number_of_vectors > 1) {
  int number_of_tx_vectors = intr->number_of_vectors - 1;

  if (number_of_tx_vectors > used_tx_channels)
   number_of_tx_vectors = used_tx_channels;
  flags = LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ |
   LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C |
   LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK |
   LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR |
   LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR |
   LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET;

  if (adapter->csr.flags &
     LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR) {
   flags = LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET |
    LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET |
    LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR |
    LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR;
  }

  for (index = 0; index < number_of_tx_vectors; index++) {
   u32 int_bit = INT_BIT_DMA_TX_(index);
   int vector = index + 1;

   /* map TX interrupt to vector */
   int_vec_map1 |= INT_VEC_MAP1_TX_VEC_(index, vector);
   lan743x_csr_write(adapter, INT_VEC_MAP1, int_vec_map1);

   /* Remove TX interrupt from shared mask */
   intr->vector_list[0].int_mask &= ~int_bit;
   ret = lan743x_intr_register_isr(adapter, vector, flags,
       int_bit, lan743x_tx_isr,
       &adapter->tx[index]);
   if (ret)
    goto clean_up;
   intr->flags |= INTR_FLAG_IRQ_REQUESTED(vector);
   if (!(flags &
       LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET))
    lan743x_csr_write(adapter, INT_VEC_EN_SET,
        INT_VEC_EN_(vector));
  }
 }
 if ((intr->number_of_vectors - used_tx_channels) > 1) {
  int number_of_rx_vectors = intr->number_of_vectors -
      used_tx_channels - 1;

  if (number_of_rx_vectors > LAN743X_USED_RX_CHANNELS)
   number_of_rx_vectors = LAN743X_USED_RX_CHANNELS;

  flags = LAN743X_VECTOR_FLAG_SOURCE_STATUS_READ |
   LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C |
   LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CHECK |
   LAN743X_VECTOR_FLAG_SOURCE_ENABLE_CLEAR |
   LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_CLEAR |
   LAN743X_VECTOR_FLAG_VECTOR_ENABLE_ISR_SET;

  if (adapter->csr.flags &
      LAN743X_CSR_FLAG_SUPPORTS_INTR_AUTO_SET_CLR) {
   flags = LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_CLEAR |
    LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET |
    LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET |
    LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR |
    LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR;
  }
  for (index = 0; index < number_of_rx_vectors; index++) {
   int vector = index + 1 + used_tx_channels;
   u32 int_bit = INT_BIT_DMA_RX_(index);

   /* map RX interrupt to vector */
   int_vec_map0 |= INT_VEC_MAP0_RX_VEC_(index, vector);
   lan743x_csr_write(adapter, INT_VEC_MAP0, int_vec_map0);
   if (flags &
       LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_CLEAR) {
    int_vec_en_auto_clr |= INT_VEC_EN_(vector);
    lan743x_csr_write(adapter, INT_VEC_EN_AUTO_CLR,
        int_vec_en_auto_clr);
   }

   /* Remove RX interrupt from shared mask */
   intr->vector_list[0].int_mask &= ~int_bit;
   ret = lan743x_intr_register_isr(adapter, vector, flags,
       int_bit, lan743x_rx_isr,
       &adapter->rx[index]);
   if (ret)
    goto clean_up;
   intr->flags |= INTR_FLAG_IRQ_REQUESTED(vector);

   lan743x_csr_write(adapter, INT_VEC_EN_SET,
       INT_VEC_EN_(vector));
  }
 }
 return 0;

clean_up:
 lan743x_intr_close(adapter);
 return ret;
}

static int lan743x_dp_write(struct lan743x_adapter *adapter,
       u32 select, u32 addr, u32 length, u32 *buf)
{
 u32 dp_sel;
 int i;

 if (lan743x_csr_wait_for_bit_atomic(adapter, DP_SEL, DP_SEL_DPRDY_,
         1, 40, 100, 100))
  return -EIO;
 dp_sel = lan743x_csr_read(adapter, DP_SEL);
 dp_sel &= ~DP_SEL_MASK_;
 dp_sel |= select;
 lan743x_csr_write(adapter, DP_SEL, dp_sel);

 for (i = 0; i < length; i++) {
  lan743x_csr_write(adapter, DP_ADDR, addr + i);
  lan743x_csr_write(adapter, DP_DATA_0, buf[i]);
  lan743x_csr_write(adapter, DP_CMD, DP_CMD_WRITE_);
  if (lan743x_csr_wait_for_bit_atomic(adapter, DP_SEL,
          DP_SEL_DPRDY_,
          1, 40, 100, 100))
   return -EIO;
 }

 return 0;
}

static u32 lan743x_mac_mii_access(u16 id, u16 index, int read)
{
 u32 ret;

 ret = (id << MAC_MII_ACC_PHY_ADDR_SHIFT_) &
  MAC_MII_ACC_PHY_ADDR_MASK_;
 ret |= (index << MAC_MII_ACC_MIIRINDA_SHIFT_) &
  MAC_MII_ACC_MIIRINDA_MASK_;

 if (read)
  ret |= MAC_MII_ACC_MII_READ_;
 else
  ret |= MAC_MII_ACC_MII_WRITE_;
 ret |= MAC_MII_ACC_MII_BUSY_;

 return ret;
}

static int lan743x_mac_mii_wait_till_not_busy(struct lan743x_adapter *adapter)
{
 u32 data;

 return readx_poll_timeout(LAN743X_CSR_READ_OP, MAC_MII_ACC, data,
      !(data & MAC_MII_ACC_MII_BUSY_), 0, 1000000);
}

static int lan743x_mdiobus_read_c22(struct mii_bus *bus, int phy_id, int index)
{
 struct lan743x_adapter *adapter = bus->priv;
 u32 val, mii_access;
 int ret;

 /* confirm MII not busy */
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 if (ret < 0)
  return ret;

 /* set the address, index & direction (read from PHY) */
 mii_access = lan743x_mac_mii_access(phy_id, index, MAC_MII_READ);
 lan743x_csr_write(adapter, MAC_MII_ACC, mii_access);
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 if (ret < 0)
  return ret;

 val = lan743x_csr_read(adapter, MAC_MII_DATA);
 return (int)(val & 0xFFFF);
}

static int lan743x_mdiobus_write_c22(struct mii_bus *bus,
         int phy_id, int index, u16 regval)
{
 struct lan743x_adapter *adapter = bus->priv;
 u32 val, mii_access;
 int ret;

 /* confirm MII not busy */
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 if (ret < 0)
  return ret;
 val = (u32)regval;
 lan743x_csr_write(adapter, MAC_MII_DATA, val);

 /* set the address, index & direction (write to PHY) */
 mii_access = lan743x_mac_mii_access(phy_id, index, MAC_MII_WRITE);
 lan743x_csr_write(adapter, MAC_MII_ACC, mii_access);
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 return ret;
}

static u32 lan743x_mac_mmd_access(int id, int dev_addr, int op)
{
 u32 ret;

 ret = (id << MAC_MII_ACC_PHY_ADDR_SHIFT_) &
  MAC_MII_ACC_PHY_ADDR_MASK_;
 ret |= (dev_addr << MAC_MII_ACC_MIIMMD_SHIFT_) &
  MAC_MII_ACC_MIIMMD_MASK_;
 if (op == MMD_ACCESS_WRITE)
  ret |= MAC_MII_ACC_MIICMD_WRITE_;
 else if (op == MMD_ACCESS_READ)
  ret |= MAC_MII_ACC_MIICMD_READ_;
 else if (op == MMD_ACCESS_READ_INC)
  ret |= MAC_MII_ACC_MIICMD_READ_INC_;
 else
  ret |= MAC_MII_ACC_MIICMD_ADDR_;
 ret |= (MAC_MII_ACC_MII_BUSY_ | MAC_MII_ACC_MIICL45_);

 return ret;
}

static int lan743x_mdiobus_read_c45(struct mii_bus *bus, int phy_id,
        int dev_addr, int index)
{
 struct lan743x_adapter *adapter = bus->priv;
 u32 mmd_access;
 int ret;

 /* confirm MII not busy */
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 if (ret < 0)
  return ret;

 /* Load Register Address */
 lan743x_csr_write(adapter, MAC_MII_DATA, index);
 mmd_access = lan743x_mac_mmd_access(phy_id, dev_addr,
         MMD_ACCESS_ADDRESS);
 lan743x_csr_write(adapter, MAC_MII_ACC, mmd_access);
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 if (ret < 0)
  return ret;

 /* Read Data */
 mmd_access = lan743x_mac_mmd_access(phy_id, dev_addr,
         MMD_ACCESS_READ);
 lan743x_csr_write(adapter, MAC_MII_ACC, mmd_access);
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 if (ret < 0)
  return ret;

 ret = lan743x_csr_read(adapter, MAC_MII_DATA);
 return (int)(ret & 0xFFFF);
}

static int lan743x_mdiobus_write_c45(struct mii_bus *bus, int phy_id,
         int dev_addr, int index, u16 regval)
{
 struct lan743x_adapter *adapter = bus->priv;
 u32 mmd_access;
 int ret;

 /* confirm MII not busy */
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 if (ret < 0)
  return ret;

 /* Load Register Address */
 lan743x_csr_write(adapter, MAC_MII_DATA, (u32)index);
 mmd_access = lan743x_mac_mmd_access(phy_id, dev_addr,
         MMD_ACCESS_ADDRESS);
 lan743x_csr_write(adapter, MAC_MII_ACC, mmd_access);
 ret = lan743x_mac_mii_wait_till_not_busy(adapter);
 if (ret < 0)
  return ret;

 /* Write Data */
 lan743x_csr_write(adapter, MAC_MII_DATA, (u32)regval);
 mmd_access = lan743x_mac_mmd_access(phy_id, dev_addr,
         MMD_ACCESS_WRITE);
 lan743x_csr_write(adapter, MAC_MII_ACC, mmd_access);

 return lan743x_mac_mii_wait_till_not_busy(adapter);
}

static int lan743x_sgmii_wait_till_not_busy(struct lan743x_adapter *adapter)
{
 u32 data;
 int ret;

 ret = readx_poll_timeout(LAN743X_CSR_READ_OP, SGMII_ACC, data,
     !(data & SGMII_ACC_SGMII_BZY_), 100, 1000000);
 if (ret < 0)
  netif_err(adapter, drv, adapter->netdev,
     "%s: error %d sgmii wait timeout\n", __func__, ret);

 return ret;
}

int lan743x_sgmii_read(struct lan743x_adapter *adapter, u8 mmd, u16 addr)
{
 u32 mmd_access;
 int ret;
 u32 val;

 if (mmd > 31) {
  netif_err(adapter, probe, adapter->netdev,
     "%s mmd should <= 31\n", __func__);
  return -EINVAL;
 }

 mutex_lock(&adapter->sgmii_rw_lock);
 /* Load Register Address */
 mmd_access = mmd << SGMII_ACC_SGMII_MMD_SHIFT_;
 mmd_access |= (addr | SGMII_ACC_SGMII_BZY_);
 lan743x_csr_write(adapter, SGMII_ACC, mmd_access);
 ret = lan743x_sgmii_wait_till_not_busy(adapter);
 if (ret < 0)
  goto sgmii_unlock;

 val = lan743x_csr_read(adapter, SGMII_DATA);
 ret = (int)(val & SGMII_DATA_MASK_);

sgmii_unlock:
 mutex_unlock(&adapter->sgmii_rw_lock);

 return ret;
}

static int lan743x_sgmii_write(struct lan743x_adapter *adapter,
          u8 mmd, u16 addr, u16 val)
{
 u32 mmd_access;
 int ret;

 if (mmd > 31) {
  netif_err(adapter, probe, adapter->netdev,
     "%s mmd should <= 31\n", __func__);
  return -EINVAL;
 }
 mutex_lock(&adapter->sgmii_rw_lock);
 /* Load Register Data */
 lan743x_csr_write(adapter, SGMII_DATA, (u32)(val & SGMII_DATA_MASK_));
 /* Load Register Address */
 mmd_access = mmd << SGMII_ACC_SGMII_MMD_SHIFT_;
 mmd_access |= (addr | SGMII_ACC_SGMII_BZY_ | SGMII_ACC_SGMII_WR_);
 lan743x_csr_write(adapter, SGMII_ACC, mmd_access);
 ret = lan743x_sgmii_wait_till_not_busy(adapter);
 mutex_unlock(&adapter->sgmii_rw_lock);

 return ret;
}

static int lan743x_get_lsd(int speed, int duplex, u8 mss)
{
 int lsd;

 switch (speed) {
 case SPEED_2500:
  if (mss == MASTER_SLAVE_STATE_SLAVE)
   lsd = LINK_2500_SLAVE;
  else
   lsd = LINK_2500_MASTER;
  break;
 case SPEED_1000:
  if (mss == MASTER_SLAVE_STATE_SLAVE)
   lsd = LINK_1000_SLAVE;
  else
   lsd = LINK_1000_MASTER;
  break;
 case SPEED_100:
  if (duplex == DUPLEX_FULL)
   lsd = LINK_100FD;
  else
   lsd = LINK_100HD;
  break;
 case SPEED_10:
  if (duplex == DUPLEX_FULL)
   lsd = LINK_10FD;
  else
   lsd = LINK_10HD;
  break;
 default:
  lsd = -EINVAL;
 }

 return lsd;
}

static int lan743x_sgmii_mpll_set(struct lan743x_adapter *adapter,
      u16 baud)
{
 int mpllctrl0;
 int mpllctrl1;
 int miscctrl1;
 int ret;

 mpllctrl0 = lan743x_sgmii_read(adapter, MDIO_MMD_VEND2,
           VR_MII_GEN2_4_MPLL_CTRL0);
 if (mpllctrl0 < 0)
  return mpllctrl0;

 mpllctrl0 &= ~VR_MII_MPLL_CTRL0_USE_REFCLK_PAD_;
 if (baud == VR_MII_BAUD_RATE_1P25GBPS) {
  mpllctrl1 = VR_MII_MPLL_MULTIPLIER_100;
  /* mpll_baud_clk/4 */
  miscctrl1 = 0xA;
 } else {
  mpllctrl1 = VR_MII_MPLL_MULTIPLIER_125;
  /* mpll_baud_clk/2 */
  miscctrl1 = 0x5;
 }

 ret = lan743x_sgmii_write(adapter, MDIO_MMD_VEND2,
      VR_MII_GEN2_4_MPLL_CTRL0, mpllctrl0);
 if (ret < 0)
  return ret;

 ret = lan743x_sgmii_write(adapter, MDIO_MMD_VEND2,
      VR_MII_GEN2_4_MPLL_CTRL1, mpllctrl1);
 if (ret < 0)
  return ret;

 return lan743x_sgmii_write(adapter, MDIO_MMD_VEND2,
      VR_MII_GEN2_4_MISC_CTRL1, miscctrl1);
}

static int lan743x_sgmii_2_5G_mode_set(struct lan743x_adapter *adapter,
           bool enable)
{
 if (enable)
  return lan743x_sgmii_mpll_set(adapter,
           VR_MII_BAUD_RATE_3P125GBPS);
 else
  return lan743x_sgmii_mpll_set(adapter,
           VR_MII_BAUD_RATE_1P25GBPS);
}

static int lan743x_serdes_clock_and_aneg_update(struct lan743x_adapter *adapter)
{
 enum lan743x_sgmii_lsd lsd = adapter->sgmii_lsd;
 int mii_ctrl;
 int dgt_ctrl;
 int an_ctrl;
 int ret;

 if (lsd == LINK_2500_MASTER || lsd == LINK_2500_SLAVE)
  /* Switch to 2.5 Gbps */
  ret = lan743x_sgmii_2_5G_mode_set(adapter, true);
 else
  /* Switch to 10/100/1000 Mbps clock */
  ret = lan743x_sgmii_2_5G_mode_set(adapter, false);
 if (ret < 0)
  return ret;

 /* Enable SGMII Auto NEG */
 mii_ctrl = lan743x_sgmii_read(adapter, MDIO_MMD_VEND2, MII_BMCR);
 if (mii_ctrl < 0)
  return mii_ctrl;

 an_ctrl = lan743x_sgmii_read(adapter, MDIO_MMD_VEND2, VR_MII_AN_CTRL);
 if (an_ctrl < 0)
  return an_ctrl;

 dgt_ctrl = lan743x_sgmii_read(adapter, MDIO_MMD_VEND2,
          VR_MII_DIG_CTRL1);
 if (dgt_ctrl < 0)
  return dgt_ctrl;

 if (lsd == LINK_2500_MASTER || lsd == LINK_2500_SLAVE) {
  mii_ctrl &= ~(BMCR_ANENABLE | BMCR_ANRESTART | BMCR_SPEED100);
  mii_ctrl |= BMCR_SPEED1000;
  dgt_ctrl |= VR_MII_DIG_CTRL1_CL37_TMR_OVR_RIDE_;
  dgt_ctrl &= ~VR_MII_DIG_CTRL1_MAC_AUTO_SW_;
  /* In order for Auto-Negotiation to operate properly at
 * 2.5 Gbps the 1.6ms link timer values must be adjusted
 * The VR_MII_LINK_TIMER_CTRL Register must be set to
 * 16'h7A1 and The CL37_TMR_OVR_RIDE bit of the
 * VR_MII_DIG_CTRL1 Register set to 1
 */
  ret = lan743x_sgmii_write(adapter, MDIO_MMD_VEND2,
       VR_MII_LINK_TIMER_CTRL, 0x7A1);
  if (ret < 0)
   return ret;
 } else {
  mii_ctrl |= (BMCR_ANENABLE | BMCR_ANRESTART);
  an_ctrl &= ~VR_MII_AN_CTRL_SGMII_LINK_STS_;
  dgt_ctrl &= ~VR_MII_DIG_CTRL1_CL37_TMR_OVR_RIDE_;
  dgt_ctrl |= VR_MII_DIG_CTRL1_MAC_AUTO_SW_;
 }

 ret = lan743x_sgmii_write(adapter, MDIO_MMD_VEND2, MII_BMCR,
      mii_ctrl);
 if (ret < 0)
  return ret;

 ret = lan743x_sgmii_write(adapter, MDIO_MMD_VEND2,
      VR_MII_DIG_CTRL1, dgt_ctrl);
 if (ret < 0)
  return ret;

 return lan743x_sgmii_write(adapter, MDIO_MMD_VEND2,
      VR_MII_AN_CTRL, an_ctrl);
}

static int lan743x_pcs_seq_state(struct lan743x_adapter *adapter, u8 state)
{
 u8 wait_cnt = 0;
 u32 dig_sts;

 do {
  dig_sts = lan743x_sgmii_read(adapter, MDIO_MMD_VEND2,
          VR_MII_DIG_STS);
  if (((dig_sts & VR_MII_DIG_STS_PSEQ_STATE_MASK_) >>
        VR_MII_DIG_STS_PSEQ_STATE_POS_) == state)
   break;
  usleep_range(1000, 2000);
 } while (wait_cnt++ < 10);

 if (wait_cnt >= 10)
  return -ETIMEDOUT;

 return 0;
}

static int lan743x_pcs_power_reset(struct lan743x_adapter *adapter)
{
 int mii_ctl;
 int ret;

 /* SGMII/1000/2500BASE-X PCS power down */
 mii_ctl = lan743x_sgmii_read(adapter, MDIO_MMD_VEND2, MII_BMCR);
 if (mii_ctl < 0)
  return mii_ctl;

 mii_ctl |= BMCR_PDOWN;
 ret = lan743x_sgmii_write(adapter, MDIO_MMD_VEND2, MII_BMCR, mii_ctl);
 if (ret < 0)
  return ret;

 ret = lan743x_pcs_seq_state(adapter, PCS_POWER_STATE_DOWN);
 if (ret < 0)
  return ret;

 /* SGMII/1000/2500BASE-X PCS power up */
 mii_ctl &= ~BMCR_PDOWN;
 ret = lan743x_sgmii_write(adapter, MDIO_MMD_VEND2, MII_BMCR, mii_ctl);
 if (ret < 0)
  return ret;

 return lan743x_pcs_seq_state(adapter, PCS_POWER_STATE_UP);
}

static void lan743x_mac_set_address(struct lan743x_adapter *adapter,
        u8 *addr)
{
 u32 addr_lo, addr_hi;

 addr_lo = addr[0] |
  addr[1] << 8 |
  addr[2] << 16 |
  addr[3] << 24;
 addr_hi = addr[4] |
  addr[5] << 8;
 lan743x_csr_write(adapter, MAC_RX_ADDRL, addr_lo);
 lan743x_csr_write(adapter, MAC_RX_ADDRH, addr_hi);

 ether_addr_copy(adapter->mac_address, addr);
 netif_info(adapter, drv, adapter->netdev,
     "MAC address set to %pM\n", addr);
}

static int lan743x_mac_init(struct lan743x_adapter *adapter)
{
 bool mac_address_valid = true;
 struct net_device *netdev;
 u32 mac_addr_hi = 0;
 u32 mac_addr_lo = 0;
 u32 data;

 netdev = adapter->netdev;

 /* disable auto duplex, and speed detection. Phylib does that */
 data = lan743x_csr_read(adapter, MAC_CR);
 data &= ~(MAC_CR_ADD_ | MAC_CR_ASD_);
 data |= MAC_CR_CNTR_RST_;
 lan743x_csr_write(adapter, MAC_CR, data);

 if (!is_valid_ether_addr(adapter->mac_address)) {
  mac_addr_hi = lan743x_csr_read(adapter, MAC_RX_ADDRH);
  mac_addr_lo = lan743x_csr_read(adapter, MAC_RX_ADDRL);
  adapter->mac_address[0] = mac_addr_lo & 0xFF;
  adapter->mac_address[1] = (mac_addr_lo >> 8) & 0xFF;
  adapter->mac_address[2] = (mac_addr_lo >> 16) & 0xFF;
  adapter->mac_address[3] = (mac_addr_lo >> 24) & 0xFF;
  adapter->mac_address[4] = mac_addr_hi & 0xFF;
  adapter->mac_address[5] = (mac_addr_hi >> 8) & 0xFF;

  if (((mac_addr_hi & 0x0000FFFF) == 0x0000FFFF) &&
      mac_addr_lo == 0xFFFFFFFF) {
   mac_address_valid = false;
  } else if (!is_valid_ether_addr(adapter->mac_address)) {
   mac_address_valid = false;
  }

  if (!mac_address_valid)
   eth_random_addr(adapter->mac_address);
 }
 lan743x_mac_set_address(adapter, adapter->mac_address);
 eth_hw_addr_set(netdev, adapter->mac_address);

 return 0;
}

static int lan743x_mac_open(struct lan743x_adapter *adapter)
{
 u32 temp;

 temp = lan743x_csr_read(adapter, MAC_RX);
 lan743x_csr_write(adapter, MAC_RX, temp | MAC_RX_RXEN_);
 temp = lan743x_csr_read(adapter, MAC_TX);
 lan743x_csr_write(adapter, MAC_TX, temp | MAC_TX_TXEN_);
 return 0;
}

static void lan743x_mac_close(struct lan743x_adapter *adapter)
{
 u32 temp;

 temp = lan743x_csr_read(adapter, MAC_TX);
 temp &= ~MAC_TX_TXEN_;
 lan743x_csr_write(adapter, MAC_TX, temp);
 lan743x_csr_wait_for_bit(adapter, MAC_TX, MAC_TX_TXD_,
     1, 1000, 20000, 100);

 temp = lan743x_csr_read(adapter, MAC_RX);
 temp &= ~MAC_RX_RXEN_;
 lan743x_csr_write(adapter, MAC_RX, temp);
 lan743x_csr_wait_for_bit(adapter, MAC_RX, MAC_RX_RXD_,
     1, 1000, 20000, 100);
}

void lan743x_mac_flow_ctrl_set_enables(struct lan743x_adapter *adapter,
           bool tx_enable, bool rx_enable)
{
 u32 flow_setting = 0;

 /* set maximum pause time because when fifo space frees
 * up a zero value pause frame will be sent to release the pause
 */
 flow_setting = MAC_FLOW_CR_FCPT_MASK_;
 if (tx_enable)
  flow_setting |= MAC_FLOW_CR_TX_FCEN_;
 if (rx_enable)
  flow_setting |= MAC_FLOW_CR_RX_FCEN_;
 lan743x_csr_write(adapter, MAC_FLOW, flow_setting);
}

static int lan743x_mac_set_mtu(struct lan743x_adapter *adapter, int new_mtu)
{
 int enabled = 0;
 u32 mac_rx = 0;

 mac_rx = lan743x_csr_read(adapter, MAC_RX);
 if (mac_rx & MAC_RX_RXEN_) {
  enabled = 1;
  if (mac_rx & MAC_RX_RXD_) {
   lan743x_csr_write(adapter, MAC_RX, mac_rx);
   mac_rx &= ~MAC_RX_RXD_;
  }
  mac_rx &= ~MAC_RX_RXEN_;
  lan743x_csr_write(adapter, MAC_RX, mac_rx);
  lan743x_csr_wait_for_bit(adapter, MAC_RX, MAC_RX_RXD_,
      1, 1000, 20000, 100);
  lan743x_csr_write(adapter, MAC_RX, mac_rx | MAC_RX_RXD_);
 }

 mac_rx &= ~(MAC_RX_MAX_SIZE_MASK_);
 mac_rx |= (((new_mtu + ETH_HLEN + ETH_FCS_LEN)
    << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_);
 lan743x_csr_write(adapter, MAC_RX, mac_rx);

 if (enabled) {
  mac_rx |= MAC_RX_RXEN_;
  lan743x_csr_write(adapter, MAC_RX, mac_rx);
 }
 return 0;
}

/* PHY */
static int lan743x_hw_reset_phy(struct lan743x_adapter *adapter)
{
 u32 data;

 /* Only called with in probe, and before mdiobus_register */

 data = lan743x_csr_read(adapter, PMT_CTL);
 data |= PMT_CTL_ETH_PHY_RST_;
 lan743x_csr_write(adapter, PMT_CTL, data);

 return readx_poll_timeout(LAN743X_CSR_READ_OP, PMT_CTL, data,
      (!(data & PMT_CTL_ETH_PHY_RST_) &&
      (data & PMT_CTL_READY_)),
      50000, 1000000);
}

static void lan743x_phy_interface_select(struct lan743x_adapter *adapter)
{
 u32 id_rev;
 u32 data;

 data = lan743x_csr_read(adapter, MAC_CR);
 id_rev = adapter->csr.id_rev & ID_REV_ID_MASK_;

 if (adapter->is_pci11x1x && adapter->is_sgmii_en)
  adapter->phy_interface = PHY_INTERFACE_MODE_SGMII;
 else if (id_rev == ID_REV_ID_LAN7430_)
  adapter->phy_interface = PHY_INTERFACE_MODE_GMII;
 else if ((id_rev == ID_REV_ID_LAN7431_) && (data & MAC_CR_MII_EN_))
  adapter->phy_interface = PHY_INTERFACE_MODE_MII;
 else
  adapter->phy_interface = PHY_INTERFACE_MODE_RGMII;

 netif_dbg(adapter, drv, adapter->netdev,
    "selected phy interface: 0x%X\n", adapter->phy_interface);
}

static void lan743x_rfe_open(struct lan743x_adapter *adapter)
{
 lan743x_csr_write(adapter, RFE_RSS_CFG,
  RFE_RSS_CFG_UDP_IPV6_EX_ |
  RFE_RSS_CFG_TCP_IPV6_EX_ |
  RFE_RSS_CFG_IPV6_EX_ |
  RFE_RSS_CFG_UDP_IPV6_ |
  RFE_RSS_CFG_TCP_IPV6_ |
  RFE_RSS_CFG_IPV6_ |
  RFE_RSS_CFG_UDP_IPV4_ |
  RFE_RSS_CFG_TCP_IPV4_ |
  RFE_RSS_CFG_IPV4_ |
  RFE_RSS_CFG_VALID_HASH_BITS_ |
  RFE_RSS_CFG_RSS_QUEUE_ENABLE_ |
  RFE_RSS_CFG_RSS_HASH_STORE_ |
  RFE_RSS_CFG_RSS_ENABLE_);
}

static void lan743x_rfe_update_mac_address(struct lan743x_adapter *adapter)
{
 u8 *mac_addr;
 u32 mac_addr_hi = 0;
 u32 mac_addr_lo = 0;

 /* Add mac address to perfect Filter */
 mac_addr = adapter->mac_address;
 mac_addr_lo = ((((u32)(mac_addr[0])) << 0) |
        (((u32)(mac_addr[1])) << 8) |
        (((u32)(mac_addr[2])) << 16) |
        (((u32)(mac_addr[3])) << 24));
 mac_addr_hi = ((((u32)(mac_addr[4])) << 0) |
        (((u32)(mac_addr[5])) << 8));

 lan743x_csr_write(adapter, RFE_ADDR_FILT_LO(0), mac_addr_lo);
 lan743x_csr_write(adapter, RFE_ADDR_FILT_HI(0),
     mac_addr_hi | RFE_ADDR_FILT_HI_VALID_);
}

static void lan743x_rfe_set_multicast(struct lan743x_adapter *adapter)
{
 struct net_device *netdev = adapter->netdev;
 u32 hash_table[DP_SEL_VHF_HASH_LEN];
 u32 rfctl;
 u32 data;

 rfctl = lan743x_csr_read(adapter, RFE_CTL);
 rfctl &= ~(RFE_CTL_AU_ | RFE_CTL_AM_ |
   RFE_CTL_DA_PERFECT_ | RFE_CTL_MCAST_HASH_);
 rfctl |= RFE_CTL_AB_;
 if (netdev->flags & IFF_PROMISC) {
  rfctl |= RFE_CTL_AM_ | RFE_CTL_AU_;
 } else {
  if (netdev->flags & IFF_ALLMULTI)
   rfctl |= RFE_CTL_AM_;
 }

 if (netdev->features & NETIF_F_RXCSUM)
  rfctl |= RFE_CTL_IP_COE_ | RFE_CTL_TCP_UDP_COE_;

 memset(hash_table, 0, DP_SEL_VHF_HASH_LEN * sizeof(u32));
 if (netdev_mc_count(netdev)) {
  struct netdev_hw_addr *ha;
  int i;

  rfctl |= RFE_CTL_DA_PERFECT_;
  i = 1;
  netdev_for_each_mc_addr(ha, netdev) {
   /* set first 32 into Perfect Filter */
   if (i < 33) {
    lan743x_csr_write(adapter,
        RFE_ADDR_FILT_HI(i), 0);
    data = ha->addr[3];
    data = ha->addr[2] | (data << 8);
    data = ha->addr[1] | (data << 8);
    data = ha->addr[0] | (data << 8);
    lan743x_csr_write(adapter,
        RFE_ADDR_FILT_LO(i), data);
    data = ha->addr[5];
    data = ha->addr[4] | (data << 8);
    data |= RFE_ADDR_FILT_HI_VALID_;
    lan743x_csr_write(adapter,
        RFE_ADDR_FILT_HI(i), data);
   } else {
    u32 bitnum = (ether_crc(ETH_ALEN, ha->addr) >>
          23) & 0x1FF;
    hash_table[bitnum / 32] |= (1 << (bitnum % 32));
    rfctl |= RFE_CTL_MCAST_HASH_;
   }
   i++;
  }
 }

 lan743x_dp_write(adapter, DP_SEL_RFE_RAM,
    DP_SEL_VHF_VLAN_LEN,
    DP_SEL_VHF_HASH_LEN, hash_table);
 lan743x_csr_write(adapter, RFE_CTL, rfctl);
}

static int lan743x_dmac_init(struct lan743x_adapter *adapter)
{
 u32 data = 0;

 lan743x_csr_write(adapter, DMAC_CMD, DMAC_CMD_SWR_);
 lan743x_csr_wait_for_bit(adapter, DMAC_CMD, DMAC_CMD_SWR_,
     0, 1000, 20000, 100);
 switch (DEFAULT_DMA_DESCRIPTOR_SPACING) {
 case DMA_DESCRIPTOR_SPACING_16:
  data = DMAC_CFG_MAX_DSPACE_16_;
  break;
 case DMA_DESCRIPTOR_SPACING_32:
  data = DMAC_CFG_MAX_DSPACE_32_;
  break;
 case DMA_DESCRIPTOR_SPACING_64:
  data = DMAC_CFG_MAX_DSPACE_64_;
  break;
 case DMA_DESCRIPTOR_SPACING_128:
  data = DMAC_CFG_MAX_DSPACE_128_;
  break;
 default:
  return -EPERM;
 }
 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0))
  data |= DMAC_CFG_COAL_EN_;
 data |= DMAC_CFG_CH_ARB_SEL_RX_HIGH_;
 data |= DMAC_CFG_MAX_READ_REQ_SET_(6);
 lan743x_csr_write(adapter, DMAC_CFG, data);
 data = DMAC_COAL_CFG_TIMER_LIMIT_SET_(1);
 data |= DMAC_COAL_CFG_TIMER_TX_START_;
 data |= DMAC_COAL_CFG_FLUSH_INTS_;
 data |= DMAC_COAL_CFG_INT_EXIT_COAL_;
 data |= DMAC_COAL_CFG_CSR_EXIT_COAL_;
 data |= DMAC_COAL_CFG_TX_THRES_SET_(0x0A);
 data |= DMAC_COAL_CFG_RX_THRES_SET_(0x0C);
 lan743x_csr_write(adapter, DMAC_COAL_CFG, data);
 data = DMAC_OBFF_TX_THRES_SET_(0x08);
 data |= DMAC_OBFF_RX_THRES_SET_(0x0A);
 lan743x_csr_write(adapter, DMAC_OBFF_CFG, data);
 return 0;
}

static int lan743x_dmac_tx_get_state(struct lan743x_adapter *adapter,
         int tx_channel)
{
 u32 dmac_cmd = 0;

 dmac_cmd = lan743x_csr_read(adapter, DMAC_CMD);
 return DMAC_CHANNEL_STATE_SET((dmac_cmd &
          DMAC_CMD_START_T_(tx_channel)),
          (dmac_cmd &
          DMAC_CMD_STOP_T_(tx_channel)));
}

static int lan743x_dmac_tx_wait_till_stopped(struct lan743x_adapter *adapter,
          int tx_channel)
{
 int timeout = 100;
 int result = 0;

 while (timeout &&
        ((result = lan743x_dmac_tx_get_state(adapter, tx_channel)) ==
        DMAC_CHANNEL_STATE_STOP_PENDING)) {
  usleep_range(1000, 20000);
  timeout--;
 }
 if (result == DMAC_CHANNEL_STATE_STOP_PENDING)
  result = -ENODEV;
 return result;
}

static int lan743x_dmac_rx_get_state(struct lan743x_adapter *adapter,
         int rx_channel)
{
 u32 dmac_cmd = 0;

 dmac_cmd = lan743x_csr_read(adapter, DMAC_CMD);
 return DMAC_CHANNEL_STATE_SET((dmac_cmd &
          DMAC_CMD_START_R_(rx_channel)),
          (dmac_cmd &
          DMAC_CMD_STOP_R_(rx_channel)));
}

static int lan743x_dmac_rx_wait_till_stopped(struct lan743x_adapter *adapter,
          int rx_channel)
{
 int timeout = 100;
 int result = 0;

 while (timeout &&
        ((result = lan743x_dmac_rx_get_state(adapter, rx_channel)) ==
        DMAC_CHANNEL_STATE_STOP_PENDING)) {
  usleep_range(1000, 20000);
  timeout--;
 }
 if (result == DMAC_CHANNEL_STATE_STOP_PENDING)
  result = -ENODEV;
 return result;
}

static void lan743x_tx_release_desc(struct lan743x_tx *tx,
        int descriptor_index, bool cleanup)
{
 struct lan743x_tx_buffer_info *buffer_info = NULL;
 struct lan743x_tx_descriptor *descriptor = NULL;
 u32 descriptor_type = 0;
 bool ignore_sync;

 descriptor = &tx->ring_cpu_ptr[descriptor_index];
 buffer_info = &tx->buffer_info[descriptor_index];
 if (!(buffer_info->flags & TX_BUFFER_INFO_FLAG_ACTIVE))
  goto done;

 descriptor_type = le32_to_cpu(descriptor->data0) &
     TX_DESC_DATA0_DTYPE_MASK_;
 if (descriptor_type == TX_DESC_DATA0_DTYPE_DATA_)
  goto clean_up_data_descriptor;
 else
  goto clear_active;

clean_up_data_descriptor:
 if (buffer_info->dma_ptr) {
  if (buffer_info->flags &
      TX_BUFFER_INFO_FLAG_SKB_FRAGMENT) {
   dma_unmap_page(&tx->adapter->pdev->dev,
           buffer_info->dma_ptr,
           buffer_info->buffer_length,
           DMA_TO_DEVICE);
  } else {
   dma_unmap_single(&tx->adapter->pdev->dev,
      buffer_info->dma_ptr,
      buffer_info->buffer_length,
      DMA_TO_DEVICE);
  }
  buffer_info->dma_ptr = 0;
  buffer_info->buffer_length = 0;
 }
 if (!buffer_info->skb)
  goto clear_active;

 if (!(buffer_info->flags & TX_BUFFER_INFO_FLAG_TIMESTAMP_REQUESTED)) {
  dev_kfree_skb_any(buffer_info->skb);
  goto clear_skb;
 }

 if (cleanup) {
  lan743x_ptp_unrequest_tx_timestamp(tx->adapter);
  dev_kfree_skb_any(buffer_info->skb);
 } else {
  ignore_sync = (buffer_info->flags &
          TX_BUFFER_INFO_FLAG_IGNORE_SYNC) != 0;
  lan743x_ptp_tx_timestamp_skb(tx->adapter,
          buffer_info->skb, ignore_sync);
 }

clear_skb:
 buffer_info->skb = NULL;

clear_active:
 buffer_info->flags &= ~TX_BUFFER_INFO_FLAG_ACTIVE;

done:
 memset(buffer_info, 0, sizeof(*buffer_info));
 memset(descriptor, 0, sizeof(*descriptor));
}

static int lan743x_tx_next_index(struct lan743x_tx *tx, int index)
{
 return ((++index) % tx->ring_size);
}

static void lan743x_tx_release_completed_descriptors(struct lan743x_tx *tx)
{
 while (le32_to_cpu(*tx->head_cpu_ptr) != (tx->last_head)) {
  lan743x_tx_release_desc(tx, tx->last_head, false);
  tx->last_head = lan743x_tx_next_index(tx, tx->last_head);
 }
}

static void lan743x_tx_release_all_descriptors(struct lan743x_tx *tx)
{
 u32 original_head = 0;

 original_head = tx->last_head;
 do {
  lan743x_tx_release_desc(tx, tx->last_head, true);
  tx->last_head = lan743x_tx_next_index(tx, tx->last_head);
 } while (tx->last_head != original_head);
 memset(tx->ring_cpu_ptr, 0,
        sizeof(*tx->ring_cpu_ptr) * (tx->ring_size));
 memset(tx->buffer_info, 0,
        sizeof(*tx->buffer_info) * (tx->ring_size));
}

static int lan743x_tx_get_desc_cnt(struct lan743x_tx *tx,
       struct sk_buff *skb)
{
 int result = 1; /* 1 for the main skb buffer */
 int nr_frags = 0;

 if (skb_is_gso(skb))
  result++; /* requires an extension descriptor */
 nr_frags = skb_shinfo(skb)->nr_frags;
 result += nr_frags; /* 1 for each fragment buffer */
 return result;
}

static int lan743x_tx_get_avail_desc(struct lan743x_tx *tx)
{
 int last_head = tx->last_head;
 int last_tail = tx->last_tail;

 if (last_tail >= last_head)
  return tx->ring_size - last_tail + last_head - 1;
 else
  return last_head - last_tail - 1;
}

static void lan743x_rx_cfg_b_tstamp_config(struct lan743x_adapter *adapter,
        int rx_ts_config)
{
 int channel_number;
 int index;
 u32 data;

 for (index = 0; index < LAN743X_USED_RX_CHANNELS; index++) {
  channel_number = adapter->rx[index].channel_number;
  data = lan743x_csr_read(adapter, RX_CFG_B(channel_number));
  data &= RX_CFG_B_TS_MASK_;
  data |= rx_ts_config;
  lan743x_csr_write(adapter, RX_CFG_B(channel_number),
      data);
 }
}

int lan743x_rx_set_tstamp_mode(struct lan743x_adapter *adapter,
          int rx_filter)
{
 u32 data;

 switch (rx_filter) {
 case HWTSTAMP_FILTER_PTP_V2_EVENT:
   lan743x_rx_cfg_b_tstamp_config(adapter,
             RX_CFG_B_TS_DESCR_EN_);
   data = lan743x_csr_read(adapter, PTP_RX_TS_CFG);
   data |= PTP_RX_TS_CFG_EVENT_MSGS_;
   lan743x_csr_write(adapter, PTP_RX_TS_CFG, data);
   break;
 case HWTSTAMP_FILTER_NONE:
   lan743x_rx_cfg_b_tstamp_config(adapter,
             RX_CFG_B_TS_NONE_);
   break;
 case HWTSTAMP_FILTER_ALL:
   lan743x_rx_cfg_b_tstamp_config(adapter,
             RX_CFG_B_TS_ALL_RX_);
   break;
 default:
   return -ERANGE;
 }
 adapter->rx_tstamp_filter = rx_filter;
 return 0;
}

void lan743x_tx_set_timestamping_mode(struct lan743x_tx *tx,
          bool enable_timestamping,
          bool enable_onestep_sync)
{
 if (enable_timestamping)
  tx->ts_flags |= TX_TS_FLAG_TIMESTAMPING_ENABLED;
 else
  tx->ts_flags &= ~TX_TS_FLAG_TIMESTAMPING_ENABLED;
 if (enable_onestep_sync)
  tx->ts_flags |= TX_TS_FLAG_ONE_STEP_SYNC;
 else
  tx->ts_flags &= ~TX_TS_FLAG_ONE_STEP_SYNC;
}

static int lan743x_tx_frame_start(struct lan743x_tx *tx,
      unsigned char *first_buffer,
      unsigned int first_buffer_length,
      unsigned int frame_length,
      bool time_stamp,
      bool check_sum)
{
 /* called only from within lan743x_tx_xmit_frame.
 * assuming tx->ring_lock has already been acquired.
 */
 struct lan743x_tx_descriptor *tx_descriptor = NULL;
 struct lan743x_tx_buffer_info *buffer_info = NULL;
 struct lan743x_adapter *adapter = tx->adapter;
 struct device *dev = &adapter->pdev->dev;
 dma_addr_t dma_ptr;

 tx->frame_flags |= TX_FRAME_FLAG_IN_PROGRESS;
 tx->frame_first = tx->last_tail;
 tx->frame_tail = tx->frame_first;

 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
 buffer_info = &tx->buffer_info[tx->frame_tail];
 dma_ptr = dma_map_single(dev, first_buffer, first_buffer_length,
     DMA_TO_DEVICE);
 if (dma_mapping_error(dev, dma_ptr))
  return -ENOMEM;

 tx_descriptor->data1 = cpu_to_le32(DMA_ADDR_LOW32(dma_ptr));
 tx_descriptor->data2 = cpu_to_le32(DMA_ADDR_HIGH32(dma_ptr));
 tx_descriptor->data3 = cpu_to_le32((frame_length << 16) &
  TX_DESC_DATA3_FRAME_LENGTH_MSS_MASK_);

 buffer_info->skb = NULL;
 buffer_info->dma_ptr = dma_ptr;
 buffer_info->buffer_length = first_buffer_length;
 buffer_info->flags |= TX_BUFFER_INFO_FLAG_ACTIVE;

 tx->frame_data0 = (first_buffer_length &
  TX_DESC_DATA0_BUF_LENGTH_MASK_) |
  TX_DESC_DATA0_DTYPE_DATA_ |
  TX_DESC_DATA0_FS_ |
  TX_DESC_DATA0_FCS_;
 if (time_stamp)
  tx->frame_data0 |= TX_DESC_DATA0_TSE_;

 if (check_sum)
  tx->frame_data0 |= TX_DESC_DATA0_ICE_ |
       TX_DESC_DATA0_IPE_ |
       TX_DESC_DATA0_TPE_;

 /* data0 will be programmed in one of other frame assembler functions */
 return 0;
}

static void lan743x_tx_frame_add_lso(struct lan743x_tx *tx,
         unsigned int frame_length,
         int nr_frags)
{
 /* called only from within lan743x_tx_xmit_frame.
 * assuming tx->ring_lock has already been acquired.
 */
 struct lan743x_tx_descriptor *tx_descriptor = NULL;
 struct lan743x_tx_buffer_info *buffer_info = NULL;

 /* wrap up previous descriptor */
 tx->frame_data0 |= TX_DESC_DATA0_EXT_;
 if (nr_frags <= 0) {
  tx->frame_data0 |= TX_DESC_DATA0_LS_;
  tx->frame_data0 |= TX_DESC_DATA0_IOC_;
  tx->frame_last = tx->frame_first;
 }
 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
 tx_descriptor->data0 = cpu_to_le32(tx->frame_data0);

 /* move to next descriptor */
 tx->frame_tail = lan743x_tx_next_index(tx, tx->frame_tail);
 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
 buffer_info = &tx->buffer_info[tx->frame_tail];

 /* add extension descriptor */
 tx_descriptor->data1 = 0;
 tx_descriptor->data2 = 0;
 tx_descriptor->data3 = 0;

 buffer_info->skb = NULL;
 buffer_info->dma_ptr = 0;
 buffer_info->buffer_length = 0;
 buffer_info->flags |= TX_BUFFER_INFO_FLAG_ACTIVE;

 tx->frame_data0 = (frame_length & TX_DESC_DATA0_EXT_PAY_LENGTH_MASK_) |
     TX_DESC_DATA0_DTYPE_EXT_ |
     TX_DESC_DATA0_EXT_LSO_;

 /* data0 will be programmed in one of other frame assembler functions */
}

static int lan743x_tx_frame_add_fragment(struct lan743x_tx *tx,
      const skb_frag_t *fragment,
      unsigned int frame_length)
{
 /* called only from within lan743x_tx_xmit_frame
 * assuming tx->ring_lock has already been acquired
 */
 struct lan743x_tx_descriptor *tx_descriptor = NULL;
 struct lan743x_tx_buffer_info *buffer_info = NULL;
 struct lan743x_adapter *adapter = tx->adapter;
 struct device *dev = &adapter->pdev->dev;
 unsigned int fragment_length = 0;
 dma_addr_t dma_ptr;

 fragment_length = skb_frag_size(fragment);
 if (!fragment_length)
  return 0;

 /* wrap up previous descriptor */
 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
 tx_descriptor->data0 = cpu_to_le32(tx->frame_data0);

 /* move to next descriptor */
 tx->frame_tail = lan743x_tx_next_index(tx, tx->frame_tail);
 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
 buffer_info = &tx->buffer_info[tx->frame_tail];
 dma_ptr = skb_frag_dma_map(dev, fragment,
       0, fragment_length,
       DMA_TO_DEVICE);
 if (dma_mapping_error(dev, dma_ptr)) {
  int desc_index;

  /* cleanup all previously setup descriptors */
  desc_index = tx->frame_first;
  while (desc_index != tx->frame_tail) {
   lan743x_tx_release_desc(tx, desc_index, true);
   desc_index = lan743x_tx_next_index(tx, desc_index);
  }
  dma_wmb();
  tx->frame_flags &= ~TX_FRAME_FLAG_IN_PROGRESS;
  tx->frame_first = 0;
  tx->frame_data0 = 0;
  tx->frame_tail = 0;
  tx->frame_last = 0;
  return -ENOMEM;
 }

 tx_descriptor->data1 = cpu_to_le32(DMA_ADDR_LOW32(dma_ptr));
 tx_descriptor->data2 = cpu_to_le32(DMA_ADDR_HIGH32(dma_ptr));
 tx_descriptor->data3 = cpu_to_le32((frame_length << 16) &
          TX_DESC_DATA3_FRAME_LENGTH_MSS_MASK_);

 buffer_info->skb = NULL;
 buffer_info->dma_ptr = dma_ptr;
 buffer_info->buffer_length = fragment_length;
 buffer_info->flags |= TX_BUFFER_INFO_FLAG_ACTIVE;
 buffer_info->flags |= TX_BUFFER_INFO_FLAG_SKB_FRAGMENT;

 tx->frame_data0 = (fragment_length & TX_DESC_DATA0_BUF_LENGTH_MASK_) |
     TX_DESC_DATA0_DTYPE_DATA_ |
     TX_DESC_DATA0_FCS_;

 /* data0 will be programmed in one of other frame assembler functions */
 return 0;
}

static void lan743x_tx_frame_end(struct lan743x_tx *tx,
     struct sk_buff *skb,
     bool time_stamp,
     bool ignore_sync)
{
 /* called only from within lan743x_tx_xmit_frame
 * assuming tx->ring_lock has already been acquired
 */
 struct lan743x_tx_descriptor *tx_descriptor = NULL;
 struct lan743x_tx_buffer_info *buffer_info = NULL;
 struct lan743x_adapter *adapter = tx->adapter;
 u32 tx_tail_flags = 0;

 /* wrap up previous descriptor */
 if ((tx->frame_data0 & TX_DESC_DATA0_DTYPE_MASK_) ==
     TX_DESC_DATA0_DTYPE_DATA_) {
  tx->frame_data0 |= TX_DESC_DATA0_LS_;
  tx->frame_data0 |= TX_DESC_DATA0_IOC_;
  tx->frame_last = tx->frame_tail;
 }

 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_last];
 buffer_info = &tx->buffer_info[tx->frame_last];
 buffer_info->skb = skb;
 if (time_stamp)
  buffer_info->flags |= TX_BUFFER_INFO_FLAG_TIMESTAMP_REQUESTED;
 if (ignore_sync)
  buffer_info->flags |= TX_BUFFER_INFO_FLAG_IGNORE_SYNC;

 tx_descriptor = &tx->ring_cpu_ptr[tx->frame_tail];
 tx_descriptor->data0 = cpu_to_le32(tx->frame_data0);
 tx->frame_tail = lan743x_tx_next_index(tx, tx->frame_tail);
 tx->last_tail = tx->frame_tail;

 dma_wmb();

 if (tx->vector_flags & LAN743X_VECTOR_FLAG_VECTOR_ENABLE_AUTO_SET)
  tx_tail_flags |= TX_TAIL_SET_TOP_INT_VEC_EN_;
 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET)
  tx_tail_flags |= TX_TAIL_SET_DMAC_INT_EN_ |
  TX_TAIL_SET_TOP_INT_EN_;

 lan743x_csr_write(adapter, TX_TAIL(tx->channel_number),
     tx_tail_flags | tx->frame_tail);
 tx->frame_flags &= ~TX_FRAME_FLAG_IN_PROGRESS;
}

static netdev_tx_t lan743x_tx_xmit_frame(struct lan743x_tx *tx,
      struct sk_buff *skb)
{
 int required_number_of_descriptors = 0;
 unsigned int start_frame_length = 0;
 netdev_tx_t retval = NETDEV_TX_OK;
 unsigned int frame_length = 0;
 unsigned int head_length = 0;
 unsigned long irq_flags = 0;
 bool do_timestamp = false;
 bool ignore_sync = false;
 struct netdev_queue *txq;
 int nr_frags = 0;
 bool gso = false;
 int j;

 required_number_of_descriptors = lan743x_tx_get_desc_cnt(tx, skb);

 spin_lock_irqsave(&tx->ring_lock, irq_flags);
 if (required_number_of_descriptors >
  lan743x_tx_get_avail_desc(tx)) {
  if (required_number_of_descriptors > (tx->ring_size - 1)) {
   dev_kfree_skb_irq(skb);
  } else {
   /* save how many descriptors we needed to restart the queue */
   tx->rqd_descriptors = required_number_of_descriptors;
   retval = NETDEV_TX_BUSY;
   txq = netdev_get_tx_queue(tx->adapter->netdev,
        tx->channel_number);
   netif_tx_stop_queue(txq);
  }
  goto unlock;
 }

 /* space available, transmit skb  */
 if ((skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) &&
     (tx->ts_flags & TX_TS_FLAG_TIMESTAMPING_ENABLED) &&
     (lan743x_ptp_request_tx_timestamp(tx->adapter))) {
  skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
  do_timestamp = true;
  if (tx->ts_flags & TX_TS_FLAG_ONE_STEP_SYNC)
   ignore_sync = true;
 }
 head_length = skb_headlen(skb);
 frame_length = skb_pagelen(skb);
 nr_frags = skb_shinfo(skb)->nr_frags;
 start_frame_length = frame_length;
 gso = skb_is_gso(skb);
 if (gso) {
  start_frame_length = max(skb_shinfo(skb)->gso_size,
      (unsigned short)8);
 }

 if (lan743x_tx_frame_start(tx,
       skb->data, head_length,
       start_frame_length,
       do_timestamp,
       skb->ip_summed == CHECKSUM_PARTIAL)) {
  dev_kfree_skb_irq(skb);
  goto unlock;
 }
 tx->frame_count++;

 if (gso)
  lan743x_tx_frame_add_lso(tx, frame_length, nr_frags);

 if (nr_frags <= 0)
  goto finish;

 for (j = 0; j < nr_frags; j++) {
  const skb_frag_t *frag = &(skb_shinfo(skb)->frags[j]);

  if (lan743x_tx_frame_add_fragment(tx, frag, frame_length)) {
   /* upon error no need to call
 * lan743x_tx_frame_end
 * frame assembler clean up was performed inside
 * lan743x_tx_frame_add_fragment
 */
   dev_kfree_skb_irq(skb);
   goto unlock;
  }
 }

finish:
 lan743x_tx_frame_end(tx, skb, do_timestamp, ignore_sync);

unlock:
 spin_unlock_irqrestore(&tx->ring_lock, irq_flags);
 return retval;
}

static int lan743x_tx_napi_poll(struct napi_struct *napi, int weight)
{
 struct lan743x_tx *tx = container_of(napi, struct lan743x_tx, napi);
 struct lan743x_adapter *adapter = tx->adapter;
 unsigned long irq_flags = 0;
 struct netdev_queue *txq;
 u32 ioc_bit = 0;

 ioc_bit = DMAC_INT_BIT_TX_IOC_(tx->channel_number);
 lan743x_csr_read(adapter, DMAC_INT_STS);
 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_W2C)
  lan743x_csr_write(adapter, DMAC_INT_STS, ioc_bit);
 spin_lock_irqsave(&tx->ring_lock, irq_flags);

 /* clean up tx ring */
 lan743x_tx_release_completed_descriptors(tx);
 txq = netdev_get_tx_queue(adapter->netdev, tx->channel_number);
 if (netif_tx_queue_stopped(txq)) {
  if (tx->rqd_descriptors) {
   if (tx->rqd_descriptors <=
       lan743x_tx_get_avail_desc(tx)) {
    tx->rqd_descriptors = 0;
    netif_tx_wake_queue(txq);
   }
  } else {
   netif_tx_wake_queue(txq);
  }
 }
 spin_unlock_irqrestore(&tx->ring_lock, irq_flags);

 if (!napi_complete(napi))
  goto done;

 /* enable isr */
 lan743x_csr_write(adapter, INT_EN_SET,
     INT_BIT_DMA_TX_(tx->channel_number));
 lan743x_csr_read(adapter, INT_STS);

done:
 return 0;
}

static void lan743x_tx_ring_cleanup(struct lan743x_tx *tx)
{
 if (tx->head_cpu_ptr) {
  dma_free_coherent(&tx->adapter->pdev->dev,
      sizeof(*tx->head_cpu_ptr), tx->head_cpu_ptr,
      tx->head_dma_ptr);
  tx->head_cpu_ptr = NULL;
  tx->head_dma_ptr = 0;
 }
 kfree(tx->buffer_info);
 tx->buffer_info = NULL;

 if (tx->ring_cpu_ptr) {
  dma_free_coherent(&tx->adapter->pdev->dev,
      tx->ring_allocation_size, tx->ring_cpu_ptr,
      tx->ring_dma_ptr);
  tx->ring_allocation_size = 0;
  tx->ring_cpu_ptr = NULL;
  tx->ring_dma_ptr = 0;
 }
 tx->ring_size = 0;
}

static int lan743x_tx_ring_init(struct lan743x_tx *tx)
{
 size_t ring_allocation_size = 0;
 void *cpu_ptr = NULL;
 dma_addr_t dma_ptr;
 int ret = -ENOMEM;

 tx->ring_size = LAN743X_TX_RING_SIZE;
 if (tx->ring_size & ~TX_CFG_B_TX_RING_LEN_MASK_) {
  ret = -EINVAL;
  goto cleanup;
 }
 if (dma_set_mask_and_coherent(&tx->adapter->pdev->dev,
          DMA_BIT_MASK(64))) {
  dev_warn(&tx->adapter->pdev->dev,
    "lan743x_: No suitable DMA available\n");
  ret = -ENOMEM;
  goto cleanup;
 }
 ring_allocation_size = ALIGN(tx->ring_size *
         sizeof(struct lan743x_tx_descriptor),
         PAGE_SIZE);
 dma_ptr = 0;
 cpu_ptr = dma_alloc_coherent(&tx->adapter->pdev->dev,
         ring_allocation_size, &dma_ptr, GFP_KERNEL);
 if (!cpu_ptr) {
  ret = -ENOMEM;
  goto cleanup;
 }

 tx->ring_allocation_size = ring_allocation_size;
 tx->ring_cpu_ptr = (struct lan743x_tx_descriptor *)cpu_ptr;
 tx->ring_dma_ptr = dma_ptr;

 cpu_ptr = kcalloc(tx->ring_size, sizeof(*tx->buffer_info), GFP_KERNEL);
 if (!cpu_ptr) {
  ret = -ENOMEM;
  goto cleanup;
 }
 tx->buffer_info = (struct lan743x_tx_buffer_info *)cpu_ptr;
 dma_ptr = 0;
 cpu_ptr = dma_alloc_coherent(&tx->adapter->pdev->dev,
         sizeof(*tx->head_cpu_ptr), &dma_ptr,
         GFP_KERNEL);
 if (!cpu_ptr) {
  ret = -ENOMEM;
  goto cleanup;
 }

 tx->head_cpu_ptr = cpu_ptr;
 tx->head_dma_ptr = dma_ptr;
 if (tx->head_dma_ptr & 0x3) {
  ret = -ENOMEM;
  goto cleanup;
 }

 return 0;

cleanup:
 lan743x_tx_ring_cleanup(tx);
 return ret;
}

static void lan743x_tx_close(struct lan743x_tx *tx)
{
 struct lan743x_adapter *adapter = tx->adapter;

 lan743x_csr_write(adapter,
     DMAC_CMD,
     DMAC_CMD_STOP_T_(tx->channel_number));
 lan743x_dmac_tx_wait_till_stopped(adapter, tx->channel_number);

 lan743x_csr_write(adapter,
     DMAC_INT_EN_CLR,
     DMAC_INT_BIT_TX_IOC_(tx->channel_number));
 lan743x_csr_write(adapter, INT_EN_CLR,
     INT_BIT_DMA_TX_(tx->channel_number));
 napi_disable(&tx->napi);
 netif_napi_del(&tx->napi);

 lan743x_csr_write(adapter, FCT_TX_CTL,
     FCT_TX_CTL_DIS_(tx->channel_number));
 lan743x_csr_wait_for_bit(adapter, FCT_TX_CTL,
     FCT_TX_CTL_EN_(tx->channel_number),
     0, 1000, 20000, 100);

 lan743x_tx_release_all_descriptors(tx);

 tx->rqd_descriptors = 0;

 lan743x_tx_ring_cleanup(tx);
}

static int lan743x_tx_open(struct lan743x_tx *tx)
{
 struct lan743x_adapter *adapter = NULL;
 u32 data = 0;
 int ret;

 adapter = tx->adapter;
 ret = lan743x_tx_ring_init(tx);
 if (ret)
  return ret;

 /* initialize fifo */
 lan743x_csr_write(adapter, FCT_TX_CTL,
     FCT_TX_CTL_RESET_(tx->channel_number));
 lan743x_csr_wait_for_bit(adapter, FCT_TX_CTL,
     FCT_TX_CTL_RESET_(tx->channel_number),
     0, 1000, 20000, 100);

 /* enable fifo */
 lan743x_csr_write(adapter, FCT_TX_CTL,
     FCT_TX_CTL_EN_(tx->channel_number));

 /* reset tx channel */
 lan743x_csr_write(adapter, DMAC_CMD,
     DMAC_CMD_TX_SWR_(tx->channel_number));
 lan743x_csr_wait_for_bit(adapter, DMAC_CMD,
     DMAC_CMD_TX_SWR_(tx->channel_number),
     0, 1000, 20000, 100);

 /* Write TX_BASE_ADDR */
 lan743x_csr_write(adapter,
     TX_BASE_ADDRH(tx->channel_number),
     DMA_ADDR_HIGH32(tx->ring_dma_ptr));
 lan743x_csr_write(adapter,
     TX_BASE_ADDRL(tx->channel_number),
     DMA_ADDR_LOW32(tx->ring_dma_ptr));

 /* Write TX_CFG_B */
 data = lan743x_csr_read(adapter, TX_CFG_B(tx->channel_number));
 data &= ~TX_CFG_B_TX_RING_LEN_MASK_;
 data |= ((tx->ring_size) & TX_CFG_B_TX_RING_LEN_MASK_);
 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0))
  data |= TX_CFG_B_TDMABL_512_;
 lan743x_csr_write(adapter, TX_CFG_B(tx->channel_number), data);

 /* Write TX_CFG_A */
 data = TX_CFG_A_TX_TMR_HPWB_SEL_IOC_ | TX_CFG_A_TX_HP_WB_EN_;
 if (!(adapter->csr.flags & LAN743X_CSR_FLAG_IS_A0)) {
  data |= TX_CFG_A_TX_HP_WB_ON_INT_TMR_;
  data |= TX_CFG_A_TX_PF_THRES_SET_(0x10);
  data |= TX_CFG_A_TX_PF_PRI_THRES_SET_(0x04);
  data |= TX_CFG_A_TX_HP_WB_THRES_SET_(0x07);
 }
 lan743x_csr_write(adapter, TX_CFG_A(tx->channel_number), data);

 /* Write TX_HEAD_WRITEBACK_ADDR */
 lan743x_csr_write(adapter,
     TX_HEAD_WRITEBACK_ADDRH(tx->channel_number),
     DMA_ADDR_HIGH32(tx->head_dma_ptr));
 lan743x_csr_write(adapter,
     TX_HEAD_WRITEBACK_ADDRL(tx->channel_number),
     DMA_ADDR_LOW32(tx->head_dma_ptr));

 /* set last head */
 tx->last_head = lan743x_csr_read(adapter, TX_HEAD(tx->channel_number));

 /* write TX_TAIL */
 tx->last_tail = 0;
 lan743x_csr_write(adapter, TX_TAIL(tx->channel_number),
     (u32)(tx->last_tail));
 tx->vector_flags = lan743x_intr_get_vector_flags(adapter,
        INT_BIT_DMA_TX_
        (tx->channel_number));
 netif_napi_add_tx_weight(adapter->netdev,
     &tx->napi, lan743x_tx_napi_poll,
     NAPI_POLL_WEIGHT);
 napi_enable(&tx->napi);

 data = 0;
 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_CLEAR)
  data |= TX_CFG_C_TX_TOP_INT_EN_AUTO_CLR_;
 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_AUTO_CLEAR)
  data |= TX_CFG_C_TX_DMA_INT_STS_AUTO_CLR_;
 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_STATUS_R2C)
  data |= TX_CFG_C_TX_INT_STS_R2C_MODE_MASK_;
 if (tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_R2C)
  data |= TX_CFG_C_TX_INT_EN_R2C_;
 lan743x_csr_write(adapter, TX_CFG_C(tx->channel_number), data);

 if (!(tx->vector_flags & LAN743X_VECTOR_FLAG_SOURCE_ENABLE_AUTO_SET))
  lan743x_csr_write(adapter, INT_EN_SET,
      INT_BIT_DMA_TX_(tx->channel_number));
 lan743x_csr_write(adapter, DMAC_INT_EN_SET,
     DMAC_INT_BIT_TX_IOC_(tx->channel_number));

 /*  start dmac channel */
 lan743x_csr_write(adapter, DMAC_CMD,
     DMAC_CMD_START_T_(tx->channel_number));
 return 0;
}

static int lan743x_rx_next_index(struct lan743x_rx *rx, int index)
{
 return ((++index) % rx->ring_size);
}

static void lan743x_rx_update_tail(struct lan743x_rx *rx, int index)
{
 /* update the tail once per 8 descriptors */
 if ((index & 7) == 7)
  lan743x_csr_write(rx->adapter, RX_TAIL(rx->channel_number),
      index);
}

static int lan743x_rx_init_ring_element(struct lan743x_rx *rx, int index,
     gfp_t gfp)
{
 struct net_device *netdev = rx->adapter->netdev;
 struct device *dev = &rx->adapter->pdev->dev;
 struct lan743x_rx_buffer_info *buffer_info;
 unsigned int buffer_length, used_length;
 struct lan743x_rx_descriptor *descriptor;
 struct sk_buff *skb;
 dma_addr_t dma_ptr;

 buffer_length = netdev->mtu + ETH_HLEN + ETH_FCS_LEN + RX_HEAD_PADDING;

--> --------------------

--> maximum size reached

--> --------------------