Quelle  t3_hw.c   Sprache: C

/*
 * Copyright (c) 2003-2008 Chelsio, Inc. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#include <linux/etherdevice.h>
#include "common.h"
#include "regs.h"
#include "sge_defs.h"
#include "firmware_exports.h"

static void t3_port_intr_clear(struct adapter *adapter, int idx);

/**
 * t3_wait_op_done_val - wait until an operation is completed
 * @adapter: the adapter performing the operation
 * @reg: the register to check for completion
 * @mask: a single-bit field within @reg that indicates completion
 * @polarity: the value of the field when the operation is completed
 * @attempts: number of check iterations
 * @delay: delay in usecs between iterations
 * @valp: where to store the value of the register at completion time
 *
 * Wait until an operation is completed by checking a bit in a register
 * up to @attempts times.  If @valp is not NULL the value of the register
 * at the time it indicated completion is stored there.  Returns 0 if the
 * operation completes and -EAGAIN otherwise.
 */

int t3_wait_op_done_val(struct adapter *adapter, int reg, u32 mask,
   int polarity, int attempts, int delay, u32 *valp)
{
 while (1) {
  u32 val = t3_read_reg(adapter, reg);

  if (!!(val & mask) == polarity) {
   if (valp)
    *valp = val;
   return 0;
  }
  if (--attempts == 0)
   return -EAGAIN;
  if (delay)
   udelay(delay);
 }
}

/**
 * t3_write_regs - write a bunch of registers
 * @adapter: the adapter to program
 * @p: an array of register address/register value pairs
 * @n: the number of address/value pairs
 * @offset: register address offset
 *
 * Takes an array of register address/register value pairs and writes each
 * value to the corresponding register.  Register addresses are adjusted
 * by the supplied offset.
 */
void t3_write_regs(struct adapter *adapter, const struct addr_val_pair *p,
     int n, unsigned int offset)
{
 while (n--) {
  t3_write_reg(adapter, p->reg_addr + offset, p->val);
  p++;
 }
}

/**
 * t3_set_reg_field - set a register field to a value
 * @adapter: the adapter to program
 * @addr: the register address
 * @mask: specifies the portion of the register to modify
 * @val: the new value for the register field
 *
 * Sets a register field specified by the supplied mask to the
 * given value.
 */
void t3_set_reg_field(struct adapter *adapter, unsigned int addr, u32 mask,
        u32 val)
{
 u32 v = t3_read_reg(adapter, addr) & ~mask;

 t3_write_reg(adapter, addr, v | val);
 t3_read_reg(adapter, addr); /* flush */
}

/**
 * t3_read_indirect - read indirectly addressed registers
 * @adap: the adapter
 * @addr_reg: register holding the indirect address
 * @data_reg: register holding the value of the indirect register
 * @vals: where the read register values are stored
 * @start_idx: index of first indirect register to read
 * @nregs: how many indirect registers to read
 *
 * Reads registers that are accessed indirectly through an address/data
 * register pair.
 */
static void t3_read_indirect(struct adapter *adap, unsigned int addr_reg,
        unsigned int data_reg, u32 *vals,
        unsigned int nregs, unsigned int start_idx)
{
 while (nregs--) {
  t3_write_reg(adap, addr_reg, start_idx);
  *vals++ = t3_read_reg(adap, data_reg);
  start_idx++;
 }
}

/**
 * t3_mc7_bd_read - read from MC7 through backdoor accesses
 * @mc7: identifies MC7 to read from
 * @start: index of first 64-bit word to read
 * @n: number of 64-bit words to read
 * @buf: where to store the read result
 *
 * Read n 64-bit words from MC7 starting at word start, using backdoor
 * accesses.
 */
int t3_mc7_bd_read(struct mc7 *mc7, unsigned int start, unsigned int n,
     u64 *buf)
{
 static const int shift[] = { 0, 0, 16, 24 };
 static const int step[] = { 0, 32, 16, 8 };

 unsigned int size64 = mc7->size / 8; /* # of 64-bit words */
 struct adapter *adap = mc7->adapter;

 if (start >= size64 || start + n > size64)
  return -EINVAL;

 start *= (8 << mc7->width);
 while (n--) {
  int i;
  u64 val64 = 0;

  for (i = (1 << mc7->width) - 1; i >= 0; --i) {
   int attempts = 10;
   u32 val;

   t3_write_reg(adap, mc7->offset + A_MC7_BD_ADDR, start);
   t3_write_reg(adap, mc7->offset + A_MC7_BD_OP, 0);
   val = t3_read_reg(adap, mc7->offset + A_MC7_BD_OP);
   while ((val & F_BUSY) && attempts--)
    val = t3_read_reg(adap,
        mc7->offset + A_MC7_BD_OP);
   if (val & F_BUSY)
    return -EIO;

   val = t3_read_reg(adap, mc7->offset + A_MC7_BD_DATA1);
   if (mc7->width == 0) {
    val64 = t3_read_reg(adap,
          mc7->offset +
          A_MC7_BD_DATA0);
    val64 |= (u64) val << 32;
   } else {
    if (mc7->width > 1)
     val >>= shift[mc7->width];
    val64 |= (u64) val << (step[mc7->width] * i);
   }
   start += 8;
  }
  *buf++ = val64;
 }
 return 0;
}

/*
 * Initialize MI1.
 */
static void mi1_init(struct adapter *adap, const struct adapter_info *ai)
{
 u32 clkdiv = adap->params.vpd.cclk / (2 * adap->params.vpd.mdc) - 1;
 u32 val = F_PREEN | V_CLKDIV(clkdiv);

 t3_write_reg(adap, A_MI1_CFG, val);
}

#define MDIO_ATTEMPTS 20

/*
 * MI1 read/write operations for clause 22 PHYs.
 */
static int t3_mi1_read(struct net_device *dev, int phy_addr, int mmd_addr,
         u16 reg_addr)
{
 struct port_info *pi = netdev_priv(dev);
 struct adapter *adapter = pi->adapter;
 int ret;
 u32 addr = V_REGADDR(reg_addr) | V_PHYADDR(phy_addr);

 mutex_lock(&adapter->mdio_lock);
 t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), V_ST(1));
 t3_write_reg(adapter, A_MI1_ADDR, addr);
 t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(2));
 ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0, MDIO_ATTEMPTS, 10);
 if (!ret)
  ret = t3_read_reg(adapter, A_MI1_DATA);
 mutex_unlock(&adapter->mdio_lock);
 return ret;
}

static int t3_mi1_write(struct net_device *dev, int phy_addr, int mmd_addr,
   u16 reg_addr, u16 val)
{
 struct port_info *pi = netdev_priv(dev);
 struct adapter *adapter = pi->adapter;
 int ret;
 u32 addr = V_REGADDR(reg_addr) | V_PHYADDR(phy_addr);

 mutex_lock(&adapter->mdio_lock);
 t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), V_ST(1));
 t3_write_reg(adapter, A_MI1_ADDR, addr);
 t3_write_reg(adapter, A_MI1_DATA, val);
 t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(1));
 ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0, MDIO_ATTEMPTS, 10);
 mutex_unlock(&adapter->mdio_lock);
 return ret;
}

static const struct mdio_ops mi1_mdio_ops = {
 .read = t3_mi1_read,
 .write = t3_mi1_write,
 .mode_support = MDIO_SUPPORTS_C22
};

/*
 * Performs the address cycle for clause 45 PHYs.
 * Must be called with the MDIO_LOCK held.
 */
static int mi1_wr_addr(struct adapter *adapter, int phy_addr, int mmd_addr,
         int reg_addr)
{
 u32 addr = V_REGADDR(mmd_addr) | V_PHYADDR(phy_addr);

 t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), 0);
 t3_write_reg(adapter, A_MI1_ADDR, addr);
 t3_write_reg(adapter, A_MI1_DATA, reg_addr);
 t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(0));
 return t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0,
          MDIO_ATTEMPTS, 10);
}

/*
 * MI1 read/write operations for indirect-addressed PHYs.
 */
static int mi1_ext_read(struct net_device *dev, int phy_addr, int mmd_addr,
   u16 reg_addr)
{
 struct port_info *pi = netdev_priv(dev);
 struct adapter *adapter = pi->adapter;
 int ret;

 mutex_lock(&adapter->mdio_lock);
 ret = mi1_wr_addr(adapter, phy_addr, mmd_addr, reg_addr);
 if (!ret) {
  t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(3));
  ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0,
          MDIO_ATTEMPTS, 10);
  if (!ret)
   ret = t3_read_reg(adapter, A_MI1_DATA);
 }
 mutex_unlock(&adapter->mdio_lock);
 return ret;
}

static int mi1_ext_write(struct net_device *dev, int phy_addr, int mmd_addr,
    u16 reg_addr, u16 val)
{
 struct port_info *pi = netdev_priv(dev);
 struct adapter *adapter = pi->adapter;
 int ret;

 mutex_lock(&adapter->mdio_lock);
 ret = mi1_wr_addr(adapter, phy_addr, mmd_addr, reg_addr);
 if (!ret) {
  t3_write_reg(adapter, A_MI1_DATA, val);
  t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(1));
  ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0,
          MDIO_ATTEMPTS, 10);
 }
 mutex_unlock(&adapter->mdio_lock);
 return ret;
}

static const struct mdio_ops mi1_mdio_ext_ops = {
 .read = mi1_ext_read,
 .write = mi1_ext_write,
 .mode_support = MDIO_SUPPORTS_C45 | MDIO_EMULATE_C22
};

/**
 * t3_mdio_change_bits - modify the value of a PHY register
 * @phy: the PHY to operate on
 * @mmd: the device address
 * @reg: the register address
 * @clear: what part of the register value to mask off
 * @set: what part of the register value to set
 *
 * Changes the value of a PHY register by applying a mask to its current
 * value and ORing the result with a new value.
 */
int t3_mdio_change_bits(struct cphy *phy, int mmd, int reg, unsigned int clear,
   unsigned int set)
{
 int ret;
 unsigned int val;

 ret = t3_mdio_read(phy, mmd, reg, &val);
 if (!ret) {
  val &= ~clear;
  ret = t3_mdio_write(phy, mmd, reg, val | set);
 }
 return ret;
}

/**
 * t3_phy_reset - reset a PHY block
 * @phy: the PHY to operate on
 * @mmd: the device address of the PHY block to reset
 * @wait: how long to wait for the reset to complete in 1ms increments
 *
 * Resets a PHY block and optionally waits for the reset to complete.
 * @mmd should be 0 for 10/100/1000 PHYs and the device address to reset
 * for 10G PHYs.
 */
