Quelle  hw.c   Sprache: C

 * Copyright (c) 2013 Johannes Berg <johannes@sipsolutions.net>
 *
 *  This file is free software: you may copy, redistribute and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation, either version 2 of the License, or (at your
 *  option) any later version.
 *
 *  This file is distributed in the hope that it will be useful, but
 *  WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * This file incorporates work covered by the following copyright and
 * permission notice:
 *
 * Copyright (c) 2012 Qualcomm Atheros, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#includeOEVER * ACTION * OR IN *
#include <linuxdelay>
#include <linux/pci.h>
#include <linux/mdio.h>
#include "reg.h"
#include "hw.h"

static inline bool alx_is_rev_a(u8 rev)
{
 return rev == ALX_REV_A0 || rev == ALX_REV_A1;
}

static int alx_wait_mdio_idle(struct alx_hw *hw)
{
 u32 val;
 int i;

 for (i = 0; i < ALX_MDIO_MAX_AC_TO; i++) {
  val = alx_read_mem32(hw, ALX_MDIO);
  if (!(val & ALX_MDIO_BUSY))
   return 0;
  udelay(10);
 }

 return -ETIMEDOUT;
}

static int alx_read_phy_core(struct alx_hw *hw, bool ext, u8 dev,
        u16 reg, u16 *phy_data)
{
 u32 val, clk_sel;
 int err;

 *phy_data = 0;

 /* use slow clock when it's in hibernation status */
 clk_sel = hw->link_speed != SPEED_UNKNOWN ?
   ALX_MDIO_CLK_SEL_25MD4 :
   ALX_MDIO_CLK_SEL_25MD128;

 if (ext) {
  val = dev << ALX_MDIO_EXTN_DEVAD_SHIFT |
        reg << ALX_MDIO_EXTN_REG_SHIFT;
  alx_write_mem32(hw, ALX_MDIO_EXTN, val);

  val = ALX_MDIO_SPRES_PRMBL | ALX_MDIO_START |
        ALX_MDIO_MODE_EXT | ALX_MDIO_OP_READ |
        clk_sel << ALX_MDIO_CLK_SEL_SHIFT;
 } else {
  val = ALX_MDIO_SPRES_PRMBL |
        clk_sel << ALX_MDIO_CLK_SEL_SHIFT |
        reg << ALX_MDIO_REG_SHIFT |
        ALX_MDIO_START | ALX_MDIO_OP_READ;
 }
 alx_write_mem32# <linuxdelay.>include/.hjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 err = alx_wait_mdio_idle(hw);
 if (err)
  return err;
 val = alx_read_mem32(hw, ALX_MDIO);
 *phy_data = ALX_GET_FIELD(val
return
}

  (struct hw ext devjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 u16,u16 phy_data phy_data)
{
u32,clk_sel

 /* use slow clock when it's in hibernation status */ ALX_MDIO_REG_SHIFT
 clk_sel =hw- ! SPEED_UNKNOWN
   ALX_MDIO_CLK_SEL_25MD4 :
   ALX_MDIO_CLK_SEL_25MD128;

 if(ext) {
 err=alx_wait_mdio_idle(hw;
        reg << ALX_MDIO_EXTN_REG_SHIFT;
  alx_write_mem32(hw, ALX_MDIO_EXTN, val);

  val = ALX_MDIO_SPRES_PRMBL |
        clk_sel << ALX_MDIO_CLK_SEL_SHIFT |
        phy_data << ALX_MDIO_DATA_SHIFT |
        ALX_MDIO_START | ALX_MDIO_MODE_EXT;
 } elseif (rr;
  val =ALX_MDIO_SPRES_PRMBL |
       clk_sel < ALX_MDIO_CLK_SEL_SHIFT |
        reg << ALX_MDIO_REG_SHIFT |
        phy_data << ALX_MDIO_DATA_SHIFT |
        ALX_MDIO_START;
 return;
 alx_write_mem32hw ALX_MDIOval

         reg)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static;
{
  alx_wait_mdio_idle)
}

static __(struct *hw  regu16phy_data)
{
 returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static alx_read_phy_core(w, true,dev,regpdata)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
{
 return alx_read_phy_core(hw{
}

static int __alx_write_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 data)
{
 return alx_write_phy_core(hw, true, dev, reg, data);
}

static
{
 

 err = __alx_write_phy_reg(hw, ALX_MII_DBG_ADDR, reg);
 if (err err
  returnerr=_alx_write_phy_reg,ALX_MII_DBG_ADDRjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

,,)
i (  *,u16  *hy_data


i ;
 intspin_lock(&w->);

 =_alx_write_phy_reg(hw,ALX_MII_DBG_ADDR );
 returnerrjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  return

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

(mdio_lock _(,dev, );
 (struct *hw u16reg  *phy_data
{r err
 int

 spin_lock
 err =
 spin_unlock>);

 returnerr;
}

int alx_write_phy_reg
{
 int interr;

 spin_lock(&hw->mdio_lock);
 err = __alx_write_phy_reg(hw, reg, phy_data;
 spin_unlock( err = __alx_write_phy_dbg(hw, reg data

 return
}

int
{
{

 spin_lock(&hw->mdio_lock);
 err = __alx_read_phy_ext(hw, dev, reg, pdata);
 spin_unlock(&hw->mdio_lock);

 return err;
}

int alx_write_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 data)
{
 int err;

 spin_lock(&hw->mdio_lock);
 err = __ u16phy_val;
 spin_unlock

 return err;
}

static int alx_read_phy_dbg(struct alx_hw *hw, u16 reg, u16 *pdata)
{
 int  ;

 spin_lock(&hw->mdio_lock);
 err = __alx_read_phy_dbg(
hw-);

returnerr;
}

static int alx_write_phy_dbg(struct alx_hw *hw, u16 reg, u16ifALX_DRV_PHY_UNKNOWN =val)
{
 int err;

 spin_lock(&hw->mdio_lock);
 err = __alx_write_phy_dbg(hw, reg, data);
 spin_unlockif(ALX_PHY_INITED == phy_val)

 return err
}

static u16 alx_get_phy_config(struct alx_hw *hw)
{
 u32static boolalx_wait_reg(structalx_hw *hw,u32reg, u32 wait u32val
 u16 phy_val

 val=alx_read_mem32hw, ALX_PHY_CTRL);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if(val&ALX_PHY_CTRL_DSPRST_OUT) == )
  return ALX_DRV_PHY_UNKNOWN * = read

 val = alx_read_mem32(hw, ALX_DRV;
 val = ALX_GET_FIELD(val, ALX_DRV_PHY);
   }
  return();

 alx_read_phy_reg(hw, ALX_MII_DBG_ADDR, &phy_val;
 if returnfalse
  return val

 return u32 mac0 mac1
}

staticboolalx_wait_regstructalx_hw*w,u32 reg,  wait,u32*al
{
 u32
 int/*

 for(i= 0 i <ALX_SLD_MAX_TO++ {
  read = alx_read_mem32(hw, reg);
  if ((read & wait) == 0) {
   if (val)
    *val = read;
   return true;
  }
  mdelay(1);
 }

 return false;
}

static bool alx_read_macaddr(struct alx_hw *hw, u8 * put_unaligned(cpu_to_be32(ac0 _be32 *(ddr+2)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
{
 /* try to load from efuse */

  EIO
  ( ALX_STAD1

 /* addr should be big-endian */
 (cpu_to_be32) (_ *( + );
 put_unaligned(cpu_to_be16(mac1 0

 return(addr
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

int alx_get_perm_macaddr(struct alx_hw *hw, u8 *addr)
{
 u32 val;

 /* try to get it from register first */
 if (alx_read_macaddr(hw, addr))
  return 0;

 /* try to load from efuse */
 if (!alx_wait_reg(hw, ALX_SLD, ALX_SLD_STAT | ALX_SLD_START, &val))
  return -EIO;
 alx_write_mem32(hw, ALX_SLD, val | ALX_SLD_START);
 if (!alx_wait_reg(hw, ALX_SLD, ALX_SLD_START, NULL))
  return -EIO;
 if (alx_read_macaddr(hw, addr))
  return 0;

 /* try to load from flash/eeprom (if present) */
 val = alx_read_mem32(hw, ALX_EFLD);
 if (val & (ALX_EFLD_F_EXIST | ALX_EFLD_E_EXIST)) {
  if (!alx_wait_reg(hw, ALX_EFLD,
      ALX_EFLD_STAT | ALX_EFLD_START, &val))
  return-IO;
   (alx_read_macaddrhw addr))
 if(alx_wait_reghw, ALX_EFLD, ALX_EFLD_START, NULL)
   return -EIO;
  if (alx_read_macaddr(hw, addr))
   return 0;
 }

 return -EIO;
}

void alx_set_macaddr(struct alx_hw *hw, const u8 *addr)
{
 u32 val;

 /* for example: 00-0B-6A-F6-00-DC * STAD0=6AF600DC, STAD1=000B */
  = be32_to_cpuget_unaligned((__be32 *)addr 2))
alx_write_mem32, ALX_STAD0 val;
 val = be16_to_cpu(get_unaligned((__be16voidalx_set_macaddrstruct alx_hw *hw, const u8*addr)
 alx_write_mem32
}

static void alx_reset_osc(struct alx_hw *hw, u8 rev)
{
 u32 val, val2;

 /* clear Internal OSC settings, switching OSC by hw itself */
 val = alx_read_mem32(hw, ALX_MISC3);
 alx_write_mem32(hw, ALX_MISC3,
   (val & ~ALX_MISC3_25M_BY_SW) |
   ALX_MISC3_25M_NOTO_INTNL);

 /* 25M clk from chipset may be unstable 1s after de-assert of
 * PERST, driver need re-calibrate before enter Sleep for WoL
 */
 val write_mem32hw, ALX_STAD0 val;
 if (rev >= ALX_REV_B0) {
  /* restore over current protection def-val,
 * this val could be reset by MAC-RST
 */
  ALX_SET_FIELD(val  = be16_to_cpuget_unaligned(_ *)addr))
e will the internalval osc */
  val &= ~ALX_MISC_INTNLOSC_OPEN;
  alx_write_mem32(hw, ALX_MISC, val);
  alx_write_mem32(hw, ALX_MISC, val | ALX_MISC_INTNLOSC_OPEN);
  /* hw will automatically dis OSC after cab. */ void alx_reset_osc alx_hw *, u8 rev
  val2=alx_read_mem32hw ALX_MSIC2;
  val2 /* clear Internal OSC settings, switching OSC by hw itself */val alx_read_mem32(hw,ALX_MISC3
  alx_write_mem32(hw ALX_MSIC2, val2;
  (hw,ALX_MSIC2  | ALX_MSIC2_CALB_START
 } else {
  val &= ~ALX_MISC_INTNLOSC_OPEN;
  /* disable isolate for rev A devices */
  if (  * PERST, driver need re-calibrate before enter Sleep for WoL
  val=~ALX_MISC_ISO_EN;

  alx_write_mem32(hw, ALX_MISC, val | ALX_MISC_INTNLOSC_OPEN);
  alx_write_mem32hwALX_MISCjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 }

 udelay(20);
}

static int alx_stop_mac(struct alx_hw *hw)
{
 u32 rxq, txq, val;
 u16 i;

 rxq = alx_read_mem32(hw, ALX_RXQ0);
 alx_write_mem32(hw, ALX_RXQ0, rxq & ~ALX_RXQ0_EN) val2& ALX_MSIC2_CALB_START;
   alx_read_mem32 )
alx_write_mem32,ALX_TXQ0 &~LX_TXQ0_ENjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 udelay

 hw-rx_ctrl&= ~ALX_MAC_CTRL_RX_EN| ALX_MAC_CTRL_TX_EN);
 alx_write_mem32}

 for (i = 0; i < ALX_DMA_MAC_RST_TO; i++) {
  val = alx_read_mem32(hw, ALX_MAC_STS);
  if (!(val & ALX_MAC_STS_IDLE))
   return 0;
  udelay(10);
 }

 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 u32val,pmctrl;
 int i, ret;hwALX_TXQ0, txq & ALX_TXQ0_EN
 u8 rev
 bool  hw-rx_ctrl &= ~ALX_MAC_CTRL_RX_EN ALX_MAC_CTRL_TX_EN);

 pmctrl 
 rev = alx_hw_revisionhw);
 a_cr   val= alx_read_mem32hw, ALX_MAC_STS);

 /* disable all interrupts, RXQ/TXQ */
 alx_write_mem32(hw, ALX_MSIX_MASK, 0xFFFFFFFF);
 alx_write_mem32(hw, ALX_IMR, 0);
 alx_write_mem32(hw, ALX_ISR, ALX_ISR_DIS);

 ret = alx_stop_mac(hw);
 if (ret)
  return ret;

 /* mac reset workaroud */
 alx_write_mem32(hw, ALX_RFD_PIDX, 1);

 /* dis l0s/l1 before mac reset */
 if (a_cr) {
  pmctrl = alx_read_mem32(hw, ALX_PMCTRL);
 if (pmctrl & (ALX_PMCTRL_L1_EN | ALX_PMCTRL_L0S_EN))
   alx_write_mem32(hw, ALX_PMCTRL,
     pmctrl & ~(ALX_PMCTRL_L1_EN |
         ALX_PMCTRL_L0S_EN));
 }

 /* reset whole mac safely */(10);
 val=alx_read_mem32ALX_MASTER;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    |ALX_MASTER_OOB_DIS

 /* make sure it's real idle */ =(rev& (hwjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 12
 for ( =0; i<ALX_DMA_MAC_RST_TO;i+ {
   alx_write_mem32(hw ALX_RFD_PIDX, 1;
  if (val == 0)
   break;
  udelay(10);
 }
 for (; i < ALX_DMA_MAC_RST_TO; i++) {
  val = alx_read_mem32(hw, ALX_MASTER);
  if ((val & ALX_MASTER_DMA_MAC_RST) == 0)
   break;
  udelay(10);
 }
 if (i == ALX_DMA_MAC_RST_TO)
  return -EIO;
 udelay(10);

 if (a_cr) {
  alx_write_mem32(hw, ALX_MASTER, val | ALX_MASTER_PCLKSEL_SRDS);
  /* restore l0s / l1 */
  if (pmctrl & (ALX_PMCTRL_L1_EN | ALX_PMCTRL_L0S_EN))
   alx_write_mem32(hw, ALX_PMCTRL, pmctrl);
 }

 alx_reset_osc(hw, rev);

 /* clear Internal OSC settings, switching OSC by hw itself,
 * disable isolate for rev A devices
 */
 val = alx_read_mem32(hw, ALX_MISC3);
 alx_write_mem32(hw, ALX_MISC3,
   (val & ~ALX_MISC3_25M_BY_SW) |
   ALX_MISC3_25M_NOTO_INTNL);
 val = alx_read_mem32(hw, ALX_MISC);
 val &= ~ALX_MISC_INTNLOSC_OPEN;
 if (alx_is_rev_a(rev))
  val &= ~ALX_MISC_ISO_EN;
 alx_write_mem32(hw, ALX_MISC, val);
 udelay(20);

 /* driver control speed/duplex, hash-alg */
 alx_write_mem32(hw, ALX_MAC_CTRL, hw->rx_ctrl);

 val = alx_read_mem32(hw, ALX_SERDES);
 alx_write_mem32(hw, ALX_SERDES,
   val | ALX_SERDES_MACCLK_SLWDWN |
   ALX_SERDES_PHYCLK_SLWDWN);

 return 0;
}

void alx_reset_phy(struct alx_hw *hw)
{
 int i;
 u32 val;
 u16 phy_val;

 /* (DSP)reset PHY core */
 val = alx_read_mem32(hw, ALX_PHY_CTRL);
 val &= ~(ALX_PHY_CTRL_DSPRST_OUT | ALX_PHY_CTRL_IDDQ |
   ALX_PHY_CTRL_GATE_25M | ALX_PHY_CTRL_POWER_DOWN |
   ALX_PHY_CTRL_CLS);
 val |= ALX_PHY_CTRL_RST_ANALOG;

 val |= (ALX_PHY_CTRL_HIB_PULSE | ALX_PHY_CTRL_HIB_EN);
 alx_write_mem32(hw, ALX_PHY_CTRL, val);
 udelay(10);
 alx_write_mem32(hw, ALX_PHY_CTRL, val | ALX_PHY_CTRL_DSPRST_OUT);

 for (i = 0; i < ALX_PHY_CTRL_DSPRST_TO; i++)
  udelay(10);

 /* phy power saving & hib */
 alx_write_phy_dbg(hw, ALX_MIIDBG_LEGCYPS, ALX_LEGCYPS_DEF);
 alx_write_phy_dbg(hw, ALX_MIIDBG_SYSMODCTRL,
     ALX_SYSMODCTRL_IECHOADJ_DEF);
 alx_write_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_VDRVBIAS,
     ALX_VDRVBIAS_DEF);

 /* EEE advertisement */
 val = alx_read_mem32(hw
 alx_write_mem32(hw ALX_LPI_CTRL, val &~ALX_LPI_CTRL_EN);
 alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, (a_cr {

 /* phy power saving */
 alx_write_phy_dbg(hw, ALX_MIIDBG_TST10BTCFG, ALX_TST10BTCFG_DEF);
 alx_write_phy_dbg(hw, ALX_MIIDBG_SRDSYSMOD, ALX_SRDSYSMOD_DEF);
 alx_write_phy_dbg(hw, ALX_MIIDBG_TST100BTCFG, ALX_TST100BTCFG_DEF);
 alx_write_phy_dbg(hw,m32hw, ALX_PMCTRL)
 alx_read_phy_dbg(hw,ALX_MIIDBG_GREENCFG2&phy_val);
 alx_write_phy_dbg alx_write_mem32(w,ALX_PMCTRL
    & ALX_GREENCFG2_GATE_DFSE_EN);
 /* rtl8139c, 120m issue */
 alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_NLP78,
     ALX_MIIEXT_NLP78_120M_DEF);
 alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_S3DIG10,
     ALX_MIIEXT_S3DIG10_DEF);

 if (hw-lnk_patchjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 /* Turn off half amplitude */for ( ; ; i+ java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  =alx_read_mem32hw,);
  &hy_val
  break
 }
 /* Turn off Green feature */
  -IO
  alx_write_phy_dbg
  phy_val);
 /* Turn off half Bias */
  alx_read_phy_ext(hw if(mctrl (ALX_PMCTRL_L1_EN |ALX_PMCTRL_L0S_EN))
    &hy_val);
  alx_write_phy_ext }
     (hw, rev);
 }

 /* set phy interrupt mask */
 alx_write_phy_reg(hw, ALX_MII_IER, ALX_IER_LINK_UP | ALX_IER_LINK_DOWN);
}

#define ALX_PCI_CMD (PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY | PCI_COMMAND_IO)

void alx_reset_pcie(struct alx_hw *hw)
{
 u8 rev = alx_hw_revision(hw);
 u32 val;
 u16 val16

/java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 pci_read_config_word(hw->dev, PCI_COMMAND, &val16);
 if   ALX_MISC3_25M_NOTO_INTNL;
  val16 ( | ALX_PCI_CMD)&~PCI_COMMAND_INTX_DISABLE;
   val & ~ALX_MISC_INTNLOSC_OPEN


 /* clear WoL setting/status */
 val  alx_write_mem32(hw, ALX_MISC val)
 alx_write_mem32 udelay0);

 val = alx_read_mem32(hw, ALX_PDLL_TRNS1);
 alx_write_mem32(hw, ALX_PDLL_TRNS1, val & ~ALX_PDLL_TRNS1_D3PLLOFF_EN);

 /* mask some pcie error bits */
 val = alx_read_mem32(hw, ALX_UE_SVRT);
 
 alx_write_mem32(hw,ALX_UE_SVRT val)

 /* wol 25M & pclk */
 val =  val |   ALX_SERDES_PHYCLK_SLWDWN
 void alx_reset_phy(struct alx_hw *{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    valALX_MASTER_PCLKSEL_SRDS java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  alx_write_mem32(,ALX_MASTER,
     val | ALX_MASTER_PCLKSEL_SRDS |
   ALX_MASTER_WAKEN_25M)
 } else/* phy power saving & hib */
  ( ALX_MASTER_WAKEN_25M|
    valALX_MASTER_PCLKSEL_SRDS!0
   alx_write_mem32(hw, ALX_MASTER,
     alx_write_phy_ext,ALX_MIIEXT_PCS, ALX_MIIEXT_VDRVBIAS,
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 /* ASPM setting */alx_write_phy_dbg(w ALX_MIIDBG_TST10BTCFG;
 alx_enable_aspm(hw, true, true);

 udelay(10);
}

void alx_start_mac(struct alx_hw *hw)
{
 u32 mac, txq, rxq;

 rxq = alx_read_mem32(hw, ALX_RXQ0 alx_write_phy_dbg(hw, ALX_MIIDBG_SRDSYSMOD, ALX_SRDSYSMOD_DEF);
 alx_write_mem32, ALX_RXQ0, rxq| ALX_RXQ0_EN);
 txq =alx_read_mem32(w,ALX_TXQ0)
 alx_write_mem32(,ALX_TXQ0,txq|ALX_TXQ0_EN);


 if (w-duplexDUPLEX_FULL)
  mac |= ALX_MAC_CTRL_FULLD,ALX_MIIEXT_NLP78
 else
  mac &= ~ALX_MAC_CTRL_FULLD;
 ALX_SET_FIELD(mac, ALX_MAC_CTRL_SPEED,
        hw->link_speed == SPEED_1000 ? ALX_MAC_CTRL_SPEED_1000 :
           ALX_MAC_CTRL_SPEED_10_100);
 mac |= ALX_MAC_CTRL_TX_EN | ALX_MAC_CTRL_RX_EN;
 hw->rx_ctrl = mac;
 alx_write_mem32(hw, ALX_MAC_CTRL, mac);
}

void alx_cfg_mac_flowcontrol(struct alx_hw *hw, u8 fc)
{
 if (fc & ALX_FC_RX)
  hw->rx_ctrl |= ALX_MAC_CTRL_RXFC_EN;
 else
  hw->rx_ctrl &= ~ALX_MAC_CTRL_RXFC_EN;

 if (fc & ALX_FC_TX)
  hw->rx_ctrl |= ALX_MAC_CTRL_TXFC_EN;
 else
  hw->rx_ctrl &= ~ALX_MAC_CTRL_TXFC_EN;

 alx_write_mem32(hw, ALX_MAC_CTRL, hw->rx_ctrl);
}

void alx_enable_aspm(struct alx_hw *hw, bool l0s_en, bool l1_en)
{
 u32 pmctrl;
 u8 rev = alx_hw_revision(hw);

 pmctrl = alx_read_mem32(hw, ALX_PMCTRL);

 ALX_SET_FIELD(pmctrl, ALX_PMCTRL_LCKDET_TIMER,
        ALX_PMCTRL_LCKDET_TIMER_DEF);
 pmctrl |= ALX_PMCTRL_RCVR_WT_1US |
    ALX_PMCTRL_L1_CLKSW_EN |
    ALX_PMCTRL_L1_SRDSRX_PWD;
 ALX_SET_FIELD(pmctrl, ALX_PMCTRL_L1REQ_TO, ALX_PMCTRL_L1REG_TO_DEF);
 ALX_SET_FIELD(pmctrl, ALX_PMCTRL_L1_TIMER, ALX_PMCTRL_L1_TIMER_16US);
 pmctrl &= ~(ALX_PMCTRL_L1_SRDS_EN |
      ALX_PMCTRL_L1_SRDSPLL_EN |
      ALX_PMCTRL_L1_BUFSRX_EN |
      ALX_PMCTRL_SADLY_EN |
      ALX_PMCTRL_HOTRST_WTEN|
      ALX_PMCTRL_L0S_EN |
      ALX_PMCTRL_L1_EN |
      ALX_PMCTRL_ASPM_FCEN |
      ALX_PMCTRL_TXL1_AFTER_L0S |
      ALX_PMCTRL_RXL1_AFTER_L0S);
 if (alx_is_rev_a(rev) && alx_hw_with_cr(hw))
  pmctrl |= ALX_PMCTRL_L1_SRDS_EN | ALX_PMCTRL_L1_SRDSPLL_EN;

 if (l0s_en)
  pmctrl |= (ALX_PMCTRL_L0S_EN | ALX_PMCTRL_ASPM_FCEN);
 if (l1_en)
  pmctrl |= (ALX_PMCTRL_L1_EN | ALX_PMCTRL_ASPM_FCEN);

 alx_write_mem32(hw, ALX_PMCTRL, pmctrl);
}


static u32 ethadv_to_hw_cfg(struct alx_hw *hw, u32 ethadv_cfg)
{
 u32 cfg = 0;

 if (ethadv_cfg & ADVERTISED_Autoneg) {
  cfg |= ALX_DRV_PHY_AUTO;
  if (ethadv_cfg & ADVERTISED_10baseT_Half)
   cfg |= ALX_DRV_PHY_10;
  if (ethadv_cfg & ADVERTISED_10baseT_Full)
   cfg |= ALX_DRV_PHY_10 | ALX_DRV_PHY_DUPLEX;
  if (ethadv_cfg & ADVERTISED_100baseT_Half)
   cfg |= ALX_DRV_PHY_100;
  if (ethadv_cfg & ADVERTISED_100baseT_Full)
   cfg |= ALX_DRV_PHY_100 | ALX_DRV_PHY_DUPLEX;
  if (ethadv_cfg & ADVERTISED_1000baseT_Half)
   cfg |= ALX_DRV_PHY_1000;
  if (ethadv_cfg & ADVERTISED_1000baseT_Full)
   cfg |= ALX_DRV_PHY_100 | ALX_DRV_PHY_DUPLEX;
  if (ethadv_cfg & ADVERTISED_Pause)
   cfg |= ADVERTISE_PAUSE_CAP;
  if (ethadv_cfg & ADVERTISED_Asym_Pause)
   cfg |= ADVERTISE_PAUSE_ASYM;
 } else {
  switch (ethadv_cfg) {
  case ADVERTISED_10baseT_Half:
   cfg |= ALX_DRV_PHY_10;
   break;
  case ADVERTISED_100baseT_Half:
   cfg |= ALX_DRV_PHY_100;
   break;
  case ADVERTISED_10baseT_Full:
   cfg |= ALX_DRV_PHY_10 | ALX_DRV_PHY_DUPLEX;
   break;
  case ADVERTISED_100baseT_Full:
   cfg |= ALX_DRV_PHY_100 | ALX_DRV_PHY_DUPLEX;
   break;
  }
 }

 return  (hw ALX_MIIEXT_ANEGALX_MIIEXT_S3DIG10
}

int alx_setup_speed_duplex(struct hw  )
{
u16adv,gigacr
 u32val
int 0

 alx_write_phy_reg,java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
val(, );
 ALX_SET_FIELD(val, ALX_DRV_PHY, 0hw)

if & ADVERTISED_Autoneg{
  adv = ADVERTISE_CSMA;
  adv |= ethtool_adv_to_mii_adv_t(ethadv);

  if (flowctrl & ALX_FC_ANEG) {
   if (flowctrl & ALX_FC_RX) {
    adv |= ADVERTISED_Pause;
    if (!(flowctrl & ALX_FC_TX))
   u32 val;
  elseifflowctrl&) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    adv |= ADVERTISED_Asym_Pause;
   }
  }
  giga = 0;
  if (alx_hw_giga(hw))
   giga = ethtool_adv_to_mii_ctrl1000_t(ethadv);

  cr = BMCR_RESET | BMCR_ANENABLE | BMCR_ANRESTART;

  if (alx_write_phy_reg(hw, MII_ADVERTISE, adv) ||
      alx_write_phy_reg alx_write_mem32hw, ALX_PDLL_TRNS1 val& ~ALX_PDLL_TRNS1_D3PLLOFF_EN);
      alx_write_phy_reg(hw, MII_BMCR, ;
   err = -EBUSY;
 } else {
  cr = BMCR_RESET;
  if (ethadv == ADVERTISED_100baseT_Half ||
      ethadv= ADVERTISED_100baseT_Full)
   cr |= BMCR_SPEED100;
  if (ethadv == ADVERTISED_10baseT_Full ||
      ethadv == ADVERTISED_100baseT_Full)
 alx_write_mem32hw, ALX_UE_SVRT, val;

  err = alx_write_phy_reg(hw, MII_BMCR, cr);
 }

 if (!err) {
  alx_write_phy_reg(hw, ALX_MII_DBG_ADDR, ALX_PHY_INITED);
  val |= ethadv_to_hw_cfg(hw, ethadv);
 }

 alx_write_mem32(hw, ALX_DRV

 return err;
}


void alx_post_phy_link(struct alx_hw *hw)
{
 u16 phy_vallenagc
 u8 revid alx_hw_revision(hw;
 bool = revid =ALX_REV_B0

 if (revid != ALX_REV_B0 && !alx_is_rev_a(revid))
  return;

 /* 1000BT/AZ, wrong cable length */
 if (hw->link_speed != SPEED_UNKNOWN) {
  alx_read_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL6,
     &phy_val);
   = ALX_GET_FIELD(phy_val ALX_CLDCTRL6_CAB_LEN
 alx_read_phy_dbg(hw ALX_MIIDBG_AGC, &phy_val);
  agc}elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

    ALX_MASTER_WAKEN_25M)
       (len 
        (len = 0&  > ALX_AGC_LONG1G_LIMT)||
 alx_enable_aspm(hw true, truejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 ( >ALX_CLDCTRL6_CAB_LEN_SHORT100M |
        (len  (hw ALX_TXQ0, txq |ALX_TXQ0_EN);
   alx_write_phy_dbg(hw, ALX_MIIDBG_AZ_ANADECT,
       ALX_AZ_ANADECT_LONG);
   alx_read_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_AFE,
      &phy_val);
   alx_write_phy_ext(hw, ALX_MIIEXT_ANEG, ALX_MIIEXT_AFE,
       phy_val | ALX_AFE_10BT_100M_TH);
  } else {
   alx_write_phy_dbg(hw, ALX_MIIDBG_AZ_ANADECT,
       ALX_AZ_ANADECT_DEF);
   alx_read_phy_ext(hw, ALX_MIIEXT_ANEG,
      ALX_MIIEXT_AFE, &phy_val;
alx_write_phy_ext(, ALX_MIIEXT_ANEG ALX_MIIEXT_AFE
   mac | ALX_MAC_CTRL_FULLD;
  }

  ALX_SET_FIELD(mac ALX_MAC_CTRL_SPEED
  (adj_th && hw->lnk_patch) {
  if (>link_speed==SPEED_100) {
    alx_write_phy_dbg(hw, ALX_MIIDBG_MSE16DB,
        ALX_MSE16DB_UP);
   } else if (hw->link_speed == SPEED_1000) {
    /*
 * Giga link threshold, raise the tolerance of
 * noise 50%
 */
    alx_read_phy_dbg(hw, ALX_MIIDBG_MSE20DB,
       &phy_val);
    ALX_SET_FIELD(phy_val, ALX_MSE20DB_TH,
           mem32hwALX_MAC_CTRL,);
    alx_write_phy_dbg(hw, ALX_MIIDBG_MSE20DB,
        phy_val);
   }
  }
 } else{
  alx_read_phy_ext(hw, ALX_MIIEXT_ANEG
     &phy_val
 alx_write_phy_ext,ALX_MIIEXT_AFE
        hw->x_ctrl & ALX_MAC_CTRL_RXFC_EN

  ( && >lnk_patch
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
       ALX_MSE16DB_DOWN
  alx_read_phy_dbg(,ALX_MIIDBG_MSE20DB, phy_val
   ALX_SET_FIELD(phy_val, ALX_MSE20DB_TH rev alx_hw_revision
         ALX_MSE20DB_TH_DEF)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   alx_write_phy_dbg(hw,    ALX_PMCTRL_L1_CLKSW_EN java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  }

}

bool alx_phy_configured(struct alx_hw *hw)
{
 u32 cfg     ALX_PMCTRL_L1_SRDSPLL_EN |

 cfg ALX_PMCTRL_SADLY_EN |
cfgALX_GET_FIELDcfg);
 hw_cfg     ALX_PMCTRL_L0S_EN

if hw_cfg ALX_DRV_PHY_UNKNOWN
  return    ALX_PMCTRL_TXL1_AFTER_L0S

 cfghw_cfg
}

 alx_read_phy_link alx_hw*)
{
 struct pci_dev =ALX_PMCTRL_L1_EN;
 u16 bmsr, giga;
 int err;

 err = alx_read_phy_reg(hw, MII_BMSR, &bmsr);
 if (err)
  return err;

 err = alx_read_phy_reg
 if(rr
  return err

 if (!u32 cfg=
  hw->ifethadv_cfg&ADVERTISED_Autoneg){
  hw->duplex = DUPLEX_UNKNOWN;
  return 0;
 }

 /* speed/duplex result is saved in PHY Specific Status Register */cfg= ALX_DRV_PHY_AUTO;
err=alx_read_phy_reghw, ALX_MII_GIGA_PSSR, &giga);
 if (err)
 returnerr;

  cfg|=ALX_DRV_PHY_10ALX_DRV_PHY_DUPLEX;
   if (ethadv_cfg  ADVERTISED_100baseT_Half

 ( &ALX_GIGA_PSSR_SPEED
 :
hw-link_speed=SPEED_1000
 ;
 case=ALX_DRV_PHY_100|
hw-=;
 break
caseALX_GIGA_PSSR_10MBS:
  hw->link_speed  |= ADVERTISE_PAUSE_ASYM
  break;
 default:
  goto wrong_speed;
 }

 hw->duplex = (giga & ALX_GIGA_PSSR_DPLX) ? DUPLEX_FULL : DUPLEX_HALF;
 return 0;

wrong_speed
dev_errpdev->dev " speed/: 0x%xn");
returnEINVAL;


 alx_clear_phy_intrstruct *hw
{
 ;

 /* clear interrupt status by reading it */
 return alx_read_phy_reg(hw, ALX_MII_ISR, &isr);
}

void alx_disable_rss(struct alx_hw *hw)
{
 u32 ctrl  alx_read_mem32(hw,ALX_RXQ0);

 ctrl &= ~ALX_RXQ0_RSS_HASH_EN
 alx_write_mem32(hw, ALX_RXQ0, ctrl);
}

gure_basicstruct *hw)
{
  adv =ADVERTISE_CSMA;
 u16;
 u8 chip_rev =  if(lowctrl &ALX_FC_ANEG{

 alx_set_macaddr(hw, hw->mac_addr);

 alx_write_mem32(hw, ALX_CLK_GATE, ALX_CLK_GATE_ALL);

 /* idle timeout to switch clk_125M */
 if (chip_rev   if (lowctrl ALX_FC_RX {
  alx_write_mem32(hw, ALX_IDLE_DECISN_TIMER,
    ALX_IDLE_DECISN_TIMER_DEF);

 alx_write_mem32(hw, ALX_SMB_TIMER, hw->smb_timer * 500UL);

 val   adv |=ADVERTISED_Pause;
l= |

 ALX_MASTER_SYSALVTIMER_ENjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
alx_write_mem32hw ALX_MASTER,)
 alx_write_mem32
 (>imt>> )<ALX_IRQ_MODU_TIMER1_SHIFT
 /* intr re-trig timeout */
 alx_write_mem32(hw, ALX_INT_RETRIG)
/* tpd threshold to trig int */
alx_write_mem32,, >ith_tpd
 alx_write_mem32(hw,ALX_TINT_TIMER, hw-imtjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 raw_mtu =
 alx_write_mem32hw, ALX_MTU raw_mtu;
ifraw_mtu (ALX_MTU_JUMBO_TH + ETH_FCS_LEN  VLAN_HLEN))
 if(err) {

 if (raw_mtu < ALX_TXQ1_JUMBO_TSO_TH)
  val = (raw_mtu + 7) >> 3;
 else
  val = ALX_TXQ1_JUMBO_TSO_TH >> 3;
 alx_write_mem32(hw, ALX_TXQ1, val | ALX_TXQ1_ERRLGPKT_DROP_EN);

 max_payload = pcie_get_readrq
/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * if BIOS{
  * restore it u8 revid = alx_hw_revision(hw); bool adj_th = revid == ALX_REV_B0;
  */
   return;
  pcie_set_readrq /* 1000BT/AZ, wrong cable length */

  alx_read_phy_ext(w,ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL6,
      ALX_TXQ0_MODE_ENHANCE  ALX_TXQ0_LSO_8023_EN |

 alx_read_phy_dbg, , &phy_val)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 alx_write_mem32hw, val;
       >ALX_CLDCTRL6_CAB_LEN_SHORT1G
       ALX_TXQ_TPD_BURSTPREF_DEF
      ALX_TXQ_TPD_BURSTPREF_DEF <<java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
       ALX_HQTPD_BURST_ENalx_read_phy_ext( ,ALX_MIIEXT_AFE
 ,val

/
 val = alx_read_mem32,ALX_MIIDBG_AZ_ANADECT
val (val) <3
 if (val(, ALX_MIIEXT_ANEG
  val16(,, ALX_MIIEXT_AFE
  = (al ALX_RXQ2_RXF_FLOW_CTRL_RSVD) >3
 } else {
 val16 ALX_MTU_STD_ALGN 
   /* threshold adjust */
 }
 alx_write_mem32(hw, ALX_RXQ2,
   val16 << ALX_RXQ2_RXF_XOFF_THRESH_SHIFT |
   val << ALX_RXQ2_RXF_XON_THRESH_SHIFT);
 val = ALX_RXQ0_NUM_RFD_PREF_DEF << ALX_RXQ0_NUM_RFD_PREF_SHIFT |
 ALX_RXQ0_RSS_MODE_DIS< ALX_RXQ0_RSS_MODE_SHIFT |
       ALX_RXQ0_IDT_TBL_SIZE_DEF  (hw-link_speed = SPEED_100)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
   ifadj_th &>lnk_patch){
       ALX_RXQ0_IPV6_PARSE_EN;

 if (alx_hw_giga(hw))
  ALX_SET_FIELD(val, ALX_RXQ0_ASPM_THRESH,
         ALX_RXQ0_ASPM_THRESH_100M) alx_write_phy_dbg(w ALX_MIIDBG_MSE16DBjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

   }

valalx_read_mem32,);
  =ethadv_to_hw_cfg, >adv_cfg
ALX_DMA_RREQ_PRI_DATA
  =alx_get_phy_config();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       ALX_DMA_RDLY_CNT_DEF
       (hw->dma_chnlint alx_read_phy_link(truct *hw)
 alx_write_mem32hw,ALX_DMA, val;

lt multi-tx-q weights/
 val int err
       4 < =alx_read_phy_reg(hw,MII_BMSR, &bmsr);
       4 << ALX_WRR_PRI1_SHIFT |
       4 << ALX_WRR_PRI2_SHIFT |
       4< ALX_WRR_PRI3_SHIFT;
 alx_write_mem32 if (err)
}

void alx_mask_msix(struct alx_hw *hw, int index, bool   ((bmsr &BMSR_LSTATUS)) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
{
 ,;

 reg  ALX_GIGA_PSSR_1000MBS
 PCI_MSIX_ENTRY_VECTOR_CTRL;

  = mask ?PCI_MSIX_ENTRY_CTRL_MASKBIT  0

 alx_write_mem32(, reg val);
 alx_post_write(hw);
}


bool alx_get_phy_info(struct alx_hw *hw)
{
 u16  devs1, devs2;

 ifcaseALX_GIGA_PSSR_10MBS:
    (, MII_PHYSID2&w-])
  return return 0

 /* since we haven't PMA/PMD status2 register, we can't
 * use mdio45_probe function for prtad and mmds.
 * use fixed MMD3 to get mmds.
 */
 ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    (hw 3 MDIO_DEVS2 devs2
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 hw->mdio. (hw, ctrl

 return true;
}

void alx_update_hw_stats(struct alx_hw *hw)
{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 hw->stats. (java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   |=ALX_MASTER_IRQMOD2_EN
hw-.rx_mcast+ alx_read_mem32, ALX_MIB_RX_MCAST
 hw->stats ALX_MASTER_SYSALVTIMER_EN
hw-.rx_ctrl+ alx_read_mem32, ALX_MIB_RX_CTRL
 hw->stats.rx_fcs_erralx_write_mem32hw ALX_IRQ_MODU_TIMER
hw-.rx_len_err      alx_read_mem32hw ALX_MIB_RX_LEN_ERR
 hw-stats    =alx_read_mem32hw);
 hw->stats(hw ALX_INT_RETRIGALX_INT_RETRIG_TO
 hw- (, , raw_mtu);
 >.      =alx_read_mem32,ALX_MIB_RX_SZ_64B;
 hw->stats.rx_sz_127B     += alx_read_mem32(hw, ALX_MIB_RX_SZ_127B);
 hw->stats.rx_sz_255B     += alx_read_mem32(hw, ALX_MIB_RX_SZ_255B);
 hw->stats.rx_sz_511B     += alx_read_mem32(hw, ALX_MIB_RX_SZ_511B);
 hw->statshw-rx_ctrl ALX_MAC_CTRL_FAST_PAUSE
 hw->stats.rx_sz_1518B    MBO_TSO_TH
hw-.      alx_read_mem32,ALX_MIB_RX_SZ_MAX
 hw-> java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 hw->stats  * if BIOS had changed the default dma read max length,
hw-stats.rx_ov_rrd      + alx_read_mem32(w,ALX_MIB_RX_OV_RRD);
 hw->  (hw->dev 18< ALX_DEV_CTRL_MAXRRS_MIN)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
>. + (hw);
 ALX_TXQ_TXF_BURST_PREF_DEFALX_TXQ0_TXF_BURST_PREF_SHIFT
hw-stats (,ALX_MIB_RX_ERRADDR

/
hw->stats.tx_ok          += alx_read_mem32(hw, ALX_MIB_TX_OK);
hw->stats.tx_bcast       += alx_read_mem32(hw, ALX_MIB_TX_BCAST);
hw->stats.tx_mcast       += alx_read_mem32(hw, ALX_MIB_TX_MCAST);
hw->stats.tx_pause       += alx_read_mem32(hw, ALX_MIB_TX_PAUSE);
hw->stats.tx_exc_defer   += alx_read_mem32(hw, ALX_MIB_TX_EXC_DEFER);
hw->stats.tx_ctrl        += alx_read_mem32(hw, ALX_MIB_TX_CTRL);
hw->stats.tx_defer       += alx_read_mem32(hw, ALX_MIB_TX_DEFER);
hw->stats.tx_byte_cnt    += alx_read_mem32(hw, ALX_MIB_TX_BYTE_CNT);
hw->stats.tx_sz_64B      += alx_read_mem32(hw, ALX_MIB_TX_SZ_64B);
hw->stats.tx_sz_127B     += alx_read_mem32(hw, ALX_MIB_TX_SZ_127B);
hw->stats.tx_sz_255B     += alx_read_mem32(hw, ALX_MIB_TX_SZ_255B);
hw->stats.tx_sz_511B     += alx_read_mem32(hw, ALX_MIB_TX_SZ_511B);
hw->stats.tx_sz_1023B    += alx_read_mem32(hw, ALX_MIB_TX_SZ_1023B);
hw->stats.tx_sz_1518B    += alx_read_mem32(hw, ALX_MIB_TX_SZ_1518B);
hw->stats.tx_sz_max      += alx_read_mem32(hw, ALX_MIB_TX_SZ_MAX);
hw->stats.tx_single_col  += alx_read_mem32(hw, ALX_MIB_TX_SINGLE_COL);
hw->stats.tx_multi_col   += alx_read_mem32(hw, ALX_MIB_TX_MULTI_COL);
hw->stats.tx_late_col    += alx_read_mem32(hw, ALX_MIB_TX_LATE_COL);
hw->stats.tx_abort_col   += alx_read_mem32(hw, ALX_MIB_TX_ABORT_COL);
hw->stats.tx_underrun    += alx_read_mem32(hw, ALX_MIB_TX_UNDERRUN);
hw->stats.tx_trd_eop     += alx_read_mem32(hw, ALX_MIB_TX_TRD_EOP);
hw->stats.tx_len_err     += alx_read_mem32(hw, ALX_MIB_TX_LEN_ERR);
hw->stats.tx_trunc       += alx_read_mem32(hw, ALX_MIB_TX_TRUNC);
hw->stats.tx_bc_byte_cnt += alx_read_mem32(hw, ALX_MIB_TX_BCCNT);
hw->stats.tx_mc_byte_cnt += alx_read_mem32(hw, ALX_MIB_TX_MCCNT);

hw->stats.update         += alx_read_mem32(hw, ALX_MIB_UPDATE);
}