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.
 */
#include <include/.hjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
include/delayh
#include <linux/cih>
#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 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 }

 return return 0;
}

static
        staticintalx_write_phy_core alx_hw*, bool, u8dev,
{
 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        u16 reg u16  val clk_sel;
        reg << ALX_MDIO_REG_SHIFT |
        ALX_MDIO_START | ALX_MDIO_OP_READ; clk_sel = >link_speed=SPEED_UNKNOWN ?
 }
 alx_write_mem32 ext{

   alx_wait_mdio_idle)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  ()
  return err
 val = alx_read_mem32val=ALX_MDIO_SPRES_PRMBL
  clk_sel<ALX_MDIO_CLK_SEL_SHIFT java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 return 0
}

staticalx_write_mem32(hw, ALX_MDIO, val);
  u16, u16 phy_data
{
 u32 val, clk_sel}

 /* 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 |
        clk_sel << ALX_MDIO_CLK_SEL_SHIFT |
        phy_data << ALX_MDIO_DATA_SHIFT |
        ALX_MDIO_START | ALX_MDIO_MODE_EXT;
 } else {
  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
 }
 alx_write_mem32

 returnalx_wait_mdio_idle(hw;
}

 int_alx_write_phy_reg alx_hw,u16, u16 phy_data)
{
 return alx_read_phy_core
}

static int __alx_write_phy_reg(struct alx_hw *hw, u16 reg, u16 phy_data)
{
 return alx_write_phy_core(hw, false, 0, reg, phy_data);
}

static int __alx_read_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 *pdata)
{
 return alx_read_phy_core(true,dev,, pdata)
}

static int __alx_write_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 data)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return
}

static
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int;

 err  _(hw ALX_MII_DBG_ADDR, reg);
 if (err)
  return err;

 return __alx_read_phy_reg(hw, ALX_MII_DBG_DATA, pdata);
}

static int __alx_write_phy_dbg(struct alx_hw *hw, u16 reg, u16 data)
{
 int err;

 err = __alx_write_phy_reg(hw, ALX_MII_DBG_ADDR, reg);
 if (err)
  return err;

 return __alx_write_phy_reghw ALX_MII_DBG_DATA,pdata;
}

ntalx_read_phy_regstructalx_hwhw u16 reg, u16*hy_data)
{
 nterr

 spin_lock(&w-mdio_lock
 err 
  err _alx_write_phy_reg(hw ALX_MII_DBG_ADDR,reg

 return err;
}

int alx_write_phy_reg(struct alx_hw *hw, u16 reg, u16 phy_data)
{
 int err;

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

 return err;
}

int alx_read_phy_ext(struct alx_hw *hw, u8 dev, u16 reg, u16 *pdata)
{
 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)
{
}

 spin_lock&hw->mdio_lock);
 err= _alx_write_phy_exthw dev, regdata
 spin_unlock(&intalx_read_phy_regstruct alx_hw*hw,u16 reg,u16phy_data)

 return err;
}

static
{
 int err;

 spin_lock(&hw-(&hw-mdio_lock
 
  return err;

 return
}

static int
{
 int err

 spin_lock(&hw->mdio_lock)
erralx_write_phy_dbghw , );
 spin_unlock(&hw-

 return
}

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

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 /* phy in reset */
 if (
 returnALX_DRV_PHY_UNKNOWNjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  spin_unlock(&>mdio_lock
 return errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  (ALX_DRV_PHY_UNKNOWN= val
  return ALX_DRV_PHY_UNKNOWN;

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if ALX_PHY_INITED=phy_val
  return val

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

static alx_wait_reg alx_hw  regu32, *)
{
 u32u16;
 int  (hwALX_PHY_CTRL

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

(
alx_read_phy_regALX_MII_DBG_ADDR)

  ;
}

static;
{
 u32,;

  (  *,u32u32  *)
 mac1

 * addr should be big-endian */  0<; i+java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
put_unalignedcpu_to_be32(),(_be32*( +);
 put_unaligned(cpu_to_be16(mac1), (__be16 *)addr);

 return is_valid_ether_addr(addr);
}

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
 return-EIO;
 alx_write_mem32 mac1=alx_read_mem32hw, ALX_STAD1);
 if (!alx_wait_reg(hw
  return -EIO/* addr should be big-endian */
 if (alx_read_macaddr(hw, addrput_unalignedcpu_to_be32(mac0, (_be32)addr2)
  return;

 /* try to load from flash/eeprom (if present) */
 valreturn is_valid_ether_addraddr);
 }
  if (!alx_wait_reg(hw, ALX_EFLD,
      ALX_EFLD_STAT | ALX_EFLD_START, &val))
   return -EIO;
  alx_write_mem32(hw, ALX_EFLD, val | ALX_EFLD_START);
  if (!alx_wait_reg(hw
  -;
 if(,addr
   !(hwALX_EFLDALX_EFLD_START)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 }

 return val(get_unalignedbe32( +))
 (hw, );

 (alx_hw addr
{
 u32 val;

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 val = be32_to_cpu(get_unaligned  
(hw, )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
val(((be16)
 alx_write_mem32(  update  of*java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

staticvoid(struct hw )
{
 u32 =(, );

/
  =alx_read_mem32 );
 alx_write_mem32(hw, ALX_MISC3,
   alx_write_mem32,ALX_MSIC2);
 alx_write_mem32 ,val2);

 /* 25M clk from chipset may be unstable 1s after de-assert of
 * PERST, driver need re-calibrate before enter Sleep for WoL
 */
 val = alx_read_mem32(hw,   &=~ALX_MISC_ISO_EN
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* restore over current protection def-val,alx_write_mem32(hw, ALX_MISC, val);
 * this val could be reset by MAC-RST
 */
  ALX_SET_FIELD(val, ALX_MISC_PSW_OCP, ALX_MISC_PSW_OCP_DEF);
  /* a 0->1 change will update the internal val of osc */
  val &= ~ALX_MISC_INTNLOSC_OPEN;
  alx_write_mem32(hw, ALX_MISC, val);
  alx_write_mem32(hw, ALX_MISC, val | ALX_MISC_INTNLOSC_OPEN);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  val2java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  val2 &~ALX_MSIC2_CALB_START
  alx_write_mem32(hw, ALX_MSIC2, val2txq=alx_read_mem32(hw,ALX_TXQ0;
  alx_write_mem32 alx_write_mem32(hw ALX_TXQ0, txq ~LX_TXQ0_EN);
 } else {
  val &= ~ALX_MISC_INTNLOSC_OPEN;
  /* disable isolate for rev A devices */
  if (alx_is_rev_a(rev))
   val &= ~ALX_MISC_ISO_EN;

  alx_write_mem32(hw, ALX_MISC, val | ALX_MISC_INTNLOSC_OPEN);
  alx_write_mem32(hw
 }

 udelay> ~ ALX_MAC_CTRL_TX_EN
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

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

 rxq = alx_read_mem32(hw, ALX_RXQ0);
 alx_write_mem32(hw, ALX_RXQ0, rxq &{
u32 val pmctrl
 alx_write_mem32(hw, ALX_TXQ0txq~);

 udelay;

>rx_ctrl( |ALX_MAC_CTRL_TX_EN
 alx_write_mem32(

rev (hw
 (ALX_MAC_STS
 java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  udelay;
 }

 returnval =alx_read_mem32(hw, ALX_MASTER);
}

int alx_reset_mac(struct alx_hw *hw)
{
 u32 val, pmctrl;
 int i, ret;
 u8 rev;
 bool a_cr;

 pmctrl = 0;
 rev = alx_hw_revision(hw)  val|ALX_MASTER_DMA_MAC_RST ALX_MASTER_OOB_DIS);
 a_cr =alx_is_rev_a) &alx_hw_with_cr);

 /* 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
 if (ret)
  return ret;

 /* mac reset workaroud */i   ALX_DMA_MAC_RST_TO +){
alx_write_mem32,ALX_RFD_PIDX1java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 /* dis l0s/l1 before mac reset */,ALX_LPI_CTRLval&ALX_LPI_CTRL_EN)
if) java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
(hw ALX_PMCTRL)
  alx_read_phy_dbg,, phy_val
  alx_write_mem32(w, ALX_PMCTRL,
  phy_val ~ALX_GREENCFG2_GATE_DFSE_ENjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
ifhw->) {
 }

 /* reset whole mac safely */
 val = alx_read_mem32(hw, ALX_MASTER);
 alx_write_mem32(hw, ALX_MASTER,
   val | ALX_MASTER_DMA_MAC_RST | ALX_MASTER_OOB_DIS);

 /* make sure it's real idle */
 udelay(10); /
 for ( =0 i < ALX_DMA_MAC_RST_TO+){
  val = alx_read_mem32(hw, ALX_RFD_PIDX);
  if (val == 0)
   break;
  udelay(10);
 }
 for (; i < ALX_DMA_MAC_RST_TO; i++) {
  val=alx_read_mem32(hw,ALX_MASTER;
  if    &hy_val);
   break;
  udelay(10);
 }
 if (i   /* Turn off Green feature */
 return-IO;
 udelay(10);

      | ALX_GREENCFG2_BP_GREEN
   /
  /* restore l0s / l1 */
  ( & (ALX_PMCTRL_L1_EN ALX_PMCTRL_L0S_EN)
   alx_write_mem32(hw, ALX_PMCTRL,     &hy_val;
}

alx_reset_oscrevjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24


 * Workaround for PCI problem when BIOS sets MMRBC incorrectly. */
  */
 val = alx_read_mem32(hw, ALX_MISC3);
 alx_write_mem32(hw, ALX_MISC3,
 pci_read_config_word> PCI_COMMANDval16
 )
 val = alx_read_mem32 =val16) PCI_COMMAND_INTX_DISABLE
&;
 if
  val/* clear WoL setting/status */
 alx_write_mem32hw,;
(2)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  alx_write_mem32(hw, ALX_UE_SVRT, val);,,val;
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 |      (val & ALX_MASTER_PCLKSEL_SRDS) ==0)
 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  alx_write_mem32hw ALX_MASTER
  udelay(10)  ALX_MASTER_WAKEN_25M)

 /* phy power saving & hib */
 alx_write_phy_dbg(hw, ALX_MIIDBG_LEGCYPS,  if(val& ALX_MASTER_WAKEN_25M) == 0 |
       ( & ALX_MASTER_PCLKSEL_SRDS) ! 0)
     ALX_SYSMODCTRL_IECHOADJ_DEF);
 (hw ALX_MIIEXT_PCS, ALX_MIIEXT_VDRVBIAS,
     ALX_VDRVBIAS_DEF);

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

 /* phy power saving */
 alx_write_phy_dbg(, ALX_MIIDBG_TST10BTCFG, ALX_TST10BTCFG_DEF)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
alx_write_phy_dbgALX_MIIDBG_SRDSYSMODALX_SRDSYSMOD_DEF
 alx_write_phy_dbg((hwALX_RXQ0 ALX_RXQ0_EN
txq  alx_read_mem32(w,ALX_TXQ0;
 alx_read_phy_dbg alx_write_mem32(w ALX_TXQ0 txq  ALX_TXQ0_EN)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 alx_write_phy_dbg(hw, ALX_MIIDBG_GREENCFG2,
     phy_val & ~ALX_GREENCFG2_GATE_DFSE_EN);
 /* rtl8139c, 120m issue */(w-> == DUPLEX_FULL
MIIEXT_ANEG ALX_MIIEXT_NLP78,
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
alx_write_phy_ext,ALX_MIIEXT_ANEG, ALX_MIIEXT_S3DIG10,
     ALX_MIIEXT_S3DIG10_DEF);

 if
 int alx_setup_speed_duplexstruct alx_hw*hw,u32 ethadv, u8 flowctrl
   u16 adv,, ;
     &phy_val ;
  alx_write_phy_ext( err = ;
      phy_val
  /* Turn off Green feature */(hw ALX_MII_DBG_ADDR, 0);
  alx_read_phy_dbg(hw, ALX_MIIDBG_GREENCFG2, &phy_val);
  alx_write_phy_dbg(hw, ALX_MIIDBG_GREENCFG2,
      phy_val | ALX_GREENCFG2_BP_GREEN);
  /* Turn off half Bias */
  alx_read_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL5,
     &phy_val);
  alx_write_phy_ext(hw, ALX_MIIEXT_PCS, ALX_MIIEXT_CLDCTRL5,
      phy_val | ALX_CLDCTRL5_BP_VD_HLFBIAS);
 }

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

#define  = alx_read_mem32hw ALX_DRV

void alx_reset_pcie(struct alx_hw *hw)
{
  (ethadv ADVERTISED_Autoneg) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
u32;
 u16 val16;

 /* Workaround for PCI problem when BIOS sets MMRBC incorrectly. */
 pci_read_config_word(hw->  } else  (flowctrl &ALX_FC_TX{
 if (!(val16 & ALX_PCI_CMD) || (val16 & PCI_COMMAND_INTX_DISABLE)) {
  val16 = (val16 | ALX_PCI_CMD) & ~PCI_COMMAND_INTX_DISABLE;
  pci_write_config_word(hw->pdev, PCI_COMMAND, val16);
 }

 /* clear WoL setting/status */
 val = alx_read_mem32(hw, ALX_WOL0);
 alx_write_mem32(hw, ALX_WOL0, 0);

 val = alx_read_mem32(hw, ALX_PDLL_TRNS1java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
( , & ALX_PDLL_TRNS1_D3PLLOFF_EN

 /* mask some pcie error bits */
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 val     =ADVERTISED_100baseT_Fulljava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
(hw ALX_UE_SVRT)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 val = alx_read_mem32(hw,
 ifu16, , ;
u8 =alx_hw_revision)
   adj_th= ;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     val lenALX_GET_FIELD,);
 alx_read_phy_dbg,ALX_MIIDBG_AGCphy_val
   {
  if ((val & ALX_MASTER_WAKEN_25M) == 0 ||
      (val & ALX_MASTER_PCLKSEL_SRDS) != 0)
   alx_write_mem32(hw, ALX_MASTER,
     (val & ~ALX_MASTER_PCLKSEL_SRDS
   ALX_MASTER_WAKEN_25M;
 }

 /* ASPM setting */len= 0&agc)) |
 alx_enable_aspm,true);

 udelay(10);
}

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

 rxq = alx_read_mem32(hw, ALX_RXQ0);
 alx_write_mem32(hw, ALX_RXQ0, rxq | ALX_RXQ0_EN);
       len ALX_CLDCTRL6_CAB_LEN_SHORT100M |
alx_write_mem32,ALX_TXQ0txq |ALX_TXQ0_ENjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

 mac =ALX_MIIEXT_AFE);
 ifhw,,
mac=ALX_MAC_CTRL_FULLD
 else
  mac
ALX_SET_FIELD, ,
 ifadj_th hw-lnk_patch
      if hw- ==SPEED_100java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 mac |= ALX_MAC_CTRL_TX_EN | ALX_MAC_CTRL_RX_EN;
 hw-> java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
mem32(, ALX_MAC_CTRL,macjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

void alx_cfg_mac_flowcontrolelse 
{
  &);
   (hw, ALX_MIIEXT_ANEG ,
 else
 hw->x_ctrl&~;

 if
  hw->rx_ctrl ifadj_th hw-) {
 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  alx_read_phy_dbghw ALX_MIIDBG_MSE20DB &);
 u8 = alx_hw_revision(hw);

 pmctrl       ALX_MSE20DB_TH_DEF;

 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
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     ALX_PMCTRL_L1_SRDSPLL_EN
      ALX_PMCTRL_L1_BUFSRX_EN |
     ALX_PMCTRL_SADLY_EN |
        = ALX_GET_FIELD(, ALX_DRV_PHY
      ALX_PMCTRL_L0S_EN |
      
   if ( ==ALX_DRV_PHY_UNKNOWN)
      ALX_PMCTRL_TXL1_AFTER_L0S |
      ALX_PMCTRL_RXL1_AFTER_L0S);
 if (alx_is_rev_a
  pmctrl |= returncfg == hw_cfg;

 if (l0s_en
  pmctrl |= (intalx_read_phy_link(structalx_hw *w)
 if (l1_en)
  pmctrl|=(ALX_PMCTRL_L1_EN | ALX_PMCTRL_ASPM_FCEN)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

 alx_write_mem32 ()
}


static
{
 u32 cfg =0;

  (ethadv_cfg  ADVERTISED_Autoneg) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
   |ALX_DRV_PHY_AUTO
  if (ethadv_cfg & ADVERTISED_10baseT_Half  =(hwALX_MII_GIGA_PSSRgiga
  err
  if (ethadv_cfg
  = | ALX_DRV_PHY_DUPLEX
 ifethadv_cfg&ADVERTISED_100baseT_Half)
   cfg |= ALX_DRV_PHY_100;
  if
    switchgiga&ALX_GIGA_PSSR_SPEED) {
   caseALX_GIGA_PSSR_1000MBS
   cfg | hw->link_speed = SPEED_1000;
  if ( break
g | ALX_DRV_PHY_100  ALX_DRV_PHY_DUPLEX;
  if (ethadv_cfg  hw->link_speed  SPEED_100
   cfg  break;
  if  case ALX_GIGA_PSSR_10MBS:
  cfgADVERTISE_PAUSE_ASYM;
 } else {
  switch (ethadv_cfgdefaultjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  case:
  (&pdev-, invalidPHYduplex\, giga
  -EINVAL
 
   cfg
   breakintalx_clear_phy_intr(struct alx_hw*hw)
  case  u16isr
   cfg |= java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   breakjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32ctrl=alx_read_mem32hw ALX_RXQ0
   cfg
   break;
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
 }

 return cfg;
}

int alx_setup_speed_duplex(struct alx_hw *hw, u32 ethadv, u8 flowctrl)
{
 u16 adv, giga, cr;
 u32 val;
 int err = 0;

 alx_write_phy_reg(hw, ALX_MII_DBG_ADDR, 0);
 val = alx_read_mem32(hw, ALX_DRV);
 ALX_SET_FIELD( alx_hw

{
 adv ADVERTISE_CSMA
  adv val16

   (lowctrl ) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 if( &ALX_FC_RX) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 adv ADVERTISED_Pause
   l |=ALX_MASTER_IRQMOD2_EN
     adv |= ADVERTISED_Asym_Pause
   } else       ALX_MASTER_SYSALVTIMER_EN;
    adv |= ADVERTISED_Asym_Pause;
   }
  }
  giga = 0;
  if (alx_hw_giga(hw))
   giga = ethtool_adv_to_mii_ctrl1000_t(ethadv);

  cr = BMCR_RESET | alx_write_mem32(hw, ALX_MASTER val;

  if ( hw-imt >> 1 < ALX_IRQ_MODU_TIMER1_SHIFT);
      alx_write_phy_reg(hw, MII_CTRL1000, giga) ||
      R, cr))
   err /* tpd threshold to trig int */
 } else {
  cr alx_write_mem32(hw,ALX_TINT_TPD_THRSHLDhw-ith_tpd);
  alx_write_mem32hw,ALX_TINT_TIMER hw->);
      ethadv == ADVERTISED_100baseT_Full)
   cr |= BMCR_SPEED100;
  if (ethadv == ADVERTISED_10baseT_Full ||
      ethadv == ADVERTISED_100baseT_Full)
   cr |= BMCR_FULLDPLX

( ,);
  ( >(ALX_MTU_JUMBO_THETH_FCS_LEN+VLAN_HLEN

  (err{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  val |= 
 }

 alx_write_mem32( *

return err;
}


void alx_post_phy_link(struct alx_hw *hw)
{
u16 phy_val, len, agc;
u8 revid = alx_hw_revision(hw);
bool adj_th = revid == ALX_REV_B0;

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

/* 1000BT/AZ, wrong cable length */
 if (hw-
alx_read_phy_ext(w ALX_MIIEXT_PCS ALX_MIIEXT_CLDCTRL6
     & ALX_TXQ0_MODE_ENHANCE|ALX_TXQ0_LSO_8023_EN
  len = ALX_GET_FIELD(phy_val
 (hwALX_MIIDBG_AGCphy_val;
  agc = ALX_GET_FIELD(phy_val, ALX_AGC_2_VGA);

  if ((hw->link_speed == SPEED_1000alx_write_mem32(, ALX_TXQ0val);
  (len ALX_CLDCTRL6_CAB_LEN_SHORT1G ||
         << ALX_HQTPD_Q2_NUMPREF_SHIFT |
       ALX_TXQ_TPD_BURSTPREF_DEF< ALX_HQTPD_Q3_NUMPREF_SHIFT |
       (len > ALX_CLDCTRL6_CAB_LEN_SHORT100M ||
        (len == 0 && agc > ALX_AGC_LONG100M_LIMT)))) {
   alx_write_phy_dbg(hw, ALX_MIIDBG_AZ_ANADECT,
       ALX_AZ_ANADECT_LONG);
   alx_read_phy_ext(w,ALX_MIIEXT_ANEG ALX_MIIEXT_AFE,
      &phy_val);
   alx_write_phy_extALX_HQTPD val);
 
  /* rxq, flow control */
hw,ALX_MIIDBG_AZ_ANADECT,
       ALX_AZ_ANADECT_DEF  = ALX_GET_FIELDval, ALX_SRAM_RXF_LEN < 3
ead_phy_exthwALX_MIIEXT_ANEG,
      ALX_MIIEXT_AFE, &phy_val);
   alx_write_phy_exthw ALX_MIIEXT_ANEGALX_MIIEXT_AFE,
       phy_val &  val ( -ALX_RXQ2_RXF_FLOW_CTRL_RSVD)> ;
  }
  = ALX_MTU_STD_ALGN>> 3;
 /java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
         <ALX_RXQ0_RSS_MODE_SHIFT
  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,
           ALX_MSE20DB_TH_HI);
    alx_write_phy_dbg(hw, ALX_MIIDBG_MSE20DB,
        phy_val);
   }
  }
 } else {
  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);

 if (adj_th & hw-lnk_patch java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  alx_write_phy_dbg(,ALX_MIIDBG_MSE16DB,
       ALX_MSE16DB_DOWN);
   alx_read_phy_dbg(hw, ALX_MIIDBG_MSE20DB, &phy_val);
   ALX_SET_FIELD(phy_val, ALX_MSE20DB_TH,
          ALX_MSE20DB_TH_DEF);
   alx_write_phy_dbg(hw, ALX_MIIDBG_MSE20DB, phy_val);

 }
}

bool alx_phy_configured(struct alx_hw *hw)
{
 u32 cfg, val = alx_read_mem32(hw,ALX_DMA

 cfg ethadv_to_hw_cfg(hw hw-);
 cfg =       ALX_DMA_RREQ_PRI_DATA |
 hw_cfg alx_get_phy_confighw

 if (hw_cfg == ALX_DRV_PHY_UNKNOWN)
  return false;

 return cfg == hw_cfg;
}

intalx_read_phy_link( alx_hwhw
{
 struct pci_dev(hw ALX_DMAval)
 u16 bmsrmulti-tx-q */
 int;

 err alx_read_phy_reghw MII_BMSR&bmsr;
 if (err)
  return err;

 err = alx_read_phy_reg4<ALX_WRR_PRI3_SHIFT
if(err
  return err;

if!bmsr BMSR_LSTATUS{
  hw->link_speed = SPEED_UNKNOWN;
  hw->duplex = DUPLEX_UNKNOWN;
  return 0;
 }

 /* speed/duplex result is saved in PHY Specific Status Register */
 err = alx_read_phy_reg u32reg val
 if (err)
  return err;

 if (!(giga & ALX_GIGA_PSSR_SPD_DPLX_RESOLVED))
  goto wrong_speed;

 switch (giga & ALX_GIGA_PSSR_SPEED) {
caseALX_GIGA_PSSR_1000MBS:
  hw->link_speed PCI_MSIX_ENTRY_VECTOR_CTRL
  break;
 case ALX_GIGA_PSSR_100MBSval mask PCI_MSIX_ENTRY_CTRL_MASKBIT:0
  hw->link_speedalx_write_mem32hw, valjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  break;
  ALX_GIGA_PSSR_10MBS
  hw->link_speed = SPEED_10;
  break;
 default:
  goto wrong_speed;
 }

 hw-     alx_read_phy_reghw MII_PHYSID2, &w->phy_id[1)
 return0

wrong_speed
, giga);
 return -EINVAL;
}

int  * use fixed MMD3 to get mmds.
{
 u16 isr;

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

void alx_read_phy_ext, 3 MDIO_DEVS2,&))
{
 u32 ctrl = alx_read_mem32(hw, ALX_RXQ0);

 ctrl &= ~ALX_RXQ0_RSS_HASH_EN;
alx_write_mem32, ALX_RXQ0ctrl);
}

void alx_configure_basic(struct alx_hw *hw)
{
 u32 val, raw_mtu, max_payload;
 u16 val16;
 u8 chip_rev = alx_hw_revision(hw);

 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 >= ALX_REV_B0)
 alx_write_mem32hw, ALX_IDLE_DECISN_TIMER,
    ALX_IDLE_DECISN_TIMER_DEF);

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

 val = alx_read_mem32(hw, ALX_MASTER);
val|=ALX_MASTER_IRQMOD2_EN |
        ALX_MASTER_IRQMOD1_EN >statsrx_mcast       =alx_read_mem32(hwALX_MIB_RX_MCAST);
        ;
 alx_write_mem32(hw,  >statsrx_ctrl        =alx_read_mem32(hwALX_MIB_RX_CTRL);
 alx_write_mem32(hw, ALX_IRQ_MODU_TIMER,
   (hw->imt >> >statsrx_len_err     +=alx_read_mem32(hw, ALX_MIB_RX_LEN_ERR);
 /* intr re-trig timeout */>.rx_byte_cnt+ alx_read_mem32(, ALX_MIB_RX_BYTE_CNT
 alx_write_mem32hw, ALX_INT_RETRIG, ALX_INT_RETRIG_TO);
 /* tpd threshold to trig int */
 alx_write_mem32(hw, ALX_TINT_TPD_THRSHLD, hw->ith_tpd);
 alx_write_mem32(hw, ALX_TINT_TIMER, hw->imt);

 raw_mtu = ALX_RAW_MTU(hw->mtu);
 alx_write_mem32hw ALX_MTUraw_mtu
 if ( hw-statsrx_sz_64B+ alx_read_mem32(hw, ALX_MIB_RX_SZ_64B)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  hw-> &= ~ALX_MAC_CTRL_FAST_PAUSE;

MBO_TSO_TH)
  val = (raw_mtu hw->statsrx_sz_max+= alx_read_mem32(hw ALX_MIB_RX_SZ_MAX);
 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(hw->pdev) >> 8;
 /*
 * if BIOS had changed the default dma read max length,
 * restore it to default value
 */
 if (max_payload  >statsrx_ov_rrd      =alx_read_mem32(w ALX_MIB_RX_OV_RRD
 pcie_set_readrq>, 2 <ALX_DEV_CTRL_MAXRRS_MIN;

 val = ALX_TXQ_TPD_BURSTPREF_DEF << ALX_TXQ0_TPD_BURSTPREF_SHIFT |
       ALX_TXQ0_MODE_ENHANCE | ALX_TXQ0_LSO_8023_EN |
        hw-statsrx_bc_byte_cnt=alx_read_mem32, ALX_MIB_RX_BCCNT
       ALX_TXQ_TXF_BURST_PREF_DEF << ALX_TXQ0_TXF_BURST_PREF_SHIFT;
 alx_write_mem32( hw->stats.rx_err_addr    += alx_read_mem32hw ALX_MIB_RX_ERRADDR);
 val /* TX stats */
 hw->stats.tx_ok          += alx_read_mem32(hw, ALX_MIB_TX_OK);
       ALX_TXQ_TPD_BURSTPREF_DEF << ALX_HQTPD_Q3_NUMPREF_SHIFT |
       ALX_HQTPD_BURST_EN;
 alx_write_mem32(hw, ALX_HQTPD,  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);

 /* rxq, flow control */
 val = alx_read_mem32(hw,  hw->stats.tx_byte_cnt    += alx_read_mem32(hw, ALX_MIB_TX_BYTE_CNT);
 val = hw->stats.tx_sz_127B     += alx_read_mem32(hw, ALX_MIB_TX_SZ_127B);
  hw->stats.tx_sz_511B     += alx_read_mem32(hw, ALX_MIB_TX_SZ_511B);
  val16 = ALX_MTU_STD_ALGN >> 3;
  val = (valx_sz_1518B    += alx_read_mem32(hw, ALX_MIB_TX_SZ_1518B);
 } else {
  val16 = ALX_MTU_STD_ALGN >> 3;
 hw->stats.tx_multi_col   += alx_read_mem32(hw, ALX_MIB_TX_MULTI_COL);
 }
 alx_write_mem32(hw, ALX_RXQ2,
   val16 << hw->stats.tx_underrun    += alx_read_mem32(hw, ALX_MIB_TX_UNDERRUN);
   val << ALX_RXQ2_RXF_XON_THRESH_SHIFTem32(hw, ALX_MIB_TX_LEN_ERR);
 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 << ALX_RXQ0_IDT_TBL_SIZE_SHIFT
       ALX_RXQ0_RSS_HSTYP_ALL | ALX_RXQ0_RSS_HASH_EN |
       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_mem32(hw, ALX_RXQ0, val);

 val = alx_read_mem32(hw, ALX_DMA);
 val = ALX_DMA_RORDER_MODE_OUT << ALX_DMA_RORDER_MODE_SHIFT |
       ALX_DMA_RREQ_PRI_DATA |
       max_payload << ALX_DMA_RREQ_BLEN_SHIFT |
       ALX_DMA_WDLY_CNT_DEF << ALX_DMA_WDLY_CNT_SHIFT |
       ALX_DMA_RDLY_CNT_DEF << ALX_DMA_RDLY_CNT_SHIFT |
       (hw->dma_chnl - 1) << ALX_DMA_RCHNL_SEL_SHIFT;
 alx_write_mem32(hw, ALX_DMA, val);

 /* default multi-tx-q weights */
 val = ALX_WRR_PRI_RESTRICT_NONE << ALX_WRR_PRI_SHIFT |
       4 << ALX_WRR_PRI0_SHIFT |
       4 << ALX_WRR_PRI1_SHIFT |
       4 << ALX_WRR_PRI2_SHIFT |
       4 << ALX_WRR_PRI3_SHIFT;
 alx_write_mem32(hw, ALX_WRR, val);
}

void alx_mask_msix(struct alx_hw *hw, int index, bool mask)
{
 u32 reg, val;

 reg = ALX_MSIX_ENTRY_BASE + index * PCI_MSIX_ENTRY_SIZE +
  PCI_MSIX_ENTRY_VECTOR_CTRL;

 val = mask ? PCI_MSIX_ENTRY_CTRL_MASKBIT : 0;

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


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

 if (alx_read_phy_reg(hw, MII_PHYSID1, &hw->phy_id[0]) ||
     alx_read_phy_reg(hw, MII_PHYSID2, &hw->phy_id[1]))
  return false;

 /* 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.
 */
 if (alx_read_phy_ext(hw, 3, MDIO_DEVS1, &devs1) ||
     alx_read_phy_ext(hw, 3, MDIO_DEVS2, &devs2))
  return false;
 hw->mdio.mmds = devs1 | devs2 << 16;

 return true;
}

void alx_update_hw_stats(struct alx_hw *hw)
{
 /* RX stats */
 hw->stats.rx_ok          += alx_read_mem32(hw, ALX_MIB_RX_OK);
 hw->stats.rx_bcast       += alx_read_mem32(hw, ALX_MIB_RX_BCAST);
 hw->stats.rx_mcast       += alx_read_mem32(hw, ALX_MIB_RX_MCAST);
 hw->stats.rx_pause       += alx_read_mem32(hw, ALX_MIB_RX_PAUSE);
 hw->stats.rx_ctrl        += alx_read_mem32(hw, ALX_MIB_RX_CTRL);
 hw->stats.rx_fcs_err     += alx_read_mem32(hw, ALX_MIB_RX_FCS_ERR);
 hw->stats.rx_len_err     += alx_read_mem32(hw, ALX_MIB_RX_LEN_ERR);
 hw->stats.rx_byte_cnt    += alx_read_mem32(hw, ALX_MIB_RX_BYTE_CNT);
 hw->stats.rx_runt        += alx_read_mem32(hw, ALX_MIB_RX_RUNT);
 hw->stats.rx_frag        += alx_read_mem32(hw, ALX_MIB_RX_FRAG);
 hw->stats.rx_sz_64B      += alx_read_mem32(hw, 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->stats.rx_sz_1023B    += alx_read_mem32(hw, ALX_MIB_RX_SZ_1023B);
 hw->stats.rx_sz_1518B    += alx_read_mem32(hw, ALX_MIB_RX_SZ_1518B);
 hw->stats.rx_sz_max      += alx_read_mem32(hw, ALX_MIB_RX_SZ_MAX);
 hw->stats.rx_ov_sz       += alx_read_mem32(hw, ALX_MIB_RX_OV_SZ);
 hw->stats.rx_ov_rxf      += alx_read_mem32(hw, ALX_MIB_RX_OV_RXF);
 hw->stats.rx_ov_rrd      += alx_read_mem32(hw, ALX_MIB_RX_OV_RRD);
 hw->stats.rx_align_err   += alx_read_mem32(hw, ALX_MIB_RX_ALIGN_ERR);
 hw->stats.rx_bc_byte_cnt += alx_read_mem32(hw, ALX_MIB_RX_BCCNT);
 hw->stats.rx_mc_byte_cnt += alx_read_mem32(hw, ALX_MIB_RX_MCCNT);
 hw->stats.rx_err_addr    += alx_read_mem32(hw, ALX_MIB_RX_ERRADDR);

 /* TX stats */
 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);
}