int t3_phy_reset(struct cphy *phy, int mmd, int wait)
{
 int err;
 unsigned int ctl;

 err = t3_mdio_change_bits(phy, mmd, MDIO_CTRL1, MDIO_CTRL1_LPOWER,
      MDIO_CTRL1_RESET);
 if (err || !wait)
  return err;

 do {
  err = t3_mdio_read(phy, mmd, MDIO_CTRL1, &ctl);
  if (err)
   return err;
  ctl &= MDIO_CTRL1_RESET;
  if (ctl)
   msleep(1);
 } while (ctl && --wait);

 return ctl ? -1 : 0;
}

/**
 * t3_phy_advertise - set the PHY advertisement registers for autoneg
 * @phy: the PHY to operate on
 * @advert: bitmap of capabilities the PHY should advertise
 *
 * Sets a 10/100/1000 PHY's advertisement registers to advertise the
 * requested capabilities.
 */
int t3_phy_advertise(struct cphy *phy, unsigned int advert)
{
 int err;
 unsigned int val = 0;

 err = t3_mdio_read(phy, MDIO_DEVAD_NONE, MII_CTRL1000, &val);
 if (err)
  return err;

 val &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
 if (advert & ADVERTISED_1000baseT_Half)
  val |= ADVERTISE_1000HALF;
 if (advert & ADVERTISED_1000baseT_Full)
  val |= ADVERTISE_1000FULL;

 err = t3_mdio_write(phy, MDIO_DEVAD_NONE, MII_CTRL1000, val);
 if (err)
  return err;

 val = 1;
 if (advert & ADVERTISED_10baseT_Half)
  val |= ADVERTISE_10HALF;
 if (advert & ADVERTISED_10baseT_Full)
  val |= ADVERTISE_10FULL;
 if (advert & ADVERTISED_100baseT_Half)
  val |= ADVERTISE_100HALF;
 if (advert & ADVERTISED_100baseT_Full)
  val |= ADVERTISE_100FULL;
 if (advert & ADVERTISED_Pause)
  val |= ADVERTISE_PAUSE_CAP;
 if (advert & ADVERTISED_Asym_Pause)
  val |= ADVERTISE_PAUSE_ASYM;
 return t3_mdio_write(phy, MDIO_DEVAD_NONE, MII_ADVERTISE, val);
}

/**
 * t3_phy_advertise_fiber - set fiber PHY advertisement register
 * @phy: the PHY to operate on
 * @advert: bitmap of capabilities the PHY should advertise
 *
 * Sets a fiber PHY's advertisement register to advertise the
 * requested capabilities.
 */
int t3_phy_advertise_fiber(struct cphy *phy, unsigned int advert)
{
 unsigned int val = 0;

 if (advert & ADVERTISED_1000baseT_Half)
  val |= ADVERTISE_1000XHALF;
 if (advert & ADVERTISED_1000baseT_Full)
  val |= ADVERTISE_1000XFULL;
 if (advert & ADVERTISED_Pause)
  val |= ADVERTISE_1000XPAUSE;
 if (advert & ADVERTISED_Asym_Pause)
  val |= ADVERTISE_1000XPSE_ASYM;
 return t3_mdio_write(phy, MDIO_DEVAD_NONE, MII_ADVERTISE, val);
}

/**
 * t3_set_phy_speed_duplex - force PHY speed and duplex
 * @phy: the PHY to operate on
 * @speed: requested PHY speed
 * @duplex: requested PHY duplex
 *
 * Force a 10/100/1000 PHY's speed and duplex.  This also disables
 * auto-negotiation except for GigE, where auto-negotiation is mandatory.
 */
int t3_set_phy_speed_duplex(struct cphy *phy, int speed, int duplex)
{
 int err;
 unsigned int ctl;

 err = t3_mdio_read(phy, MDIO_DEVAD_NONE, MII_BMCR, &ctl);
 if (err)
  return err;

 if (speed >= 0) {
  ctl &= ~(BMCR_SPEED100 | BMCR_SPEED1000 | BMCR_ANENABLE);
  if (speed == SPEED_100)
   ctl |= BMCR_SPEED100;
  else if (speed == SPEED_1000)
   ctl |= BMCR_SPEED1000;
 }
 if (duplex >= 0) {
  ctl &= ~(BMCR_FULLDPLX | BMCR_ANENABLE);
  if (duplex == DUPLEX_FULL)
   ctl |= BMCR_FULLDPLX;
 }
 if (ctl & BMCR_SPEED1000) /* auto-negotiation required for GigE */
  ctl |= BMCR_ANENABLE;
 return t3_mdio_write(phy, MDIO_DEVAD_NONE, MII_BMCR, ctl);
}

int t3_phy_lasi_intr_enable(struct cphy *phy)
{
 return t3_mdio_write(phy, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_CTRL,
        MDIO_PMA_LASI_LSALARM);
}

int t3_phy_lasi_intr_disable(struct cphy *phy)
{
 return t3_mdio_write(phy, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_CTRL, 0);
}

int t3_phy_lasi_intr_clear(struct cphy *phy)
{
 u32 val;

 return t3_mdio_read(phy, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_STAT, &val);
}

int t3_phy_lasi_intr_handler(struct cphy *phy)
{
 unsigned int status;
 int err = t3_mdio_read(phy, MDIO_MMD_PMAPMD, MDIO_PMA_LASI_STAT,
          &status);

 if (err)
  return err;
 return (status & MDIO_PMA_LASI_LSALARM) ? cphy_cause_link_change : 0;
}

static const struct adapter_info t3_adap_info[] = {
 {1, 1, 0,
  F_GPIO2_OEN | F_GPIO4_OEN |
  F_GPIO2_OUT_VAL | F_GPIO4_OUT_VAL, { S_GPIO3, S_GPIO5 }, 0,
  &mi1_mdio_ops, "Chelsio PE9000"},
 {1, 1, 0,
  F_GPIO2_OEN | F_GPIO4_OEN |
  F_GPIO2_OUT_VAL | F_GPIO4_OUT_VAL, { S_GPIO3, S_GPIO5 }, 0,
  &mi1_mdio_ops, "Chelsio T302"},
 {1, 0, 0,
  F_GPIO1_OEN | F_GPIO6_OEN | F_GPIO7_OEN | F_GPIO10_OEN |
  F_GPIO11_OEN | F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
  { 0 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
  &mi1_mdio_ext_ops, "Chelsio T310"},
 {1, 1, 0,
  F_GPIO1_OEN | F_GPIO2_OEN | F_GPIO4_OEN | F_GPIO5_OEN | F_GPIO6_OEN |
  F_GPIO7_OEN | F_GPIO10_OEN | F_GPIO11_OEN | F_GPIO1_OUT_VAL |
  F_GPIO5_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
  { S_GPIO9, S_GPIO3 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
  &mi1_mdio_ext_ops, "Chelsio T320"},
 {},
 {},
 {1, 0, 0,
  F_GPIO1_OEN | F_GPIO2_OEN | F_GPIO4_OEN | F_GPIO6_OEN | F_GPIO7_OEN |
  F_GPIO10_OEN | F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
  { S_GPIO9 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
  &mi1_mdio_ext_ops, "Chelsio T310" },
 {1, 0, 0,
  F_GPIO1_OEN | F_GPIO6_OEN | F_GPIO7_OEN |
  F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL,
  { S_GPIO9 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
  &mi1_mdio_ext_ops, "Chelsio N320E-G2" },
};

/*
 * Return the adapter_info structure with a given index.  Out-of-range indices
 * return NULL.
 */
const struct adapter_info *t3_get_adapter_info(unsigned int id)
{
 return id < ARRAY_SIZE(t3_adap_info) ? &t3_adap_info[id] : NULL;
}

struct port_type_info {
 int (*phy_prep)(struct cphy *phy, struct adapter *adapter,
   int phy_addr, const struct mdio_ops *ops);
};

static const struct port_type_info port_types[] = {
 { NULL },
 { t3_ael1002_phy_prep },
 { t3_vsc8211_phy_prep },
 { NULL},
 { t3_xaui_direct_phy_prep },
 { t3_ael2005_phy_prep },
 { t3_qt2045_phy_prep },
 { t3_ael1006_phy_prep },
 { NULL },
 { t3_aq100x_phy_prep },
 { t3_ael2020_phy_prep },
};

#define VPD_ENTRY(name, len) \
 u8 name##_kword[2]; u8 name##_len; u8 name##_data[len]

/*
 * Partial EEPROM Vital Product Data structure.  Includes only the ID and
 * VPD-R sections.
 */
struct t3_vpd {
 u8 id_tag;
 u8 id_len[2];
 u8 id_data[16];
 u8 vpdr_tag;
 u8 vpdr_len[2];
 VPD_ENTRY(pn, 16); /* part number */
 VPD_ENTRY(ec, 16); /* EC level */
 VPD_ENTRY(sn, SERNUM_LEN); /* serial number */
 VPD_ENTRY(na, 12); /* MAC address base */
 VPD_ENTRY(cclk, 6); /* core clock */
 VPD_ENTRY(mclk, 6); /* mem clock */
 VPD_ENTRY(uclk, 6); /* uP clk */
 VPD_ENTRY(mdc, 6); /* MDIO clk */
 VPD_ENTRY(mt, 2); /* mem timing */
 VPD_ENTRY(xaui0cfg, 6); /* XAUI0 config */
 VPD_ENTRY(xaui1cfg, 6); /* XAUI1 config */
 VPD_ENTRY(port0, 2); /* PHY0 complex */
 VPD_ENTRY(port1, 2); /* PHY1 complex */
 VPD_ENTRY(port2, 2); /* PHY2 complex */
 VPD_ENTRY(port3, 2); /* PHY3 complex */
 VPD_ENTRY(rv, 1); /* csum */
 u32 pad;  /* for multiple-of-4 sizing and alignment */
};

#define EEPROM_STAT_ADDR  0x4000
#define VPD_BASE          0xc00

/**
 * t3_seeprom_wp - enable/disable EEPROM write protection
 * @adapter: the adapter
 * @enable: 1 to enable write protection, 0 to disable it
 *
 * Enables or disables write protection on the serial EEPROM.
 */
int t3_seeprom_wp(struct adapter *adapter, int enable)
{
 u32 data = enable ? 0xc : 0;
 int ret;

 /* EEPROM_STAT_ADDR is outside VPD area, use pci_write_vpd_any() */
 ret = pci_write_vpd_any(adapter->pdev, EEPROM_STAT_ADDR, sizeof(u32),
    &data);

 return ret < 0 ? ret : 0;
}

static int vpdstrtouint(char *s, u8 len, unsigned int base, unsigned int *val)
{
 char tok[256];

 memcpy(tok, s, len);
 tok[len] = 0;
 return kstrtouint(strim(tok), base, val);
}

static int vpdstrtou16(char *s, u8 len, unsigned int base, u16 *val)
{
 char tok[256];

 memcpy(tok, s, len);
 tok[len] = 0;
 return kstrtou16(strim(tok), base, val);
}

/**
 * get_vpd_params - read VPD parameters from VPD EEPROM
 * @adapter: adapter to read
 * @p: where to store the parameters
 *
 * Reads card parameters stored in VPD EEPROM.
 */
static int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
{
 struct t3_vpd vpd;
 u8 base_val = 0;
 int addr, ret;

 /*
 * Card information is normally at VPD_BASE but some early cards had
 * it at 0.
 */
 ret = pci_read_vpd(adapter->pdev, VPD_BASE, 1, &base_val);
 if (ret < 0)
  return ret;
 addr = base_val == PCI_VPD_LRDT_ID_STRING ? VPD_BASE : 0;

 ret = pci_read_vpd(adapter->pdev, addr, sizeof(vpd), &vpd);
 if (ret < 0)
  return ret;

 ret = vpdstrtouint(vpd.cclk_data, vpd.cclk_len, 10, &p->cclk);
 if (ret)
  return ret;
 ret = vpdstrtouint(vpd.mclk_data, vpd.mclk_len, 10, &p->mclk);
 if (ret)
  return ret;
 ret = vpdstrtouint(vpd.uclk_data, vpd.uclk_len, 10, &p->uclk);
 if (ret)
  return ret;
 ret = vpdstrtouint(vpd.mdc_data, vpd.mdc_len, 10, &p->mdc);
 if (ret)
  return ret;
 ret = vpdstrtouint(vpd.mt_data, vpd.mt_len, 10, &p->mem_timing);
 if (ret)
  return ret;
 memcpy(p->sn, vpd.sn_data, SERNUM_LEN);

 /* Old eeproms didn't have port information */
 if (adapter->params.rev == 0 && !vpd.port0_data[0]) {
  p->port_type[0] = uses_xaui(adapter) ? 1 : 2;
  p->port_type[1] = uses_xaui(adapter) ? 6 : 2;
 } else {
  p->port_type[0] = hex_to_bin(vpd.port0_data[0]);
  p->port_type[1] = hex_to_bin(vpd.port1_data[0]);
  ret = vpdstrtou16(vpd.xaui0cfg_data, vpd.xaui0cfg_len, 16,
      &p->xauicfg[0]);
  if (ret)
   return ret;
  ret = vpdstrtou16(vpd.xaui1cfg_data, vpd.xaui1cfg_len, 16,
      &p->xauicfg[1]);
  if (ret)
   return ret;
 }

 ret = hex2bin(p->eth_base, vpd.na_data, 6);
 if (ret < 0)
  return -EINVAL;
 return 0;
}

/* serial flash and firmware constants */
enum {
 SF_ATTEMPTS = 5, /* max retries for SF1 operations */
 SF_SEC_SIZE = 64 * 1024, /* serial flash sector size */
 SF_SIZE = SF_SEC_SIZE * 8, /* serial flash size */

 /* flash command opcodes */
 SF_PROG_PAGE = 2, /* program page */
 SF_WR_DISABLE = 4, /* disable writes */
 SF_RD_STATUS = 5, /* read status register */
 SF_WR_ENABLE = 6, /* enable writes */
 SF_RD_DATA_FAST = 0xb, /* read flash */
 SF_ERASE_SECTOR = 0xd8, /* erase sector */

 FW_FLASH_BOOT_ADDR = 0x70000, /* start address of FW in flash */
 FW_VERS_ADDR = 0x7fffc,    /* flash address holding FW version */
 FW_MIN_SIZE = 8            /* at least version and csum */
};

/**
 * sf1_read - read data from the serial flash
 * @adapter: the adapter
 * @byte_cnt: number of bytes to read
 * @cont: whether another operation will be chained
 * @valp: where to store the read data
 *
 * Reads up to 4 bytes of data from the serial flash.  The location of
 * the read needs to be specified prior to calling this by issuing the
 * appropriate commands to the serial flash.
 */
static int sf1_read(struct adapter *adapter, unsigned int byte_cnt, int cont,
      u32 *valp)
{
 int ret;

 if (!byte_cnt || byte_cnt > 4)
  return -EINVAL;
 if (t3_read_reg(adapter, A_SF_OP) & F_BUSY)
  return -EBUSY;
 t3_write_reg(adapter, A_SF_OP, V_CONT(cont) | V_BYTECNT(byte_cnt - 1));
 ret = t3_wait_op_done(adapter, A_SF_OP, F_BUSY, 0, SF_ATTEMPTS, 10);
 if (!ret)
  *valp = t3_read_reg(adapter, A_SF_DATA);
 return ret;
}

/**
 * sf1_write - write data to the serial flash
 * @adapter: the adapter
 * @byte_cnt: number of bytes to write
 * @cont: whether another operation will be chained
 * @val: value to write
 *
 * Writes up to 4 bytes of data to the serial flash.  The location of
 * the write needs to be specified prior to calling this by issuing the
 * appropriate commands to the serial flash.
 */
static int sf1_write(struct adapter *adapter, unsigned int byte_cnt, int cont,
       u32 val)
{
 if (!byte_cnt || byte_cnt > 4)
  return -EINVAL;
 if (t3_read_reg(adapter, A_SF_OP) & F_BUSY)
  return -EBUSY;
 t3_write_reg(adapter, A_SF_DATA, val);
 t3_write_reg(adapter, A_SF_OP,
       V_CONT(cont) | V_BYTECNT(byte_cnt - 1) | V_OP(1));
 return t3_wait_op_done(adapter, A_SF_OP, F_BUSY, 0, SF_ATTEMPTS, 10);
}

/**
 * flash_wait_op - wait for a flash operation to complete
 * @adapter: the adapter
 * @attempts: max number of polls of the status register
 * @delay: delay between polls in ms
 *
 * Wait for a flash operation to complete by polling the status register.
 */
static int flash_wait_op(struct adapter *adapter, int attempts, int delay)
{
 int ret;
 u32 status;

 while (1) {
  if ((ret = sf1_write(adapter, 1, 1, SF_RD_STATUS)) != 0 ||
      (ret = sf1_read(adapter, 1, 0, &status)) != 0)
   return ret;
  if (!(status & 1))
   return 0;
  if (--attempts == 0)
   return -EAGAIN;
  if (delay)
   msleep(delay);
 }
}

/**
 * t3_read_flash - read words from serial flash
 * @adapter: the adapter
 * @addr: the start address for the read
 * @nwords: how many 32-bit words to read
 * @data: where to store the read data
 * @byte_oriented: whether to store data as bytes or as words
 *
 * Read the specified number of 32-bit words from the serial flash.
 * If @byte_oriented is set the read data is stored as a byte array
 * (i.e., big-endian), otherwise as 32-bit words in the platform's
 * natural endianness.
 */
static int t3_read_flash(struct adapter *adapter, unsigned int addr,
    unsigned int nwords, u32 *data, int byte_oriented)
{
 int ret;

 if (addr + nwords * sizeof(u32) > SF_SIZE || (addr & 3))
  return -EINVAL;

 addr = swab32(addr) | SF_RD_DATA_FAST;

 if ((ret = sf1_write(adapter, 4, 1, addr)) != 0 ||
     (ret = sf1_read(adapter, 1, 1, data)) != 0)
  return ret;

 for (; nwords; nwords--, data++) {
  ret = sf1_read(adapter, 4, nwords > 1, data);
  if (ret)
   return ret;
  if (byte_oriented)
   *data = htonl(*data);
 }
 return 0;
}

/**
 * t3_write_flash - write up to a page of data to the serial flash
 * @adapter: the adapter
 * @addr: the start address to write
 * @n: length of data to write
 * @data: the data to write
 *
 * Writes up to a page of data (256 bytes) to the serial flash starting
 * at the given address.
 */
static int t3_write_flash(struct adapter *adapter, unsigned int addr,
     unsigned int n, const u8 *data)
{
 int ret;
 u32 buf[64];
 unsigned int i, c, left, val, offset = addr & 0xff;

 if (addr + n > SF_SIZE || offset + n > 256)
  return -EINVAL;

 val = swab32(addr) | SF_PROG_PAGE;

 if ((ret = sf1_write(adapter, 1, 0, SF_WR_ENABLE)) != 0 ||
     (ret = sf1_write(adapter, 4, 1, val)) != 0)
  return ret;

 for (left = n; left; left -= c) {
  c = min(left, 4U);
  for (val = 0, i = 0; i < c; ++i)
   val = (val << 8) + *data++;

  ret = sf1_write(adapter, c, c != left, val);
  if (ret)
   return ret;
 }
 if ((ret = flash_wait_op(adapter, 5, 1)) != 0)
  return ret;

 /* Read the page to verify the write succeeded */
 ret = t3_read_flash(adapter, addr & ~0xff, ARRAY_SIZE(buf), buf, 1);
 if (ret)
  return ret;

 if (memcmp(data - n, (u8 *) buf + offset, n))
  return -EIO;
 return 0;
}

/**
 * t3_get_tp_version - read the tp sram version
 * @adapter: the adapter
 * @vers: where to place the version
 *
 * Reads the protocol sram version from sram.
 */
int t3_get_tp_version(struct adapter *adapter, u32 *vers)
{
 int ret;

 /* Get version loaded in SRAM */
 t3_write_reg(adapter, A_TP_EMBED_OP_FIELD0, 0);
 ret = t3_wait_op_done(adapter, A_TP_EMBED_OP_FIELD0,
         1, 1, 5, 1);
 if (ret)
  return ret;

 *vers = t3_read_reg(adapter, A_TP_EMBED_OP_FIELD1);

 return 0;
}

/**
 * t3_check_tpsram_version - read the tp sram version
 * @adapter: the adapter
 *
 * Reads the protocol sram version from flash.
 */
int t3_check_tpsram_version(struct adapter *adapter)
{
 int ret;
 u32 vers;
 unsigned int major, minor;

 if (adapter->params.rev == T3_REV_A)
  return 0;


 ret = t3_get_tp_version(adapter, &vers);
 if (ret)
  return ret;

 major = G_TP_VERSION_MAJOR(vers);
 minor = G_TP_VERSION_MINOR(vers);

 if (major == TP_VERSION_MAJOR && minor == TP_VERSION_MINOR)
  return 0;
 else {
  CH_ERR(adapter, "found wrong TP version (%u.%u), "
         "driver compiled for version %d.%d\n", major, minor,
         TP_VERSION_MAJOR, TP_VERSION_MINOR);
 }
 return -EINVAL;
}

/**
 * t3_check_tpsram - check if provided protocol SRAM
 *   is compatible with this driver
 * @adapter: the adapter
 * @tp_sram: the firmware image to write
 * @size: image size
 *
 * Checks if an adapter's tp sram is compatible with the driver.
 * Returns 0 if the versions are compatible, a negative error otherwise.
 */
int t3_check_tpsram(struct adapter *adapter, const u8 *tp_sram,
      unsigned int size)
{
 u32 csum;
 unsigned int i;
 const __be32 *p = (const __be32 *)tp_sram;

 /* Verify checksum */
 for (csum = 0, i = 0; i < size / sizeof(csum); i++)
  csum += ntohl(p[i]);
 if (csum != 0xffffffff) {
  CH_ERR(adapter, "corrupted protocol SRAM image, checksum %u\n",
         csum);
  return -EINVAL;
 }

 return 0;
}

enum fw_version_type {
 FW_VERSION_N3,
 FW_VERSION_T3
};

/**
 * t3_get_fw_version - read the firmware version
 * @adapter: the adapter
 * @vers: where to place the version
 *
 * Reads the FW version from flash.
 */
int t3_get_fw_version(struct adapter *adapter, u32 *vers)
{
 return t3_read_flash(adapter, FW_VERS_ADDR, 1, vers, 0);
}

/**
 * t3_check_fw_version - check if the FW is compatible with this driver
 * @adapter: the adapter
 *
 * Checks if an adapter's FW is compatible with the driver.  Returns 0
 * if the versions are compatible, a negative error otherwise.
 */
int t3_check_fw_version(struct adapter *adapter)
{
 int ret;
 u32 vers;
 unsigned int type, major, minor;

 ret = t3_get_fw_version(adapter, &vers);
 if (ret)
  return ret;

 type = G_FW_VERSION_TYPE(vers);
 major = G_FW_VERSION_MAJOR(vers);
 minor = G_FW_VERSION_MINOR(vers);

 if (type == FW_VERSION_T3 && major == FW_VERSION_MAJOR &&
     minor == FW_VERSION_MINOR)
  return 0;
 else if (major != FW_VERSION_MAJOR || minor < FW_VERSION_MINOR)
  CH_WARN(adapter, "found old FW minor version(%u.%u), "
          "driver compiled for version %u.%u\n", major, minor,
   FW_VERSION_MAJOR, FW_VERSION_MINOR);
 else {
  CH_WARN(adapter, "found newer FW version(%u.%u), "
          "driver compiled for version %u.%u\n", major, minor,
   FW_VERSION_MAJOR, FW_VERSION_MINOR);
  return 0;
 }
 return -EINVAL;
}

/**
 * t3_flash_erase_sectors - erase a range of flash sectors
 * @adapter: the adapter
 * @start: the first sector to erase
 * @end: the last sector to erase
 *
 * Erases the sectors in the given range.
 */
static int t3_flash_erase_sectors(struct adapter *adapter, int start, int end)
{
 while (start <= end) {
  int ret;

  if ((ret = sf1_write(adapter, 1, 0, SF_WR_ENABLE)) != 0 ||
      (ret = sf1_write(adapter, 4, 0,
         SF_ERASE_SECTOR | (start << 8))) != 0 ||
      (ret = flash_wait_op(adapter, 5, 500)) != 0)
   return ret;
  start++;
 }
 return 0;
}

/**
 * t3_load_fw - download firmware
 * @adapter: the adapter
 * @fw_data: the firmware image to write
 * @size: image size
 *
 * Write the supplied firmware image to the card's serial flash.
 * The FW image has the following sections: @size - 8 bytes of code and
 * data, followed by 4 bytes of FW version, followed by the 32-bit
 * 1's complement checksum of the whole image.
 */
int t3_load_fw(struct adapter *adapter, const u8 *fw_data, unsigned int size)
{
 u32 csum;
 unsigned int i;
 const __be32 *p = (const __be32 *)fw_data;
 int ret, addr, fw_sector = FW_FLASH_BOOT_ADDR >> 16;

 if ((size & 3) || size < FW_MIN_SIZE)
  return -EINVAL;
 if (size > FW_VERS_ADDR + 8 - FW_FLASH_BOOT_ADDR)
  return -EFBIG;

 for (csum = 0, i = 0; i < size / sizeof(csum); i++)
  csum += ntohl(p[i]);
 if (csum != 0xffffffff) {
  CH_ERR(adapter, "corrupted firmware image, checksum %u\n",
         csum);
  return -EINVAL;
 }

 ret = t3_flash_erase_sectors(adapter, fw_sector, fw_sector);
 if (ret)
  goto out;

 size -= 8;  /* trim off version and checksum */
 for (addr = FW_FLASH_BOOT_ADDR; size;) {
  unsigned int chunk_size = min(size, 256U);

  ret = t3_write_flash(adapter, addr, chunk_size, fw_data);
  if (ret)
   goto out;

  addr += chunk_size;
  fw_data += chunk_size;
  size -= chunk_size;
 }

 ret = t3_write_flash(adapter, FW_VERS_ADDR, 4, fw_data);
out:
 if (ret)
  CH_ERR(adapter, "firmware download failed, error %d\n", ret);
 return ret;
}

#define CIM_CTL_BASE 0x2000

/**
 *      t3_cim_ctl_blk_read - read a block from CIM control region
 *
 *      @adap: the adapter
 *      @addr: the start address within the CIM control region
 *      @n: number of words to read
 *      @valp: where to store the result
 *
 *      Reads a block of 4-byte words from the CIM control region.
 */
int t3_cim_ctl_blk_read(struct adapter *adap, unsigned int addr,
   unsigned int n, unsigned int *valp)
{
 int ret = 0;

 if (t3_read_reg(adap, A_CIM_HOST_ACC_CTRL) & F_HOSTBUSY)
  return -EBUSY;

 for ( ; !ret && n--; addr += 4) {
  t3_write_reg(adap, A_CIM_HOST_ACC_CTRL, CIM_CTL_BASE + addr);
  ret = t3_wait_op_done(adap, A_CIM_HOST_ACC_CTRL, F_HOSTBUSY,
          0, 5, 2);
  if (!ret)
   *valp++ = t3_read_reg(adap, A_CIM_HOST_ACC_DATA);
 }
 return ret;
}

static void t3_gate_rx_traffic(struct cmac *mac, u32 *rx_cfg,
          u32 *rx_hash_high, u32 *rx_hash_low)
{
 /* stop Rx unicast traffic */
 t3_mac_disable_exact_filters(mac);

 /* stop broadcast, multicast, promiscuous mode traffic */
 *rx_cfg = t3_read_reg(mac->adapter, A_XGM_RX_CFG);
 t3_set_reg_field(mac->adapter, A_XGM_RX_CFG,
    F_ENHASHMCAST | F_DISBCAST | F_COPYALLFRAMES,
    F_DISBCAST);

 *rx_hash_high = t3_read_reg(mac->adapter, A_XGM_RX_HASH_HIGH);
 t3_write_reg(mac->adapter, A_XGM_RX_HASH_HIGH, 0);

 *rx_hash_low = t3_read_reg(mac->adapter, A_XGM_RX_HASH_LOW);
 t3_write_reg(mac->adapter, A_XGM_RX_HASH_LOW, 0);

 /* Leave time to drain max RX fifo */
 msleep(1);
}

static void t3_open_rx_traffic(struct cmac *mac, u32 rx_cfg,
          u32 rx_hash_high, u32 rx_hash_low)
{
 t3_mac_enable_exact_filters(mac);
 t3_set_reg_field(mac->adapter, A_XGM_RX_CFG,
    F_ENHASHMCAST | F_DISBCAST | F_COPYALLFRAMES,
    rx_cfg);
 t3_write_reg(mac->adapter, A_XGM_RX_HASH_HIGH, rx_hash_high);
 t3_write_reg(mac->adapter, A_XGM_RX_HASH_LOW, rx_hash_low);
}

/**
 * t3_link_changed - handle interface link changes
 * @adapter: the adapter
 * @port_id: the port index that changed link state
 *
 * Called when a port's link settings change to propagate the new values
 * to the associated PHY and MAC.  After performing the common tasks it
 * invokes an OS-specific handler.
 */
void t3_link_changed(struct adapter *adapter, int port_id)
{
 int link_ok, speed, duplex, fc;
 struct port_info *pi = adap2pinfo(adapter, port_id);
 struct cphy *phy = &pi->phy;
 struct cmac *mac = &pi->mac;
 struct link_config *lc = &pi->link_config;

 phy->ops->get_link_status(phy, &link_ok, &speed, &duplex, &fc);

 if (!lc->link_ok && link_ok) {
  u32 rx_cfg, rx_hash_high, rx_hash_low;
  u32 status;

  t3_xgm_intr_enable(adapter, port_id);
  t3_gate_rx_traffic(mac, &rx_cfg, &rx_hash_high, &rx_hash_low);
  t3_write_reg(adapter, A_XGM_RX_CTRL + mac->offset, 0);
  t3_mac_enable(mac, MAC_DIRECTION_RX);

  status = t3_read_reg(adapter, A_XGM_INT_STATUS + mac->offset);
  if (status & F_LINKFAULTCHANGE) {
   mac->stats.link_faults++;
   pi->link_fault = 1;
  }
  t3_open_rx_traffic(mac, rx_cfg, rx_hash_high, rx_hash_low);
 }

 if (lc->requested_fc & PAUSE_AUTONEG)
  fc &= lc->requested_fc;
 else
  fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);

 if (link_ok == lc->link_ok && speed == lc->speed &&
     duplex == lc->duplex && fc == lc->fc)
  return;                            /* nothing changed */

 if (link_ok != lc->link_ok && adapter->params.rev > 0 &&
     uses_xaui(adapter)) {
  if (link_ok)
   t3b_pcs_reset(mac);
  t3_write_reg(adapter, A_XGM_XAUI_ACT_CTRL + mac->offset,
        link_ok ? F_TXACTENABLE | F_RXEN : 0);
 }
 lc->link_ok = link_ok;
 lc->speed = speed < 0 ? SPEED_INVALID : speed;
 lc->duplex = duplex < 0 ? DUPLEX_INVALID : duplex;

 if (link_ok && speed >= 0 && lc->autoneg == AUTONEG_ENABLE) {
  /* Set MAC speed, duplex, and flow control to match PHY. */
  t3_mac_set_speed_duplex_fc(mac, speed, duplex, fc);
  lc->fc = fc;
 }

 t3_os_link_changed(adapter, port_id, link_ok && !pi->link_fault,
      speed, duplex, fc);
}

void t3_link_fault(struct adapter *adapter, int port_id)
{
 struct port_info *pi = adap2pinfo(adapter, port_id);
 struct cmac *mac = &pi->mac;
 struct cphy *phy = &pi->phy;
 struct link_config *lc = &pi->link_config;
 int link_ok, speed, duplex, fc, link_fault;
 u32 rx_cfg, rx_hash_high, rx_hash_low;

 t3_gate_rx_traffic(mac, &rx_cfg, &rx_hash_high, &rx_hash_low);

 if (adapter->params.rev > 0 && uses_xaui(adapter))
  t3_write_reg(adapter, A_XGM_XAUI_ACT_CTRL + mac->offset, 0);

 t3_write_reg(adapter, A_XGM_RX_CTRL + mac->offset, 0);
 t3_mac_enable(mac, MAC_DIRECTION_RX);

 t3_open_rx_traffic(mac, rx_cfg, rx_hash_high, rx_hash_low);

 link_fault = t3_read_reg(adapter,
     A_XGM_INT_STATUS + mac->offset);
 link_fault &= F_LINKFAULTCHANGE;

 link_ok = lc->link_ok;
 speed = lc->speed;
 duplex = lc->duplex;
 fc = lc->fc;

 phy->ops->get_link_status(phy, &link_ok, &speed, &duplex, &fc);

 if (link_fault) {
  lc->link_ok = 0;
  lc->speed = SPEED_INVALID;
  lc->duplex = DUPLEX_INVALID;

  t3_os_link_fault(adapter, port_id, 0);

  /* Account link faults only when the phy reports a link up */
  if (link_ok)
   mac->stats.link_faults++;
 } else {
  if (link_ok)
   t3_write_reg(adapter, A_XGM_XAUI_ACT_CTRL + mac->offset,
         F_TXACTENABLE | F_RXEN);

  pi->link_fault = 0;
  lc->link_ok = (unsigned char)link_ok;
  lc->speed = speed < 0 ? SPEED_INVALID : speed;
  lc->duplex = duplex < 0 ? DUPLEX_INVALID : duplex;
  t3_os_link_fault(adapter, port_id, link_ok);
 }
}

/**
 * t3_link_start - apply link configuration to MAC/PHY
 * @phy: the PHY to setup
 * @mac: the MAC to setup
 * @lc: the requested link configuration
 *
 * Set up a port's MAC and PHY according to a desired link configuration.
 * - If the PHY can auto-negotiate first decide what to advertise, then
 *   enable/disable auto-negotiation as desired, and reset.
 * - If the PHY does not auto-negotiate just reset it.
 * - If auto-negotiation is off set the MAC to the proper speed/duplex/FC,
 *   otherwise do it later based on the outcome of auto-negotiation.
 */
int t3_link_start(struct cphy *phy, struct cmac *mac, struct link_config *lc)
{
 unsigned int fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);

 lc->link_ok = 0;
 if (lc->supported & SUPPORTED_Autoneg) {
  lc->advertising &= ~(ADVERTISED_Asym_Pause | ADVERTISED_Pause);
  if (fc) {
   lc->advertising |= ADVERTISED_Asym_Pause;
   if (fc & PAUSE_RX)
    lc->advertising |= ADVERTISED_Pause;
  }
  phy->ops->advertise(phy, lc->advertising);

  if (lc->autoneg == AUTONEG_DISABLE) {
   lc->speed = lc->requested_speed;
   lc->duplex = lc->requested_duplex;
   lc->fc = (unsigned char)fc;
   t3_mac_set_speed_duplex_fc(mac, lc->speed, lc->duplex,
         fc);
   /* Also disables autoneg */
   phy->ops->set_speed_duplex(phy, lc->speed, lc->duplex);
  } else
   phy->ops->autoneg_enable(phy);
 } else {
  t3_mac_set_speed_duplex_fc(mac, -1, -1, fc);
  lc->fc = (unsigned char)fc;
  phy->ops->reset(phy, 0);
 }
 return 0;
}

/**
 * t3_set_vlan_accel - control HW VLAN extraction
 * @adapter: the adapter
 * @ports: bitmap of adapter ports to operate on
 * @on: enable (1) or disable (0) HW VLAN extraction
 *
 * Enables or disables HW extraction of VLAN tags for the given port.
 */
void t3_set_vlan_accel(struct adapter *adapter, unsigned int ports, int on)
{
 t3_set_reg_field(adapter, A_TP_OUT_CONFIG,
    ports << S_VLANEXTRACTIONENABLE,
    on ? (ports << S_VLANEXTRACTIONENABLE) : 0);
}

struct intr_info {
 unsigned int mask; /* bits to check in interrupt status */
 const char *msg; /* message to print or NULL */
 short stat_idx;  /* stat counter to increment or -1 */
 unsigned short fatal; /* whether the condition reported is fatal */
};

/**
 * t3_handle_intr_status - table driven interrupt handler
 * @adapter: the adapter that generated the interrupt
 * @reg: the interrupt status register to process
 * @mask: a mask to apply to the interrupt status
 * @acts: table of interrupt actions
 * @stats: statistics counters tracking interrupt occurrences
 *
 * A table driven interrupt handler that applies a set of masks to an
 * interrupt status word and performs the corresponding actions if the
 * interrupts described by the mask have occurred.  The actions include
 * optionally printing a warning or alert message, and optionally
 * incrementing a stat counter.  The table is terminated by an entry
 * specifying mask 0.  Returns the number of fatal interrupt conditions.
 */
static int t3_handle_intr_status(struct adapter *adapter, unsigned int reg,
     unsigned int mask,
     const struct intr_info *acts,
     unsigned long *stats)
{
 int fatal = 0;
 unsigned int status = t3_read_reg(adapter, reg) & mask;

 for (; acts->mask; ++acts) {
  if (!(status & acts->mask))
   continue;
  if (acts->fatal) {
   fatal++;
   CH_ALERT(adapter, "%s (0x%x)\n",
     acts->msg, status & acts->mask);
   status &= ~acts->mask;
  } else if (acts->msg)
   CH_WARN(adapter, "%s (0x%x)\n",
    acts->msg, status & acts->mask);
  if (acts->stat_idx >= 0)
   stats[acts->stat_idx]++;
 }
 if (status)  /* clear processed interrupts */
  t3_write_reg(adapter, reg, status);
 return fatal;
}

#define SGE_INTR_MASK (F_RSPQDISABLED | \
         F_UC_REQ_FRAMINGERROR | F_R_REQ_FRAMINGERROR | \
         F_CPPARITYERROR | F_OCPARITYERROR | F_RCPARITYERROR | \
         F_IRPARITYERROR | V_ITPARITYERROR(M_ITPARITYERROR) | \
         V_FLPARITYERROR(M_FLPARITYERROR) | F_LODRBPARITYERROR | \
         F_HIDRBPARITYERROR | F_LORCQPARITYERROR | \
         F_HIRCQPARITYERROR | F_LOPRIORITYDBFULL | \
         F_HIPRIORITYDBFULL | F_LOPRIORITYDBEMPTY | \
         F_HIPRIORITYDBEMPTY | F_HIPIODRBDROPERR | \
         F_LOPIODRBDROPERR)
#define MC5_INTR_MASK (F_PARITYERR | F_ACTRGNFULL | F_UNKNOWNCMD | \
         F_REQQPARERR | F_DISPQPARERR | F_DELACTEMPTY | \
         F_NFASRCHFAIL)
#define MC7_INTR_MASK (F_AE | F_UE | F_CE | V_PE(M_PE))
#define XGM_INTR_MASK (V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR) | \
         V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR) | \
         F_TXFIFO_UNDERRUN)
#define PCIX_INTR_MASK (F_MSTDETPARERR | F_SIGTARABT | F_RCVTARABT | \
   F_RCVMSTABT | F_SIGSYSERR | F_DETPARERR | \
   F_SPLCMPDIS | F_UNXSPLCMP | F_RCVSPLCMPERR | \
   F_DETCORECCERR | F_DETUNCECCERR | F_PIOPARERR | \
   V_WFPARERR(M_WFPARERR) | V_RFPARERR(M_RFPARERR) | \
   V_CFPARERR(M_CFPARERR) /* | V_MSIXPARERR(M_MSIXPARERR) */)
#define PCIE_INTR_MASK (F_UNXSPLCPLERRR | F_UNXSPLCPLERRC | F_PCIE_PIOPARERR |\
   F_PCIE_WFPARERR | F_PCIE_RFPARERR | F_PCIE_CFPARERR | \
   /* V_PCIE_MSIXPARERR(M_PCIE_MSIXPARERR) | */ \
   F_RETRYBUFPARERR | F_RETRYLUTPARERR | F_RXPARERR | \
   F_TXPARERR | V_BISTERR(M_BISTERR))
#define ULPRX_INTR_MASK (F_PARERRDATA | F_PARERRPCMD | F_ARBPF1PERR | \
    F_ARBPF0PERR | F_ARBFPERR | F_PCMDMUXPERR | \
    F_DATASELFRAMEERR1 | F_DATASELFRAMEERR0)
#define ULPTX_INTR_MASK 0xfc
#define CPLSW_INTR_MASK (F_CIM_OP_MAP_PERR | F_TP_FRAMING_ERROR | \
    F_SGE_FRAMING_ERROR | F_CIM_FRAMING_ERROR | \
    F_ZERO_SWITCH_ERROR)
#define CIM_INTR_MASK (F_BLKWRPLINT | F_BLKRDPLINT | F_BLKWRCTLINT | \
         F_BLKRDCTLINT | F_BLKWRFLASHINT | F_BLKRDFLASHINT | \
         F_SGLWRFLASHINT | F_WRBLKFLASHINT | F_BLKWRBOOTINT | \
          F_FLASHRANGEINT | F_SDRAMRANGEINT | F_RSVDSPACEINT | \
         F_DRAMPARERR | F_ICACHEPARERR | F_DCACHEPARERR | \
         F_OBQSGEPARERR | F_OBQULPHIPARERR | F_OBQULPLOPARERR | \
         F_IBQSGELOPARERR | F_IBQSGEHIPARERR | F_IBQULPPARERR | \
         F_IBQTPPARERR | F_ITAGPARERR | F_DTAGPARERR)
#define PMTX_INTR_MASK (F_ZERO_C_CMD_ERROR | ICSPI_FRM_ERR | OESPI_FRM_ERR | \
   V_ICSPI_PAR_ERROR(M_ICSPI_PAR_ERROR) | \
   V_OESPI_PAR_ERROR(M_OESPI_PAR_ERROR))
#define PMRX_INTR_MASK (F_ZERO_E_CMD_ERROR | IESPI_FRM_ERR | OCSPI_FRM_ERR | \
   V_IESPI_PAR_ERROR(M_IESPI_PAR_ERROR) | \
   V_OCSPI_PAR_ERROR(M_OCSPI_PAR_ERROR))
#define MPS_INTR_MASK (V_TX0TPPARERRENB(M_TX0TPPARERRENB) | \
         V_TX1TPPARERRENB(M_TX1TPPARERRENB) | \
         V_RXTPPARERRENB(M_RXTPPARERRENB) | \
         V_MCAPARERRENB(M_MCAPARERRENB))
#define XGM_EXTRA_INTR_MASK (F_LINKFAULTCHANGE)
#define PL_INTR_MASK (F_T3DBG | F_XGMAC0_0 | F_XGMAC0_1 | F_MC5A | F_PM1_TX | \
        F_PM1_RX | F_ULP2_TX | F_ULP2_RX | F_TP1 | F_CIM | \
        F_MC7_CM | F_MC7_PMTX | F_MC7_PMRX | F_SGE3 | F_PCIM0 | \
        F_MPS0 | F_CPL_SWITCH)
/*
 * Interrupt handler for the PCIX1 module.
 */
static void pci_intr_handler(struct adapter *adapter)
{
 static const struct intr_info pcix1_intr_info[] = {
  {F_MSTDETPARERR, "PCI master detected parity error", -1, 1},
  {F_SIGTARABT, "PCI signaled target abort", -1, 1},
  {F_RCVTARABT, "PCI received target abort", -1, 1},
  {F_RCVMSTABT, "PCI received master abort", -1, 1},
  {F_SIGSYSERR, "PCI signaled system error", -1, 1},
  {F_DETPARERR, "PCI detected parity error", -1, 1},
  {F_SPLCMPDIS, "PCI split completion discarded", -1, 1},
  {F_UNXSPLCMP, "PCI unexpected split completion error", -1, 1},
  {F_RCVSPLCMPERR, "PCI received split completion error", -1,
   1},
  {F_DETCORECCERR, "PCI correctable ECC error",
   STAT_PCI_CORR_ECC, 0},
  {F_DETUNCECCERR, "PCI uncorrectable ECC error", -1, 1},
  {F_PIOPARERR, "PCI PIO FIFO parity error", -1, 1},
  {V_WFPARERR(M_WFPARERR), "PCI write FIFO parity error", -1,
   1},
  {V_RFPARERR(M_RFPARERR), "PCI read FIFO parity error", -1,
   1},
  {V_CFPARERR(M_CFPARERR), "PCI command FIFO parity error", -1,
   1},
  {V_MSIXPARERR(M_MSIXPARERR), "PCI MSI-X table/PBA parity "
   "error", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_PCIX_INT_CAUSE, PCIX_INTR_MASK,
      pcix1_intr_info, adapter->irq_stats))
  t3_fatal_err(adapter);
}

/*
 * Interrupt handler for the PCIE module.
 */
static void pcie_intr_handler(struct adapter *adapter)
{
 static const struct intr_info pcie_intr_info[] = {
  {F_PEXERR, "PCI PEX error", -1, 1},
  {F_UNXSPLCPLERRR,
   "PCI unexpected split completion DMA read error", -1, 1},
  {F_UNXSPLCPLERRC,
   "PCI unexpected split completion DMA command error", -1, 1},
  {F_PCIE_PIOPARERR, "PCI PIO FIFO parity error", -1, 1},
  {F_PCIE_WFPARERR, "PCI write FIFO parity error", -1, 1},
  {F_PCIE_RFPARERR, "PCI read FIFO parity error", -1, 1},
  {F_PCIE_CFPARERR, "PCI command FIFO parity error", -1, 1},
  {V_PCIE_MSIXPARERR(M_PCIE_MSIXPARERR),
   "PCI MSI-X table/PBA parity error", -1, 1},
  {F_RETRYBUFPARERR, "PCI retry buffer parity error", -1, 1},
  {F_RETRYLUTPARERR, "PCI retry LUT parity error", -1, 1},
  {F_RXPARERR, "PCI Rx parity error", -1, 1},
  {F_TXPARERR, "PCI Tx parity error", -1, 1},
  {V_BISTERR(M_BISTERR), "PCI BIST error", -1, 1},
  {0}
 };

 if (t3_read_reg(adapter, A_PCIE_INT_CAUSE) & F_PEXERR)
  CH_ALERT(adapter, "PEX error code 0x%x\n",
    t3_read_reg(adapter, A_PCIE_PEX_ERR));

 if (t3_handle_intr_status(adapter, A_PCIE_INT_CAUSE, PCIE_INTR_MASK,
      pcie_intr_info, adapter->irq_stats))
  t3_fatal_err(adapter);
}

/*
 * TP interrupt handler.
 */
static void tp_intr_handler(struct adapter *adapter)
{
 static const struct intr_info tp_intr_info[] = {
  {0xffffff, "TP parity error", -1, 1},
  {0x1000000, "TP out of Rx pages", -1, 1},
  {0x2000000, "TP out of Tx pages", -1, 1},
  {0}
 };

 static const struct intr_info tp_intr_info_t3c[] = {
  {0x1fffffff, "TP parity error", -1, 1},
  {F_FLMRXFLSTEMPTY, "TP out of Rx pages", -1, 1},
  {F_FLMTXFLSTEMPTY, "TP out of Tx pages", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_TP_INT_CAUSE, 0xffffffff,
      adapter->params.rev < T3_REV_C ?
      tp_intr_info : tp_intr_info_t3c, NULL))
  t3_fatal_err(adapter);
}

/*
 * CIM interrupt handler.
 */
static void cim_intr_handler(struct adapter *adapter)
{
 static const struct intr_info cim_intr_info[] = {
  {F_RSVDSPACEINT, "CIM reserved space write", -1, 1},
  {F_SDRAMRANGEINT, "CIM SDRAM address out of range", -1, 1},
  {F_FLASHRANGEINT, "CIM flash address out of range", -1, 1},
  {F_BLKWRBOOTINT, "CIM block write to boot space", -1, 1},
  {F_WRBLKFLASHINT, "CIM write to cached flash space", -1, 1},
  {F_SGLWRFLASHINT, "CIM single write to flash space", -1, 1},
  {F_BLKRDFLASHINT, "CIM block read from flash space", -1, 1},
  {F_BLKWRFLASHINT, "CIM block write to flash space", -1, 1},
  {F_BLKRDCTLINT, "CIM block read from CTL space", -1, 1},
  {F_BLKWRCTLINT, "CIM block write to CTL space", -1, 1},
  {F_BLKRDPLINT, "CIM block read from PL space", -1, 1},
  {F_BLKWRPLINT, "CIM block write to PL space", -1, 1},
  {F_DRAMPARERR, "CIM DRAM parity error", -1, 1},
  {F_ICACHEPARERR, "CIM icache parity error", -1, 1},
  {F_DCACHEPARERR, "CIM dcache parity error", -1, 1},
  {F_OBQSGEPARERR, "CIM OBQ SGE parity error", -1, 1},
  {F_OBQULPHIPARERR, "CIM OBQ ULPHI parity error", -1, 1},
  {F_OBQULPLOPARERR, "CIM OBQ ULPLO parity error", -1, 1},
  {F_IBQSGELOPARERR, "CIM IBQ SGELO parity error", -1, 1},
  {F_IBQSGEHIPARERR, "CIM IBQ SGEHI parity error", -1, 1},
  {F_IBQULPPARERR, "CIM IBQ ULP parity error", -1, 1},
  {F_IBQTPPARERR, "CIM IBQ TP parity error", -1, 1},
  {F_ITAGPARERR, "CIM itag parity error", -1, 1},
  {F_DTAGPARERR, "CIM dtag parity error", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_CIM_HOST_INT_CAUSE, 0xffffffff,
      cim_intr_info, NULL))
  t3_fatal_err(adapter);
}

/*
 * ULP RX interrupt handler.
 */
static void ulprx_intr_handler(struct adapter *adapter)
{
 static const struct intr_info ulprx_intr_info[] = {
  {F_PARERRDATA, "ULP RX data parity error", -1, 1},
  {F_PARERRPCMD, "ULP RX command parity error", -1, 1},
  {F_ARBPF1PERR, "ULP RX ArbPF1 parity error", -1, 1},
  {F_ARBPF0PERR, "ULP RX ArbPF0 parity error", -1, 1},
  {F_ARBFPERR, "ULP RX ArbF parity error", -1, 1},
  {F_PCMDMUXPERR, "ULP RX PCMDMUX parity error", -1, 1},
  {F_DATASELFRAMEERR1, "ULP RX frame error", -1, 1},
  {F_DATASELFRAMEERR0, "ULP RX frame error", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_ULPRX_INT_CAUSE, 0xffffffff,
      ulprx_intr_info, NULL))
  t3_fatal_err(adapter);
}

/*
 * ULP TX interrupt handler.
 */
static void ulptx_intr_handler(struct adapter *adapter)
{
 static const struct intr_info ulptx_intr_info[] = {
  {F_PBL_BOUND_ERR_CH0, "ULP TX channel 0 PBL out of bounds",
   STAT_ULP_CH0_PBL_OOB, 0},
  {F_PBL_BOUND_ERR_CH1, "ULP TX channel 1 PBL out of bounds",
   STAT_ULP_CH1_PBL_OOB, 0},
  {0xfc, "ULP TX parity error", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_ULPTX_INT_CAUSE, 0xffffffff,
      ulptx_intr_info, adapter->irq_stats))
  t3_fatal_err(adapter);
}

#define ICSPI_FRM_ERR (F_ICSPI0_FIFO2X_RX_FRAMING_ERROR | \
 F_ICSPI1_FIFO2X_RX_FRAMING_ERROR | F_ICSPI0_RX_FRAMING_ERROR | \
 F_ICSPI1_RX_FRAMING_ERROR | F_ICSPI0_TX_FRAMING_ERROR | \
 F_ICSPI1_TX_FRAMING_ERROR)
#define OESPI_FRM_ERR (F_OESPI0_RX_FRAMING_ERROR | \
 F_OESPI1_RX_FRAMING_ERROR | F_OESPI0_TX_FRAMING_ERROR | \
 F_OESPI1_TX_FRAMING_ERROR | F_OESPI0_OFIFO2X_TX_FRAMING_ERROR | \
 F_OESPI1_OFIFO2X_TX_FRAMING_ERROR)

/*
 * PM TX interrupt handler.
 */
static void pmtx_intr_handler(struct adapter *adapter)
{
 static const struct intr_info pmtx_intr_info[] = {
  {F_ZERO_C_CMD_ERROR, "PMTX 0-length pcmd", -1, 1},
  {ICSPI_FRM_ERR, "PMTX ispi framing error", -1, 1},
  {OESPI_FRM_ERR, "PMTX ospi framing error", -1, 1},
  {V_ICSPI_PAR_ERROR(M_ICSPI_PAR_ERROR),
   "PMTX ispi parity error", -1, 1},
  {V_OESPI_PAR_ERROR(M_OESPI_PAR_ERROR),
   "PMTX ospi parity error", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_PM1_TX_INT_CAUSE, 0xffffffff,
      pmtx_intr_info, NULL))
  t3_fatal_err(adapter);
}

#define IESPI_FRM_ERR (F_IESPI0_FIFO2X_RX_FRAMING_ERROR | \
 F_IESPI1_FIFO2X_RX_FRAMING_ERROR | F_IESPI0_RX_FRAMING_ERROR | \
 F_IESPI1_RX_FRAMING_ERROR | F_IESPI0_TX_FRAMING_ERROR | \
 F_IESPI1_TX_FRAMING_ERROR)
#define OCSPI_FRM_ERR (F_OCSPI0_RX_FRAMING_ERROR | \
 F_OCSPI1_RX_FRAMING_ERROR | F_OCSPI0_TX_FRAMING_ERROR | \
 F_OCSPI1_TX_FRAMING_ERROR | F_OCSPI0_OFIFO2X_TX_FRAMING_ERROR | \
 F_OCSPI1_OFIFO2X_TX_FRAMING_ERROR)

/*
 * PM RX interrupt handler.
 */
static void pmrx_intr_handler(struct adapter *adapter)
{
 static const struct intr_info pmrx_intr_info[] = {
  {F_ZERO_E_CMD_ERROR, "PMRX 0-length pcmd", -1, 1},
  {IESPI_FRM_ERR, "PMRX ispi framing error", -1, 1},
  {OCSPI_FRM_ERR, "PMRX ospi framing error", -1, 1},
  {V_IESPI_PAR_ERROR(M_IESPI_PAR_ERROR),
   "PMRX ispi parity error", -1, 1},
  {V_OCSPI_PAR_ERROR(M_OCSPI_PAR_ERROR),
   "PMRX ospi parity error", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_PM1_RX_INT_CAUSE, 0xffffffff,
      pmrx_intr_info, NULL))
  t3_fatal_err(adapter);
}

/*
 * CPL switch interrupt handler.
 */
static void cplsw_intr_handler(struct adapter *adapter)
{
 static const struct intr_info cplsw_intr_info[] = {
  {F_CIM_OP_MAP_PERR, "CPL switch CIM parity error", -1, 1},
  {F_CIM_OVFL_ERROR, "CPL switch CIM overflow", -1, 1},
  {F_TP_FRAMING_ERROR, "CPL switch TP framing error", -1, 1},
  {F_SGE_FRAMING_ERROR, "CPL switch SGE framing error", -1, 1},
  {F_CIM_FRAMING_ERROR, "CPL switch CIM framing error", -1, 1},
  {F_ZERO_SWITCH_ERROR, "CPL switch no-switch error", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_CPL_INTR_CAUSE, 0xffffffff,
      cplsw_intr_info, NULL))
  t3_fatal_err(adapter);
}

/*
 * MPS interrupt handler.
 */
static void mps_intr_handler(struct adapter *adapter)
{
 static const struct intr_info mps_intr_info[] = {
  {0x1ff, "MPS parity error", -1, 1},
  {0}
 };

 if (t3_handle_intr_status(adapter, A_MPS_INT_CAUSE, 0xffffffff,
      mps_intr_info, NULL))
  t3_fatal_err(adapter);
}

#define MC7_INTR_FATAL (F_UE | V_PE(M_PE) | F_AE)

/*
 * MC7 interrupt handler.
 */
static void mc7_intr_handler(struct mc7 *mc7)
{
 struct adapter *adapter = mc7->adapter;
 u32 cause = t3_read_reg(adapter, mc7->offset + A_MC7_INT_CAUSE);

 if (cause & F_CE) {
  mc7->stats.corr_err++;
  CH_WARN(adapter, "%s MC7 correctable error at addr 0x%x, "
   "data 0x%x 0x%x 0x%x\n", mc7->name,
   t3_read_reg(adapter, mc7->offset + A_MC7_CE_ADDR),
   t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA0),
   t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA1),
   t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA2));
 }

 if (cause & F_UE) {
  mc7->stats.uncorr_err++;
  CH_ALERT(adapter, "%s MC7 uncorrectable error at addr 0x%x, "
    "data 0x%x 0x%x 0x%x\n", mc7->name,
    t3_read_reg(adapter, mc7->offset + A_MC7_UE_ADDR),
    t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA0),
    t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA1),
    t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA2));
 }

 if (G_PE(cause)) {
  mc7->stats.parity_err++;
  CH_ALERT(adapter, "%s MC7 parity error 0x%x\n",
    mc7->name, G_PE(cause));
 }

 if (cause & F_AE) {
  u32 addr = 0;

  if (adapter->params.rev > 0)
   addr = t3_read_reg(adapter,
        mc7->offset + A_MC7_ERR_ADDR);
  mc7->stats.addr_err++;
  CH_ALERT(adapter, "%s MC7 address error: 0x%x\n",
    mc7->name, addr);
 }

 if (cause & MC7_INTR_FATAL)
  t3_fatal_err(adapter);

 t3_write_reg(adapter, mc7->offset + A_MC7_INT_CAUSE, cause);
}

#define XGM_INTR_FATAL (V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR) | \
   V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR))
/*
 * XGMAC interrupt handler.
 */
static int mac_intr_handler(struct adapter *adap, unsigned int idx)
{
 struct cmac *mac = &adap2pinfo(adap, idx)->mac;
 /*
 * We mask out interrupt causes for which we're not taking interrupts.
 * This allows us to use polling logic to monitor some of the other
 * conditions when taking interrupts would impose too much load on the
 * system.
 */
 u32 cause = t3_read_reg(adap, A_XGM_INT_CAUSE + mac->offset) &
      ~F_RXFIFO_OVERFLOW;

 if (cause & V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR)) {
  mac->stats.tx_fifo_parity_err++;
  CH_ALERT(adap, "port%d: MAC TX FIFO parity error\n", idx);
 }
 if (cause & V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR)) {
  mac->stats.rx_fifo_parity_err++;
  CH_ALERT(adap, "port%d: MAC RX FIFO parity error\n", idx);
 }
 if (cause & F_TXFIFO_UNDERRUN)
  mac->stats.tx_fifo_urun++;
 if (cause & F_RXFIFO_OVERFLOW)
  mac->stats.rx_fifo_ovfl++;
 if (cause & V_SERDES_LOS(M_SERDES_LOS))
  mac->stats.serdes_signal_loss++;
 if (cause & F_XAUIPCSCTCERR)
  mac->stats.xaui_pcs_ctc_err++;
 if (cause & F_XAUIPCSALIGNCHANGE)
  mac->stats.xaui_pcs_align_change++;
 if (cause & F_XGM_INT) {
  t3_set_reg_field(adap,
     A_XGM_INT_ENABLE + mac->offset,
     F_XGM_INT, 0);
  mac->stats.link_faults++;

  t3_os_link_fault_handler(adap, idx);
 }

 if (cause & XGM_INTR_FATAL)
  t3_fatal_err(adap);

 t3_write_reg(adap, A_XGM_INT_CAUSE + mac->offset, cause);
 return cause != 0;
}

/*
 * Interrupt handler for PHY events.
 */
int t3_phy_intr_handler(struct adapter *adapter)
{
 u32 i, cause = t3_read_reg(adapter, A_T3DBG_INT_CAUSE);

 for_each_port(adapter, i) {
  struct port_info *p = adap2pinfo(adapter, i);

  if (!(p->phy.caps & SUPPORTED_IRQ))
   continue;

  if (cause & (1 << adapter_info(adapter)->gpio_intr[i])) {
   int phy_cause = p->phy.ops->intr_handler(&p->phy);

   if (phy_cause & cphy_cause_link_change)
    t3_link_changed(adapter, i);
   if (phy_cause & cphy_cause_fifo_error)
    p->phy.fifo_errors++;
   if (phy_cause & cphy_cause_module_change)
    t3_os_phymod_changed(adapter, i);
  }
 }

 t3_write_reg(adapter, A_T3DBG_INT_CAUSE, cause);
 return 0;
}

/*
 * T3 slow path (non-data) interrupt handler.
 */
int t3_slow_intr_handler(struct adapter *adapter)
{
 u32 cause = t3_read_reg(adapter, A_PL_INT_CAUSE0);

 cause &= adapter->slow_intr_mask;
 if (!cause)
  return 0;
 if (cause & F_PCIM0) {
  if (is_pcie(adapter))
   pcie_intr_handler(adapter);
  else
   pci_intr_handler(adapter);
 }
 if (cause & F_SGE3)
  t3_sge_err_intr_handler(adapter);
 if (cause & F_MC7_PMRX)
  mc7_intr_handler(&adapter->pmrx);
 if (cause & F_MC7_PMTX)
  mc7_intr_handler(&adapter->pmtx);
 if (cause & F_MC7_CM)
  mc7_intr_handler(&adapter->cm);
 if (cause & F_CIM)
  cim_intr_handler(adapter);
 if (cause & F_TP1)
  tp_intr_handler(adapter);
 if (cause & F_ULP2_RX)
  ulprx_intr_handler(adapter);
 if (cause & F_ULP2_TX)
  ulptx_intr_handler(adapter);
 if (cause & F_PM1_RX)
  pmrx_intr_handler(adapter);
 if (cause & F_PM1_TX)
  pmtx_intr_handler(adapter);
 if (cause & F_CPL_SWITCH)
  cplsw_intr_handler(adapter);
 if (cause & F_MPS0)
  mps_intr_handler(adapter);
 if (cause & F_MC5A)
  t3_mc5_intr_handler(&adapter->mc5);
 if (cause & F_XGMAC0_0)
  mac_intr_handler(adapter, 0);
 if (cause & F_XGMAC0_1)
  mac_intr_handler(adapter, 1);
 if (cause & F_T3DBG)
  t3_os_ext_intr_handler(adapter);

 /* Clear the interrupts just processed. */
 t3_write_reg(adapter, A_PL_INT_CAUSE0, cause);
 t3_read_reg(adapter, A_PL_INT_CAUSE0); /* flush */
 return 1;
}

static unsigned int calc_gpio_intr(struct adapter *adap)
{
 unsigned int i, gpi_intr = 0;

 for_each_port(adap, i)
  if ((adap2pinfo(adap, i)->phy.caps & SUPPORTED_IRQ) &&
      adapter_info(adap)->gpio_intr[i])
   gpi_intr |= 1 << adapter_info(adap)->gpio_intr[i];
 return gpi_intr;
}

/**
 * t3_intr_enable - enable interrupts
 * @adapter: the adapter whose interrupts should be enabled
 *
 * Enable interrupts by setting the interrupt enable registers of the
 * various HW modules and then enabling the top-level interrupt
 * concentrator.
 */
void t3_intr_enable(struct adapter *adapter)
{
 static const struct addr_val_pair intr_en_avp[] = {
  {A_SG_INT_ENABLE, SGE_INTR_MASK},
  {A_MC7_INT_ENABLE, MC7_INTR_MASK},
  {A_MC7_INT_ENABLE - MC7_PMRX_BASE_ADDR + MC7_PMTX_BASE_ADDR,
   MC7_INTR_MASK},
  {A_MC7_INT_ENABLE - MC7_PMRX_BASE_ADDR + MC7_CM_BASE_ADDR,
   MC7_INTR_MASK},
  {A_MC5_DB_INT_ENABLE, MC5_INTR_MASK},
  {A_ULPRX_INT_ENABLE, ULPRX_INTR_MASK},
  {A_PM1_TX_INT_ENABLE, PMTX_INTR_MASK},
  {A_PM1_RX_INT_ENABLE, PMRX_INTR_MASK},
  {A_CIM_HOST_INT_ENABLE, CIM_INTR_MASK},
  {A_MPS_INT_ENABLE, MPS_INTR_MASK},
 };

 adapter->slow_intr_mask = PL_INTR_MASK;

 t3_write_regs(adapter, intr_en_avp, ARRAY_SIZE(intr_en_avp), 0);
 t3_write_reg(adapter, A_TP_INT_ENABLE,
       adapter->params.rev >= T3_REV_C ? 0x2bfffff : 0x3bfffff);

 if (adapter->params.rev > 0) {
  t3_write_reg(adapter, A_CPL_INTR_ENABLE,
        CPLSW_INTR_MASK | F_CIM_OVFL_ERROR);
  t3_write_reg(adapter, A_ULPTX_INT_ENABLE,
        ULPTX_INTR_MASK | F_PBL_BOUND_ERR_CH0 |
        F_PBL_BOUND_ERR_CH1);
 } else {
  t3_write_reg(adapter, A_CPL_INTR_ENABLE, CPLSW_INTR_MASK);
  t3_write_reg(adapter, A_ULPTX_INT_ENABLE, ULPTX_INTR_MASK);
 }

 t3_write_reg(adapter, A_T3DBG_INT_ENABLE, calc_gpio_intr(adapter));

 if (is_pcie(adapter))
  t3_write_reg(adapter, A_PCIE_INT_ENABLE, PCIE_INTR_MASK);
 else
  t3_write_reg(adapter, A_PCIX_INT_ENABLE, PCIX_INTR_MASK);
 t3_write_reg(adapter, A_PL_INT_ENABLE0, adapter->slow_intr_mask);
 t3_read_reg(adapter, A_PL_INT_ENABLE0); /* flush */
}

/**
 * t3_intr_disable - disable a card's interrupts
 * @adapter: the adapter whose interrupts should be disabled
 *
 * Disable interrupts.  We only disable the top-level interrupt
 * concentrator and the SGE data interrupts.
 */
void t3_intr_disable(struct adapter *adapter)
{
 t3_write_reg(adapter, A_PL_INT_ENABLE0, 0);
 t3_read_reg(adapter, A_PL_INT_ENABLE0); /* flush */
 adapter->slow_intr_mask = 0;
}

/**
 * t3_intr_clear - clear all interrupts
 * @adapter: the adapter whose interrupts should be cleared
 *
 * Clears all interrupts.
 */
void t3_intr_clear(struct adapter *adapter)
{
 static const unsigned int cause_reg_addr[] = {
  A_SG_INT_CAUSE,
  A_SG_RSPQ_FL_STATUS,
  A_PCIX_INT_CAUSE,
  A_MC7_INT_CAUSE,
  A_MC7_INT_CAUSE - MC7_PMRX_BASE_ADDR + MC7_PMTX_BASE_ADDR,
  A_MC7_INT_CAUSE - MC7_PMRX_BASE_ADDR + MC7_CM_BASE_ADDR,
  A_CIM_HOST_INT_CAUSE,
  A_TP_INT_CAUSE,
  A_MC5_DB_INT_CAUSE,
  A_ULPRX_INT_CAUSE,
  A_ULPTX_INT_CAUSE,
  A_CPL_INTR_CAUSE,
  A_PM1_TX_INT_CAUSE,
  A_PM1_RX_INT_CAUSE,
  A_MPS_INT_CAUSE,
  A_T3DBG_INT_CAUSE,
 };
 unsigned int i;

 /* Clear PHY and MAC interrupts for each port. */
 for_each_port(adapter, i)
     t3_port_intr_clear(adapter, i);

 for (i = 0; i < ARRAY_SIZE(cause_reg_addr); ++i)
  t3_write_reg(adapter, cause_reg_addr[i], 0xffffffff);

 if (is_pcie(adapter))
  t3_write_reg(adapter, A_PCIE_PEX_ERR, 0xffffffff);
 t3_write_reg(adapter, A_PL_INT_CAUSE0, 0xffffffff);
 t3_read_reg(adapter, A_PL_INT_CAUSE0); /* flush */
}

void t3_xgm_intr_enable(struct adapter *adapter, int idx)
{
 struct port_info *pi = adap2pinfo(adapter, idx);

 t3_write_reg(adapter, A_XGM_XGM_INT_ENABLE + pi->mac.offset,
       XGM_EXTRA_INTR_MASK);
}

void t3_xgm_intr_disable(struct adapter *adapter, int idx)
{
 struct port_info *pi = adap2pinfo(adapter, idx);

 t3_write_reg(adapter, A_XGM_XGM_INT_DISABLE + pi->mac.offset,
       0x7ff);
}

/**
 * t3_port_intr_enable - enable port-specific interrupts
 * @adapter: associated adapter
 * @idx: index of port whose interrupts should be enabled
 *
 * Enable port-specific (i.e., MAC and PHY) interrupts for the given
 * adapter port.
 */
void t3_port_intr_enable(struct adapter *adapter, int idx)
{
 struct cphy *phy = &adap2pinfo(adapter, idx)->phy;

 t3_write_reg(adapter, XGM_REG(A_XGM_INT_ENABLE, idx), XGM_INTR_MASK);
 t3_read_reg(adapter, XGM_REG(A_XGM_INT_ENABLE, idx)); /* flush */
 phy->ops->intr_enable(phy);
}

/**
 * t3_port_intr_disable - disable port-specific interrupts
 * @adapter: associated adapter
 * @idx: index of port whose interrupts should be disabled
 *
 * Disable port-specific (i.e., MAC and PHY) interrupts for the given
 * adapter port.
 */
void t3_port_intr_disable(struct adapter *adapter, int idx)
{
 struct cphy *phy = &adap2pinfo(adapter, idx)->phy;

 t3_write_reg(adapter, XGM_REG(A_XGM_INT_ENABLE, idx), 0);
 t3_read_reg(adapter, XGM_REG(A_XGM_INT_ENABLE, idx)); /* flush */
 phy->ops->intr_disable(phy);
}

/**
 * t3_port_intr_clear - clear port-specific interrupts
 * @adapter: associated adapter
 * @idx: index of port whose interrupts to clear
 *
 * Clear port-specific (i.e., MAC and PHY) interrupts for the given
 * adapter port.
 */
static void t3_port_intr_clear(struct adapter *adapter, int idx)
{
 struct cphy *phy = &adap2pinfo(adapter, idx)->phy;

 t3_write_reg(adapter, XGM_REG(A_XGM_INT_CAUSE, idx), 0xffffffff);
 t3_read_reg(adapter, XGM_REG(A_XGM_INT_CAUSE, idx)); /* flush */
 phy->ops->intr_clear(phy);
}

#define SG_CONTEXT_CMD_ATTEMPTS 100

/**
 *  t3_sge_write_context - write an SGE context
 *  @adapter: the adapter
 *  @id: the context id
 *  @type: the context type
 *
 *  Program an SGE context with the values already loaded in the
 *  CONTEXT_DATA? registers.
 */
static int t3_sge_write_context(struct adapter *adapter, unsigned int id,
    unsigned int type)
{
 if (type == F_RESPONSEQ) {
  /*
 * Can't write the Response Queue Context bits for
 * Interrupt Armed or the Reserve bits after the chip
 * has been initialized out of reset.  Writing to these
 * bits can confuse the hardware.
 */
  t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0xffffffff);
  t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0xffffffff);
  t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0x17ffffff);
  t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0xffffffff);
 } else {
  t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0xffffffff);
  t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0xffffffff);
  t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0xffffffff);
  t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0xffffffff);
 }
 t3_write_reg(adapter, A_SG_CONTEXT_CMD,
       V_CONTEXT_CMD_OPCODE(1) | type | V_CONTEXT(id));
 return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
          0, SG_CONTEXT_CMD_ATTEMPTS, 1);
}

/**
 * clear_sge_ctxt - completely clear an SGE context
 * @adap: the adapter
 * @id: the context id
 * @type: the context type
 *
 * Completely clear an SGE context.  Used predominantly at post-reset
 * initialization.  Note in particular that we don't skip writing to any
 * "sensitive bits" in the contexts the way that t3_sge_write_context()
 * does ...
 */
static int clear_sge_ctxt(struct adapter *adap, unsigned int id,
     unsigned int type)
{
 t3_write_reg(adap, A_SG_CONTEXT_DATA0, 0);
 t3_write_reg(adap, A_SG_CONTEXT_DATA1, 0);
 t3_write_reg(adap, A_SG_CONTEXT_DATA2, 0);
 t3_write_reg(adap, A_SG_CONTEXT_DATA3, 0);
 t3_write_reg(adap, A_SG_CONTEXT_MASK0, 0xffffffff);
 t3_write_reg(adap, A_SG_CONTEXT_MASK1, 0xffffffff);
 t3_write_reg(adap, A_SG_CONTEXT_MASK2, 0xffffffff);
 t3_write_reg(adap, A_SG_CONTEXT_MASK3, 0xffffffff);
 t3_write_reg(adap, A_SG_CONTEXT_CMD,
       V_CONTEXT_CMD_OPCODE(1) | type | V_CONTEXT(id));
 return t3_wait_op_done(adap, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
          0, SG_CONTEXT_CMD_ATTEMPTS, 1);
}

/**
 * t3_sge_init_ecntxt - initialize an SGE egress context
 * @adapter: the adapter to configure
 * @id: the context id
 * @gts_enable: whether to enable GTS for the context
 * @type: the egress context type
 * @respq: associated response queue
 * @base_addr: base address of queue
 * @size: number of queue entries
 * @token: uP token
 * @gen: initial generation value for the context
 * @cidx: consumer pointer
 *
 * Initialize an SGE egress context and make it ready for use.  If the
 * platform allows concurrent context operations, the caller is
 * responsible for appropriate locking.
 */
--> --------------------

--> maximum size reached

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