sys/dev/cxgb/common/cxgb_t3_hw.c

   1 /**************************************************************************
   2 SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3
   4 Copyright (c) 2007-2009, Chelsio Inc.
   5 All rights reserved.
   6
   7 Redistribution and use in source and binary forms, with or without
   8 modification, are permitted provided that the following conditions are met:
   9
  10  1. Redistributions of source code must retain the above copyright notice,
  11     this list of conditions and the following disclaimer.
  12
  13  2. Neither the name of the Chelsio Corporation nor the names of its
  14     contributors may be used to endorse or promote products derived from
  15     this software without specific prior written permission.
  16
  17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 POSSIBILITY OF SUCH DAMAGE.
  28
  29 ***************************************************************************/
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34
  35 #include <cxgb_include.h>
  36
  37 #undef msleep
  38 #define msleep t3_os_sleep
  39
  40 /**
  41  *      t3_wait_op_done_val - wait until an operation is completed
  42  *      @adapter: the adapter performing the operation
  43  *      @reg: the register to check for completion
  44  *      @mask: a single-bit field within @reg that indicates completion
  45  *      @polarity: the value of the field when the operation is completed
  46  *      @attempts: number of check iterations
  47  *      @delay: delay in usecs between iterations
  48  *      @valp: where to store the value of the register at completion time
  49  *
  50  *      Wait until an operation is completed by checking a bit in a register
  51  *      up to @attempts times.  If @valp is not NULL the value of the register
  52  *      at the time it indicated completion is stored there.  Returns 0 if the
  53  *      operation completes and -EAGAIN otherwise.
  54  */
  55 int t3_wait_op_done_val(adapter_t *adapter, int reg, u32 mask, int polarity,
  56                         int attempts, int delay, u32 *valp)
  57 {
  58         while (1) {
  59                 u32 val = t3_read_reg(adapter, reg);
  60
  61                 if (!!(val & mask) == polarity) {
  62                         if (valp)
  63                                 *valp = val;
  64                         return 0;
  65                 }
  66                 if (--attempts == 0)
  67                         return -EAGAIN;
  68                 if (delay)
  69                         udelay(delay);
  70         }
  71 }
  72
  73 /**
  74  *      t3_write_regs - write a bunch of registers
  75  *      @adapter: the adapter to program
  76  *      @p: an array of register address/register value pairs
  77  *      @n: the number of address/value pairs
  78  *      @offset: register address offset
  79  *
  80  *      Takes an array of register address/register value pairs and writes each
  81  *      value to the corresponding register.  Register addresses are adjusted
  82  *      by the supplied offset.
  83  */
  84 void t3_write_regs(adapter_t *adapter, const struct addr_val_pair *p, int n,
  85                    unsigned int offset)
  86 {
  87         while (n--) {
  88                 t3_write_reg(adapter, p->reg_addr + offset, p->val);
  89                 p++;
  90         }
  91 }
  92
  93 /**
  94  *      t3_set_reg_field - set a register field to a value
  95  *      @adapter: the adapter to program
  96  *      @addr: the register address
  97  *      @mask: specifies the portion of the register to modify
  98  *      @val: the new value for the register field
  99  *
 100  *      Sets a register field specified by the supplied mask to the
 101  *      given value.
 102  */
 103 void t3_set_reg_field(adapter_t *adapter, unsigned int addr, u32 mask, u32 val)
 104 {
 105         u32 v = t3_read_reg(adapter, addr) & ~mask;
 106
 107         t3_write_reg(adapter, addr, v | val);
 108         (void) t3_read_reg(adapter, addr);      /* flush */
 109 }
 110
 111 /**
 112  *      t3_read_indirect - read indirectly addressed registers
 113  *      @adap: the adapter
 114  *      @addr_reg: register holding the indirect address
 115  *      @data_reg: register holding the value of the indirect register
 116  *      @vals: where the read register values are stored
 117  *      @start_idx: index of first indirect register to read
 118  *      @nregs: how many indirect registers to read
 119  *
 120  *      Reads registers that are accessed indirectly through an address/data
 121  *      register pair.
 122  */
 123 static void t3_read_indirect(adapter_t *adap, unsigned int addr_reg,
 124                       unsigned int data_reg, u32 *vals, unsigned int nregs,
 125                       unsigned int start_idx)
 126 {
 127         while (nregs--) {
 128                 t3_write_reg(adap, addr_reg, start_idx);
 129                 *vals++ = t3_read_reg(adap, data_reg);
 130                 start_idx++;
 131         }
 132 }
 133
 134 /**
 135  *      t3_mc7_bd_read - read from MC7 through backdoor accesses
 136  *      @mc7: identifies MC7 to read from
 137  *      @start: index of first 64-bit word to read
 138  *      @n: number of 64-bit words to read
 139  *      @buf: where to store the read result
 140  *
 141  *      Read n 64-bit words from MC7 starting at word start, using backdoor
 142  *      accesses.
 143  */
 144 int t3_mc7_bd_read(struct mc7 *mc7, unsigned int start, unsigned int n,
 145                    u64 *buf)
 146 {
 147         static int shift[] = { 0, 0, 16, 24 };
 148         static int step[]  = { 0, 32, 16, 8 };
 149
 150         unsigned int size64 = mc7->size / 8;  /* # of 64-bit words */
 151         adapter_t *adap = mc7->adapter;
 152
 153         if (start >= size64 || start + n > size64)
 154                 return -EINVAL;
 155
 156         start *= (8 << mc7->width);
 157         while (n--) {
 158                 int i;
 159                 u64 val64 = 0;
 160
 161                 for (i = (1 << mc7->width) - 1; i >= 0; --i) {
 162                         int attempts = 10;
 163                         u32 val;
 164
 165                         t3_write_reg(adap, mc7->offset + A_MC7_BD_ADDR,
 166                                        start);
 167                         t3_write_reg(adap, mc7->offset + A_MC7_BD_OP, 0);
 168                         val = t3_read_reg(adap, mc7->offset + A_MC7_BD_OP);
 169                         while ((val & F_BUSY) && attempts--)
 170                                 val = t3_read_reg(adap,
 171                                                   mc7->offset + A_MC7_BD_OP);
 172                         if (val & F_BUSY)
 173                                 return -EIO;
 174
 175                         val = t3_read_reg(adap, mc7->offset + A_MC7_BD_DATA1);
 176                         if (mc7->width == 0) {
 177                                 val64 = t3_read_reg(adap,
 178                                                 mc7->offset + A_MC7_BD_DATA0);
 179                                 val64 |= (u64)val << 32;
 180                         } else {
 181                                 if (mc7->width > 1)
 182                                         val >>= shift[mc7->width];
 183                                 val64 |= (u64)val << (step[mc7->width] * i);
 184                         }
 185                         start += 8;
 186                 }
 187                 *buf++ = val64;
 188         }
 189         return 0;
 190 }
 191
 192 /*
 193  * Low-level I2C read and write routines.  These simply read and write a
 194  * single byte with the option of indicating a "continue" if another operation
 195  * is to be chained.  Generally most code will use higher-level routines to
 196  * read and write to I2C Slave Devices.
 197  */
 198 #define I2C_ATTEMPTS 100
 199
 200 /*
 201  * Read an 8-bit value from the I2C bus.  If the "chained" parameter is
 202  * non-zero then a STOP bit will not be written after the read command.  On
 203  * error (the read timed out, etc.), a negative errno will be returned (e.g.
 204  * -EAGAIN, etc.).  On success, the 8-bit value read from the I2C bus is
 205  * stored into the buffer *valp and the value of the I2C ACK bit is returned
 206  * as a 0/1 value.
 207  */
 208 int t3_i2c_read8(adapter_t *adapter, int chained, u8 *valp)
 209 {
 210         int ret;
 211         u32 opval;
 212         MDIO_LOCK(adapter);
 213         t3_write_reg(adapter, A_I2C_OP,
 214                      F_I2C_READ | (chained ? F_I2C_CONT : 0));
 215         ret = t3_wait_op_done_val(adapter, A_I2C_OP, F_I2C_BUSY, 0,
 216                                   I2C_ATTEMPTS, 10, &opval);
 217         if (ret >= 0) {
 218                 ret = ((opval & F_I2C_ACK) == F_I2C_ACK);
 219                 *valp = G_I2C_DATA(t3_read_reg(adapter, A_I2C_DATA));
 220         }
 221         MDIO_UNLOCK(adapter);
 222         return ret;
 223 }
 224
 225 /*
 226  * Write an 8-bit value to the I2C bus.  If the "chained" parameter is
 227  * non-zero, then a STOP bit will not be written after the write command.  On
 228  * error (the write timed out, etc.), a negative errno will be returned (e.g.
 229  * -EAGAIN, etc.).  On success, the value of the I2C ACK bit is returned as a
 230  * 0/1 value.
 231  */
 232 int t3_i2c_write8(adapter_t *adapter, int chained, u8 val)
 233 {
 234         int ret;
 235         u32 opval;
 236         MDIO_LOCK(adapter);
 237         t3_write_reg(adapter, A_I2C_DATA, V_I2C_DATA(val));
 238         t3_write_reg(adapter, A_I2C_OP,
 239                      F_I2C_WRITE | (chained ? F_I2C_CONT : 0));
 240         ret = t3_wait_op_done_val(adapter, A_I2C_OP, F_I2C_BUSY, 0,
 241                                   I2C_ATTEMPTS, 10, &opval);
 242         if (ret >= 0)
 243                 ret = ((opval & F_I2C_ACK) == F_I2C_ACK);
 244         MDIO_UNLOCK(adapter);
 245         return ret;
 246 }
 247
 248 /*
 249  * Initialize MI1.
 250  */
 251 static void mi1_init(adapter_t *adap, const struct adapter_info *ai)
 252 {
 253         u32 clkdiv = adap->params.vpd.cclk / (2 * adap->params.vpd.mdc) - 1;
 254         u32 val = F_PREEN | V_CLKDIV(clkdiv);
 255
 256         t3_write_reg(adap, A_MI1_CFG, val);
 257 }
 258
 259 #define MDIO_ATTEMPTS 20
 260
 261 /*
 262  * MI1 read/write operations for clause 22 PHYs.
 263  */
 264 int t3_mi1_read(adapter_t *adapter, int phy_addr, int mmd_addr,
 265                 int reg_addr, unsigned int *valp)
 266 {
 267         int ret;
 268         u32 addr = V_REGADDR(reg_addr) | V_PHYADDR(phy_addr);
 269
 270         if (mmd_addr)
 271                 return -EINVAL;
 272
 273         MDIO_LOCK(adapter);
 274         t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), V_ST(1));
 275         t3_write_reg(adapter, A_MI1_ADDR, addr);
 276         t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(2));
 277         ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0, MDIO_ATTEMPTS, 10);
 278         if (!ret)
 279                 *valp = t3_read_reg(adapter, A_MI1_DATA);
 280         MDIO_UNLOCK(adapter);
 281         return ret;
 282 }
 283
 284 int t3_mi1_write(adapter_t *adapter, int phy_addr, int mmd_addr,
 285                  int reg_addr, unsigned int val)
 286 {
 287         int ret;
 288         u32 addr = V_REGADDR(reg_addr) | V_PHYADDR(phy_addr);
 289
 290         if (mmd_addr)
 291                 return -EINVAL;
 292
 293         MDIO_LOCK(adapter);
 294         t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), V_ST(1));
 295         t3_write_reg(adapter, A_MI1_ADDR, addr);
 296         t3_write_reg(adapter, A_MI1_DATA, val);
 297         t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(1));
 298         ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0, MDIO_ATTEMPTS, 10);
 299         MDIO_UNLOCK(adapter);
 300         return ret;
 301 }
 302
 303 static struct mdio_ops mi1_mdio_ops = {
 304         t3_mi1_read,
 305         t3_mi1_write
 306 };
 307
 308 /*
 309  * MI1 read/write operations for clause 45 PHYs.
 310  */
 311 static int mi1_ext_read(adapter_t *adapter, int phy_addr, int mmd_addr,
 312                         int reg_addr, unsigned int *valp)
 313 {
 314         int ret;
 315         u32 addr = V_REGADDR(mmd_addr) | V_PHYADDR(phy_addr);
 316
 317         MDIO_LOCK(adapter);
 318         t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), 0);
 319         t3_write_reg(adapter, A_MI1_ADDR, addr);
 320         t3_write_reg(adapter, A_MI1_DATA, reg_addr);
 321         t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(0));
 322         ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0, MDIO_ATTEMPTS, 10);
 323         if (!ret) {
 324                 t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(3));
 325                 ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0,
 326                                       MDIO_ATTEMPTS, 10);
 327                 if (!ret)
 328                         *valp = t3_read_reg(adapter, A_MI1_DATA);
 329         }
 330         MDIO_UNLOCK(adapter);
 331         return ret;
 332 }
 333
 334 static int mi1_ext_write(adapter_t *adapter, int phy_addr, int mmd_addr,
 335                          int reg_addr, unsigned int val)
 336 {
 337         int ret;
 338         u32 addr = V_REGADDR(mmd_addr) | V_PHYADDR(phy_addr);
 339
 340         MDIO_LOCK(adapter);
 341         t3_set_reg_field(adapter, A_MI1_CFG, V_ST(M_ST), 0);
 342         t3_write_reg(adapter, A_MI1_ADDR, addr);
 343         t3_write_reg(adapter, A_MI1_DATA, reg_addr);
 344         t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(0));
 345         ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0, MDIO_ATTEMPTS, 10);
 346         if (!ret) {
 347                 t3_write_reg(adapter, A_MI1_DATA, val);
 348                 t3_write_reg(adapter, A_MI1_OP, V_MDI_OP(1));
 349                 ret = t3_wait_op_done(adapter, A_MI1_OP, F_BUSY, 0,
 350                                       MDIO_ATTEMPTS, 10);
 351         }
 352         MDIO_UNLOCK(adapter);
 353         return ret;
 354 }
 355
 356 static struct mdio_ops mi1_mdio_ext_ops = {
 357         mi1_ext_read,
 358         mi1_ext_write
 359 };
 360
 361 /**
 362  *      t3_mdio_change_bits - modify the value of a PHY register
 363  *      @phy: the PHY to operate on
 364  *      @mmd: the device address
 365  *      @reg: the register address
 366  *      @clear: what part of the register value to mask off
 367  *      @set: what part of the register value to set
 368  *
 369  *      Changes the value of a PHY register by applying a mask to its current
 370  *      value and ORing the result with a new value.
 371  */
 372 int t3_mdio_change_bits(struct cphy *phy, int mmd, int reg, unsigned int clear,
 373                         unsigned int set)
 374 {
 375         int ret;
 376         unsigned int val;
 377
 378         ret = mdio_read(phy, mmd, reg, &val);
 379         if (!ret) {
 380                 val &= ~clear;
 381                 ret = mdio_write(phy, mmd, reg, val | set);
 382         }
 383         return ret;
 384 }
 385
 386 /**
 387  *      t3_phy_reset - reset a PHY block
 388  *      @phy: the PHY to operate on
 389  *      @mmd: the device address of the PHY block to reset
 390  *      @wait: how long to wait for the reset to complete in 1ms increments
 391  *
 392  *      Resets a PHY block and optionally waits for the reset to complete.
 393  *      @mmd should be 0 for 10/100/1000 PHYs and the device address to reset
 394  *      for 10G PHYs.
 395  */
 396 int t3_phy_reset(struct cphy *phy, int mmd, int wait)
 397 {
 398         int err;
 399         unsigned int ctl;
 400
 401         err = t3_mdio_change_bits(phy, mmd, MII_BMCR, BMCR_PDOWN, BMCR_RESET);
 402         if (err || !wait)
 403                 return err;
 404
 405         do {
 406                 err = mdio_read(phy, mmd, MII_BMCR, &ctl);
 407                 if (err)
 408                         return err;
 409                 ctl &= BMCR_RESET;
 410                 if (ctl)
 411                         msleep(1);
 412         } while (ctl && --wait);
 413
 414         return ctl ? -1 : 0;
 415 }
 416
 417 /**
 418  *      t3_phy_advertise - set the PHY advertisement registers for autoneg
 419  *      @phy: the PHY to operate on
 420  *      @advert: bitmap of capabilities the PHY should advertise
 421  *
 422  *      Sets a 10/100/1000 PHY's advertisement registers to advertise the
 423  *      requested capabilities.
 424  */
 425 int t3_phy_advertise(struct cphy *phy, unsigned int advert)
 426 {
 427         int err;
 428         unsigned int val = 0;
 429
 430         err = mdio_read(phy, 0, MII_CTRL1000, &val);
 431         if (err)
 432                 return err;
 433
 434         val &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
 435         if (advert & ADVERTISED_1000baseT_Half)
 436                 val |= ADVERTISE_1000HALF;
 437         if (advert & ADVERTISED_1000baseT_Full)
 438                 val |= ADVERTISE_1000FULL;
 439
 440         err = mdio_write(phy, 0, MII_CTRL1000, val);
 441         if (err)
 442                 return err;
 443
 444         val = 1;
 445         if (advert & ADVERTISED_10baseT_Half)
 446                 val |= ADVERTISE_10HALF;
 447         if (advert & ADVERTISED_10baseT_Full)
 448                 val |= ADVERTISE_10FULL;
 449         if (advert & ADVERTISED_100baseT_Half)
 450                 val |= ADVERTISE_100HALF;
 451         if (advert & ADVERTISED_100baseT_Full)
 452                 val |= ADVERTISE_100FULL;
 453         if (advert & ADVERTISED_Pause)
 454                 val |= ADVERTISE_PAUSE_CAP;
 455         if (advert & ADVERTISED_Asym_Pause)
 456                 val |= ADVERTISE_PAUSE_ASYM;
 457         return mdio_write(phy, 0, MII_ADVERTISE, val);
 458 }
 459
 460 /**
 461  *      t3_phy_advertise_fiber - set fiber PHY advertisement register
 462  *      @phy: the PHY to operate on
 463  *      @advert: bitmap of capabilities the PHY should advertise
 464  *
 465  *      Sets a fiber PHY's advertisement register to advertise the
 466  *      requested capabilities.
 467  */
 468 int t3_phy_advertise_fiber(struct cphy *phy, unsigned int advert)
 469 {
 470         unsigned int val = 0;
 471
 472         if (advert & ADVERTISED_1000baseT_Half)
 473                 val |= ADVERTISE_1000XHALF;
 474         if (advert & ADVERTISED_1000baseT_Full)
 475                 val |= ADVERTISE_1000XFULL;
 476         if (advert & ADVERTISED_Pause)
 477                 val |= ADVERTISE_1000XPAUSE;
 478         if (advert & ADVERTISED_Asym_Pause)
 479                 val |= ADVERTISE_1000XPSE_ASYM;
 480         return mdio_write(phy, 0, MII_ADVERTISE, val);
 481 }
 482
 483 /**
 484  *      t3_set_phy_speed_duplex - force PHY speed and duplex
 485  *      @phy: the PHY to operate on
 486  *      @speed: requested PHY speed
 487  *      @duplex: requested PHY duplex
 488  *
 489  *      Force a 10/100/1000 PHY's speed and duplex.  This also disables
 490  *      auto-negotiation except for GigE, where auto-negotiation is mandatory.
 491  */
 492 int t3_set_phy_speed_duplex(struct cphy *phy, int speed, int duplex)
 493 {
 494         int err;
 495         unsigned int ctl;
 496
 497         err = mdio_read(phy, 0, MII_BMCR, &ctl);
 498         if (err)
 499                 return err;
 500
 501         if (speed >= 0) {
 502                 ctl &= ~(BMCR_SPEED100 | BMCR_SPEED1000 | BMCR_ANENABLE);
 503                 if (speed == SPEED_100)
 504                         ctl |= BMCR_SPEED100;
 505                 else if (speed == SPEED_1000)
 506                         ctl |= BMCR_SPEED1000;
 507         }
 508         if (duplex >= 0) {
 509                 ctl &= ~(BMCR_FULLDPLX | BMCR_ANENABLE);
 510                 if (duplex == DUPLEX_FULL)
 511                         ctl |= BMCR_FULLDPLX;
 512         }
 513         if (ctl & BMCR_SPEED1000)  /* auto-negotiation required for GigE */
 514                 ctl |= BMCR_ANENABLE;
 515         return mdio_write(phy, 0, MII_BMCR, ctl);
 516 }
 517
 518 int t3_phy_lasi_intr_enable(struct cphy *phy)
 519 {
 520         return mdio_write(phy, MDIO_DEV_PMA_PMD, LASI_CTRL, 1);
 521 }
 522
 523 int t3_phy_lasi_intr_disable(struct cphy *phy)
 524 {
 525         return mdio_write(phy, MDIO_DEV_PMA_PMD, LASI_CTRL, 0);
 526 }
 527
 528 int t3_phy_lasi_intr_clear(struct cphy *phy)
 529 {
 530         u32 val;
 531
 532         return mdio_read(phy, MDIO_DEV_PMA_PMD, LASI_STAT, &val);
 533 }
 534
 535 int t3_phy_lasi_intr_handler(struct cphy *phy)
 536 {
 537         unsigned int status;
 538         int err = mdio_read(phy, MDIO_DEV_PMA_PMD, LASI_STAT, &status);
 539
 540         if (err)
 541                 return err;
 542         return (status & 1) ?  cphy_cause_link_change : 0;
 543 }
 544
 545 static struct adapter_info t3_adap_info[] = {
 546         { 1, 1, 0,
 547           F_GPIO2_OEN | F_GPIO4_OEN |
 548           F_GPIO2_OUT_VAL | F_GPIO4_OUT_VAL, { S_GPIO3, S_GPIO5 }, 0,
 549           &mi1_mdio_ops, "Chelsio PE9000" },
 550         { 1, 1, 0,
 551           F_GPIO2_OEN | F_GPIO4_OEN |
 552           F_GPIO2_OUT_VAL | F_GPIO4_OUT_VAL, { S_GPIO3, S_GPIO5 }, 0,
 553           &mi1_mdio_ops, "Chelsio T302" },
 554         { 1, 0, 0,
 555           F_GPIO1_OEN | F_GPIO6_OEN | F_GPIO7_OEN | F_GPIO10_OEN |
 556           F_GPIO11_OEN | F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
 557           { 0 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
 558           &mi1_mdio_ext_ops, "Chelsio T310" },
 559         { 1, 1, 0,
 560           F_GPIO1_OEN | F_GPIO2_OEN | F_GPIO4_OEN | F_GPIO5_OEN | F_GPIO6_OEN |
 561           F_GPIO7_OEN | F_GPIO10_OEN | F_GPIO11_OEN | F_GPIO1_OUT_VAL |
 562           F_GPIO5_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
 563           { S_GPIO9, S_GPIO3 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
 564           &mi1_mdio_ext_ops, "Chelsio T320" },
 565         { 4, 0, 0,
 566           F_GPIO5_OEN | F_GPIO6_OEN | F_GPIO7_OEN | F_GPIO5_OUT_VAL |
 567           F_GPIO6_OUT_VAL | F_GPIO7_OUT_VAL,
 568           { S_GPIO1, S_GPIO2, S_GPIO3, S_GPIO4 }, SUPPORTED_AUI,
 569           &mi1_mdio_ops, "Chelsio T304" },
 570         { 0 },
 571         { 1, 0, 0,
 572           F_GPIO1_OEN | F_GPIO2_OEN | F_GPIO4_OEN | F_GPIO6_OEN | F_GPIO7_OEN |
 573           F_GPIO10_OEN | F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL | F_GPIO10_OUT_VAL,
 574           { S_GPIO9 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
 575           &mi1_mdio_ext_ops, "Chelsio T310" },
 576         { 1, 0, 0,
 577           F_GPIO1_OEN | F_GPIO6_OEN | F_GPIO7_OEN |
 578           F_GPIO1_OUT_VAL | F_GPIO6_OUT_VAL,
 579           { S_GPIO9 }, SUPPORTED_10000baseT_Full | SUPPORTED_AUI,
 580           &mi1_mdio_ext_ops, "Chelsio N320E-G2" },
 581 };
 582
 583 /*
 584  * Return the adapter_info structure with a given index.  Out-of-range indices
 585  * return NULL.
 586  */
 587 const struct adapter_info *t3_get_adapter_info(unsigned int id)
 588 {
 589         return id < ARRAY_SIZE(t3_adap_info) ? &t3_adap_info[id] : NULL;
 590 }
 591
 592 struct port_type_info {
 593         int (*phy_prep)(pinfo_t *pinfo, int phy_addr,
 594                         const struct mdio_ops *ops);
 595 };
 596
 597 static struct port_type_info port_types[] = {
 598         { NULL },
 599         { t3_ael1002_phy_prep },
 600         { t3_vsc8211_phy_prep },
 601         { t3_mv88e1xxx_phy_prep },
 602         { t3_xaui_direct_phy_prep },
 603         { t3_ael2005_phy_prep },
 604         { t3_qt2045_phy_prep },
 605         { t3_ael1006_phy_prep },
 606         { t3_tn1010_phy_prep },
 607         { t3_aq100x_phy_prep },
 608         { t3_ael2020_phy_prep },
 609 };
 610
 611 #define VPD_ENTRY(name, len) \
 612         u8 name##_kword[2]; u8 name##_len; u8 name##_data[len]
 613
 614 /*
 615  * Partial EEPROM Vital Product Data structure.  Includes only the ID and
 616  * VPD-R sections.
 617  */
 618 struct t3_vpd {
 619         u8  id_tag;
 620         u8  id_len[2];
 621         u8  id_data[16];
 622         u8  vpdr_tag;
 623         u8  vpdr_len[2];
 624         VPD_ENTRY(pn, 16);                     /* part number */
 625         VPD_ENTRY(ec, ECNUM_LEN);              /* EC level */
 626         VPD_ENTRY(sn, SERNUM_LEN);             /* serial number */
 627         VPD_ENTRY(na, 12);                     /* MAC address base */
 628         VPD_ENTRY(cclk, 6);                    /* core clock */
 629         VPD_ENTRY(mclk, 6);                    /* mem clock */
 630         VPD_ENTRY(uclk, 6);                    /* uP clk */
 631         VPD_ENTRY(mdc, 6);                     /* MDIO clk */
 632         VPD_ENTRY(mt, 2);                      /* mem timing */
 633         VPD_ENTRY(xaui0cfg, 6);                /* XAUI0 config */
 634         VPD_ENTRY(xaui1cfg, 6);                /* XAUI1 config */
 635         VPD_ENTRY(port0, 2);                   /* PHY0 complex */
 636         VPD_ENTRY(port1, 2);                   /* PHY1 complex */
 637         VPD_ENTRY(port2, 2);                   /* PHY2 complex */
 638         VPD_ENTRY(port3, 2);                   /* PHY3 complex */
 639         VPD_ENTRY(rv, 1);                      /* csum */
 640         u32 pad;                  /* for multiple-of-4 sizing and alignment */
 641 };
 642
 643 #define EEPROM_MAX_POLL   40
 644 #define EEPROM_STAT_ADDR  0x4000
 645 #define VPD_BASE          0xc00
 646
 647 /**
 648  *      t3_seeprom_read - read a VPD EEPROM location
 649  *      @adapter: adapter to read
 650  *      @addr: EEPROM address
 651  *      @data: where to store the read data
 652  *
 653  *      Read a 32-bit word from a location in VPD EEPROM using the card's PCI
 654  *      VPD ROM capability.  A zero is written to the flag bit when the
 655  *      address is written to the control register.  The hardware device will
 656  *      set the flag to 1 when 4 bytes have been read into the data register.
 657  */
 658 int t3_seeprom_read(adapter_t *adapter, u32 addr, u32 *data)
 659 {
 660         u16 val;
 661         int attempts = EEPROM_MAX_POLL;
 662         unsigned int base = adapter->params.pci.vpd_cap_addr;
 663
 664         if ((addr >= EEPROMSIZE && addr != EEPROM_STAT_ADDR) || (addr & 3))
 665                 return -EINVAL;
 666
 667         t3_os_pci_write_config_2(adapter, base + PCI_VPD_ADDR, (u16)addr);
 668         do {
 669                 udelay(10);
 670                 t3_os_pci_read_config_2(adapter, base + PCI_VPD_ADDR, &val);
 671         } while (!(val & PCI_VPD_ADDR_F) && --attempts);
 672
 673         if (!(val & PCI_VPD_ADDR_F)) {
 674                 CH_ERR(adapter, "reading EEPROM address 0x%x failed\n", addr);
 675                 return -EIO;
 676         }
 677         t3_os_pci_read_config_4(adapter, base + PCI_VPD_DATA, data);
 678         *data = le32_to_cpu(*data);
 679         return 0;
 680 }
 681
 682 /**
 683  *      t3_seeprom_write - write a VPD EEPROM location
 684  *      @adapter: adapter to write
 685  *      @addr: EEPROM address
 686  *      @data: value to write
 687  *
 688  *      Write a 32-bit word to a location in VPD EEPROM using the card's PCI
 689  *      VPD ROM capability.
 690  */
 691 int t3_seeprom_write(adapter_t *adapter, u32 addr, u32 data)
 692 {
 693         u16 val;
 694         int attempts = EEPROM_MAX_POLL;
 695         unsigned int base = adapter->params.pci.vpd_cap_addr;
 696
 697         if ((addr >= EEPROMSIZE && addr != EEPROM_STAT_ADDR) || (addr & 3))
 698                 return -EINVAL;
 699
 700         t3_os_pci_write_config_4(adapter, base + PCI_VPD_DATA,
 701                                  cpu_to_le32(data));
 702         t3_os_pci_write_config_2(adapter, base + PCI_VPD_ADDR,
 703                                  (u16)addr | PCI_VPD_ADDR_F);
 704         do {
 705                 msleep(1);
 706                 t3_os_pci_read_config_2(adapter, base + PCI_VPD_ADDR, &val);
 707         } while ((val & PCI_VPD_ADDR_F) && --attempts);
 708
 709         if (val & PCI_VPD_ADDR_F) {
 710                 CH_ERR(adapter, "write to EEPROM address 0x%x failed\n", addr);
 711                 return -EIO;
 712         }
 713         return 0;
 714 }
 715
 716 /**
 717  *      t3_seeprom_wp - enable/disable EEPROM write protection
 718  *      @adapter: the adapter
 719  *      @enable: 1 to enable write protection, 0 to disable it
 720  *
 721  *      Enables or disables write protection on the serial EEPROM.
 722  */
 723 int t3_seeprom_wp(adapter_t *adapter, int enable)
 724 {
 725         return t3_seeprom_write(adapter, EEPROM_STAT_ADDR, enable ? 0xc : 0);
 726 }
 727
 728 /*
 729  * Convert a character holding a hex digit to a number.
 730  */
 731 static unsigned int hex2int(unsigned char c)
 732 {
 733         return isdigit(c) ? c - '0' : toupper(c) - 'A' + 10;
 734 }
 735
 736 /**
 737  *      get_desc_len - get the length of a vpd descriptor.
 738  *      @adapter: the adapter
 739  *      @offset: first byte offset of the vpd descriptor
 740  *
 741  *      Retrieves the length of the small/large resource
 742  *      data type starting at offset.
 743  */
 744 static int get_desc_len(adapter_t *adapter, u32 offset)
 745 {
 746         u32 read_offset, tmp, shift, len = 0;
 747         u8 tag, buf[8];
 748         int ret;
 749
 750         read_offset = offset & 0xfffffffc;
 751         shift = offset & 0x03;
 752
 753         ret = t3_seeprom_read(adapter, read_offset, &tmp);
 754         if (ret < 0)
 755                 return ret;
 756
 757         *((u32 *)buf) = cpu_to_le32(tmp);
 758
 759         tag = buf[shift];
 760         if (tag & 0x80) {
 761                 ret = t3_seeprom_read(adapter, read_offset + 4, &tmp);
 762                 if (ret < 0)
 763                         return ret;
 764
 765                 *((u32 *)(&buf[4])) = cpu_to_le32(tmp);
 766                 len = (buf[shift + 1] & 0xff) +
 767                       ((buf[shift+2] << 8) & 0xff00) + 3;
 768         } else
 769                 len = (tag & 0x07) + 1;
 770
 771         return len;
 772 }
 773
 774 /**
 775  *      is_end_tag - Check if a vpd tag is the end tag.
 776  *      @adapter: the adapter
 777  *      @offset: first byte offset of the tag
 778  *
 779  *      Checks if the tag located at offset is the end tag.
 780  */
 781 static int is_end_tag(adapter_t * adapter, u32 offset)
 782 {
 783         u32 read_offset, shift, ret, tmp;
 784         u8 buf[4];
 785
 786         read_offset = offset & 0xfffffffc;
 787         shift = offset & 0x03;
 788
 789         ret = t3_seeprom_read(adapter, read_offset, &tmp);
 790         if (ret)
 791                 return ret;
 792         *((u32 *)buf) = cpu_to_le32(tmp);
 793
 794         if (buf[shift] == 0x78)
 795                 return 1;
 796         else
 797                 return 0;
 798 }
 799
 800 /**
 801  *      t3_get_vpd_len - computes the length of a vpd structure
 802  *      @adapter: the adapter
 803  *      @vpd: contains the offset of first byte of vpd
 804  *
 805  *      Computes the lentgh of the vpd structure starting at vpd->offset.
 806  */
 807
 808 int t3_get_vpd_len(adapter_t * adapter, struct generic_vpd *vpd)
 809 {
 810         u32 len=0, offset;
 811         int inc, ret;
 812
 813         offset = vpd->offset;
 814
 815         while (offset < (vpd->offset + MAX_VPD_BYTES)) {
 816                 ret = is_end_tag(adapter, offset);
 817                 if (ret < 0)
 818                         return ret;
 819                 else if (ret == 1)
 820                         break;
 821
 822                 inc = get_desc_len(adapter, offset);
 823                 if (inc < 0)
 824                         return inc;
 825                 len += inc;
 826                 offset += inc;
 827         }
 828         return (len + 1);
 829 }
 830
 831 /**
 832  *      t3_read_vpd - reads the stream of bytes containing a vpd structure
 833  *      @adapter: the adapter
 834  *      @vpd: contains a buffer that would hold the stream of bytes
 835  *
 836  *      Reads the vpd structure starting at vpd->offset into vpd->data,
 837  *      the length of the byte stream to read is vpd->len.
 838  */
 839
 840 int t3_read_vpd(adapter_t *adapter, struct generic_vpd *vpd)
 841 {
 842         u32 i, ret;
 843
 844         for (i = 0; i < vpd->len; i += 4) {
 845                 ret = t3_seeprom_read(adapter, vpd->offset + i,
 846                                       (u32 *) &(vpd->data[i]));
 847                 if (ret)
 848                         return ret;
 849         }
 850
 851         return 0;
 852 }
 853
 854
 855 /**
 856  *      get_vpd_params - read VPD parameters from VPD EEPROM
 857  *      @adapter: adapter to read
 858  *      @p: where to store the parameters
 859  *
 860  *      Reads card parameters stored in VPD EEPROM.
 861  */
 862 static int get_vpd_params(adapter_t *adapter, struct vpd_params *p)
 863 {
 864         int i, addr, ret;
 865         struct t3_vpd vpd;
 866
 867         /*
 868          * Card information is normally at VPD_BASE but some early cards had
 869          * it at 0.
 870          */
 871         ret = t3_seeprom_read(adapter, VPD_BASE, (u32 *)&vpd);
 872         if (ret)
 873                 return ret;
 874         addr = vpd.id_tag == 0x82 ? VPD_BASE : 0;
 875
 876         for (i = 0; i < sizeof(vpd); i += 4) {
 877                 ret = t3_seeprom_read(adapter, addr + i,
 878                                       (u32 *)((u8 *)&vpd + i));
 879                 if (ret)
 880                         return ret;
 881         }
 882
 883         p->cclk = simple_strtoul(vpd.cclk_data, NULL, 10);
 884         p->mclk = simple_strtoul(vpd.mclk_data, NULL, 10);
 885         p->uclk = simple_strtoul(vpd.uclk_data, NULL, 10);
 886         p->mdc = simple_strtoul(vpd.mdc_data, NULL, 10);
 887         p->mem_timing = simple_strtoul(vpd.mt_data, NULL, 10);
 888         memcpy(p->sn, vpd.sn_data, SERNUM_LEN);
 889         memcpy(p->ec, vpd.ec_data, ECNUM_LEN);
 890
 891         /* Old eeproms didn't have port information */
 892         if (adapter->params.rev == 0 && !vpd.port0_data[0]) {
 893                 p->port_type[0] = uses_xaui(adapter) ? 1 : 2;
 894                 p->port_type[1] = uses_xaui(adapter) ? 6 : 2;
 895         } else {
 896                 p->port_type[0] = (u8)hex2int(vpd.port0_data[0]);
 897                 p->port_type[1] = (u8)hex2int(vpd.port1_data[0]);
 898                 p->port_type[2] = (u8)hex2int(vpd.port2_data[0]);
 899                 p->port_type[3] = (u8)hex2int(vpd.port3_data[0]);
 900                 p->xauicfg[0] = simple_strtoul(vpd.xaui0cfg_data, NULL, 16);
 901                 p->xauicfg[1] = simple_strtoul(vpd.xaui1cfg_data, NULL, 16);
 902         }
 903
 904         for (i = 0; i < 6; i++)
 905                 p->eth_base[i] = hex2int(vpd.na_data[2 * i]) * 16 +
 906                                  hex2int(vpd.na_data[2 * i + 1]);
 907         return 0;
 908 }
 909
 910 /* BIOS boot header */
 911 typedef struct boot_header_s {
 912         u8      signature[2];   /* signature */
 913         u8      length;         /* image length (include header) */
 914         u8      offset[4];      /* initialization vector */
 915         u8      reserved[19];   /* reserved */
 916         u8      exheader[2];    /* offset to expansion header */
 917 } boot_header_t;
 918
 919 /* serial flash and firmware constants */
 920 enum {
 921         SF_ATTEMPTS = 5,           /* max retries for SF1 operations */
 922         SF_SEC_SIZE = 64 * 1024,   /* serial flash sector size */
 923         SF_SIZE = SF_SEC_SIZE * 8, /* serial flash size */
 924
 925         /* flash command opcodes */
 926         SF_PROG_PAGE    = 2,       /* program page */
 927         SF_WR_DISABLE   = 4,       /* disable writes */
 928         SF_RD_STATUS    = 5,       /* read status register */
 929         SF_WR_ENABLE    = 6,       /* enable writes */
 930         SF_RD_DATA_FAST = 0xb,     /* read flash */
 931         SF_ERASE_SECTOR = 0xd8,    /* erase sector */
 932
 933         FW_FLASH_BOOT_ADDR = 0x70000, /* start address of FW in flash */
 934         FW_VERS_ADDR = 0x7fffc,    /* flash address holding FW version */
 935         FW_VERS_ADDR_PRE8 = 0x77ffc,/* flash address holding FW version pre8 */
 936         FW_MIN_SIZE = 8,           /* at least version and csum */
 937         FW_MAX_SIZE = FW_VERS_ADDR - FW_FLASH_BOOT_ADDR,
 938         FW_MAX_SIZE_PRE8 = FW_VERS_ADDR_PRE8 - FW_FLASH_BOOT_ADDR,
 939
 940         BOOT_FLASH_BOOT_ADDR = 0x0,/* start address of boot image in flash */
 941         BOOT_SIGNATURE = 0xaa55,   /* signature of BIOS boot ROM */
 942         BOOT_SIZE_INC = 512,       /* image size measured in 512B chunks */
 943         BOOT_MIN_SIZE = sizeof(boot_header_t), /* at least basic header */
 944         BOOT_MAX_SIZE = 1024*BOOT_SIZE_INC /* 1 byte * length increment  */
 945 };
 946
 947 /**
 948  *      sf1_read - read data from the serial flash
 949  *      @adapter: the adapter
 950  *      @byte_cnt: number of bytes to read
 951  *      @cont: whether another operation will be chained
 952  *      @valp: where to store the read data
 953  *
 954  *      Reads up to 4 bytes of data from the serial flash.  The location of
 955  *      the read needs to be specified prior to calling this by issuing the
 956  *      appropriate commands to the serial flash.
 957  */
 958 static int sf1_read(adapter_t *adapter, unsigned int byte_cnt, int cont,
 959                     u32 *valp)
 960 {
 961         int ret;
 962
 963         if (!byte_cnt || byte_cnt > 4)
 964                 return -EINVAL;
 965         if (t3_read_reg(adapter, A_SF_OP) & F_BUSY)
 966                 return -EBUSY;
 967         t3_write_reg(adapter, A_SF_OP, V_CONT(cont) | V_BYTECNT(byte_cnt - 1));
 968         ret = t3_wait_op_done(adapter, A_SF_OP, F_BUSY, 0, SF_ATTEMPTS, 10);
 969         if (!ret)
 970                 *valp = t3_read_reg(adapter, A_SF_DATA);
 971         return ret;
 972 }
 973
 974 /**
 975  *      sf1_write - write data to the serial flash
 976  *      @adapter: the adapter
 977  *      @byte_cnt: number of bytes to write
 978  *      @cont: whether another operation will be chained
 979  *      @val: value to write
 980  *
 981  *      Writes up to 4 bytes of data to the serial flash.  The location of
 982  *      the write needs to be specified prior to calling this by issuing the
 983  *      appropriate commands to the serial flash.
 984  */
 985 static int sf1_write(adapter_t *adapter, unsigned int byte_cnt, int cont,
 986                      u32 val)
 987 {
 988         if (!byte_cnt || byte_cnt > 4)
 989                 return -EINVAL;
 990         if (t3_read_reg(adapter, A_SF_OP) & F_BUSY)
 991                 return -EBUSY;
 992         t3_write_reg(adapter, A_SF_DATA, val);
 993         t3_write_reg(adapter, A_SF_OP,
 994                      V_CONT(cont) | V_BYTECNT(byte_cnt - 1) | V_OP(1));
 995         return t3_wait_op_done(adapter, A_SF_OP, F_BUSY, 0, SF_ATTEMPTS, 10);
 996 }
 997
 998 /**
 999  *      flash_wait_op - wait for a flash operation to complete
1000  *      @adapter: the adapter
1001  *      @attempts: max number of polls of the status register
1002  *      @delay: delay between polls in ms
1003  *
1004  *      Wait for a flash operation to complete by polling the status register.
1005  */
1006 static int flash_wait_op(adapter_t *adapter, int attempts, int delay)
1007 {
1008         int ret;
1009         u32 status;
1010
1011         while (1) {
1012                 if ((ret = sf1_write(adapter, 1, 1, SF_RD_STATUS)) != 0 ||
1013                     (ret = sf1_read(adapter, 1, 0, &status)) != 0)
1014                         return ret;
1015                 if (!(status & 1))
1016                         return 0;
1017                 if (--attempts == 0)
1018                         return -EAGAIN;
1019                 if (delay)
1020                         msleep(delay);
1021         }
1022 }
1023
1024 /**
1025  *      t3_read_flash - read words from serial flash
1026  *      @adapter: the adapter
1027  *      @addr: the start address for the read
1028  *      @nwords: how many 32-bit words to read
1029  *      @data: where to store the read data
1030  *      @byte_oriented: whether to store data as bytes or as words
1031  *
1032  *      Read the specified number of 32-bit words from the serial flash.
1033  *      If @byte_oriented is set the read data is stored as a byte array
1034  *      (i.e., big-endian), otherwise as 32-bit words in the platform's
1035  *      natural endianness.
1036  */
1037 int t3_read_flash(adapter_t *adapter, unsigned int addr, unsigned int nwords,
1038                   u32 *data, int byte_oriented)
1039 {
1040         int ret;
1041
1042         if (addr + nwords * sizeof(u32) > SF_SIZE || (addr & 3))
1043                 return -EINVAL;
1044
1045         addr = swab32(addr) | SF_RD_DATA_FAST;
1046
1047         if ((ret = sf1_write(adapter, 4, 1, addr)) != 0 ||
1048             (ret = sf1_read(adapter, 1, 1, data)) != 0)
1049                 return ret;
1050
1051         for ( ; nwords; nwords--, data++) {
1052                 ret = sf1_read(adapter, 4, nwords > 1, data);
1053                 if (ret)
1054                         return ret;
1055                 if (byte_oriented)
1056                         *data = htonl(*data);
1057         }
1058         return 0;
1059 }
1060
1061 /**
1062  *      t3_write_flash - write up to a page of data to the serial flash
1063  *      @adapter: the adapter
1064  *      @addr: the start address to write
1065  *      @n: length of data to write
1066  *      @data: the data to write
1067  *      @byte_oriented: whether to store data as bytes or as words
1068  *
1069  *      Writes up to a page of data (256 bytes) to the serial flash starting
1070  *      at the given address.
1071  *      If @byte_oriented is set the write data is stored as a 32-bit
1072  *      big-endian array, otherwise in the processor's native endianness.
1073  *
1074  */
1075 static int t3_write_flash(adapter_t *adapter, unsigned int addr,
1076                           unsigned int n, const u8 *data,
1077                           int byte_oriented)
1078 {
1079         int ret;
1080         u32 buf[64];
1081         unsigned int c, left, val, offset = addr & 0xff;
1082
1083         if (addr + n > SF_SIZE || offset + n > 256)
1084                 return -EINVAL;
1085
1086         val = swab32(addr) | SF_PROG_PAGE;
1087
1088         if ((ret = sf1_write(adapter, 1, 0, SF_WR_ENABLE)) != 0 ||
1089             (ret = sf1_write(adapter, 4, 1, val)) != 0)
1090                 return ret;
1091
1092         for (left = n; left; left -= c) {
1093                 c = min(left, 4U);
1094                 val = *(const u32*)data;
1095                 data += c;
1096                 if (byte_oriented)
1097                         val = htonl(val);
1098
1099                 ret = sf1_write(adapter, c, c != left, val);
1100                 if (ret)
1101                         return ret;
1102         }
1103         if ((ret = flash_wait_op(adapter, 5, 1)) != 0)
1104                 return ret;
1105
1106         /* Read the page to verify the write succeeded */
1107         ret = t3_read_flash(adapter, addr & ~0xff, ARRAY_SIZE(buf), buf,
1108                             byte_oriented);
1109         if (ret)
1110                 return ret;
1111
1112         if (memcmp(data - n, (u8 *)buf + offset, n))
1113                 return -EIO;
1114         return 0;
1115 }
1116
1117 /**
1118  *      t3_get_tp_version - read the tp sram version
1119  *      @adapter: the adapter
1120  *      @vers: where to place the version
1121  *
1122  *      Reads the protocol sram version from sram.
1123  */
1124 int t3_get_tp_version(adapter_t *adapter, u32 *vers)
1125 {
1126         int ret;
1127
1128         /* Get version loaded in SRAM */
1129         t3_write_reg(adapter, A_TP_EMBED_OP_FIELD0, 0);
1130         ret = t3_wait_op_done(adapter, A_TP_EMBED_OP_FIELD0,
1131                               1, 1, 5, 1);
1132         if (ret)
1133                 return ret;
1134
1135         *vers = t3_read_reg(adapter, A_TP_EMBED_OP_FIELD1);
1136
1137         return 0;
1138 }
1139
1140 /**
1141  *      t3_check_tpsram_version - read the tp sram version
1142  *      @adapter: the adapter
1143  *
1144  */
1145 int t3_check_tpsram_version(adapter_t *adapter)
1146 {
1147         int ret;
1148         u32 vers;
1149         unsigned int major, minor;
1150
1151         if (adapter->params.rev == T3_REV_A)
1152                 return 0;
1153
1154
1155         ret = t3_get_tp_version(adapter, &vers);
1156         if (ret)
1157                 return ret;
1158
1159         vers = t3_read_reg(adapter, A_TP_EMBED_OP_FIELD1);
1160
1161         major = G_TP_VERSION_MAJOR(vers);
1162         minor = G_TP_VERSION_MINOR(vers);
1163
1164         if (major == TP_VERSION_MAJOR && minor == TP_VERSION_MINOR)
1165                 return 0;
1166         else {
1167                 CH_ERR(adapter, "found wrong TP version (%u.%u), "
1168                        "driver compiled for version %d.%d\n", major, minor,
1169                        TP_VERSION_MAJOR, TP_VERSION_MINOR);
1170         }
1171         return -EINVAL;
1172 }
1173
1174 /**
1175  *      t3_check_tpsram - check if provided protocol SRAM
1176  *                        is compatible with this driver
1177  *      @adapter: the adapter
1178  *      @tp_sram: the firmware image to write
1179  *      @size: image size
1180  *
1181  *      Checks if an adapter's tp sram is compatible with the driver.
1182  *      Returns 0 if the versions are compatible, a negative error otherwise.
1183  */
1184 int t3_check_tpsram(adapter_t *adapter, const u8 *tp_sram, unsigned int size)
1185 {
1186         u32 csum;
1187         unsigned int i;
1188         const u32 *p = (const u32 *)tp_sram;
1189
1190         /* Verify checksum */
1191         for (csum = 0, i = 0; i < size / sizeof(csum); i++)
1192                 csum += ntohl(p[i]);
1193         if (csum != 0xffffffff) {
1194                 CH_ERR(adapter, "corrupted protocol SRAM image, checksum %u\n",
1195                        csum);
1196                 return -EINVAL;
1197         }
1198
1199         return 0;
1200 }
1201
1202 enum fw_version_type {
1203         FW_VERSION_N3,
1204         FW_VERSION_T3
1205 };
1206
1207 /**
1208  *      t3_get_fw_version - read the firmware version
1209  *      @adapter: the adapter
1210  *      @vers: where to place the version
1211  *
1212  *      Reads the FW version from flash. Note that we had to move the version
1213  *      due to FW size. If we don't find a valid FW version in the new location
1214  *      we fall back and read the old location.
1215  */
1216 int t3_get_fw_version(adapter_t *adapter, u32 *vers)
1217 {
1218         int ret = t3_read_flash(adapter, FW_VERS_ADDR, 1, vers, 0);
1219         if (!ret && *vers != 0xffffffff)
1220                 return 0;
1221         else
1222                 return t3_read_flash(adapter, FW_VERS_ADDR_PRE8, 1, vers, 0);
1223 }
1224
1225 /**
1226  *      t3_check_fw_version - check if the FW is compatible with this driver
1227  *      @adapter: the adapter
1228  *
1229  *      Checks if an adapter's FW is compatible with the driver.  Returns 0
1230  *      if the versions are compatible, a negative error otherwise.
1231  */
1232 int t3_check_fw_version(adapter_t *adapter)
1233 {
1234         int ret;
1235         u32 vers;
1236         unsigned int type, major, minor;
1237
1238         ret = t3_get_fw_version(adapter, &vers);
1239         if (ret)
1240                 return ret;
1241
1242         type = G_FW_VERSION_TYPE(vers);
1243         major = G_FW_VERSION_MAJOR(vers);
1244         minor = G_FW_VERSION_MINOR(vers);
1245
1246         if (type == FW_VERSION_T3 && major == FW_VERSION_MAJOR &&
1247             minor == FW_VERSION_MINOR)
1248                 return 0;
1249
1250         else if (major != FW_VERSION_MAJOR || minor < FW_VERSION_MINOR)
1251                 CH_WARN(adapter, "found old FW minor version(%u.%u), "
1252                         "driver compiled for version %u.%u\n", major, minor,
1253                         FW_VERSION_MAJOR, FW_VERSION_MINOR);
1254         else {
1255                 CH_WARN(adapter, "found newer FW version(%u.%u), "
1256                         "driver compiled for version %u.%u\n", major, minor,
1257                         FW_VERSION_MAJOR, FW_VERSION_MINOR);
1258                         return 0;
1259         }
1260         return -EINVAL;
1261 }
1262
1263 /**
1264  *      t3_flash_erase_sectors - erase a range of flash sectors
1265  *      @adapter: the adapter
1266  *      @start: the first sector to erase
1267  *      @end: the last sector to erase
1268  *
1269  *      Erases the sectors in the given range.
1270  */
1271 static int t3_flash_erase_sectors(adapter_t *adapter, int start, int end)
1272 {
1273         while (start <= end) {
1274                 int ret;
1275
1276                 if ((ret = sf1_write(adapter, 1, 0, SF_WR_ENABLE)) != 0 ||
1277                     (ret = sf1_write(adapter, 4, 0,
1278                                      SF_ERASE_SECTOR | (start << 8))) != 0 ||
1279                     (ret = flash_wait_op(adapter, 5, 500)) != 0)
1280                         return ret;
1281                 start++;
1282         }
1283         return 0;
1284 }
1285
1286 /*
1287  *      t3_load_fw - download firmware
1288  *      @adapter: the adapter
1289  *      @fw_data: the firmware image to write
1290  *      @size: image size
1291  *
1292  *      Write the supplied firmware image to the card's serial flash.
1293  *      The FW image has the following sections: @size - 8 bytes of code and
1294  *      data, followed by 4 bytes of FW version, followed by the 32-bit
1295  *      1's complement checksum of the whole image.
1296  */
1297 int t3_load_fw(adapter_t *adapter, const u8 *fw_data, unsigned int size)
1298 {
1299         u32 version, csum, fw_version_addr;
1300         unsigned int i;
1301         const u32 *p = (const u32 *)fw_data;
1302         int ret, addr, fw_sector = FW_FLASH_BOOT_ADDR >> 16;
1303
1304         if ((size & 3) || size < FW_MIN_SIZE)
1305                 return -EINVAL;
1306         if (size - 8 > FW_MAX_SIZE)
1307                 return -EFBIG;
1308
1309         version = ntohl(*(const u32 *)(fw_data + size - 8));
1310         if (G_FW_VERSION_MAJOR(version) < 8) {
1311
1312                 fw_version_addr = FW_VERS_ADDR_PRE8;
1313
1314                 if (size - 8 > FW_MAX_SIZE_PRE8)
1315                         return -EFBIG;
1316         } else
1317                 fw_version_addr = FW_VERS_ADDR;
1318
1319         for (csum = 0, i = 0; i < size / sizeof(csum); i++)
1320                 csum += ntohl(p[i]);
1321         if (csum != 0xffffffff) {
1322                 CH_ERR(adapter, "corrupted firmware image, checksum %u\n",
1323                        csum);
1324                 return -EINVAL;
1325         }
1326
1327         ret = t3_flash_erase_sectors(adapter, fw_sector, fw_sector);
1328         if (ret)
1329                 goto out;
1330
1331         size -= 8;  /* trim off version and checksum */
1332         for (addr = FW_FLASH_BOOT_ADDR; size; ) {
1333                 unsigned int chunk_size = min(size, 256U);
1334
1335                 ret = t3_write_flash(adapter, addr, chunk_size, fw_data, 1);
1336                 if (ret)
1337                         goto out;
1338
1339                 addr += chunk_size;
1340                 fw_data += chunk_size;
1341                 size -= chunk_size;
1342         }
1343
1344         ret = t3_write_flash(adapter, fw_version_addr, 4, fw_data, 1);
1345 out:
1346         if (ret)
1347                 CH_ERR(adapter, "firmware download failed, error %d\n", ret);
1348         return ret;
1349 }
1350
1351 /*
1352  *      t3_load_boot - download boot flash
1353  *      @adapter: the adapter
1354  *      @boot_data: the boot image to write
1355  *      @size: image size
1356  *
1357  *      Write the supplied boot image to the card's serial flash.
1358  *      The boot image has the following sections: a 28-byte header and the
1359  *      boot image.
1360  */
1361 int t3_load_boot(adapter_t *adapter, u8 *boot_data, unsigned int size)
1362 {
1363         boot_header_t *header = (boot_header_t *)boot_data;
1364         int ret;
1365         unsigned int addr;
1366         unsigned int boot_sector = BOOT_FLASH_BOOT_ADDR >> 16;
1367         unsigned int boot_end = (BOOT_FLASH_BOOT_ADDR + size - 1) >> 16;
1368
1369         /*
1370          * Perform some primitive sanity testing to avoid accidentally
1371          * writing garbage over the boot sectors.  We ought to check for
1372          * more but it's not worth it for now ...
1373          */
1374         if (size < BOOT_MIN_SIZE || size > BOOT_MAX_SIZE) {
1375                 CH_ERR(adapter, "boot image too small/large\n");
1376                 return -EFBIG;
1377         }
1378         if (le16_to_cpu(*(u16*)header->signature) != BOOT_SIGNATURE) {
1379                 CH_ERR(adapter, "boot image missing signature\n");
1380                 return -EINVAL;
1381         }
1382         if (header->length * BOOT_SIZE_INC != size) {
1383                 CH_ERR(adapter, "boot image header length != image length\n");
1384                 return -EINVAL;
1385         }
1386
1387         ret = t3_flash_erase_sectors(adapter, boot_sector, boot_end);
1388         if (ret)
1389                 goto out;
1390
1391         for (addr = BOOT_FLASH_BOOT_ADDR; size; ) {
1392                 unsigned int chunk_size = min(size, 256U);
1393
1394                 ret = t3_write_flash(adapter, addr, chunk_size, boot_data, 0);
1395                 if (ret)
1396                         goto out;
1397
1398                 addr += chunk_size;
1399                 boot_data += chunk_size;
1400                 size -= chunk_size;
1401         }
1402
1403 out:
1404         if (ret)
1405                 CH_ERR(adapter, "boot image download failed, error %d\n", ret);
1406         return ret;
1407 }
1408
1409 #define CIM_CTL_BASE 0x2000
1410
1411 /**
1412  *      t3_cim_ctl_blk_read - read a block from CIM control region
1413  *      @adap: the adapter
1414  *      @addr: the start address within the CIM control region
1415  *      @n: number of words to read
1416  *      @valp: where to store the result
1417  *
1418  *      Reads a block of 4-byte words from the CIM control region.
1419  */
1420 int t3_cim_ctl_blk_read(adapter_t *adap, unsigned int addr, unsigned int n,
1421                         unsigned int *valp)
1422 {
1423         int ret = 0;
1424
1425         if (t3_read_reg(adap, A_CIM_HOST_ACC_CTRL) & F_HOSTBUSY)
1426                 return -EBUSY;
1427
1428         for ( ; !ret && n--; addr += 4) {
1429                 t3_write_reg(adap, A_CIM_HOST_ACC_CTRL, CIM_CTL_BASE + addr);
1430                 ret = t3_wait_op_done(adap, A_CIM_HOST_ACC_CTRL, F_HOSTBUSY,
1431                                       0, 5, 2);
1432                 if (!ret)
1433                         *valp++ = t3_read_reg(adap, A_CIM_HOST_ACC_DATA);
1434         }
1435         return ret;
1436 }
1437
1438 static void t3_gate_rx_traffic(struct cmac *mac, u32 *rx_cfg,
1439                                u32 *rx_hash_high, u32 *rx_hash_low)
1440 {
1441         /* stop Rx unicast traffic */
1442         t3_mac_disable_exact_filters(mac);
1443
1444         /* stop broadcast, multicast, promiscuous mode traffic */
1445         *rx_cfg = t3_read_reg(mac->adapter, A_XGM_RX_CFG + mac->offset);
1446         t3_set_reg_field(mac->adapter, A_XGM_RX_CFG + mac->offset,
1447                          F_ENHASHMCAST | F_DISBCAST | F_COPYALLFRAMES,
1448                          F_DISBCAST);
1449
1450         *rx_hash_high = t3_read_reg(mac->adapter, A_XGM_RX_HASH_HIGH +
1451             mac->offset);
1452         t3_write_reg(mac->adapter, A_XGM_RX_HASH_HIGH + mac->offset, 0);
1453
1454         *rx_hash_low = t3_read_reg(mac->adapter, A_XGM_RX_HASH_LOW +
1455             mac->offset);
1456         t3_write_reg(mac->adapter, A_XGM_RX_HASH_LOW + mac->offset, 0);
1457
1458         /* Leave time to drain max RX fifo */
1459         msleep(1);
1460 }
1461
1462 static void t3_open_rx_traffic(struct cmac *mac, u32 rx_cfg,
1463                                u32 rx_hash_high, u32 rx_hash_low)
1464 {
1465         t3_mac_enable_exact_filters(mac);
1466         t3_set_reg_field(mac->adapter, A_XGM_RX_CFG + mac->offset,
1467                          F_ENHASHMCAST | F_DISBCAST | F_COPYALLFRAMES,
1468                          rx_cfg);
1469         t3_write_reg(mac->adapter, A_XGM_RX_HASH_HIGH + mac->offset,
1470             rx_hash_high);
1471         t3_write_reg(mac->adapter, A_XGM_RX_HASH_LOW + mac->offset,
1472             rx_hash_low);
1473 }
1474
1475 static int t3_detect_link_fault(adapter_t *adapter, int port_id)
1476 {
1477         struct port_info *pi = adap2pinfo(adapter, port_id);
1478         struct cmac *mac = &pi->mac;
1479         uint32_t rx_cfg, rx_hash_high, rx_hash_low;
1480         int link_fault;
1481
1482         /* stop rx */
1483         t3_gate_rx_traffic(mac, &rx_cfg, &rx_hash_high, &rx_hash_low);
1484         t3_write_reg(adapter, A_XGM_RX_CTRL + mac->offset, 0);
1485
1486         /* clear status and make sure intr is enabled */
1487         (void) t3_read_reg(adapter, A_XGM_INT_STATUS + mac->offset);
1488         t3_xgm_intr_enable(adapter, port_id);
1489
1490         /* restart rx */
1491         t3_write_reg(adapter, A_XGM_RX_CTRL + mac->offset, F_RXEN);
1492         t3_open_rx_traffic(mac, rx_cfg, rx_hash_high, rx_hash_low);
1493
1494         link_fault = t3_read_reg(adapter, A_XGM_INT_STATUS + mac->offset);
1495         return (link_fault & F_LINKFAULTCHANGE ? 1 : 0);
1496 }
1497
1498 static void t3_clear_faults(adapter_t *adapter, int port_id)
1499 {
1500         struct port_info *pi = adap2pinfo(adapter, port_id);
1501         struct cmac *mac = &pi->mac;
1502
1503         if (adapter->params.nports <= 2) {
1504                 t3_xgm_intr_disable(adapter, pi->port_id);
1505                 t3_read_reg(adapter, A_XGM_INT_STATUS + mac->offset);
1506                 t3_write_reg(adapter, A_XGM_INT_CAUSE + mac->offset, F_XGM_INT);
1507                 t3_set_reg_field(adapter, A_XGM_INT_ENABLE + mac->offset,
1508                                  F_XGM_INT, F_XGM_INT);
1509                 t3_xgm_intr_enable(adapter, pi->port_id);
1510         }
1511 }
1512
1513 /**
1514  *      t3_link_changed - handle interface link changes
1515  *      @adapter: the adapter
1516  *      @port_id: the port index that changed link state
1517  *
1518  *      Called when a port's link settings change to propagate the new values
1519  *      to the associated PHY and MAC.  After performing the common tasks it
1520  *      invokes an OS-specific handler.
1521  */
1522 void t3_link_changed(adapter_t *adapter, int port_id)
1523 {
1524         int link_ok, speed, duplex, fc, link_fault, link_state;
1525         struct port_info *pi = adap2pinfo(adapter, port_id);
1526         struct cphy *phy = &pi->phy;
1527         struct cmac *mac = &pi->mac;
1528         struct link_config *lc = &pi->link_config;
1529
1530         link_ok = lc->link_ok;
1531         speed = lc->speed;
1532         duplex = lc->duplex;
1533         fc = lc->fc;
1534         link_fault = 0;
1535
1536         phy->ops->get_link_status(phy, &link_state, &speed, &duplex, &fc);
1537         link_ok = (link_state == PHY_LINK_UP);
1538         if (link_state != PHY_LINK_PARTIAL)
1539                 phy->rst = 0;
1540         else if (++phy->rst == 3) {
1541                 phy->ops->reset(phy, 0);
1542                 phy->rst = 0;
1543         }
1544
1545         if (link_ok == 0)
1546                 pi->link_fault = LF_NO;
1547
1548         if (lc->requested_fc & PAUSE_AUTONEG)
1549                 fc &= lc->requested_fc;
1550         else
1551                 fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
1552
1553         /* Update mac speed before checking for link fault. */
1554         if (link_ok && speed >= 0 && lc->autoneg == AUTONEG_ENABLE &&
1555             (speed != lc->speed || duplex != lc->duplex || fc != lc->fc))
1556                 t3_mac_set_speed_duplex_fc(mac, speed, duplex, fc);
1557
1558         /*
1559          * Check for link faults if any of these is true:
1560          * a) A link fault is suspected, and PHY says link ok
1561          * b) PHY link transitioned from down -> up
1562          */
1563         if (adapter->params.nports <= 2 &&
1564             ((pi->link_fault && link_ok) || (!lc->link_ok && link_ok))) {
1565
1566                 link_fault = t3_detect_link_fault(adapter, port_id);
1567                 if (link_fault) {
1568                         if (pi->link_fault != LF_YES) {
1569                                 mac->stats.link_faults++;
1570                                 pi->link_fault = LF_YES;
1571                         }
1572
1573                         if (uses_xaui(adapter)) {
1574                                 if (adapter->params.rev >= T3_REV_C)
1575                                         t3c_pcs_force_los(mac);
1576                                 else
1577                                         t3b_pcs_reset(mac);
1578                         }
1579
1580                         /* Don't report link up */
1581                         link_ok = 0;
1582                 } else {
1583                         /* clear faults here if this was a false alarm. */
1584                         if (pi->link_fault == LF_MAYBE &&
1585                             link_ok && lc->link_ok)
1586                                 t3_clear_faults(adapter, port_id);
1587
1588                         pi->link_fault = LF_NO;
1589                 }
1590         }
1591
1592         if (link_ok == lc->link_ok && speed == lc->speed &&
1593             duplex == lc->duplex && fc == lc->fc)
1594                 return;                            /* nothing changed */
1595
1596         lc->link_ok = (unsigned char)link_ok;
1597         lc->speed = speed < 0 ? SPEED_INVALID : speed;
1598         lc->duplex = duplex < 0 ? DUPLEX_INVALID : duplex;
1599         lc->fc = fc;
1600
1601         if (link_ok) {
1602
1603                 /* down -> up, or up -> up with changed settings */
1604
1605                 if (adapter->params.rev > 0 && uses_xaui(adapter)) {
1606
1607                         if (adapter->params.rev >= T3_REV_C)
1608                                 t3c_pcs_force_los(mac);
1609                         else
1610                                 t3b_pcs_reset(mac);
1611
1612                         t3_write_reg(adapter, A_XGM_XAUI_ACT_CTRL + mac->offset,
1613                                      F_TXACTENABLE | F_RXEN);
1614                 }
1615
1616                 /* disable TX FIFO drain */
1617                 t3_set_reg_field(adapter, A_XGM_TXFIFO_CFG + mac->offset,
1618                                  F_ENDROPPKT, 0);
1619
1620                 t3_mac_enable(mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX);
1621                 t3_set_reg_field(adapter, A_XGM_STAT_CTRL + mac->offset,
1622                                  F_CLRSTATS, 1);
1623                 t3_clear_faults(adapter, port_id);
1624
1625         } else {
1626
1627                 /* up -> down */
1628
1629                 if (adapter->params.rev > 0 && uses_xaui(adapter)) {
1630                         t3_write_reg(adapter,
1631                                      A_XGM_XAUI_ACT_CTRL + mac->offset, 0);
1632                 }
1633
1634                 t3_xgm_intr_disable(adapter, pi->port_id);
1635                 if (adapter->params.nports <= 2) {
1636                         t3_set_reg_field(adapter,
1637                                          A_XGM_INT_ENABLE + mac->offset,
1638                                          F_XGM_INT, 0);
1639
1640                         t3_mac_disable(mac, MAC_DIRECTION_RX);
1641
1642                         /*
1643                          * Make sure Tx FIFO continues to drain, even as rxen is
1644                          * left high to help detect and indicate remote faults.
1645                          */
1646                         t3_set_reg_field(adapter,
1647                             A_XGM_TXFIFO_CFG + mac->offset, 0, F_ENDROPPKT);
1648                         t3_write_reg(adapter, A_XGM_RX_CTRL + mac->offset, 0);
1649                         t3_write_reg(adapter,
1650                             A_XGM_TX_CTRL + mac->offset, F_TXEN);
1651                         t3_write_reg(adapter,
1652                             A_XGM_RX_CTRL + mac->offset, F_RXEN);
1653                 }
1654         }
1655
1656         t3_os_link_changed(adapter, port_id, link_ok, speed, duplex, fc,
1657             mac->was_reset);
1658         mac->was_reset = 0;
1659 }
1660
1661 /**
1662  *      t3_link_start - apply link configuration to MAC/PHY
1663  *      @phy: the PHY to setup
1664  *      @mac: the MAC to setup
1665  *      @lc: the requested link configuration
1666  *
1667  *      Set up a port's MAC and PHY according to a desired link configuration.
1668  *      - If the PHY can auto-negotiate first decide what to advertise, then
1669  *        enable/disable auto-negotiation as desired, and reset.
1670  *      - If the PHY does not auto-negotiate just reset it.
1671  *      - If auto-negotiation is off set the MAC to the proper speed/duplex/FC,
1672  *        otherwise do it later based on the outcome of auto-negotiation.
1673  */
1674 int t3_link_start(struct cphy *phy, struct cmac *mac, struct link_config *lc)
1675 {
1676         unsigned int fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
1677
1678         lc->link_ok = 0;
1679         if (lc->supported & SUPPORTED_Autoneg) {
1680                 lc->advertising &= ~(ADVERTISED_Asym_Pause | ADVERTISED_Pause);
1681                 if (fc) {
1682                         lc->advertising |= ADVERTISED_Asym_Pause;
1683                         if (fc & PAUSE_RX)
1684                                 lc->advertising |= ADVERTISED_Pause;
1685                 }
1686
1687                 phy->ops->advertise(phy, lc->advertising);
1688
1689                 if (lc->autoneg == AUTONEG_DISABLE) {
1690                         lc->speed = lc->requested_speed;
1691                         lc->duplex = lc->requested_duplex;
1692                         lc->fc = (unsigned char)fc;
1693                         t3_mac_set_speed_duplex_fc(mac, lc->speed, lc->duplex,
1694                                                    fc);
1695                         /* Also disables autoneg */
1696                         phy->ops->set_speed_duplex(phy, lc->speed, lc->duplex);
1697                         /* PR 5666. Power phy up when doing an ifup */
1698                         if (!is_10G(phy->adapter))
1699                                 phy->ops->power_down(phy, 0);
1700                 } else
1701                         phy->ops->autoneg_enable(phy);
1702         } else {
1703                 t3_mac_set_speed_duplex_fc(mac, -1, -1, fc);
1704                 lc->fc = (unsigned char)fc;
1705                 phy->ops->reset(phy, 0);
1706         }
1707         return 0;
1708 }
1709
1710 /**
1711  *      t3_set_vlan_accel - control HW VLAN extraction
1712  *      @adapter: the adapter
1713  *      @ports: bitmap of adapter ports to operate on
1714  *      @on: enable (1) or disable (0) HW VLAN extraction
1715  *
1716  *      Enables or disables HW extraction of VLAN tags for the given port.
1717  */
1718 void t3_set_vlan_accel(adapter_t *adapter, unsigned int ports, int on)
1719 {
1720         t3_set_reg_field(adapter, A_TP_OUT_CONFIG,
1721                          ports << S_VLANEXTRACTIONENABLE,
1722                          on ? (ports << S_VLANEXTRACTIONENABLE) : 0);
1723 }
1724
1725 struct intr_info {
1726         unsigned int mask;       /* bits to check in interrupt status */
1727         const char *msg;         /* message to print or NULL */
1728         short stat_idx;          /* stat counter to increment or -1 */
1729         unsigned short fatal;    /* whether the condition reported is fatal */
1730 };
1731
1732 /**
1733  *      t3_handle_intr_status - table driven interrupt handler
1734  *      @adapter: the adapter that generated the interrupt
1735  *      @reg: the interrupt status register to process
1736  *      @mask: a mask to apply to the interrupt status
1737  *      @acts: table of interrupt actions
1738  *      @stats: statistics counters tracking interrupt occurrences
1739  *
1740  *      A table driven interrupt handler that applies a set of masks to an
1741  *      interrupt status word and performs the corresponding actions if the
1742  *      interrupts described by the mask have occurred.  The actions include
1743  *      optionally printing a warning or alert message, and optionally
1744  *      incrementing a stat counter.  The table is terminated by an entry
1745  *      specifying mask 0.  Returns the number of fatal interrupt conditions.
1746  */
1747 static int t3_handle_intr_status(adapter_t *adapter, unsigned int reg,
1748                                  unsigned int mask,
1749                                  const struct intr_info *acts,
1750                                  unsigned long *stats)
1751 {
1752         int fatal = 0;
1753         unsigned int status = t3_read_reg(adapter, reg) & mask;
1754
1755         for ( ; acts->mask; ++acts) {
1756                 if (!(status & acts->mask)) continue;
1757                 if (acts->fatal) {
1758                         fatal++;
1759                         CH_ALERT(adapter, "%s (0x%x)\n",
1760                                  acts->msg, status & acts->mask);
1761                         status &= ~acts->mask;
1762                 } else if (acts->msg)
1763                         CH_WARN(adapter, "%s (0x%x)\n",
1764                                 acts->msg, status & acts->mask);
1765                 if (acts->stat_idx >= 0)
1766                         stats[acts->stat_idx]++;
1767         }
1768         if (status)                           /* clear processed interrupts */
1769                 t3_write_reg(adapter, reg, status);
1770         return fatal;
1771 }
1772
1773 #define SGE_INTR_MASK (F_RSPQDISABLED | \
1774                        F_UC_REQ_FRAMINGERROR | F_R_REQ_FRAMINGERROR | \
1775                        F_CPPARITYERROR | F_OCPARITYERROR | F_RCPARITYERROR | \
1776                        F_IRPARITYERROR | V_ITPARITYERROR(M_ITPARITYERROR) | \
1777                        V_FLPARITYERROR(M_FLPARITYERROR) | F_LODRBPARITYERROR | \
1778                        F_HIDRBPARITYERROR | F_LORCQPARITYERROR | \
1779                        F_HIRCQPARITYERROR)
1780 #define MC5_INTR_MASK (F_PARITYERR | F_ACTRGNFULL | F_UNKNOWNCMD | \
1781                        F_REQQPARERR | F_DISPQPARERR | F_DELACTEMPTY | \
1782                        F_NFASRCHFAIL)
1783 #define MC7_INTR_MASK (F_AE | F_UE | F_CE | V_PE(M_PE))
1784 #define XGM_INTR_MASK (V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR) | \
1785                        V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR) | \
1786                        F_TXFIFO_UNDERRUN)
1787 #define PCIX_INTR_MASK (F_MSTDETPARERR | F_SIGTARABT | F_RCVTARABT | \
1788                         F_RCVMSTABT | F_SIGSYSERR | F_DETPARERR | \
1789                         F_SPLCMPDIS | F_UNXSPLCMP | F_RCVSPLCMPERR | \
1790                         F_DETCORECCERR | F_DETUNCECCERR | F_PIOPARERR | \
1791                         V_WFPARERR(M_WFPARERR) | V_RFPARERR(M_RFPARERR) | \
1792                         V_CFPARERR(M_CFPARERR) /* | V_MSIXPARERR(M_MSIXPARERR) */)
1793 #define PCIE_INTR_MASK (F_UNXSPLCPLERRR | F_UNXSPLCPLERRC | F_PCIE_PIOPARERR |\
1794                         F_PCIE_WFPARERR | F_PCIE_RFPARERR | F_PCIE_CFPARERR | \
1795                         /* V_PCIE_MSIXPARERR(M_PCIE_MSIXPARERR) | */ \
1796                         F_RETRYBUFPARERR | F_RETRYLUTPARERR | F_RXPARERR | \
1797                         F_TXPARERR | V_BISTERR(M_BISTERR))
1798 #define ULPRX_INTR_MASK (F_PARERRDATA | F_PARERRPCMD | F_ARBPF1PERR | \
1799                          F_ARBPF0PERR | F_ARBFPERR | F_PCMDMUXPERR | \
1800                          F_DATASELFRAMEERR1 | F_DATASELFRAMEERR0)
1801 #define ULPTX_INTR_MASK 0xfc
1802 #define CPLSW_INTR_MASK (F_CIM_OP_MAP_PERR | F_TP_FRAMING_ERROR | \
1803                          F_SGE_FRAMING_ERROR | F_CIM_FRAMING_ERROR | \
1804                          F_ZERO_SWITCH_ERROR)
1805 #define CIM_INTR_MASK (F_BLKWRPLINT | F_BLKRDPLINT | F_BLKWRCTLINT | \
1806                        F_BLKRDCTLINT | F_BLKWRFLASHINT | F_BLKRDFLASHINT | \
1807                        F_SGLWRFLASHINT | F_WRBLKFLASHINT | F_BLKWRBOOTINT | \
1808                        F_FLASHRANGEINT | F_SDRAMRANGEINT | F_RSVDSPACEINT | \
1809                        F_DRAMPARERR | F_ICACHEPARERR | F_DCACHEPARERR | \
1810                        F_OBQSGEPARERR | F_OBQULPHIPARERR | F_OBQULPLOPARERR | \
1811                        F_IBQSGELOPARERR | F_IBQSGEHIPARERR | F_IBQULPPARERR | \
1812                        F_IBQTPPARERR | F_ITAGPARERR | F_DTAGPARERR)
1813 #define PMTX_INTR_MASK (F_ZERO_C_CMD_ERROR | ICSPI_FRM_ERR | OESPI_FRM_ERR | \
1814                         V_ICSPI_PAR_ERROR(M_ICSPI_PAR_ERROR) | \
1815                         V_OESPI_PAR_ERROR(M_OESPI_PAR_ERROR))
1816 #define PMRX_INTR_MASK (F_ZERO_E_CMD_ERROR | IESPI_FRM_ERR | OCSPI_FRM_ERR | \
1817                         V_IESPI_PAR_ERROR(M_IESPI_PAR_ERROR) | \
1818                         V_OCSPI_PAR_ERROR(M_OCSPI_PAR_ERROR))
1819 #define MPS_INTR_MASK (V_TX0TPPARERRENB(M_TX0TPPARERRENB) | \
1820                        V_TX1TPPARERRENB(M_TX1TPPARERRENB) | \
1821                        V_RXTPPARERRENB(M_RXTPPARERRENB) | \
1822                        V_MCAPARERRENB(M_MCAPARERRENB))
1823 #define XGM_EXTRA_INTR_MASK (F_LINKFAULTCHANGE)
1824 #define PL_INTR_MASK (F_T3DBG | F_XGMAC0_0 | F_XGMAC0_1 | F_MC5A | F_PM1_TX | \
1825                       F_PM1_RX | F_ULP2_TX | F_ULP2_RX | F_TP1 | F_CIM | \
1826                       F_MC7_CM | F_MC7_PMTX | F_MC7_PMRX | F_SGE3 | F_PCIM0 | \
1827                       F_MPS0 | F_CPL_SWITCH)
1828 /*
1829  * Interrupt handler for the PCIX1 module.
1830  */
1831 static void pci_intr_handler(adapter_t *adapter)
1832 {
1833         static struct intr_info pcix1_intr_info[] = {
1834                 { F_MSTDETPARERR, "PCI master detected parity error", -1, 1 },
1835                 { F_SIGTARABT, "PCI signaled target abort", -1, 1 },
1836                 { F_RCVTARABT, "PCI received target abort", -1, 1 },
1837                 { F_RCVMSTABT, "PCI received master abort", -1, 1 },
1838                 { F_SIGSYSERR, "PCI signaled system error", -1, 1 },
1839                 { F_DETPARERR, "PCI detected parity error", -1, 1 },
1840                 { F_SPLCMPDIS, "PCI split completion discarded", -1, 1 },
1841                 { F_UNXSPLCMP, "PCI unexpected split completion error", -1, 1 },
1842                 { F_RCVSPLCMPERR, "PCI received split completion error", -1,
1843                   1 },
1844                 { F_DETCORECCERR, "PCI correctable ECC error",
1845                   STAT_PCI_CORR_ECC, 0 },
1846                 { F_DETUNCECCERR, "PCI uncorrectable ECC error", -1, 1 },
1847                 { F_PIOPARERR, "PCI PIO FIFO parity error", -1, 1 },
1848                 { V_WFPARERR(M_WFPARERR), "PCI write FIFO parity error", -1,
1849                   1 },
1850                 { V_RFPARERR(M_RFPARERR), "PCI read FIFO parity error", -1,
1851                   1 },
1852                 { V_CFPARERR(M_CFPARERR), "PCI command FIFO parity error", -1,
1853                   1 },
1854                 { V_MSIXPARERR(M_MSIXPARERR), "PCI MSI-X table/PBA parity "
1855                   "error", -1, 1 },
1856                 { 0 }
1857         };
1858
1859         if (t3_handle_intr_status(adapter, A_PCIX_INT_CAUSE, PCIX_INTR_MASK,
1860                                   pcix1_intr_info, adapter->irq_stats))
1861                 t3_fatal_err(adapter);
1862 }
1863
1864 /*
1865  * Interrupt handler for the PCIE module.
1866  */
1867 static void pcie_intr_handler(adapter_t *adapter)
1868 {
1869         static struct intr_info pcie_intr_info[] = {
1870                 { F_PEXERR, "PCI PEX error", -1, 1 },
1871                 { F_UNXSPLCPLERRR,
1872                   "PCI unexpected split completion DMA read error", -1, 1 },
1873                 { F_UNXSPLCPLERRC,
1874                   "PCI unexpected split completion DMA command error", -1, 1 },
1875                 { F_PCIE_PIOPARERR, "PCI PIO FIFO parity error", -1, 1 },
1876                 { F_PCIE_WFPARERR, "PCI write FIFO parity error", -1, 1 },
1877                 { F_PCIE_RFPARERR, "PCI read FIFO parity error", -1, 1 },
1878                 { F_PCIE_CFPARERR, "PCI command FIFO parity error", -1, 1 },
1879                 { V_PCIE_MSIXPARERR(M_PCIE_MSIXPARERR),
1880                   "PCI MSI-X table/PBA parity error", -1, 1 },
1881                 { F_RETRYBUFPARERR, "PCI retry buffer parity error", -1, 1 },
1882                 { F_RETRYLUTPARERR, "PCI retry LUT parity error", -1, 1 },
1883                 { F_RXPARERR, "PCI Rx parity error", -1, 1 },
1884                 { F_TXPARERR, "PCI Tx parity error", -1, 1 },
1885                 { V_BISTERR(M_BISTERR), "PCI BIST error", -1, 1 },
1886                 { 0 }
1887         };
1888
1889         if (t3_read_reg(adapter, A_PCIE_INT_CAUSE) & F_PEXERR)
1890                 CH_ALERT(adapter, "PEX error code 0x%x\n",
1891                          t3_read_reg(adapter, A_PCIE_PEX_ERR));
1892
1893         if (t3_handle_intr_status(adapter, A_PCIE_INT_CAUSE, PCIE_INTR_MASK,
1894                                   pcie_intr_info, adapter->irq_stats))
1895                 t3_fatal_err(adapter);
1896 }
1897
1898 /*
1899  * TP interrupt handler.
1900  */
1901 static void tp_intr_handler(adapter_t *adapter)
1902 {
1903         static struct intr_info tp_intr_info[] = {
1904                 { 0xffffff,  "TP parity error", -1, 1 },
1905                 { 0x1000000, "TP out of Rx pages", -1, 1 },
1906                 { 0x2000000, "TP out of Tx pages", -1, 1 },
1907                 { 0 }
1908         };
1909         static struct intr_info tp_intr_info_t3c[] = {
1910                 { 0x1fffffff,  "TP parity error", -1, 1 },
1911                 { F_FLMRXFLSTEMPTY, "TP out of Rx pages", -1, 1 },
1912                 { F_FLMTXFLSTEMPTY, "TP out of Tx pages", -1, 1 },
1913                 { 0 }
1914         };
1915
1916         if (t3_handle_intr_status(adapter, A_TP_INT_CAUSE, 0xffffffff,
1917                                   adapter->params.rev < T3_REV_C ?
1918                                         tp_intr_info : tp_intr_info_t3c, NULL))
1919                 t3_fatal_err(adapter);
1920 }
1921
1922 /*
1923  * CIM interrupt handler.
1924  */
1925 static void cim_intr_handler(adapter_t *adapter)
1926 {
1927         static struct intr_info cim_intr_info[] = {
1928                 { F_RSVDSPACEINT, "CIM reserved space write", -1, 1 },
1929                 { F_SDRAMRANGEINT, "CIM SDRAM address out of range", -1, 1 },
1930                 { F_FLASHRANGEINT, "CIM flash address out of range", -1, 1 },
1931                 { F_BLKWRBOOTINT, "CIM block write to boot space", -1, 1 },
1932                 { F_WRBLKFLASHINT, "CIM write to cached flash space", -1, 1 },
1933                 { F_SGLWRFLASHINT, "CIM single write to flash space", -1, 1 },
1934                 { F_BLKRDFLASHINT, "CIM block read from flash space", -1, 1 },
1935                 { F_BLKWRFLASHINT, "CIM block write to flash space", -1, 1 },
1936                 { F_BLKRDCTLINT, "CIM block read from CTL space", -1, 1 },
1937                 { F_BLKWRCTLINT, "CIM block write to CTL space", -1, 1 },
1938                 { F_BLKRDPLINT, "CIM block read from PL space", -1, 1 },
1939                 { F_BLKWRPLINT, "CIM block write to PL space", -1, 1 },
1940                 { F_DRAMPARERR, "CIM DRAM parity error", -1, 1 },
1941                 { F_ICACHEPARERR, "CIM icache parity error", -1, 1 },
1942                 { F_DCACHEPARERR, "CIM dcache parity error", -1, 1 },
1943                 { F_OBQSGEPARERR, "CIM OBQ SGE parity error", -1, 1 },
1944                 { F_OBQULPHIPARERR, "CIM OBQ ULPHI parity error", -1, 1 },
1945                 { F_OBQULPLOPARERR, "CIM OBQ ULPLO parity error", -1, 1 },
1946                 { F_IBQSGELOPARERR, "CIM IBQ SGELO parity error", -1, 1 },
1947                 { F_IBQSGEHIPARERR, "CIM IBQ SGEHI parity error", -1, 1 },
1948                 { F_IBQULPPARERR, "CIM IBQ ULP parity error", -1, 1 },
1949                 { F_IBQTPPARERR, "CIM IBQ TP parity error", -1, 1 },
1950                 { F_ITAGPARERR, "CIM itag parity error", -1, 1 },
1951                 { F_DTAGPARERR, "CIM dtag parity error", -1, 1 },
1952                 { 0 }
1953         };
1954
1955         if (t3_handle_intr_status(adapter, A_CIM_HOST_INT_CAUSE, CIM_INTR_MASK,
1956                                   cim_intr_info, NULL))
1957                 t3_fatal_err(adapter);
1958 }
1959
1960 /*
1961  * ULP RX interrupt handler.
1962  */
1963 static void ulprx_intr_handler(adapter_t *adapter)
1964 {
1965         static struct intr_info ulprx_intr_info[] = {
1966                 { F_PARERRDATA, "ULP RX data parity error", -1, 1 },
1967                 { F_PARERRPCMD, "ULP RX command parity error", -1, 1 },
1968                 { F_ARBPF1PERR, "ULP RX ArbPF1 parity error", -1, 1 },
1969                 { F_ARBPF0PERR, "ULP RX ArbPF0 parity error", -1, 1 },
1970                 { F_ARBFPERR, "ULP RX ArbF parity error", -1, 1 },
1971                 { F_PCMDMUXPERR, "ULP RX PCMDMUX parity error", -1, 1 },
1972                 { F_DATASELFRAMEERR1, "ULP RX frame error", -1, 1 },
1973                 { F_DATASELFRAMEERR0, "ULP RX frame error", -1, 1 },
1974                 { 0 }
1975         };
1976
1977         if (t3_handle_intr_status(adapter, A_ULPRX_INT_CAUSE, 0xffffffff,
1978                                   ulprx_intr_info, NULL))
1979                 t3_fatal_err(adapter);
1980 }
1981
1982 /*
1983  * ULP TX interrupt handler.
1984  */
1985 static void ulptx_intr_handler(adapter_t *adapter)
1986 {
1987         static struct intr_info ulptx_intr_info[] = {
1988                 { F_PBL_BOUND_ERR_CH0, "ULP TX channel 0 PBL out of bounds",
1989                   STAT_ULP_CH0_PBL_OOB, 0 },
1990                 { F_PBL_BOUND_ERR_CH1, "ULP TX channel 1 PBL out of bounds",
1991                   STAT_ULP_CH1_PBL_OOB, 0 },
1992                 { 0xfc, "ULP TX parity error", -1, 1 },
1993                 { 0 }
1994         };
1995
1996         if (t3_handle_intr_status(adapter, A_ULPTX_INT_CAUSE, 0xffffffff,
1997                                   ulptx_intr_info, adapter->irq_stats))
1998                 t3_fatal_err(adapter);
1999 }
2000
2001 #define ICSPI_FRM_ERR (F_ICSPI0_FIFO2X_RX_FRAMING_ERROR | \
2002         F_ICSPI1_FIFO2X_RX_FRAMING_ERROR | F_ICSPI0_RX_FRAMING_ERROR | \
2003         F_ICSPI1_RX_FRAMING_ERROR | F_ICSPI0_TX_FRAMING_ERROR | \
2004         F_ICSPI1_TX_FRAMING_ERROR)
2005 #define OESPI_FRM_ERR (F_OESPI0_RX_FRAMING_ERROR | \
2006         F_OESPI1_RX_FRAMING_ERROR | F_OESPI0_TX_FRAMING_ERROR | \
2007         F_OESPI1_TX_FRAMING_ERROR | F_OESPI0_OFIFO2X_TX_FRAMING_ERROR | \
2008         F_OESPI1_OFIFO2X_TX_FRAMING_ERROR)
2009
2010 /*
2011  * PM TX interrupt handler.
2012  */
2013 static void pmtx_intr_handler(adapter_t *adapter)
2014 {
2015         static struct intr_info pmtx_intr_info[] = {
2016                 { F_ZERO_C_CMD_ERROR, "PMTX 0-length pcmd", -1, 1 },
2017                 { ICSPI_FRM_ERR, "PMTX ispi framing error", -1, 1 },
2018                 { OESPI_FRM_ERR, "PMTX ospi framing error", -1, 1 },
2019                 { V_ICSPI_PAR_ERROR(M_ICSPI_PAR_ERROR),
2020                   "PMTX ispi parity error", -1, 1 },
2021                 { V_OESPI_PAR_ERROR(M_OESPI_PAR_ERROR),
2022                   "PMTX ospi parity error", -1, 1 },
2023                 { 0 }
2024         };
2025
2026         if (t3_handle_intr_status(adapter, A_PM1_TX_INT_CAUSE, 0xffffffff,
2027                                   pmtx_intr_info, NULL))
2028                 t3_fatal_err(adapter);
2029 }
2030
2031 #define IESPI_FRM_ERR (F_IESPI0_FIFO2X_RX_FRAMING_ERROR | \
2032         F_IESPI1_FIFO2X_RX_FRAMING_ERROR | F_IESPI0_RX_FRAMING_ERROR | \
2033         F_IESPI1_RX_FRAMING_ERROR | F_IESPI0_TX_FRAMING_ERROR | \
2034         F_IESPI1_TX_FRAMING_ERROR)
2035 #define OCSPI_FRM_ERR (F_OCSPI0_RX_FRAMING_ERROR | \
2036         F_OCSPI1_RX_FRAMING_ERROR | F_OCSPI0_TX_FRAMING_ERROR | \
2037         F_OCSPI1_TX_FRAMING_ERROR | F_OCSPI0_OFIFO2X_TX_FRAMING_ERROR | \
2038         F_OCSPI1_OFIFO2X_TX_FRAMING_ERROR)
2039
2040 /*
2041  * PM RX interrupt handler.
2042  */
2043 static void pmrx_intr_handler(adapter_t *adapter)
2044 {
2045         static struct intr_info pmrx_intr_info[] = {
2046                 { F_ZERO_E_CMD_ERROR, "PMRX 0-length pcmd", -1, 1 },
2047                 { IESPI_FRM_ERR, "PMRX ispi framing error", -1, 1 },
2048                 { OCSPI_FRM_ERR, "PMRX ospi framing error", -1, 1 },
2049                 { V_IESPI_PAR_ERROR(M_IESPI_PAR_ERROR),
2050                   "PMRX ispi parity error", -1, 1 },
2051                 { V_OCSPI_PAR_ERROR(M_OCSPI_PAR_ERROR),
2052                   "PMRX ospi parity error", -1, 1 },
2053                 { 0 }
2054         };
2055
2056         if (t3_handle_intr_status(adapter, A_PM1_RX_INT_CAUSE, 0xffffffff,
2057                                   pmrx_intr_info, NULL))
2058                 t3_fatal_err(adapter);
2059 }
2060
2061 /*
2062  * CPL switch interrupt handler.
2063  */
2064 static void cplsw_intr_handler(adapter_t *adapter)
2065 {
2066         static struct intr_info cplsw_intr_info[] = {
2067                 { F_CIM_OP_MAP_PERR, "CPL switch CIM parity error", -1, 1 },
2068                 { F_CIM_OVFL_ERROR, "CPL switch CIM overflow", -1, 1 },
2069                 { F_TP_FRAMING_ERROR, "CPL switch TP framing error", -1, 1 },
2070                 { F_SGE_FRAMING_ERROR, "CPL switch SGE framing error", -1, 1 },
2071                 { F_CIM_FRAMING_ERROR, "CPL switch CIM framing error", -1, 1 },
2072                 { F_ZERO_SWITCH_ERROR, "CPL switch no-switch error", -1, 1 },
2073                 { 0 }
2074         };
2075
2076         if (t3_handle_intr_status(adapter, A_CPL_INTR_CAUSE, 0xffffffff,
2077                                   cplsw_intr_info, NULL))
2078                 t3_fatal_err(adapter);
2079 }
2080
2081 /*
2082  * MPS interrupt handler.
2083  */
2084 static void mps_intr_handler(adapter_t *adapter)
2085 {
2086         static struct intr_info mps_intr_info[] = {
2087                 { 0x1ff, "MPS parity error", -1, 1 },
2088                 { 0 }
2089         };
2090
2091         if (t3_handle_intr_status(adapter, A_MPS_INT_CAUSE, 0xffffffff,
2092                                   mps_intr_info, NULL))
2093                 t3_fatal_err(adapter);
2094 }
2095
2096 #define MC7_INTR_FATAL (F_UE | V_PE(M_PE) | F_AE)
2097
2098 /*
2099  * MC7 interrupt handler.
2100  */
2101 static void mc7_intr_handler(struct mc7 *mc7)
2102 {
2103         adapter_t *adapter = mc7->adapter;
2104         u32 cause = t3_read_reg(adapter, mc7->offset + A_MC7_INT_CAUSE);
2105
2106         if (cause & F_CE) {
2107                 mc7->stats.corr_err++;
2108                 CH_WARN(adapter, "%s MC7 correctable error at addr 0x%x, "
2109                         "data 0x%x 0x%x 0x%x\n", mc7->name,
2110                         t3_read_reg(adapter, mc7->offset + A_MC7_CE_ADDR),
2111                         t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA0),
2112                         t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA1),
2113                         t3_read_reg(adapter, mc7->offset + A_MC7_CE_DATA2));
2114         }
2115
2116         if (cause & F_UE) {
2117                 mc7->stats.uncorr_err++;
2118                 CH_ALERT(adapter, "%s MC7 uncorrectable error at addr 0x%x, "
2119                          "data 0x%x 0x%x 0x%x\n", mc7->name,
2120                          t3_read_reg(adapter, mc7->offset + A_MC7_UE_ADDR),
2121                          t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA0),
2122                          t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA1),
2123                          t3_read_reg(adapter, mc7->offset + A_MC7_UE_DATA2));
2124         }
2125
2126         if (G_PE(cause)) {
2127                 mc7->stats.parity_err++;
2128                 CH_ALERT(adapter, "%s MC7 parity error 0x%x\n",
2129                          mc7->name, G_PE(cause));
2130         }
2131
2132         if (cause & F_AE) {
2133                 u32 addr = 0;
2134
2135                 if (adapter->params.rev > 0)
2136                         addr = t3_read_reg(adapter,
2137                                            mc7->offset + A_MC7_ERR_ADDR);
2138                 mc7->stats.addr_err++;
2139                 CH_ALERT(adapter, "%s MC7 address error: 0x%x\n",
2140                          mc7->name, addr);
2141         }
2142
2143         if (cause & MC7_INTR_FATAL)
2144                 t3_fatal_err(adapter);
2145
2146         t3_write_reg(adapter, mc7->offset + A_MC7_INT_CAUSE, cause);
2147 }
2148
2149 #define XGM_INTR_FATAL (V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR) | \
2150                         V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR))
2151 /*
2152  * XGMAC interrupt handler.
2153  */
2154 static int mac_intr_handler(adapter_t *adap, unsigned int idx)
2155 {
2156         u32 cause;
2157         struct port_info *pi;
2158         struct cmac *mac;
2159
2160         idx = idx == 0 ? 0 : adapter_info(adap)->nports0; /* MAC idx -> port */
2161         pi = adap2pinfo(adap, idx);
2162         mac = &pi->mac;
2163
2164         /*
2165          * We mask out interrupt causes for which we're not taking interrupts.
2166          * This allows us to use polling logic to monitor some of the other
2167          * conditions when taking interrupts would impose too much load on the
2168          * system.
2169          */
2170         cause = (t3_read_reg(adap, A_XGM_INT_CAUSE + mac->offset)
2171                  & ~(F_RXFIFO_OVERFLOW));
2172
2173         if (cause & V_TXFIFO_PRTY_ERR(M_TXFIFO_PRTY_ERR)) {
2174                 mac->stats.tx_fifo_parity_err++;
2175                 CH_ALERT(adap, "port%d: MAC TX FIFO parity error\n", idx);
2176         }
2177         if (cause & V_RXFIFO_PRTY_ERR(M_RXFIFO_PRTY_ERR)) {
2178                 mac->stats.rx_fifo_parity_err++;
2179                 CH_ALERT(adap, "port%d: MAC RX FIFO parity error\n", idx);
2180         }
2181         if (cause & F_TXFIFO_UNDERRUN)
2182                 mac->stats.tx_fifo_urun++;
2183         if (cause & F_RXFIFO_OVERFLOW)
2184                 mac->stats.rx_fifo_ovfl++;
2185         if (cause & V_SERDES_LOS(M_SERDES_LOS))
2186                 mac->stats.serdes_signal_loss++;
2187         if (cause & F_XAUIPCSCTCERR)
2188                 mac->stats.xaui_pcs_ctc_err++;
2189         if (cause & F_XAUIPCSALIGNCHANGE)
2190                 mac->stats.xaui_pcs_align_change++;
2191         if (cause & F_XGM_INT &
2192             t3_read_reg(adap, A_XGM_INT_ENABLE + mac->offset)) {
2193                 t3_set_reg_field(adap, A_XGM_INT_ENABLE + mac->offset,
2194                     F_XGM_INT, 0);
2195
2196                 /* link fault suspected */
2197                 pi->link_fault = LF_MAYBE;
2198                 t3_os_link_intr(pi);
2199         }
2200
2201         if (cause & XGM_INTR_FATAL)
2202                 t3_fatal_err(adap);
2203
2204         t3_write_reg(adap, A_XGM_INT_CAUSE + mac->offset, cause);
2205         return cause != 0;
2206 }
2207
2208 /*
2209  * Interrupt handler for PHY events.
2210  */
2211 static int phy_intr_handler(adapter_t *adapter)
2212 {
2213         u32 i, cause = t3_read_reg(adapter, A_T3DBG_INT_CAUSE);
2214
2215         for_each_port(adapter, i) {
2216                 struct port_info *p = adap2pinfo(adapter, i);
2217
2218                 if (!(p->phy.caps & SUPPORTED_IRQ))
2219                         continue;
2220
2221                 if (cause & (1 << adapter_info(adapter)->gpio_intr[i])) {
2222                         int phy_cause = p->phy.ops->intr_handler(&p->phy);
2223
2224                         if (phy_cause & cphy_cause_link_change)
2225                                 t3_os_link_intr(p);
2226                         if (phy_cause & cphy_cause_fifo_error)
2227                                 p->phy.fifo_errors++;
2228                         if (phy_cause & cphy_cause_module_change)
2229                                 t3_os_phymod_changed(adapter, i);
2230                         if (phy_cause & cphy_cause_alarm)
2231                                 CH_WARN(adapter, "Operation affected due to "
2232                                     "adverse environment.  Check the spec "
2233                                     "sheet for corrective action.");
2234                 }
2235         }
2236
2237         t3_write_reg(adapter, A_T3DBG_INT_CAUSE, cause);
2238         return 0;
2239 }
2240
2241 /**
2242  *      t3_slow_intr_handler - control path interrupt handler
2243  *      @adapter: the adapter
2244  *
2245  *      T3 interrupt handler for non-data interrupt events, e.g., errors.
2246  *      The designation 'slow' is because it involves register reads, while
2247  *      data interrupts typically don't involve any MMIOs.
2248  */
2249 int t3_slow_intr_handler(adapter_t *adapter)
2250 {
2251         u32 cause = t3_read_reg(adapter, A_PL_INT_CAUSE0);
2252
2253         cause &= adapter->slow_intr_mask;
2254         if (!cause)
2255                 return 0;
2256         if (cause & F_PCIM0) {
2257                 if (is_pcie(adapter))
2258                         pcie_intr_handler(adapter);
2259                 else
2260                         pci_intr_handler(adapter);
2261         }
2262         if (cause & F_SGE3)
2263                 t3_sge_err_intr_handler(adapter);
2264         if (cause & F_MC7_PMRX)
2265                 mc7_intr_handler(&adapter->pmrx);
2266         if (cause & F_MC7_PMTX)
2267                 mc7_intr_handler(&adapter->pmtx);
2268         if (cause & F_MC7_CM)
2269                 mc7_intr_handler(&adapter->cm);
2270         if (cause & F_CIM)
2271                 cim_intr_handler(adapter);
2272         if (cause & F_TP1)
2273                 tp_intr_handler(adapter);
2274         if (cause & F_ULP2_RX)
2275                 ulprx_intr_handler(adapter);
2276         if (cause & F_ULP2_TX)
2277                 ulptx_intr_handler(adapter);
2278         if (cause & F_PM1_RX)
2279                 pmrx_intr_handler(adapter);
2280         if (cause & F_PM1_TX)
2281                 pmtx_intr_handler(adapter);
2282         if (cause & F_CPL_SWITCH)
2283                 cplsw_intr_handler(adapter);
2284         if (cause & F_MPS0)
2285                 mps_intr_handler(adapter);
2286         if (cause & F_MC5A)
2287                 t3_mc5_intr_handler(&adapter->mc5);
2288         if (cause & F_XGMAC0_0)
2289                 mac_intr_handler(adapter, 0);
2290         if (cause & F_XGMAC0_1)
2291                 mac_intr_handler(adapter, 1);
2292         if (cause & F_T3DBG)
2293                 phy_intr_handler(adapter);
2294
2295         /* Clear the interrupts just processed. */
2296         t3_write_reg(adapter, A_PL_INT_CAUSE0, cause);
2297         (void) t3_read_reg(adapter, A_PL_INT_CAUSE0); /* flush */
2298         return 1;
2299 }
2300
2301 static unsigned int calc_gpio_intr(adapter_t *adap)
2302 {
2303         unsigned int i, gpi_intr = 0;
2304
2305         for_each_port(adap, i)
2306                 if ((adap2pinfo(adap, i)->phy.caps & SUPPORTED_IRQ) &&
2307                     adapter_info(adap)->gpio_intr[i])
2308                         gpi_intr |= 1 << adapter_info(adap)->gpio_intr[i];
2309         return gpi_intr;
2310 }
2311
2312 /**
2313  *      t3_intr_enable - enable interrupts
2314  *      @adapter: the adapter whose interrupts should be enabled
2315  *
2316  *      Enable interrupts by setting the interrupt enable registers of the
2317  *      various HW modules and then enabling the top-level interrupt
2318  *      concentrator.
2319  */
2320 void t3_intr_enable(adapter_t *adapter)
2321 {
2322         static struct addr_val_pair intr_en_avp[] = {
2323                 { A_MC7_INT_ENABLE, MC7_INTR_MASK },
2324                 { A_MC7_INT_ENABLE - MC7_PMRX_BASE_ADDR + MC7_PMTX_BASE_ADDR,
2325                         MC7_INTR_MASK },
2326                 { A_MC7_INT_ENABLE - MC7_PMRX_BASE_ADDR + MC7_CM_BASE_ADDR,
2327                         MC7_INTR_MASK },
2328                 { A_MC5_DB_INT_ENABLE, MC5_INTR_MASK },
2329                 { A_ULPRX_INT_ENABLE, ULPRX_INTR_MASK },
2330                 { A_PM1_TX_INT_ENABLE, PMTX_INTR_MASK },
2331                 { A_PM1_RX_INT_ENABLE, PMRX_INTR_MASK },
2332                 { A_CIM_HOST_INT_ENABLE, CIM_INTR_MASK },
2333                 { A_MPS_INT_ENABLE, MPS_INTR_MASK },
2334         };
2335
2336         adapter->slow_intr_mask = PL_INTR_MASK;
2337
2338         t3_write_regs(adapter, intr_en_avp, ARRAY_SIZE(intr_en_avp), 0);
2339         t3_write_reg(adapter, A_TP_INT_ENABLE,
2340                      adapter->params.rev >= T3_REV_C ? 0x2bfffff : 0x3bfffff);
2341         t3_write_reg(adapter, A_SG_INT_ENABLE, SGE_INTR_MASK);
2342
2343         if (adapter->params.rev > 0) {
2344                 t3_write_reg(adapter, A_CPL_INTR_ENABLE,
2345                              CPLSW_INTR_MASK | F_CIM_OVFL_ERROR);
2346                 t3_write_reg(adapter, A_ULPTX_INT_ENABLE,
2347                              ULPTX_INTR_MASK | F_PBL_BOUND_ERR_CH0 |
2348                              F_PBL_BOUND_ERR_CH1);
2349         } else {
2350                 t3_write_reg(adapter, A_CPL_INTR_ENABLE, CPLSW_INTR_MASK);
2351                 t3_write_reg(adapter, A_ULPTX_INT_ENABLE, ULPTX_INTR_MASK);
2352         }
2353
2354         t3_write_reg(adapter, A_T3DBG_INT_ENABLE, calc_gpio_intr(adapter));
2355
2356         if (is_pcie(adapter))
2357                 t3_write_reg(adapter, A_PCIE_INT_ENABLE, PCIE_INTR_MASK);
2358         else
2359                 t3_write_reg(adapter, A_PCIX_INT_ENABLE, PCIX_INTR_MASK);
2360         t3_write_reg(adapter, A_PL_INT_ENABLE0, adapter->slow_intr_mask);
2361         (void) t3_read_reg(adapter, A_PL_INT_ENABLE0);          /* flush */
2362 }
2363
2364 /**
2365  *      t3_intr_disable - disable a card's interrupts
2366  *      @adapter: the adapter whose interrupts should be disabled
2367  *
2368  *      Disable interrupts.  We only disable the top-level interrupt
2369  *      concentrator and the SGE data interrupts.
2370  */
2371 void t3_intr_disable(adapter_t *adapter)
2372 {
2373         t3_write_reg(adapter, A_PL_INT_ENABLE0, 0);
2374         (void) t3_read_reg(adapter, A_PL_INT_ENABLE0);  /* flush */
2375         adapter->slow_intr_mask = 0;
2376 }
2377
2378 /**
2379  *      t3_intr_clear - clear all interrupts
2380  *      @adapter: the adapter whose interrupts should be cleared
2381  *
2382  *      Clears all interrupts.
2383  */
2384 void t3_intr_clear(adapter_t *adapter)
2385 {
2386         static const unsigned int cause_reg_addr[] = {
2387                 A_SG_INT_CAUSE,
2388                 A_SG_RSPQ_FL_STATUS,
2389                 A_PCIX_INT_CAUSE,
2390                 A_MC7_INT_CAUSE,
2391                 A_MC7_INT_CAUSE - MC7_PMRX_BASE_ADDR + MC7_PMTX_BASE_ADDR,
2392                 A_MC7_INT_CAUSE - MC7_PMRX_BASE_ADDR + MC7_CM_BASE_ADDR,
2393                 A_CIM_HOST_INT_CAUSE,
2394                 A_TP_INT_CAUSE,
2395                 A_MC5_DB_INT_CAUSE,
2396                 A_ULPRX_INT_CAUSE,
2397                 A_ULPTX_INT_CAUSE,
2398                 A_CPL_INTR_CAUSE,
2399                 A_PM1_TX_INT_CAUSE,
2400                 A_PM1_RX_INT_CAUSE,
2401                 A_MPS_INT_CAUSE,
2402                 A_T3DBG_INT_CAUSE,
2403         };
2404         unsigned int i;
2405
2406         /* Clear PHY and MAC interrupts for each port. */
2407         for_each_port(adapter, i)
2408                 t3_port_intr_clear(adapter, i);
2409
2410         for (i = 0; i < ARRAY_SIZE(cause_reg_addr); ++i)
2411                 t3_write_reg(adapter, cause_reg_addr[i], 0xffffffff);
2412
2413         if (is_pcie(adapter))
2414                 t3_write_reg(adapter, A_PCIE_PEX_ERR, 0xffffffff);
2415         t3_write_reg(adapter, A_PL_INT_CAUSE0, 0xffffffff);
2416         (void) t3_read_reg(adapter, A_PL_INT_CAUSE0);          /* flush */
2417 }
2418
2419 void t3_xgm_intr_enable(adapter_t *adapter, int idx)
2420 {
2421         struct port_info *pi = adap2pinfo(adapter, idx);
2422
2423         t3_write_reg(adapter, A_XGM_XGM_INT_ENABLE + pi->mac.offset,
2424                      XGM_EXTRA_INTR_MASK);
2425 }
2426
2427 void t3_xgm_intr_disable(adapter_t *adapter, int idx)
2428 {
2429         struct port_info *pi = adap2pinfo(adapter, idx);
2430
2431         t3_write_reg(adapter, A_XGM_XGM_INT_DISABLE + pi->mac.offset,
2432                      0x7ff);
2433 }
2434
2435 /**
2436  *      t3_port_intr_enable - enable port-specific interrupts
2437  *      @adapter: associated adapter
2438  *      @idx: index of port whose interrupts should be enabled
2439  *
2440  *      Enable port-specific (i.e., MAC and PHY) interrupts for the given
2441  *      adapter port.
2442  */
2443 void t3_port_intr_enable(adapter_t *adapter, int idx)
2444 {
2445         struct port_info *pi = adap2pinfo(adapter, idx);
2446
2447         t3_write_reg(adapter, A_XGM_INT_ENABLE + pi->mac.offset, XGM_INTR_MASK);
2448         pi->phy.ops->intr_enable(&pi->phy);
2449 }
2450
2451 /**
2452  *      t3_port_intr_disable - disable port-specific interrupts
2453  *      @adapter: associated adapter
2454  *      @idx: index of port whose interrupts should be disabled
2455  *
2456  *      Disable port-specific (i.e., MAC and PHY) interrupts for the given
2457  *      adapter port.
2458  */
2459 void t3_port_intr_disable(adapter_t *adapter, int idx)
2460 {
2461         struct port_info *pi = adap2pinfo(adapter, idx);
2462
2463         t3_write_reg(adapter, A_XGM_INT_ENABLE + pi->mac.offset, 0);
2464         pi->phy.ops->intr_disable(&pi->phy);
2465 }
2466
2467 /**
2468  *      t3_port_intr_clear - clear port-specific interrupts
2469  *      @adapter: associated adapter
2470  *      @idx: index of port whose interrupts to clear
2471  *
2472  *      Clear port-specific (i.e., MAC and PHY) interrupts for the given
2473  *      adapter port.
2474  */
2475 void t3_port_intr_clear(adapter_t *adapter, int idx)
2476 {
2477         struct port_info *pi = adap2pinfo(adapter, idx);
2478
2479         t3_write_reg(adapter, A_XGM_INT_CAUSE + pi->mac.offset, 0xffffffff);
2480         pi->phy.ops->intr_clear(&pi->phy);
2481 }
2482
2483 #define SG_CONTEXT_CMD_ATTEMPTS 100
2484
2485 /**
2486  *      t3_sge_write_context - write an SGE context
2487  *      @adapter: the adapter
2488  *      @id: the context id
2489  *      @type: the context type
2490  *
2491  *      Program an SGE context with the values already loaded in the
2492  *      CONTEXT_DATA? registers.
2493  */
2494 static int t3_sge_write_context(adapter_t *adapter, unsigned int id,
2495                                 unsigned int type)
2496 {
2497         if (type == F_RESPONSEQ) {
2498                 /*
2499                  * Can't write the Response Queue Context bits for
2500                  * Interrupt Armed or the Reserve bits after the chip
2501                  * has been initialized out of reset.  Writing to these
2502                  * bits can confuse the hardware.
2503                  */
2504                 t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0xffffffff);
2505                 t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0xffffffff);
2506                 t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0x17ffffff);
2507                 t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0xffffffff);
2508         } else {
2509                 t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0xffffffff);
2510                 t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0xffffffff);
2511                 t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0xffffffff);
2512                 t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0xffffffff);
2513         }
2514         t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2515                      V_CONTEXT_CMD_OPCODE(1) | type | V_CONTEXT(id));
2516         return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2517                                0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2518 }
2519
2520 /**
2521  *      clear_sge_ctxt - completely clear an SGE context
2522  *      @adapter: the adapter
2523  *      @id: the context id
2524  *      @type: the context type
2525  *
2526  *      Completely clear an SGE context.  Used predominantly at post-reset
2527  *      initialization.  Note in particular that we don't skip writing to any
2528  *      "sensitive bits" in the contexts the way that t3_sge_write_context()
2529  *      does ...
2530  */
2531 static int clear_sge_ctxt(adapter_t *adap, unsigned int id, unsigned int type)
2532 {
2533         t3_write_reg(adap, A_SG_CONTEXT_DATA0, 0);
2534         t3_write_reg(adap, A_SG_CONTEXT_DATA1, 0);
2535         t3_write_reg(adap, A_SG_CONTEXT_DATA2, 0);
2536         t3_write_reg(adap, A_SG_CONTEXT_DATA3, 0);
2537         t3_write_reg(adap, A_SG_CONTEXT_MASK0, 0xffffffff);
2538         t3_write_reg(adap, A_SG_CONTEXT_MASK1, 0xffffffff);
2539         t3_write_reg(adap, A_SG_CONTEXT_MASK2, 0xffffffff);
2540         t3_write_reg(adap, A_SG_CONTEXT_MASK3, 0xffffffff);
2541         t3_write_reg(adap, A_SG_CONTEXT_CMD,
2542                      V_CONTEXT_CMD_OPCODE(1) | type | V_CONTEXT(id));
2543         return t3_wait_op_done(adap, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2544                                0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2545 }
2546
2547 /**
2548  *      t3_sge_init_ecntxt - initialize an SGE egress context
2549  *      @adapter: the adapter to configure
2550  *      @id: the context id
2551  *      @gts_enable: whether to enable GTS for the context
2552  *      @type: the egress context type
2553  *      @respq: associated response queue
2554  *      @base_addr: base address of queue
2555  *      @size: number of queue entries
2556  *      @token: uP token
2557  *      @gen: initial generation value for the context
2558  *      @cidx: consumer pointer
2559  *
2560  *      Initialize an SGE egress context and make it ready for use.  If the
2561  *      platform allows concurrent context operations, the caller is
2562  *      responsible for appropriate locking.
2563  */
2564 int t3_sge_init_ecntxt(adapter_t *adapter, unsigned int id, int gts_enable,
2565                        enum sge_context_type type, int respq, u64 base_addr,
2566                        unsigned int size, unsigned int token, int gen,
2567                        unsigned int cidx)
2568 {
2569         unsigned int credits = type == SGE_CNTXT_OFLD ? 0 : FW_WR_NUM;
2570
2571         if (base_addr & 0xfff)     /* must be 4K aligned */
2572                 return -EINVAL;
2573         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2574                 return -EBUSY;
2575
2576         base_addr >>= 12;
2577         t3_write_reg(adapter, A_SG_CONTEXT_DATA0, V_EC_INDEX(cidx) |
2578                      V_EC_CREDITS(credits) | V_EC_GTS(gts_enable));
2579         t3_write_reg(adapter, A_SG_CONTEXT_DATA1, V_EC_SIZE(size) |
2580                      V_EC_BASE_LO((u32)base_addr & 0xffff));
2581         base_addr >>= 16;
2582         t3_write_reg(adapter, A_SG_CONTEXT_DATA2, (u32)base_addr);
2583         base_addr >>= 32;
2584         t3_write_reg(adapter, A_SG_CONTEXT_DATA3,
2585                      V_EC_BASE_HI((u32)base_addr & 0xf) | V_EC_RESPQ(respq) |
2586                      V_EC_TYPE(type) | V_EC_GEN(gen) | V_EC_UP_TOKEN(token) |
2587                      F_EC_VALID);
2588         return t3_sge_write_context(adapter, id, F_EGRESS);
2589 }
2590
2591 /**
2592  *      t3_sge_init_flcntxt - initialize an SGE free-buffer list context
2593  *      @adapter: the adapter to configure
2594  *      @id: the context id
2595  *      @gts_enable: whether to enable GTS for the context
2596  *      @base_addr: base address of queue
2597  *      @size: number of queue entries
2598  *      @bsize: size of each buffer for this queue
2599  *      @cong_thres: threshold to signal congestion to upstream producers
2600  *      @gen: initial generation value for the context
2601  *      @cidx: consumer pointer
2602  *
2603  *      Initialize an SGE free list context and make it ready for use.  The
2604  *      caller is responsible for ensuring only one context operation occurs
2605  *      at a time.
2606  */
2607 int t3_sge_init_flcntxt(adapter_t *adapter, unsigned int id, int gts_enable,
2608                         u64 base_addr, unsigned int size, unsigned int bsize,
2609                         unsigned int cong_thres, int gen, unsigned int cidx)
2610 {
2611         if (base_addr & 0xfff)     /* must be 4K aligned */
2612                 return -EINVAL;
2613         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2614                 return -EBUSY;
2615
2616         base_addr >>= 12;
2617         t3_write_reg(adapter, A_SG_CONTEXT_DATA0, (u32)base_addr);
2618         base_addr >>= 32;
2619         t3_write_reg(adapter, A_SG_CONTEXT_DATA1,
2620                      V_FL_BASE_HI((u32)base_addr) |
2621                      V_FL_INDEX_LO(cidx & M_FL_INDEX_LO));
2622         t3_write_reg(adapter, A_SG_CONTEXT_DATA2, V_FL_SIZE(size) |
2623                      V_FL_GEN(gen) | V_FL_INDEX_HI(cidx >> 12) |
2624                      V_FL_ENTRY_SIZE_LO(bsize & M_FL_ENTRY_SIZE_LO));
2625         t3_write_reg(adapter, A_SG_CONTEXT_DATA3,
2626                      V_FL_ENTRY_SIZE_HI(bsize >> (32 - S_FL_ENTRY_SIZE_LO)) |
2627                      V_FL_CONG_THRES(cong_thres) | V_FL_GTS(gts_enable));
2628         return t3_sge_write_context(adapter, id, F_FREELIST);
2629 }
2630
2631 /**
2632  *      t3_sge_init_rspcntxt - initialize an SGE response queue context
2633  *      @adapter: the adapter to configure
2634  *      @id: the context id
2635  *      @irq_vec_idx: MSI-X interrupt vector index, 0 if no MSI-X, -1 if no IRQ
2636  *      @base_addr: base address of queue
2637  *      @size: number of queue entries
2638  *      @fl_thres: threshold for selecting the normal or jumbo free list
2639  *      @gen: initial generation value for the context
2640  *      @cidx: consumer pointer
2641  *
2642  *      Initialize an SGE response queue context and make it ready for use.
2643  *      The caller is responsible for ensuring only one context operation
2644  *      occurs at a time.
2645  */
2646 int t3_sge_init_rspcntxt(adapter_t *adapter, unsigned int id, int irq_vec_idx,
2647                          u64 base_addr, unsigned int size,
2648                          unsigned int fl_thres, int gen, unsigned int cidx)
2649 {
2650         unsigned int ctrl, intr = 0;
2651
2652         if (base_addr & 0xfff)     /* must be 4K aligned */
2653                 return -EINVAL;
2654         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2655                 return -EBUSY;
2656
2657         base_addr >>= 12;
2658         t3_write_reg(adapter, A_SG_CONTEXT_DATA0, V_CQ_SIZE(size) |
2659                      V_CQ_INDEX(cidx));
2660         t3_write_reg(adapter, A_SG_CONTEXT_DATA1, (u32)base_addr);
2661         base_addr >>= 32;
2662         ctrl = t3_read_reg(adapter, A_SG_CONTROL);
2663         if ((irq_vec_idx > 0) ||
2664                 ((irq_vec_idx == 0) && !(ctrl & F_ONEINTMULTQ)))
2665                         intr = F_RQ_INTR_EN;
2666         if (irq_vec_idx >= 0)
2667                 intr |= V_RQ_MSI_VEC(irq_vec_idx);
2668         t3_write_reg(adapter, A_SG_CONTEXT_DATA2,
2669                      V_CQ_BASE_HI((u32)base_addr) | intr | V_RQ_GEN(gen));
2670         t3_write_reg(adapter, A_SG_CONTEXT_DATA3, fl_thres);
2671         return t3_sge_write_context(adapter, id, F_RESPONSEQ);
2672 }
2673
2674 /**
2675  *      t3_sge_init_cqcntxt - initialize an SGE completion queue context
2676  *      @adapter: the adapter to configure
2677  *      @id: the context id
2678  *      @base_addr: base address of queue
2679  *      @size: number of queue entries
2680  *      @rspq: response queue for async notifications
2681  *      @ovfl_mode: CQ overflow mode
2682  *      @credits: completion queue credits
2683  *      @credit_thres: the credit threshold
2684  *
2685  *      Initialize an SGE completion queue context and make it ready for use.
2686  *      The caller is responsible for ensuring only one context operation
2687  *      occurs at a time.
2688  */
2689 int t3_sge_init_cqcntxt(adapter_t *adapter, unsigned int id, u64 base_addr,
2690                         unsigned int size, int rspq, int ovfl_mode,
2691                         unsigned int credits, unsigned int credit_thres)
2692 {
2693         if (base_addr & 0xfff)     /* must be 4K aligned */
2694                 return -EINVAL;
2695         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2696                 return -EBUSY;
2697
2698         base_addr >>= 12;
2699         t3_write_reg(adapter, A_SG_CONTEXT_DATA0, V_CQ_SIZE(size));
2700         t3_write_reg(adapter, A_SG_CONTEXT_DATA1, (u32)base_addr);
2701         base_addr >>= 32;
2702         t3_write_reg(adapter, A_SG_CONTEXT_DATA2,
2703                      V_CQ_BASE_HI((u32)base_addr) | V_CQ_RSPQ(rspq) |
2704                      V_CQ_GEN(1) | V_CQ_OVERFLOW_MODE(ovfl_mode) |
2705                      V_CQ_ERR(ovfl_mode));
2706         t3_write_reg(adapter, A_SG_CONTEXT_DATA3, V_CQ_CREDITS(credits) |
2707                      V_CQ_CREDIT_THRES(credit_thres));
2708         return t3_sge_write_context(adapter, id, F_CQ);
2709 }
2710
2711 /**
2712  *      t3_sge_enable_ecntxt - enable/disable an SGE egress context
2713  *      @adapter: the adapter
2714  *      @id: the egress context id
2715  *      @enable: enable (1) or disable (0) the context
2716  *
2717  *      Enable or disable an SGE egress context.  The caller is responsible for
2718  *      ensuring only one context operation occurs at a time.
2719  */
2720 int t3_sge_enable_ecntxt(adapter_t *adapter, unsigned int id, int enable)
2721 {
2722         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2723                 return -EBUSY;
2724
2725         t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0);
2726         t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0);
2727         t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0);
2728         t3_write_reg(adapter, A_SG_CONTEXT_MASK3, F_EC_VALID);
2729         t3_write_reg(adapter, A_SG_CONTEXT_DATA3, V_EC_VALID(enable));
2730         t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2731                      V_CONTEXT_CMD_OPCODE(1) | F_EGRESS | V_CONTEXT(id));
2732         return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2733                                0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2734 }
2735
2736 /**
2737  *      t3_sge_disable_fl - disable an SGE free-buffer list
2738  *      @adapter: the adapter
2739  *      @id: the free list context id
2740  *
2741  *      Disable an SGE free-buffer list.  The caller is responsible for
2742  *      ensuring only one context operation occurs at a time.
2743  */
2744 int t3_sge_disable_fl(adapter_t *adapter, unsigned int id)
2745 {
2746         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2747                 return -EBUSY;
2748
2749         t3_write_reg(adapter, A_SG_CONTEXT_MASK0, 0);
2750         t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0);
2751         t3_write_reg(adapter, A_SG_CONTEXT_MASK2, V_FL_SIZE(M_FL_SIZE));
2752         t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0);
2753         t3_write_reg(adapter, A_SG_CONTEXT_DATA2, 0);
2754         t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2755                      V_CONTEXT_CMD_OPCODE(1) | F_FREELIST | V_CONTEXT(id));
2756         return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2757                                0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2758 }
2759
2760 /**
2761  *      t3_sge_disable_rspcntxt - disable an SGE response queue
2762  *      @adapter: the adapter
2763  *      @id: the response queue context id
2764  *
2765  *      Disable an SGE response queue.  The caller is responsible for
2766  *      ensuring only one context operation occurs at a time.
2767  */
2768 int t3_sge_disable_rspcntxt(adapter_t *adapter, unsigned int id)
2769 {
2770         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2771                 return -EBUSY;
2772
2773         t3_write_reg(adapter, A_SG_CONTEXT_MASK0, V_CQ_SIZE(M_CQ_SIZE));
2774         t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0);
2775         t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0);
2776         t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0);
2777         t3_write_reg(adapter, A_SG_CONTEXT_DATA0, 0);
2778         t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2779                      V_CONTEXT_CMD_OPCODE(1) | F_RESPONSEQ | V_CONTEXT(id));
2780         return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2781                                0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2782 }
2783
2784 /**
2785  *      t3_sge_disable_cqcntxt - disable an SGE completion queue
2786  *      @adapter: the adapter
2787  *      @id: the completion queue context id
2788  *
2789  *      Disable an SGE completion queue.  The caller is responsible for
2790  *      ensuring only one context operation occurs at a time.
2791  */
2792 int t3_sge_disable_cqcntxt(adapter_t *adapter, unsigned int id)
2793 {
2794         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2795                 return -EBUSY;
2796
2797         t3_write_reg(adapter, A_SG_CONTEXT_MASK0, V_CQ_SIZE(M_CQ_SIZE));
2798         t3_write_reg(adapter, A_SG_CONTEXT_MASK1, 0);
2799         t3_write_reg(adapter, A_SG_CONTEXT_MASK2, 0);
2800         t3_write_reg(adapter, A_SG_CONTEXT_MASK3, 0);
2801         t3_write_reg(adapter, A_SG_CONTEXT_DATA0, 0);
2802         t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2803                      V_CONTEXT_CMD_OPCODE(1) | F_CQ | V_CONTEXT(id));
2804         return t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2805                                0, SG_CONTEXT_CMD_ATTEMPTS, 1);
2806 }
2807
2808 /**
2809  *      t3_sge_cqcntxt_op - perform an operation on a completion queue context
2810  *      @adapter: the adapter
2811  *      @id: the context id
2812  *      @op: the operation to perform
2813  *      @credits: credits to return to the CQ
2814  *
2815  *      Perform the selected operation on an SGE completion queue context.
2816  *      The caller is responsible for ensuring only one context operation
2817  *      occurs at a time.
2818  *
2819  *      For most operations the function returns the current HW position in
2820  *      the completion queue.
2821  */
2822 int t3_sge_cqcntxt_op(adapter_t *adapter, unsigned int id, unsigned int op,
2823                       unsigned int credits)
2824 {
2825         u32 val;
2826
2827         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2828                 return -EBUSY;
2829
2830         t3_write_reg(adapter, A_SG_CONTEXT_DATA0, credits << 16);
2831         t3_write_reg(adapter, A_SG_CONTEXT_CMD, V_CONTEXT_CMD_OPCODE(op) |
2832                      V_CONTEXT(id) | F_CQ);
2833         if (t3_wait_op_done_val(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY,
2834                                 0, SG_CONTEXT_CMD_ATTEMPTS, 1, &val))
2835                 return -EIO;
2836
2837         if (op >= 2 && op < 7) {
2838                 if (adapter->params.rev > 0)
2839                         return G_CQ_INDEX(val);
2840
2841                 t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2842                              V_CONTEXT_CMD_OPCODE(0) | F_CQ | V_CONTEXT(id));
2843                 if (t3_wait_op_done(adapter, A_SG_CONTEXT_CMD,
2844                                     F_CONTEXT_CMD_BUSY, 0,
2845                                     SG_CONTEXT_CMD_ATTEMPTS, 1))
2846                         return -EIO;
2847                 return G_CQ_INDEX(t3_read_reg(adapter, A_SG_CONTEXT_DATA0));
2848         }
2849         return 0;
2850 }
2851
2852 /**
2853  *      t3_sge_read_context - read an SGE context
2854  *      @type: the context type
2855  *      @adapter: the adapter
2856  *      @id: the context id
2857  *      @data: holds the retrieved context
2858  *
2859  *      Read an SGE egress context.  The caller is responsible for ensuring
2860  *      only one context operation occurs at a time.
2861  */
2862 static int t3_sge_read_context(unsigned int type, adapter_t *adapter,
2863                                unsigned int id, u32 data[4])
2864 {
2865         if (t3_read_reg(adapter, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
2866                 return -EBUSY;
2867
2868         t3_write_reg(adapter, A_SG_CONTEXT_CMD,
2869                      V_CONTEXT_CMD_OPCODE(0) | type | V_CONTEXT(id));
2870         if (t3_wait_op_done(adapter, A_SG_CONTEXT_CMD, F_CONTEXT_CMD_BUSY, 0,
2871                             SG_CONTEXT_CMD_ATTEMPTS, 1))
2872                 return -EIO;
2873         data[0] = t3_read_reg(adapter, A_SG_CONTEXT_DATA0);
2874         data[1] = t3_read_reg(adapter, A_SG_CONTEXT_DATA1);
2875         data[2] = t3_read_reg(adapter, A_SG_CONTEXT_DATA2);
2876         data[3] = t3_read_reg(adapter, A_SG_CONTEXT_DATA3);
2877         return 0;
2878 }
2879
2880 /**
2881  *      t3_sge_read_ecntxt - read an SGE egress context
2882  *      @adapter: the adapter
2883  *      @id: the context id
2884  *      @data: holds the retrieved context
2885  *
2886  *      Read an SGE egress context.  The caller is responsible for ensuring
2887  *      only one context operation occurs at a time.
2888  */
2889 int t3_sge_read_ecntxt(adapter_t *adapter, unsigned int id, u32 data[4])
2890 {
2891         if (id >= 65536)
2892                 return -EINVAL;
2893         return t3_sge_read_context(F_EGRESS, adapter, id, data);
2894 }
2895
2896 /**
2897  *      t3_sge_read_cq - read an SGE CQ context
2898  *      @adapter: the adapter
2899  *      @id: the context id
2900  *      @data: holds the retrieved context
2901  *
2902  *      Read an SGE CQ context.  The caller is responsible for ensuring
2903  *      only one context operation occurs at a time.
2904  */
2905 int t3_sge_read_cq(adapter_t *adapter, unsigned int id, u32 data[4])
2906 {
2907         if (id >= 65536)
2908                 return -EINVAL;
2909         return t3_sge_read_context(F_CQ, adapter, id, data);
2910 }
2911
2912 /**
2913  *      t3_sge_read_fl - read an SGE free-list context
2914  *      @adapter: the adapter
2915  *      @id: the context id
2916  *      @data: holds the retrieved context
2917  *
2918  *      Read an SGE free-list context.  The caller is responsible for ensuring
2919  *      only one context operation occurs at a time.
2920  */
2921 int t3_sge_read_fl(adapter_t *adapter, unsigned int id, u32 data[4])
2922 {
2923         if (id >= SGE_QSETS * 2)
2924                 return -EINVAL;
2925         return t3_sge_read_context(F_FREELIST, adapter, id, data);
2926 }
2927
2928 /**
2929  *      t3_sge_read_rspq - read an SGE response queue context
2930  *      @adapter: the adapter
2931  *      @id: the context id
2932  *      @data: holds the retrieved context
2933  *
2934  *      Read an SGE response queue context.  The caller is responsible for
2935  *      ensuring only one context operation occurs at a time.
2936  */
2937 int t3_sge_read_rspq(adapter_t *adapter, unsigned int id, u32 data[4])
2938 {
2939         if (id >= SGE_QSETS)
2940                 return -EINVAL;
2941         return t3_sge_read_context(F_RESPONSEQ, adapter, id, data);
2942 }
2943
2944 /**
2945  *      t3_config_rss - configure Rx packet steering
2946  *      @adapter: the adapter
2947  *      @rss_config: RSS settings (written to TP_RSS_CONFIG)
2948  *      @cpus: values for the CPU lookup table (0xff terminated)
2949  *      @rspq: values for the response queue lookup table (0xffff terminated)
2950  *
2951  *      Programs the receive packet steering logic.  @cpus and @rspq provide
2952  *      the values for the CPU and response queue lookup tables.  If they
2953  *      provide fewer values than the size of the tables the supplied values
2954  *      are used repeatedly until the tables are fully populated.
2955  */
2956 void t3_config_rss(adapter_t *adapter, unsigned int rss_config, const u8 *cpus,
2957                    const u16 *rspq)
2958 {
2959         int i, j, cpu_idx = 0, q_idx = 0;
2960
2961         if (cpus)
2962                 for (i = 0; i < RSS_TABLE_SIZE; ++i) {
2963                         u32 val = i << 16;
2964
2965                         for (j = 0; j < 2; ++j) {
2966                                 val |= (cpus[cpu_idx++] & 0x3f) << (8 * j);
2967                                 if (cpus[cpu_idx] == 0xff)
2968                                         cpu_idx = 0;
2969                         }
2970                         t3_write_reg(adapter, A_TP_RSS_LKP_TABLE, val);
2971                 }
2972
2973         if (rspq)
2974                 for (i = 0; i < RSS_TABLE_SIZE; ++i) {
2975                         t3_write_reg(adapter, A_TP_RSS_MAP_TABLE,
2976                                      (i << 16) | rspq[q_idx++]);
2977                         if (rspq[q_idx] == 0xffff)
2978                                 q_idx = 0;
2979                 }
2980
2981         t3_write_reg(adapter, A_TP_RSS_CONFIG, rss_config);
2982 }
2983
2984 /**
2985  *      t3_read_rss - read the contents of the RSS tables
2986  *      @adapter: the adapter
2987  *      @lkup: holds the contents of the RSS lookup table
2988  *      @map: holds the contents of the RSS map table
2989  *
2990  *      Reads the contents of the receive packet steering tables.
2991  */
2992 int t3_read_rss(adapter_t *adapter, u8 *lkup, u16 *map)
2993 {
2994         int i;
2995         u32 val;
2996
2997         if (lkup)
2998                 for (i = 0; i < RSS_TABLE_SIZE; ++i) {
2999                         t3_write_reg(adapter, A_TP_RSS_LKP_TABLE,
3000                                      0xffff0000 | i);
3001                         val = t3_read_reg(adapter, A_TP_RSS_LKP_TABLE);
3002                         if (!(val & 0x80000000))
3003                                 return -EAGAIN;
3004                         *lkup++ = (u8)val;
3005                         *lkup++ = (u8)(val >> 8);
3006                 }
3007
3008         if (map)
3009                 for (i = 0; i < RSS_TABLE_SIZE; ++i) {
3010                         t3_write_reg(adapter, A_TP_RSS_MAP_TABLE,
3011                                      0xffff0000 | i);
3012                         val = t3_read_reg(adapter, A_TP_RSS_MAP_TABLE);
3013                         if (!(val & 0x80000000))
3014                                 return -EAGAIN;
3015                         *map++ = (u16)val;
3016                 }
3017         return 0;
3018 }
3019
3020 /**
3021  *      t3_tp_set_offload_mode - put TP in NIC/offload mode
3022  *      @adap: the adapter
3023  *      @enable: 1 to select offload mode, 0 for regular NIC
3024  *
3025  *      Switches TP to NIC/offload mode.
3026  */
3027 void t3_tp_set_offload_mode(adapter_t *adap, int enable)
3028 {
3029         if (is_offload(adap) || !enable)
3030                 t3_set_reg_field(adap, A_TP_IN_CONFIG, F_NICMODE,
3031                                  V_NICMODE(!enable));
3032 }
3033
3034 /**
3035  *      tp_wr_bits_indirect - set/clear bits in an indirect TP register
3036  *      @adap: the adapter
3037  *      @addr: the indirect TP register address
3038  *      @mask: specifies the field within the register to modify
3039  *      @val: new value for the field
3040  *
3041  *      Sets a field of an indirect TP register to the given value.
3042  */
3043 static void tp_wr_bits_indirect(adapter_t *adap, unsigned int addr,
3044                                 unsigned int mask, unsigned int val)
3045 {
3046         t3_write_reg(adap, A_TP_PIO_ADDR, addr);
3047         val |= t3_read_reg(adap, A_TP_PIO_DATA) & ~mask;
3048         t3_write_reg(adap, A_TP_PIO_DATA, val);
3049 }
3050
3051 /**
3052  *      t3_enable_filters - enable the HW filters
3053  *      @adap: the adapter
3054  *
3055  *      Enables the HW filters for NIC traffic.
3056  */
3057 void t3_enable_filters(adapter_t *adap)
3058 {
3059         t3_set_reg_field(adap, A_TP_IN_CONFIG, F_NICMODE, 0);
3060         t3_set_reg_field(adap, A_MC5_DB_CONFIG, 0, F_FILTEREN);
3061         t3_set_reg_field(adap, A_TP_GLOBAL_CONFIG, 0, V_FIVETUPLELOOKUP(3));
3062         tp_wr_bits_indirect(adap, A_TP_INGRESS_CONFIG, 0, F_LOOKUPEVERYPKT);
3063 }
3064
3065 /**
3066  *      t3_disable_filters - disable the HW filters
3067  *      @adap: the adapter
3068  *
3069  *      Disables the HW filters for NIC traffic.
3070  */
3071 void t3_disable_filters(adapter_t *adap)
3072 {
3073         /* note that we don't want to revert to NIC-only mode */
3074         t3_set_reg_field(adap, A_MC5_DB_CONFIG, F_FILTEREN, 0);
3075         t3_set_reg_field(adap, A_TP_GLOBAL_CONFIG,
3076                          V_FIVETUPLELOOKUP(M_FIVETUPLELOOKUP), 0);
3077         tp_wr_bits_indirect(adap, A_TP_INGRESS_CONFIG, F_LOOKUPEVERYPKT, 0);
3078 }
3079
3080 /**
3081  *      pm_num_pages - calculate the number of pages of the payload memory
3082  *      @mem_size: the size of the payload memory
3083  *      @pg_size: the size of each payload memory page
3084  *
3085  *      Calculate the number of pages, each of the given size, that fit in a
3086  *      memory of the specified size, respecting the HW requirement that the
3087  *      number of pages must be a multiple of 24.
3088  */
3089 static inline unsigned int pm_num_pages(unsigned int mem_size,
3090                                         unsigned int pg_size)
3091 {
3092         unsigned int n = mem_size / pg_size;
3093
3094         return n - n % 24;
3095 }
3096
3097 #define mem_region(adap, start, size, reg) \
3098         t3_write_reg((adap), A_ ## reg, (start)); \
3099         start += size
3100
3101 /**
3102  *      partition_mem - partition memory and configure TP memory settings
3103  *      @adap: the adapter
3104  *      @p: the TP parameters
3105  *
3106  *      Partitions context and payload memory and configures TP's memory
3107  *      registers.
3108  */
3109 static void partition_mem(adapter_t *adap, const struct tp_params *p)
3110 {
3111         unsigned int m, pstructs, tids = t3_mc5_size(&adap->mc5);
3112         unsigned int timers = 0, timers_shift = 22;
3113
3114         if (adap->params.rev > 0) {
3115                 if (tids <= 16 * 1024) {
3116                         timers = 1;
3117                         timers_shift = 16;
3118                 } else if (tids <= 64 * 1024) {
3119                         timers = 2;
3120                         timers_shift = 18;
3121                 } else if (tids <= 256 * 1024) {
3122                         timers = 3;
3123                         timers_shift = 20;
3124                 }
3125         }
3126
3127         t3_write_reg(adap, A_TP_PMM_SIZE,
3128                      p->chan_rx_size | (p->chan_tx_size >> 16));
3129
3130         t3_write_reg(adap, A_TP_PMM_TX_BASE, 0);
3131         t3_write_reg(adap, A_TP_PMM_TX_PAGE_SIZE, p->tx_pg_size);
3132         t3_write_reg(adap, A_TP_PMM_TX_MAX_PAGE, p->tx_num_pgs);
3133         t3_set_reg_field(adap, A_TP_PARA_REG3, V_TXDATAACKIDX(M_TXDATAACKIDX),
3134                          V_TXDATAACKIDX(fls(p->tx_pg_size) - 12));
3135
3136         t3_write_reg(adap, A_TP_PMM_RX_BASE, 0);
3137         t3_write_reg(adap, A_TP_PMM_RX_PAGE_SIZE, p->rx_pg_size);
3138         t3_write_reg(adap, A_TP_PMM_RX_MAX_PAGE, p->rx_num_pgs);
3139
3140         pstructs = p->rx_num_pgs + p->tx_num_pgs;
3141         /* Add a bit of headroom and make multiple of 24 */
3142         pstructs += 48;
3143         pstructs -= pstructs % 24;
3144         t3_write_reg(adap, A_TP_CMM_MM_MAX_PSTRUCT, pstructs);
3145
3146         m = tids * TCB_SIZE;
3147         mem_region(adap, m, (64 << 10) * 64, SG_EGR_CNTX_BADDR);
3148         mem_region(adap, m, (64 << 10) * 64, SG_CQ_CONTEXT_BADDR);
3149         t3_write_reg(adap, A_TP_CMM_TIMER_BASE, V_CMTIMERMAXNUM(timers) | m);
3150         m += ((p->ntimer_qs - 1) << timers_shift) + (1 << 22);
3151         mem_region(adap, m, pstructs * 64, TP_CMM_MM_BASE);
3152         mem_region(adap, m, 64 * (pstructs / 24), TP_CMM_MM_PS_FLST_BASE);
3153         mem_region(adap, m, 64 * (p->rx_num_pgs / 24), TP_CMM_MM_RX_FLST_BASE);
3154         mem_region(adap, m, 64 * (p->tx_num_pgs / 24), TP_CMM_MM_TX_FLST_BASE);
3155
3156         m = (m + 4095) & ~0xfff;
3157         t3_write_reg(adap, A_CIM_SDRAM_BASE_ADDR, m);
3158         t3_write_reg(adap, A_CIM_SDRAM_ADDR_SIZE, p->cm_size - m);
3159
3160         tids = (p->cm_size - m - (3 << 20)) / 3072 - 32;
3161         m = t3_mc5_size(&adap->mc5) - adap->params.mc5.nservers -
3162             adap->params.mc5.nfilters - adap->params.mc5.nroutes;
3163         if (tids < m)
3164                 adap->params.mc5.nservers += m - tids;
3165 }
3166
3167 static inline void tp_wr_indirect(adapter_t *adap, unsigned int addr, u32 val)
3168 {
3169         t3_write_reg(adap, A_TP_PIO_ADDR, addr);
3170         t3_write_reg(adap, A_TP_PIO_DATA, val);
3171 }
3172
3173 static inline u32 tp_rd_indirect(adapter_t *adap, unsigned int addr)
3174 {
3175         t3_write_reg(adap, A_TP_PIO_ADDR, addr);
3176         return t3_read_reg(adap, A_TP_PIO_DATA);
3177 }
3178
3179 static void tp_config(adapter_t *adap, const struct tp_params *p)
3180 {
3181         t3_write_reg(adap, A_TP_GLOBAL_CONFIG, F_TXPACINGENABLE | F_PATHMTU |
3182                      F_IPCHECKSUMOFFLOAD | F_UDPCHECKSUMOFFLOAD |
3183                      F_TCPCHECKSUMOFFLOAD | V_IPTTL(64));
3184         t3_write_reg(adap, A_TP_TCP_OPTIONS, V_MTUDEFAULT(576) |
3185                      F_MTUENABLE | V_WINDOWSCALEMODE(1) |
3186                      V_TIMESTAMPSMODE(1) | V_SACKMODE(1) | V_SACKRX(1));
3187         t3_write_reg(adap, A_TP_DACK_CONFIG, V_AUTOSTATE3(1) |
3188                      V_AUTOSTATE2(1) | V_AUTOSTATE1(0) |
3189                      V_BYTETHRESHOLD(26880) | V_MSSTHRESHOLD(2) |
3190                      F_AUTOCAREFUL | F_AUTOENABLE | V_DACK_MODE(1));
3191         t3_set_reg_field(adap, A_TP_IN_CONFIG, F_RXFBARBPRIO | F_TXFBARBPRIO,
3192                          F_IPV6ENABLE | F_NICMODE);
3193         t3_write_reg(adap, A_TP_TX_RESOURCE_LIMIT, 0x18141814);
3194         t3_write_reg(adap, A_TP_PARA_REG4, 0x5050105);
3195         t3_set_reg_field(adap, A_TP_PARA_REG6, 0,
3196                          adap->params.rev > 0 ? F_ENABLEESND :
3197                                                 F_T3A_ENABLEESND);
3198         t3_set_reg_field(adap, A_TP_PC_CONFIG,
3199                          F_ENABLEEPCMDAFULL,
3200                          F_ENABLEOCSPIFULL |F_TXDEFERENABLE | F_HEARBEATDACK |
3201                          F_TXCONGESTIONMODE | F_RXCONGESTIONMODE);
3202         t3_set_reg_field(adap, A_TP_PC_CONFIG2, F_CHDRAFULL,
3203                          F_ENABLEIPV6RSS | F_ENABLENONOFDTNLSYN |
3204                          F_ENABLEARPMISS | F_DISBLEDAPARBIT0);
3205         t3_write_reg(adap, A_TP_PROXY_FLOW_CNTL, 1080);
3206         t3_write_reg(adap, A_TP_PROXY_FLOW_CNTL, 1000);
3207
3208         if (adap->params.rev > 0) {
3209                 tp_wr_indirect(adap, A_TP_EGRESS_CONFIG, F_REWRITEFORCETOSIZE);
3210                 t3_set_reg_field(adap, A_TP_PARA_REG3, 0,
3211                                  F_TXPACEAUTO | F_TXPACEAUTOSTRICT);
3212                 t3_set_reg_field(adap, A_TP_PC_CONFIG, F_LOCKTID, F_LOCKTID);
3213                 tp_wr_indirect(adap, A_TP_VLAN_PRI_MAP, 0xfa50);
3214                 tp_wr_indirect(adap, A_TP_MAC_MATCH_MAP0, 0xfac688);
3215                 tp_wr_indirect(adap, A_TP_MAC_MATCH_MAP1, 0xfac688);
3216         } else
3217                 t3_set_reg_field(adap, A_TP_PARA_REG3, 0, F_TXPACEFIXED);
3218
3219         if (adap->params.rev == T3_REV_C)
3220                 t3_set_reg_field(adap, A_TP_PC_CONFIG,
3221                                  V_TABLELATENCYDELTA(M_TABLELATENCYDELTA),
3222                                  V_TABLELATENCYDELTA(4));
3223
3224         t3_write_reg(adap, A_TP_TX_MOD_QUEUE_WEIGHT1, 0);
3225         t3_write_reg(adap, A_TP_TX_MOD_QUEUE_WEIGHT0, 0);
3226         t3_write_reg(adap, A_TP_MOD_CHANNEL_WEIGHT, 0);
3227         t3_write_reg(adap, A_TP_MOD_RATE_LIMIT, 0xf2200000);
3228
3229         if (adap->params.nports > 2) {
3230                 t3_set_reg_field(adap, A_TP_PC_CONFIG2, 0,
3231                                  F_ENABLETXPORTFROMDA2 | F_ENABLETXPORTFROMDA |
3232                                  F_ENABLERXPORTFROMADDR);
3233                 tp_wr_bits_indirect(adap, A_TP_QOS_RX_MAP_MODE,
3234                                     V_RXMAPMODE(M_RXMAPMODE), 0);
3235                 tp_wr_indirect(adap, A_TP_INGRESS_CONFIG, V_BITPOS0(48) |
3236                                V_BITPOS1(49) | V_BITPOS2(50) | V_BITPOS3(51) |
3237                                F_ENABLEEXTRACT | F_ENABLEEXTRACTIONSFD |
3238                                F_ENABLEINSERTION | F_ENABLEINSERTIONSFD);
3239                 tp_wr_indirect(adap, A_TP_PREAMBLE_MSB, 0xfb000000);
3240                 tp_wr_indirect(adap, A_TP_PREAMBLE_LSB, 0xd5);
3241                 tp_wr_indirect(adap, A_TP_INTF_FROM_TX_PKT, F_INTFFROMTXPKT);
3242         }
3243 }
3244
3245 /* TCP timer values in ms */
3246 #define TP_DACK_TIMER 50
3247 #define TP_RTO_MIN    250
3248
3249 /**
3250  *      tp_set_timers - set TP timing parameters
3251  *      @adap: the adapter to set
3252  *      @core_clk: the core clock frequency in Hz
3253  *
3254  *      Set TP's timing parameters, such as the various timer resolutions and
3255  *      the TCP timer values.
3256  */
3257 static void tp_set_timers(adapter_t *adap, unsigned int core_clk)
3258 {
3259         unsigned int tre = adap->params.tp.tre;
3260         unsigned int dack_re = adap->params.tp.dack_re;
3261         unsigned int tstamp_re = fls(core_clk / 1000);     /* 1ms, at least */
3262         unsigned int tps = core_clk >> tre;
3263
3264         t3_write_reg(adap, A_TP_TIMER_RESOLUTION, V_TIMERRESOLUTION(tre) |
3265                      V_DELAYEDACKRESOLUTION(dack_re) |
3266                      V_TIMESTAMPRESOLUTION(tstamp_re));
3267         t3_write_reg(adap, A_TP_DACK_TIMER,
3268                      (core_clk >> dack_re) / (1000 / TP_DACK_TIMER));
3269         t3_write_reg(adap, A_TP_TCP_BACKOFF_REG0, 0x3020100);
3270         t3_write_reg(adap, A_TP_TCP_BACKOFF_REG1, 0x7060504);
3271         t3_write_reg(adap, A_TP_TCP_BACKOFF_REG2, 0xb0a0908);
3272         t3_write_reg(adap, A_TP_TCP_BACKOFF_REG3, 0xf0e0d0c);
3273         t3_write_reg(adap, A_TP_SHIFT_CNT, V_SYNSHIFTMAX(6) |
3274                      V_RXTSHIFTMAXR1(4) | V_RXTSHIFTMAXR2(15) |
3275                      V_PERSHIFTBACKOFFMAX(8) | V_PERSHIFTMAX(8) |
3276                      V_KEEPALIVEMAX(9));
3277
3278 #define SECONDS * tps
3279
3280         t3_write_reg(adap, A_TP_MSL,
3281                      adap->params.rev > 0 ? 0 : 2 SECONDS);
3282         t3_write_reg(adap, A_TP_RXT_MIN, tps / (1000 / TP_RTO_MIN));
3283         t3_write_reg(adap, A_TP_RXT_MAX, 64 SECONDS);
3284         t3_write_reg(adap, A_TP_PERS_MIN, 5 SECONDS);
3285         t3_write_reg(adap, A_TP_PERS_MAX, 64 SECONDS);
3286         t3_write_reg(adap, A_TP_KEEP_IDLE, 7200 SECONDS);
3287         t3_write_reg(adap, A_TP_KEEP_INTVL, 75 SECONDS);
3288         t3_write_reg(adap, A_TP_INIT_SRTT, 3 SECONDS);
3289         t3_write_reg(adap, A_TP_FINWAIT2_TIMER, 600 SECONDS);
3290
3291 #undef SECONDS
3292 }
3293
3294 /**
3295  *      t3_tp_set_coalescing_size - set receive coalescing size
3296  *      @adap: the adapter
3297  *      @size: the receive coalescing size
3298  *      @psh: whether a set PSH bit should deliver coalesced data
3299  *
3300  *      Set the receive coalescing size and PSH bit handling.
3301  */
3302 int t3_tp_set_coalescing_size(adapter_t *adap, unsigned int size, int psh)
3303 {
3304         u32 val;
3305
3306         if (size > MAX_RX_COALESCING_LEN)
3307                 return -EINVAL;
3308
3309         val = t3_read_reg(adap, A_TP_PARA_REG3);
3310         val &= ~(F_RXCOALESCEENABLE | F_RXCOALESCEPSHEN);
3311
3312         if (size) {
3313                 val |= F_RXCOALESCEENABLE;
3314                 if (psh)
3315                         val |= F_RXCOALESCEPSHEN;
3316                 size = min(MAX_RX_COALESCING_LEN, size);
3317                 t3_write_reg(adap, A_TP_PARA_REG2, V_RXCOALESCESIZE(size) |
3318                              V_MAXRXDATA(MAX_RX_COALESCING_LEN));
3319         }
3320         t3_write_reg(adap, A_TP_PARA_REG3, val);
3321         return 0;
3322 }
3323
3324 /**
3325  *      t3_tp_set_max_rxsize - set the max receive size
3326  *      @adap: the adapter
3327  *      @size: the max receive size
3328  *
3329  *      Set TP's max receive size.  This is the limit that applies when
3330  *      receive coalescing is disabled.
3331  */
3332 void t3_tp_set_max_rxsize(adapter_t *adap, unsigned int size)
3333 {
3334         t3_write_reg(adap, A_TP_PARA_REG7,
3335                      V_PMMAXXFERLEN0(size) | V_PMMAXXFERLEN1(size));
3336 }
3337
3338 static void __devinit init_mtus(unsigned short mtus[])
3339 {
3340         /*
3341          * See draft-mathis-plpmtud-00.txt for the values.  The min is 88 so
3342          * it can accommodate max size TCP/IP headers when SACK and timestamps
3343          * are enabled and still have at least 8 bytes of payload.
3344          */
3345         mtus[0] = 88;
3346         mtus[1] = 88;
3347         mtus[2] = 256;
3348         mtus[3] = 512;
3349         mtus[4] = 576;
3350         mtus[5] = 1024;
3351         mtus[6] = 1280;
3352         mtus[7] = 1492;
3353         mtus[8] = 1500;
3354         mtus[9] = 2002;
3355         mtus[10] = 2048;
3356         mtus[11] = 4096;
3357         mtus[12] = 4352;
3358         mtus[13] = 8192;
3359         mtus[14] = 9000;
3360         mtus[15] = 9600;
3361 }
3362
3363 /**
3364  *      init_cong_ctrl - initialize congestion control parameters
3365  *      @a: the alpha values for congestion control
3366  *      @b: the beta values for congestion control
3367  *
3368  *      Initialize the congestion control parameters.
3369  */
3370 static void __devinit init_cong_ctrl(unsigned short *a, unsigned short *b)
3371 {
3372         a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = a[8] = 1;
3373         a[9] = 2;
3374         a[10] = 3;
3375         a[11] = 4;
3376         a[12] = 5;
3377         a[13] = 6;
3378         a[14] = 7;
3379         a[15] = 8;
3380         a[16] = 9;
3381         a[17] = 10;
3382         a[18] = 14;
3383         a[19] = 17;
3384         a[20] = 21;
3385         a[21] = 25;
3386         a[22] = 30;
3387         a[23] = 35;
3388         a[24] = 45;
3389         a[25] = 60;
3390         a[26] = 80;
3391         a[27] = 100;
3392         a[28] = 200;
3393         a[29] = 300;
3394         a[30] = 400;
3395         a[31] = 500;
3396
3397         b[0] = b[1] = b[2] = b[3] = b[4] = b[5] = b[6] = b[7] = b[8] = 0;
3398         b[9] = b[10] = 1;
3399         b[11] = b[12] = 2;
3400         b[13] = b[14] = b[15] = b[16] = 3;
3401         b[17] = b[18] = b[19] = b[20] = b[21] = 4;
3402         b[22] = b[23] = b[24] = b[25] = b[26] = b[27] = 5;
3403         b[28] = b[29] = 6;
3404         b[30] = b[31] = 7;
3405 }
3406
3407 /* The minimum additive increment value for the congestion control table */
3408 #define CC_MIN_INCR 2U
3409
3410 /**
3411  *      t3_load_mtus - write the MTU and congestion control HW tables
3412  *      @adap: the adapter
3413  *      @mtus: the unrestricted values for the MTU table
3414  *      @alpha: the values for the congestion control alpha parameter
3415  *      @beta: the values for the congestion control beta parameter
3416  *      @mtu_cap: the maximum permitted effective MTU
3417  *
3418  *      Write the MTU table with the supplied MTUs capping each at &mtu_cap.
3419  *      Update the high-speed congestion control table with the supplied alpha,
3420  *      beta, and MTUs.
3421  */
3422 void t3_load_mtus(adapter_t *adap, unsigned short mtus[NMTUS],
3423                   unsigned short alpha[NCCTRL_WIN],
3424                   unsigned short beta[NCCTRL_WIN], unsigned short mtu_cap)
3425 {
3426         static const unsigned int avg_pkts[NCCTRL_WIN] = {
3427                 2, 6, 10, 14, 20, 28, 40, 56, 80, 112, 160, 224, 320, 448, 640,
3428                 896, 1281, 1792, 2560, 3584, 5120, 7168, 10240, 14336, 20480,
3429                 28672, 40960, 57344, 81920, 114688, 163840, 229376 };
3430
3431         unsigned int i, w;
3432
3433         for (i = 0; i < NMTUS; ++i) {
3434                 unsigned int mtu = min(mtus[i], mtu_cap);
3435                 unsigned int log2 = fls(mtu);
3436
3437                 if (!(mtu & ((1 << log2) >> 2)))     /* round */
3438                         log2--;
3439                 t3_write_reg(adap, A_TP_MTU_TABLE,
3440                              (i << 24) | (log2 << 16) | mtu);
3441
3442                 for (w = 0; w < NCCTRL_WIN; ++w) {
3443                         unsigned int inc;
3444
3445                         inc = max(((mtu - 40) * alpha[w]) / avg_pkts[w],
3446                                   CC_MIN_INCR);
3447
3448                         t3_write_reg(adap, A_TP_CCTRL_TABLE, (i << 21) |
3449                                      (w << 16) | (beta[w] << 13) | inc);
3450                 }
3451         }
3452 }
3453
3454 /**
3455  *      t3_read_hw_mtus - returns the values in the HW MTU table
3456  *      @adap: the adapter
3457  *      @mtus: where to store the HW MTU values
3458  *
3459  *      Reads the HW MTU table.
3460  */
3461 void t3_read_hw_mtus(adapter_t *adap, unsigned short mtus[NMTUS])
3462 {
3463         int i;
3464
3465         for (i = 0; i < NMTUS; ++i) {
3466                 unsigned int val;
3467
3468                 t3_write_reg(adap, A_TP_MTU_TABLE, 0xff000000 | i);
3469                 val = t3_read_reg(adap, A_TP_MTU_TABLE);
3470                 mtus[i] = val & 0x3fff;
3471         }
3472 }
3473
3474 /**
3475  *      t3_get_cong_cntl_tab - reads the congestion control table
3476  *      @adap: the adapter
3477  *      @incr: where to store the alpha values
3478  *
3479  *      Reads the additive increments programmed into the HW congestion
3480  *      control table.
3481  */
3482 void t3_get_cong_cntl_tab(adapter_t *adap,
3483                           unsigned short incr[NMTUS][NCCTRL_WIN])
3484 {
3485         unsigned int mtu, w;
3486
3487         for (mtu = 0; mtu < NMTUS; ++mtu)
3488                 for (w = 0; w < NCCTRL_WIN; ++w) {
3489                         t3_write_reg(adap, A_TP_CCTRL_TABLE,
3490                                      0xffff0000 | (mtu << 5) | w);
3491                         incr[mtu][w] = (unsigned short)t3_read_reg(adap,
3492                                         A_TP_CCTRL_TABLE) & 0x1fff;
3493                 }
3494 }
3495
3496 /**
3497  *      t3_tp_get_mib_stats - read TP's MIB counters
3498  *      @adap: the adapter
3499  *      @tps: holds the returned counter values
3500  *
3501  *      Returns the values of TP's MIB counters.
3502  */
3503 void t3_tp_get_mib_stats(adapter_t *adap, struct tp_mib_stats *tps)
3504 {
3505         t3_read_indirect(adap, A_TP_MIB_INDEX, A_TP_MIB_RDATA, (u32 *)tps,
3506                          sizeof(*tps) / sizeof(u32), 0);
3507 }
3508
3509 /**
3510  *      t3_read_pace_tbl - read the pace table
3511  *      @adap: the adapter
3512  *      @pace_vals: holds the returned values
3513  *
3514  *      Returns the values of TP's pace table in nanoseconds.
3515  */
3516 void t3_read_pace_tbl(adapter_t *adap, unsigned int pace_vals[NTX_SCHED])
3517 {
3518         unsigned int i, tick_ns = dack_ticks_to_usec(adap, 1000);
3519
3520         for (i = 0; i < NTX_SCHED; i++) {
3521                 t3_write_reg(adap, A_TP_PACE_TABLE, 0xffff0000 + i);
3522                 pace_vals[i] = t3_read_reg(adap, A_TP_PACE_TABLE) * tick_ns;
3523         }
3524 }
3525
3526 /**
3527  *      t3_set_pace_tbl - set the pace table
3528  *      @adap: the adapter
3529  *      @pace_vals: the pace values in nanoseconds
3530  *      @start: index of the first entry in the HW pace table to set
3531  *      @n: how many entries to set
3532  *
3533  *      Sets (a subset of the) HW pace table.
3534  */
3535 void t3_set_pace_tbl(adapter_t *adap, unsigned int *pace_vals,
3536                      unsigned int start, unsigned int n)
3537 {
3538         unsigned int tick_ns = dack_ticks_to_usec(adap, 1000);
3539
3540         for ( ; n; n--, start++, pace_vals++)
3541                 t3_write_reg(adap, A_TP_PACE_TABLE, (start << 16) |
3542                              ((*pace_vals + tick_ns / 2) / tick_ns));
3543 }
3544
3545 #define ulp_region(adap, name, start, len) \
3546         t3_write_reg((adap), A_ULPRX_ ## name ## _LLIMIT, (start)); \
3547         t3_write_reg((adap), A_ULPRX_ ## name ## _ULIMIT, \
3548                      (start) + (len) - 1); \
3549         start += len
3550
3551 #define ulptx_region(adap, name, start, len) \
3552         t3_write_reg((adap), A_ULPTX_ ## name ## _LLIMIT, (start)); \
3553         t3_write_reg((adap), A_ULPTX_ ## name ## _ULIMIT, \
3554                      (start) + (len) - 1)
3555
3556 static void ulp_config(adapter_t *adap, const struct tp_params *p)
3557 {
3558         unsigned int m = p->chan_rx_size;
3559
3560         ulp_region(adap, ISCSI, m, p->chan_rx_size / 8);
3561         ulp_region(adap, TDDP, m, p->chan_rx_size / 8);
3562         ulptx_region(adap, TPT, m, p->chan_rx_size / 4);
3563         ulp_region(adap, STAG, m, p->chan_rx_size / 4);
3564         ulp_region(adap, RQ, m, p->chan_rx_size / 4);
3565         ulptx_region(adap, PBL, m, p->chan_rx_size / 4);
3566         ulp_region(adap, PBL, m, p->chan_rx_size / 4);
3567         t3_write_reg(adap, A_ULPRX_TDDP_TAGMASK, 0xffffffff);
3568 }
3569
3570
3571 /**
3572  *      t3_set_proto_sram - set the contents of the protocol sram
3573  *      @adapter: the adapter
3574  *      @data: the protocol image
3575  *
3576  *      Write the contents of the protocol SRAM.
3577  */
3578 int t3_set_proto_sram(adapter_t *adap, const u8 *data)
3579 {
3580         int i;
3581         const u32 *buf = (const u32 *)data;
3582
3583         for (i = 0; i < PROTO_SRAM_LINES; i++) {
3584                 t3_write_reg(adap, A_TP_EMBED_OP_FIELD5, cpu_to_be32(*buf++));
3585                 t3_write_reg(adap, A_TP_EMBED_OP_FIELD4, cpu_to_be32(*buf++));
3586                 t3_write_reg(adap, A_TP_EMBED_OP_FIELD3, cpu_to_be32(*buf++));
3587                 t3_write_reg(adap, A_TP_EMBED_OP_FIELD2, cpu_to_be32(*buf++));
3588                 t3_write_reg(adap, A_TP_EMBED_OP_FIELD1, cpu_to_be32(*buf++));
3589
3590                 t3_write_reg(adap, A_TP_EMBED_OP_FIELD0, i << 1 | 1 << 31);
3591                 if (t3_wait_op_done(adap, A_TP_EMBED_OP_FIELD0, 1, 1, 5, 1))
3592                         return -EIO;
3593         }
3594         return 0;
3595 }
3596
3597 /**
3598  *      t3_config_trace_filter - configure one of the tracing filters
3599  *      @adapter: the adapter
3600  *      @tp: the desired trace filter parameters
3601  *      @filter_index: which filter to configure
3602  *      @invert: if set non-matching packets are traced instead of matching ones
3603  *      @enable: whether to enable or disable the filter
3604  *
3605  *      Configures one of the tracing filters available in HW.
3606  */
3607 void t3_config_trace_filter(adapter_t *adapter, const struct trace_params *tp,
3608                             int filter_index, int invert, int enable)
3609 {
3610         u32 addr, key[4], mask[4];
3611
3612         key[0] = tp->sport | (tp->sip << 16);
3613         key[1] = (tp->sip >> 16) | (tp->dport << 16);
3614         key[2] = tp->dip;
3615         key[3] = tp->proto | (tp->vlan << 8) | (tp->intf << 20);
3616
3617         mask[0] = tp->sport_mask | (tp->sip_mask << 16);
3618         mask[1] = (tp->sip_mask >> 16) | (tp->dport_mask << 16);
3619         mask[2] = tp->dip_mask;
3620         mask[3] = tp->proto_mask | (tp->vlan_mask << 8) | (tp->intf_mask << 20);
3621
3622         if (invert)
3623                 key[3] |= (1 << 29);
3624         if (enable)
3625                 key[3] |= (1 << 28);
3626
3627         addr = filter_index ? A_TP_RX_TRC_KEY0 : A_TP_TX_TRC_KEY0;
3628         tp_wr_indirect(adapter, addr++, key[0]);
3629         tp_wr_indirect(adapter, addr++, mask[0]);
3630         tp_wr_indirect(adapter, addr++, key[1]);
3631         tp_wr_indirect(adapter, addr++, mask[1]);
3632         tp_wr_indirect(adapter, addr++, key[2]);
3633         tp_wr_indirect(adapter, addr++, mask[2]);
3634         tp_wr_indirect(adapter, addr++, key[3]);
3635         tp_wr_indirect(adapter, addr,   mask[3]);
3636         (void) t3_read_reg(adapter, A_TP_PIO_DATA);
3637 }
3638
3639 /**
3640  *      t3_query_trace_filter - query a tracing filter
3641  *      @adapter: the adapter
3642  *      @tp: the current trace filter parameters
3643  *      @filter_index: which filter to query
3644  *      @inverted: non-zero if the filter is inverted
3645  *      @enabled: non-zero if the filter is enabled
3646  *
3647  *      Returns the current settings of the specified HW tracing filter.
3648  */
3649 void t3_query_trace_filter(adapter_t *adapter, struct trace_params *tp,
3650                            int filter_index, int *inverted, int *enabled)
3651 {
3652         u32 addr, key[4], mask[4];
3653
3654         addr = filter_index ? A_TP_RX_TRC_KEY0 : A_TP_TX_TRC_KEY0;
3655         key[0]  = tp_rd_indirect(adapter, addr++);
3656         mask[0] = tp_rd_indirect(adapter, addr++);
3657         key[1]  = tp_rd_indirect(adapter, addr++);
3658         mask[1] = tp_rd_indirect(adapter, addr++);
3659         key[2]  = tp_rd_indirect(adapter, addr++);
3660         mask[2] = tp_rd_indirect(adapter, addr++);
3661         key[3]  = tp_rd_indirect(adapter, addr++);
3662         mask[3] = tp_rd_indirect(adapter, addr);
3663
3664         tp->sport = key[0] & 0xffff;
3665         tp->sip   = (key[0] >> 16) | ((key[1] & 0xffff) << 16);
3666         tp->dport = key[1] >> 16;
3667         tp->dip   = key[2];
3668         tp->proto = key[3] & 0xff;
3669         tp->vlan  = key[3] >> 8;
3670         tp->intf  = key[3] >> 20;
3671
3672         tp->sport_mask = mask[0] & 0xffff;
3673         tp->sip_mask   = (mask[0] >> 16) | ((mask[1] & 0xffff) << 16);
3674         tp->dport_mask = mask[1] >> 16;
3675         tp->dip_mask   = mask[2];
3676         tp->proto_mask = mask[3] & 0xff;
3677         tp->vlan_mask  = mask[3] >> 8;
3678         tp->intf_mask  = mask[3] >> 20;
3679
3680         *inverted = key[3] & (1 << 29);
3681         *enabled  = key[3] & (1 << 28);
3682 }
3683
3684 /**
3685  *      t3_config_sched - configure a HW traffic scheduler
3686  *      @adap: the adapter
3687  *      @kbps: target rate in Kbps
3688  *      @sched: the scheduler index
3689  *
3690  *      Configure a Tx HW scheduler for the target rate.
3691  */
3692 int t3_config_sched(adapter_t *adap, unsigned int kbps, int sched)
3693 {
3694         unsigned int v, tps, cpt, bpt, delta, mindelta = ~0;
3695         unsigned int clk = adap->params.vpd.cclk * 1000;
3696         unsigned int selected_cpt = 0, selected_bpt = 0;
3697
3698         if (kbps > 0) {
3699                 kbps *= 125;     /* -> bytes */
3700                 for (cpt = 1; cpt <= 255; cpt++) {
3701                         tps = clk / cpt;
3702                         bpt = (kbps + tps / 2) / tps;
3703                         if (bpt > 0 && bpt <= 255) {
3704                                 v = bpt * tps;
3705                                 delta = v >= kbps ? v - kbps : kbps - v;
3706                                 if (delta < mindelta) {
3707                                         mindelta = delta;
3708                                         selected_cpt = cpt;
3709                                         selected_bpt = bpt;
3710                                 }
3711                         } else if (selected_cpt)
3712                                 break;
3713                 }
3714                 if (!selected_cpt)
3715                         return -EINVAL;
3716         }
3717         t3_write_reg(adap, A_TP_TM_PIO_ADDR,
3718                      A_TP_TX_MOD_Q1_Q0_RATE_LIMIT - sched / 2);
3719         v = t3_read_reg(adap, A_TP_TM_PIO_DATA);
3720         if (sched & 1)
3721                 v = (v & 0xffff) | (selected_cpt << 16) | (selected_bpt << 24);
3722         else
3723                 v = (v & 0xffff0000) | selected_cpt | (selected_bpt << 8);
3724         t3_write_reg(adap, A_TP_TM_PIO_DATA, v);
3725         return 0;
3726 }
3727
3728 /**
3729  *      t3_set_sched_ipg - set the IPG for a Tx HW packet rate scheduler
3730  *      @adap: the adapter
3731  *      @sched: the scheduler index
3732  *      @ipg: the interpacket delay in tenths of nanoseconds
3733  *
3734  *      Set the interpacket delay for a HW packet rate scheduler.
3735  */
3736 int t3_set_sched_ipg(adapter_t *adap, int sched, unsigned int ipg)
3737 {
3738         unsigned int v, addr = A_TP_TX_MOD_Q1_Q0_TIMER_SEPARATOR - sched / 2;
3739
3740         /* convert ipg to nearest number of core clocks */
3741         ipg *= core_ticks_per_usec(adap);
3742         ipg = (ipg + 5000) / 10000;
3743         if (ipg > 0xffff)
3744                 return -EINVAL;
3745
3746         t3_write_reg(adap, A_TP_TM_PIO_ADDR, addr);
3747         v = t3_read_reg(adap, A_TP_TM_PIO_DATA);
3748         if (sched & 1)
3749                 v = (v & 0xffff) | (ipg << 16);
3750         else
3751                 v = (v & 0xffff0000) | ipg;
3752         t3_write_reg(adap, A_TP_TM_PIO_DATA, v);
3753         t3_read_reg(adap, A_TP_TM_PIO_DATA);
3754         return 0;
3755 }
3756
3757 /**
3758  *      t3_get_tx_sched - get the configuration of a Tx HW traffic scheduler
3759  *      @adap: the adapter
3760  *      @sched: the scheduler index
3761  *      @kbps: the byte rate in Kbps
3762  *      @ipg: the interpacket delay in tenths of nanoseconds
3763  *
3764  *      Return the current configuration of a HW Tx scheduler.
3765  */
3766 void t3_get_tx_sched(adapter_t *adap, unsigned int sched, unsigned int *kbps,
3767                      unsigned int *ipg)
3768 {
3769         unsigned int v, addr, bpt, cpt;
3770
3771         if (kbps) {
3772                 addr = A_TP_TX_MOD_Q1_Q0_RATE_LIMIT - sched / 2;
3773                 t3_write_reg(adap, A_TP_TM_PIO_ADDR, addr);
3774                 v = t3_read_reg(adap, A_TP_TM_PIO_DATA);
3775                 if (sched & 1)
3776                         v >>= 16;
3777                 bpt = (v >> 8) & 0xff;
3778                 cpt = v & 0xff;
3779                 if (!cpt)
3780                         *kbps = 0;        /* scheduler disabled */
3781                 else {
3782                         v = (adap->params.vpd.cclk * 1000) / cpt;
3783                         *kbps = (v * bpt) / 125;
3784                 }
3785         }
3786         if (ipg) {
3787                 addr = A_TP_TX_MOD_Q1_Q0_TIMER_SEPARATOR - sched / 2;
3788                 t3_write_reg(adap, A_TP_TM_PIO_ADDR, addr);
3789                 v = t3_read_reg(adap, A_TP_TM_PIO_DATA);
3790                 if (sched & 1)
3791                         v >>= 16;
3792                 v &= 0xffff;
3793                 *ipg = (10000 * v) / core_ticks_per_usec(adap);
3794         }
3795 }
3796
3797 /**
3798  *      tp_init - configure TP
3799  *      @adap: the adapter
3800  *      @p: TP configuration parameters
3801  *
3802  *      Initializes the TP HW module.
3803  */
3804 static int tp_init(adapter_t *adap, const struct tp_params *p)
3805 {
3806         int busy = 0;
3807
3808         tp_config(adap, p);
3809         t3_set_vlan_accel(adap, 3, 0);
3810
3811         if (is_offload(adap)) {
3812                 tp_set_timers(adap, adap->params.vpd.cclk * 1000);
3813                 t3_write_reg(adap, A_TP_RESET, F_FLSTINITENABLE);
3814                 busy = t3_wait_op_done(adap, A_TP_RESET, F_FLSTINITENABLE,
3815                                        0, 1000, 5);
3816                 if (busy)
3817                         CH_ERR(adap, "TP initialization timed out\n");
3818         }
3819
3820         if (!busy)
3821                 t3_write_reg(adap, A_TP_RESET, F_TPRESET);
3822         return busy;
3823 }
3824
3825 /**
3826  *      t3_mps_set_active_ports - configure port failover
3827  *      @adap: the adapter
3828  *      @port_mask: bitmap of active ports
3829  *
3830  *      Sets the active ports according to the supplied bitmap.
3831  */
3832 int t3_mps_set_active_ports(adapter_t *adap, unsigned int port_mask)
3833 {
3834         if (port_mask & ~((1 << adap->params.nports) - 1))
3835                 return -EINVAL;
3836         t3_set_reg_field(adap, A_MPS_CFG, F_PORT1ACTIVE | F_PORT0ACTIVE,
3837                          port_mask << S_PORT0ACTIVE);
3838         return 0;
3839 }
3840
3841 /**
3842  *      chan_init_hw - channel-dependent HW initialization
3843  *      @adap: the adapter
3844  *      @chan_map: bitmap of Tx channels being used
3845  *
3846  *      Perform the bits of HW initialization that are dependent on the Tx
3847  *      channels being used.
3848  */
3849 static void chan_init_hw(adapter_t *adap, unsigned int chan_map)
3850 {
3851         int i;
3852
3853         if (chan_map != 3) {                                 /* one channel */
3854                 t3_set_reg_field(adap, A_ULPRX_CTL, F_ROUND_ROBIN, 0);
3855                 t3_set_reg_field(adap, A_ULPTX_CONFIG, F_CFG_RR_ARB, 0);
3856                 t3_write_reg(adap, A_MPS_CFG, F_TPRXPORTEN | F_ENFORCEPKT |
3857                              (chan_map == 1 ? F_TPTXPORT0EN | F_PORT0ACTIVE :
3858                                               F_TPTXPORT1EN | F_PORT1ACTIVE));
3859                 t3_write_reg(adap, A_PM1_TX_CFG,
3860                              chan_map == 1 ? 0xffffffff : 0);
3861                 if (chan_map == 2)
3862                         t3_write_reg(adap, A_TP_TX_MOD_QUEUE_REQ_MAP,
3863                                      V_TX_MOD_QUEUE_REQ_MAP(0xff));
3864                 t3_write_reg(adap, A_TP_TX_MOD_QUE_TABLE, (12 << 16) | 0xd9c8);
3865                 t3_write_reg(adap, A_TP_TX_MOD_QUE_TABLE, (13 << 16) | 0xfbea);
3866         } else {                                             /* two channels */
3867                 t3_set_reg_field(adap, A_ULPRX_CTL, 0, F_ROUND_ROBIN);
3868                 t3_set_reg_field(adap, A_ULPTX_CONFIG, 0, F_CFG_RR_ARB);
3869                 t3_write_reg(adap, A_ULPTX_DMA_WEIGHT,
3870                              V_D1_WEIGHT(16) | V_D0_WEIGHT(16));
3871                 t3_write_reg(adap, A_MPS_CFG, F_TPTXPORT0EN | F_TPTXPORT1EN |
3872                              F_TPRXPORTEN | F_PORT0ACTIVE | F_PORT1ACTIVE |
3873                              F_ENFORCEPKT);
3874                 t3_write_reg(adap, A_PM1_TX_CFG, 0x80008000);
3875                 t3_set_reg_field(adap, A_TP_PC_CONFIG, 0, F_TXTOSQUEUEMAPMODE);
3876                 t3_write_reg(adap, A_TP_TX_MOD_QUEUE_REQ_MAP,
3877                              V_TX_MOD_QUEUE_REQ_MAP(0xaa));
3878                 for (i = 0; i < 16; i++)
3879                         t3_write_reg(adap, A_TP_TX_MOD_QUE_TABLE,
3880                                      (i << 16) | 0x1010);
3881                 t3_write_reg(adap, A_TP_TX_MOD_QUE_TABLE, (12 << 16) | 0xba98);
3882                 t3_write_reg(adap, A_TP_TX_MOD_QUE_TABLE, (13 << 16) | 0xfedc);
3883         }
3884 }
3885
3886 static int calibrate_xgm(adapter_t *adapter)
3887 {
3888         if (uses_xaui(adapter)) {
3889                 unsigned int v, i;
3890
3891                 for (i = 0; i < 5; ++i) {
3892                         t3_write_reg(adapter, A_XGM_XAUI_IMP, 0);
3893                         (void) t3_read_reg(adapter, A_XGM_XAUI_IMP);
3894                         msleep(1);
3895                         v = t3_read_reg(adapter, A_XGM_XAUI_IMP);
3896                         if (!(v & (F_XGM_CALFAULT | F_CALBUSY))) {
3897                                 t3_write_reg(adapter, A_XGM_XAUI_IMP,
3898                                              V_XAUIIMP(G_CALIMP(v) >> 2));
3899                                 return 0;
3900                         }
3901                 }
3902                 CH_ERR(adapter, "MAC calibration failed\n");
3903                 return -1;
3904         } else {
3905                 t3_write_reg(adapter, A_XGM_RGMII_IMP,
3906                              V_RGMIIIMPPD(2) | V_RGMIIIMPPU(3));
3907                 t3_set_reg_field(adapter, A_XGM_RGMII_IMP, F_XGM_IMPSETUPDATE,
3908                                  F_XGM_IMPSETUPDATE);
3909         }
3910         return 0;
3911 }
3912
3913 static void calibrate_xgm_t3b(adapter_t *adapter)
3914 {
3915         if (!uses_xaui(adapter)) {
3916                 t3_write_reg(adapter, A_XGM_RGMII_IMP, F_CALRESET |
3917                              F_CALUPDATE | V_RGMIIIMPPD(2) | V_RGMIIIMPPU(3));
3918                 t3_set_reg_field(adapter, A_XGM_RGMII_IMP, F_CALRESET, 0);
3919                 t3_set_reg_field(adapter, A_XGM_RGMII_IMP, 0,
3920                                  F_XGM_IMPSETUPDATE);
3921                 t3_set_reg_field(adapter, A_XGM_RGMII_IMP, F_XGM_IMPSETUPDATE,
3922                                  0);
3923                 t3_set_reg_field(adapter, A_XGM_RGMII_IMP, F_CALUPDATE, 0);
3924                 t3_set_reg_field(adapter, A_XGM_RGMII_IMP, 0, F_CALUPDATE);
3925         }
3926 }
3927
3928 struct mc7_timing_params {
3929         unsigned char ActToPreDly;
3930         unsigned char ActToRdWrDly;
3931         unsigned char PreCyc;
3932         unsigned char RefCyc[5];
3933         unsigned char BkCyc;
3934         unsigned char WrToRdDly;
3935         unsigned char RdToWrDly;
3936 };
3937
3938 /*
3939  * Write a value to a register and check that the write completed.  These
3940  * writes normally complete in a cycle or two, so one read should suffice.
3941  * The very first read exists to flush the posted write to the device.
3942  */
3943 static int wrreg_wait(adapter_t *adapter, unsigned int addr, u32 val)
3944 {
3945         t3_write_reg(adapter,   addr, val);
3946         (void) t3_read_reg(adapter, addr);                   /* flush */
3947         if (!(t3_read_reg(adapter, addr) & F_BUSY))
3948                 return 0;
3949         CH_ERR(adapter, "write to MC7 register 0x%x timed out\n", addr);
3950         return -EIO;
3951 }
3952
3953 static int mc7_init(struct mc7 *mc7, unsigned int mc7_clock, int mem_type)
3954 {
3955         static const unsigned int mc7_mode[] = {
3956                 0x632, 0x642, 0x652, 0x432, 0x442
3957         };
3958         static const struct mc7_timing_params mc7_timings[] = {
3959                 { 12, 3, 4, { 20, 28, 34, 52, 0 }, 15, 6, 4 },
3960                 { 12, 4, 5, { 20, 28, 34, 52, 0 }, 16, 7, 4 },
3961                 { 12, 5, 6, { 20, 28, 34, 52, 0 }, 17, 8, 4 },
3962                 { 9,  3, 4, { 15, 21, 26, 39, 0 }, 12, 6, 4 },
3963                 { 9,  4, 5, { 15, 21, 26, 39, 0 }, 13, 7, 4 }
3964         };
3965
3966         u32 val;
3967         unsigned int width, density, slow, attempts;
3968         adapter_t *adapter = mc7->adapter;
3969         const struct mc7_timing_params *p = &mc7_timings[mem_type];
3970
3971         if (!mc7->size)
3972                 return 0;
3973
3974         val = t3_read_reg(adapter, mc7->offset + A_MC7_CFG);
3975         slow = val & F_SLOW;
3976         width = G_WIDTH(val);
3977         density = G_DEN(val);
3978
3979         t3_write_reg(adapter, mc7->offset + A_MC7_CFG, val | F_IFEN);
3980         val = t3_read_reg(adapter, mc7->offset + A_MC7_CFG);  /* flush */
3981         msleep(1);
3982
3983         if (!slow) {
3984                 t3_write_reg(adapter, mc7->offset + A_MC7_CAL, F_SGL_CAL_EN);
3985                 (void) t3_read_reg(adapter, mc7->offset + A_MC7_CAL);
3986                 msleep(1);
3987                 if (t3_read_reg(adapter, mc7->offset + A_MC7_CAL) &
3988                     (F_BUSY | F_SGL_CAL_EN | F_CAL_FAULT)) {
3989                         CH_ERR(adapter, "%s MC7 calibration timed out\n",
3990                                mc7->name);
3991                         goto out_fail;
3992                 }
3993         }
3994
3995         t3_write_reg(adapter, mc7->offset + A_MC7_PARM,
3996                      V_ACTTOPREDLY(p->ActToPreDly) |
3997                      V_ACTTORDWRDLY(p->ActToRdWrDly) | V_PRECYC(p->PreCyc) |
3998                      V_REFCYC(p->RefCyc[density]) | V_BKCYC(p->BkCyc) |
3999                      V_WRTORDDLY(p->WrToRdDly) | V_RDTOWRDLY(p->RdToWrDly));
4000
4001         t3_write_reg(adapter, mc7->offset + A_MC7_CFG,
4002                      val | F_CLKEN | F_TERM150);
4003         (void) t3_read_reg(adapter, mc7->offset + A_MC7_CFG); /* flush */
4004
4005         if (!slow)
4006                 t3_set_reg_field(adapter, mc7->offset + A_MC7_DLL, F_DLLENB,
4007                                  F_DLLENB);
4008         udelay(1);
4009
4010         val = slow ? 3 : 6;
4011         if (wrreg_wait(adapter, mc7->offset + A_MC7_PRE, 0) ||
4012             wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE2, 0) ||
4013             wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE3, 0) ||
4014             wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE1, val))
4015                 goto out_fail;
4016
4017         if (!slow) {
4018                 t3_write_reg(adapter, mc7->offset + A_MC7_MODE, 0x100);
4019                 t3_set_reg_field(adapter, mc7->offset + A_MC7_DLL,
4020                                  F_DLLRST, 0);
4021                 udelay(5);
4022         }
4023
4024         if (wrreg_wait(adapter, mc7->offset + A_MC7_PRE, 0) ||
4025             wrreg_wait(adapter, mc7->offset + A_MC7_REF, 0) ||
4026             wrreg_wait(adapter, mc7->offset + A_MC7_REF, 0) ||
4027             wrreg_wait(adapter, mc7->offset + A_MC7_MODE,
4028                        mc7_mode[mem_type]) ||
4029             wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE1, val | 0x380) ||
4030             wrreg_wait(adapter, mc7->offset + A_MC7_EXT_MODE1, val))
4031                 goto out_fail;
4032
4033         /* clock value is in KHz */
4034         mc7_clock = mc7_clock * 7812 + mc7_clock / 2;  /* ns */
4035         mc7_clock /= 1000000;                          /* KHz->MHz, ns->us */
4036
4037         t3_write_reg(adapter, mc7->offset + A_MC7_REF,
4038                      F_PERREFEN | V_PREREFDIV(mc7_clock));
4039         (void) t3_read_reg(adapter, mc7->offset + A_MC7_REF); /* flush */
4040
4041         t3_write_reg(adapter, mc7->offset + A_MC7_ECC,
4042                      F_ECCGENEN | F_ECCCHKEN);
4043         t3_write_reg(adapter, mc7->offset + A_MC7_BIST_DATA, 0);
4044         t3_write_reg(adapter, mc7->offset + A_MC7_BIST_ADDR_BEG, 0);
4045         t3_write_reg(adapter, mc7->offset + A_MC7_BIST_ADDR_END,
4046                      (mc7->size << width) - 1);
4047         t3_write_reg(adapter, mc7->offset + A_MC7_BIST_OP, V_OP(1));
4048         (void) t3_read_reg(adapter, mc7->offset + A_MC7_BIST_OP); /* flush */
4049
4050         attempts = 50;
4051         do {
4052                 msleep(250);
4053                 val = t3_read_reg(adapter, mc7->offset + A_MC7_BIST_OP);
4054         } while ((val & F_BUSY) && --attempts);
4055         if (val & F_BUSY) {
4056                 CH_ERR(adapter, "%s MC7 BIST timed out\n", mc7->name);
4057                 goto out_fail;
4058         }
4059
4060         /* Enable normal memory accesses. */
4061         t3_set_reg_field(adapter, mc7->offset + A_MC7_CFG, 0, F_RDY);
4062         return 0;
4063
4064  out_fail:
4065         return -1;
4066 }
4067
4068 static void config_pcie(adapter_t *adap)
4069 {
4070         static const u16 ack_lat[4][6] = {
4071                 { 237, 416, 559, 1071, 2095, 4143 },
4072                 { 128, 217, 289, 545, 1057, 2081 },
4073                 { 73, 118, 154, 282, 538, 1050 },
4074                 { 67, 107, 86, 150, 278, 534 }
4075         };
4076         static const u16 rpl_tmr[4][6] = {
4077                 { 711, 1248, 1677, 3213, 6285, 12429 },
4078                 { 384, 651, 867, 1635, 3171, 6243 },
4079                 { 219, 354, 462, 846, 1614, 3150 },
4080                 { 201, 321, 258, 450, 834, 1602 }
4081         };
4082
4083         u16 val, devid;
4084         unsigned int log2_width, pldsize;
4085         unsigned int fst_trn_rx, fst_trn_tx, acklat, rpllmt;
4086
4087         t3_os_pci_read_config_2(adap,
4088                                 adap->params.pci.pcie_cap_addr + PCI_EXP_DEVCTL,
4089                                 &val);
4090         pldsize = (val & PCI_EXP_DEVCTL_PAYLOAD) >> 5;
4091
4092         /*
4093          * Gen2 adapter pcie bridge compatibility requires minimum
4094          * Max_Read_Request_size
4095          */
4096         t3_os_pci_read_config_2(adap, 0x2, &devid);
4097         if (devid == 0x37) {
4098                 t3_os_pci_write_config_2(adap,
4099                     adap->params.pci.pcie_cap_addr + PCI_EXP_DEVCTL,
4100                     val & ~PCI_EXP_DEVCTL_READRQ & ~PCI_EXP_DEVCTL_PAYLOAD);
4101                 pldsize = 0;
4102         }
4103
4104         t3_os_pci_read_config_2(adap,
4105                                 adap->params.pci.pcie_cap_addr + PCI_EXP_LNKCTL,
4106                                 &val);
4107
4108         fst_trn_tx = G_NUMFSTTRNSEQ(t3_read_reg(adap, A_PCIE_PEX_CTRL0));
4109         fst_trn_rx = adap->params.rev == 0 ? fst_trn_tx :
4110                         G_NUMFSTTRNSEQRX(t3_read_reg(adap, A_PCIE_MODE));
4111         log2_width = fls(adap->params.pci.width) - 1;
4112         acklat = ack_lat[log2_width][pldsize];
4113         if (val & 1)                            /* check LOsEnable */
4114                 acklat += fst_trn_tx * 4;
4115         rpllmt = rpl_tmr[log2_width][pldsize] + fst_trn_rx * 4;
4116
4117         if (adap->params.rev == 0)
4118                 t3_set_reg_field(adap, A_PCIE_PEX_CTRL1,
4119                                  V_T3A_ACKLAT(M_T3A_ACKLAT),
4120                                  V_T3A_ACKLAT(acklat));
4121         else
4122                 t3_set_reg_field(adap, A_PCIE_PEX_CTRL1, V_ACKLAT(M_ACKLAT),
4123                                  V_ACKLAT(acklat));
4124
4125         t3_set_reg_field(adap, A_PCIE_PEX_CTRL0, V_REPLAYLMT(M_REPLAYLMT),
4126                          V_REPLAYLMT(rpllmt));
4127
4128         t3_write_reg(adap, A_PCIE_PEX_ERR, 0xffffffff);
4129         t3_set_reg_field(adap, A_PCIE_CFG, 0,
4130                          F_ENABLELINKDWNDRST | F_ENABLELINKDOWNRST |
4131                          F_PCIE_DMASTOPEN | F_PCIE_CLIDECEN);
4132 }
4133
4134 /**
4135  *      t3_init_hw - initialize and configure T3 HW modules
4136  *      @adapter: the adapter
4137  *      @fw_params: initial parameters to pass to firmware (optional)
4138  *
4139  *      Initialize and configure T3 HW modules.  This performs the
4140  *      initialization steps that need to be done once after a card is reset.
4141  *      MAC and PHY initialization is handled separarely whenever a port is
4142  *      enabled.
4143  *
4144  *      @fw_params are passed to FW and their value is platform dependent.
4145  *      Only the top 8 bits are available for use, the rest must be 0.
4146  */
4147 int t3_init_hw(adapter_t *adapter, u32 fw_params)
4148 {
4149         int err = -EIO, attempts, i;
4150         const struct vpd_params *vpd = &adapter->params.vpd;
4151
4152         if (adapter->params.rev > 0)
4153                 calibrate_xgm_t3b(adapter);
4154         else if (calibrate_xgm(adapter))
4155                 goto out_err;
4156
4157         if (adapter->params.nports > 2)
4158                 t3_mac_init(&adap2pinfo(adapter, 0)->mac);
4159
4160         if (vpd->mclk) {
4161                 partition_mem(adapter, &adapter->params.tp);
4162
4163                 if (mc7_init(&adapter->pmrx, vpd->mclk, vpd->mem_timing) ||
4164                     mc7_init(&adapter->pmtx, vpd->mclk, vpd->mem_timing) ||
4165                     mc7_init(&adapter->cm, vpd->mclk, vpd->mem_timing) ||
4166                     t3_mc5_init(&adapter->mc5, adapter->params.mc5.nservers,
4167                                 adapter->params.mc5.nfilters,
4168                                 adapter->params.mc5.nroutes))
4169                         goto out_err;
4170
4171                 for (i = 0; i < 32; i++)
4172                         if (clear_sge_ctxt(adapter, i, F_CQ))
4173                                 goto out_err;
4174         }
4175
4176         if (tp_init(adapter, &adapter->params.tp))
4177                 goto out_err;
4178
4179         t3_tp_set_coalescing_size(adapter,
4180                                   min(adapter->params.sge.max_pkt_size,
4181                                       MAX_RX_COALESCING_LEN), 1);
4182         t3_tp_set_max_rxsize(adapter,
4183                              min(adapter->params.sge.max_pkt_size, 16384U));
4184         ulp_config(adapter, &adapter->params.tp);
4185         if (is_pcie(adapter))
4186                 config_pcie(adapter);
4187         else
4188                 t3_set_reg_field(adapter, A_PCIX_CFG, 0,
4189                                  F_DMASTOPEN | F_CLIDECEN);
4190
4191         if (adapter->params.rev == T3_REV_C)
4192                 t3_set_reg_field(adapter, A_ULPTX_CONFIG, 0,
4193                                  F_CFG_CQE_SOP_MASK);
4194
4195         t3_write_reg(adapter, A_PM1_RX_CFG, 0xffffffff);
4196         t3_write_reg(adapter, A_PM1_RX_MODE, 0);
4197         t3_write_reg(adapter, A_PM1_TX_MODE, 0);
4198         chan_init_hw(adapter, adapter->params.chan_map);
4199         t3_sge_init(adapter, &adapter->params.sge);
4200         t3_set_reg_field(adapter, A_PL_RST, 0, F_FATALPERREN);
4201
4202         t3_write_reg(adapter, A_T3DBG_GPIO_ACT_LOW, calc_gpio_intr(adapter));
4203
4204         t3_write_reg(adapter, A_CIM_HOST_ACC_DATA, vpd->uclk | fw_params);
4205         t3_write_reg(adapter, A_CIM_BOOT_CFG,
4206                      V_BOOTADDR(FW_FLASH_BOOT_ADDR >> 2));
4207         (void) t3_read_reg(adapter, A_CIM_BOOT_CFG);    /* flush */
4208
4209         attempts = 100;
4210         do {                          /* wait for uP to initialize */
4211                 msleep(20);
4212         } while (t3_read_reg(adapter, A_CIM_HOST_ACC_DATA) && --attempts);
4213         if (!attempts) {
4214                 CH_ERR(adapter, "uP initialization timed out\n");
4215                 goto out_err;
4216         }
4217
4218         err = 0;
4219  out_err:
4220         return err;
4221 }
4222
4223 /**
4224  *      get_pci_mode - determine a card's PCI mode
4225  *      @adapter: the adapter
4226  *      @p: where to store the PCI settings
4227  *
4228  *      Determines a card's PCI mode and associated parameters, such as speed
4229  *      and width.
4230  */
4231 static void __devinit get_pci_mode(adapter_t *adapter, struct pci_params *p)
4232 {
4233         static unsigned short speed_map[] = { 33, 66, 100, 133 };
4234         u32 pci_mode, pcie_cap;
4235
4236         pcie_cap = t3_os_find_pci_capability(adapter, PCI_CAP_ID_EXP);
4237         if (pcie_cap) {
4238                 u16 val;
4239
4240                 p->variant = PCI_VARIANT_PCIE;
4241                 p->pcie_cap_addr = pcie_cap;
4242                 t3_os_pci_read_config_2(adapter, pcie_cap + PCI_EXP_LNKSTA,
4243                                         &val);
4244                 p->width = (val >> 4) & 0x3f;
4245                 return;
4246         }
4247
4248         pci_mode = t3_read_reg(adapter, A_PCIX_MODE);
4249         p->speed = speed_map[G_PCLKRANGE(pci_mode)];
4250         p->width = (pci_mode & F_64BIT) ? 64 : 32;
4251         pci_mode = G_PCIXINITPAT(pci_mode);
4252         if (pci_mode == 0)
4253                 p->variant = PCI_VARIANT_PCI;
4254         else if (pci_mode < 4)
4255                 p->variant = PCI_VARIANT_PCIX_MODE1_PARITY;
4256         else if (pci_mode < 8)
4257                 p->variant = PCI_VARIANT_PCIX_MODE1_ECC;
4258         else
4259                 p->variant = PCI_VARIANT_PCIX_266_MODE2;
4260 }
4261
4262 /**
4263  *      init_link_config - initialize a link's SW state
4264  *      @lc: structure holding the link state
4265  *      @caps: link capabilities
4266  *
4267  *      Initializes the SW state maintained for each link, including the link's
4268  *      capabilities and default speed/duplex/flow-control/autonegotiation
4269  *      settings.
4270  */
4271 static void __devinit init_link_config(struct link_config *lc,
4272                                        unsigned int caps)
4273 {
4274         lc->supported = caps;
4275         lc->requested_speed = lc->speed = SPEED_INVALID;
4276         lc->requested_duplex = lc->duplex = DUPLEX_INVALID;
4277         lc->requested_fc = lc->fc = PAUSE_RX | PAUSE_TX;
4278         if (lc->supported & SUPPORTED_Autoneg) {
4279                 lc->advertising = lc->supported;
4280                 lc->autoneg = AUTONEG_ENABLE;
4281                 lc->requested_fc |= PAUSE_AUTONEG;
4282         } else {
4283                 lc->advertising = 0;
4284                 lc->autoneg = AUTONEG_DISABLE;
4285         }
4286 }
4287
4288 /**
4289  *      mc7_calc_size - calculate MC7 memory size
4290  *      @cfg: the MC7 configuration
4291  *
4292  *      Calculates the size of an MC7 memory in bytes from the value of its
4293  *      configuration register.
4294  */
4295 static unsigned int __devinit mc7_calc_size(u32 cfg)
4296 {
4297         unsigned int width = G_WIDTH(cfg);
4298         unsigned int banks = !!(cfg & F_BKS) + 1;
4299         unsigned int org = !!(cfg & F_ORG) + 1;
4300         unsigned int density = G_DEN(cfg);
4301         unsigned int MBs = ((256 << density) * banks) / (org << width);
4302
4303         return MBs << 20;
4304 }
4305
4306 static void __devinit mc7_prep(adapter_t *adapter, struct mc7 *mc7,
4307                                unsigned int base_addr, const char *name)
4308 {
4309         u32 cfg;
4310
4311         mc7->adapter = adapter;
4312         mc7->name = name;
4313         mc7->offset = base_addr - MC7_PMRX_BASE_ADDR;
4314         cfg = t3_read_reg(adapter, mc7->offset + A_MC7_CFG);
4315         mc7->size = G_DEN(cfg) == M_DEN ? 0 : mc7_calc_size(cfg);
4316         mc7->width = G_WIDTH(cfg);
4317 }
4318
4319 void mac_prep(struct cmac *mac, adapter_t *adapter, int index)
4320 {
4321         u16 devid;
4322
4323         mac->adapter = adapter;
4324         mac->multiport = adapter->params.nports > 2;
4325         if (mac->multiport) {
4326                 mac->ext_port = (unsigned char)index;
4327                 mac->nucast = 8;
4328         } else
4329                 mac->nucast = 1;
4330
4331         /* Gen2 adapter uses VPD xauicfg[] to notify driver which MAC
4332            is connected to each port, its suppose to be using xgmac0 for both ports
4333          */
4334         t3_os_pci_read_config_2(adapter, 0x2, &devid);
4335
4336         if (mac->multiport ||
4337                 (!adapter->params.vpd.xauicfg[1] && (devid==0x37)))
4338                         index  = 0;
4339
4340         mac->offset = (XGMAC0_1_BASE_ADDR - XGMAC0_0_BASE_ADDR) * index;
4341
4342         if (adapter->params.rev == 0 && uses_xaui(adapter)) {
4343                 t3_write_reg(adapter, A_XGM_SERDES_CTRL + mac->offset,
4344                              is_10G(adapter) ? 0x2901c04 : 0x2301c04);
4345                 t3_set_reg_field(adapter, A_XGM_PORT_CFG + mac->offset,
4346                                  F_ENRGMII, 0);
4347         }
4348 }
4349
4350 /**
4351  *      early_hw_init - HW initialization done at card detection time
4352  *      @adapter: the adapter
4353  *      @ai: contains information about the adapter type and properties
4354  *
4355  *      Perfoms the part of HW initialization that is done early on when the
4356  *      driver first detecs the card.  Most of the HW state is initialized
4357  *      lazily later on when a port or an offload function are first used.
4358  */
4359 void early_hw_init(adapter_t *adapter, const struct adapter_info *ai)
4360 {
4361         u32 val = V_PORTSPEED(is_10G(adapter) || adapter->params.nports > 2 ?
4362                               3 : 2);
4363         u32 gpio_out = ai->gpio_out;
4364
4365         mi1_init(adapter, ai);
4366         t3_write_reg(adapter, A_I2C_CFG,                  /* set for 80KHz */
4367                      V_I2C_CLKDIV(adapter->params.vpd.cclk / 80 - 1));
4368         t3_write_reg(adapter, A_T3DBG_GPIO_EN,
4369                      gpio_out | F_GPIO0_OEN | F_GPIO0_OUT_VAL);
4370         t3_write_reg(adapter, A_MC5_DB_SERVER_INDEX, 0);
4371         t3_write_reg(adapter, A_SG_OCO_BASE, V_BASE1(0xfff));
4372
4373         if (adapter->params.rev == 0 || !uses_xaui(adapter))
4374                 val |= F_ENRGMII;
4375
4376         /* Enable MAC clocks so we can access the registers */
4377         t3_write_reg(adapter, A_XGM_PORT_CFG, val);
4378         (void) t3_read_reg(adapter, A_XGM_PORT_CFG);
4379
4380         val |= F_CLKDIVRESET_;
4381         t3_write_reg(adapter, A_XGM_PORT_CFG, val);
4382         (void) t3_read_reg(adapter, A_XGM_PORT_CFG);
4383         t3_write_reg(adapter, XGM_REG(A_XGM_PORT_CFG, 1), val);
4384         (void) t3_read_reg(adapter, A_XGM_PORT_CFG);
4385 }
4386
4387 /**
4388  *      t3_reset_adapter - reset the adapter
4389  *      @adapter: the adapter
4390  *
4391  *      Reset the adapter.
4392  */
4393 int t3_reset_adapter(adapter_t *adapter)
4394 {
4395         int i, save_and_restore_pcie =
4396             adapter->params.rev < T3_REV_B2 && is_pcie(adapter);
4397         uint16_t devid = 0;
4398
4399         if (save_and_restore_pcie)
4400                 t3_os_pci_save_state(adapter);
4401         t3_write_reg(adapter, A_PL_RST, F_CRSTWRM | F_CRSTWRMMODE);
4402
4403         /*
4404          * Delay. Give Some time to device to reset fully.
4405          * XXX The delay time should be modified.
4406          */
4407         for (i = 0; i < 10; i++) {
4408                 msleep(50);
4409                 t3_os_pci_read_config_2(adapter, 0x00, &devid);
4410                 if (devid == 0x1425)
4411                         break;
4412         }
4413
4414         if (devid != 0x1425)
4415                 return -1;
4416
4417         if (save_and_restore_pcie)
4418                 t3_os_pci_restore_state(adapter);
4419         return 0;
4420 }
4421
4422 static int init_parity(adapter_t *adap)
4423 {
4424         int i, err, addr;
4425
4426         if (t3_read_reg(adap, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
4427                 return -EBUSY;
4428
4429         for (err = i = 0; !err && i < 16; i++)
4430                 err = clear_sge_ctxt(adap, i, F_EGRESS);
4431         for (i = 0xfff0; !err && i <= 0xffff; i++)
4432                 err = clear_sge_ctxt(adap, i, F_EGRESS);
4433         for (i = 0; !err && i < SGE_QSETS; i++)
4434                 err = clear_sge_ctxt(adap, i, F_RESPONSEQ);
4435         if (err)
4436                 return err;
4437
4438         t3_write_reg(adap, A_CIM_IBQ_DBG_DATA, 0);
4439         for (i = 0; i < 4; i++)
4440                 for (addr = 0; addr <= M_IBQDBGADDR; addr++) {
4441                         t3_write_reg(adap, A_CIM_IBQ_DBG_CFG, F_IBQDBGEN |
4442                                      F_IBQDBGWR | V_IBQDBGQID(i) |
4443                                      V_IBQDBGADDR(addr));
4444                         err = t3_wait_op_done(adap, A_CIM_IBQ_DBG_CFG,
4445                                               F_IBQDBGBUSY, 0, 2, 1);
4446                         if (err)
4447                                 return err;
4448                 }
4449         return 0;
4450 }
4451
4452 /**
4453  *      t3_prep_adapter - prepare SW and HW for operation
4454  *      @adapter: the adapter
4455  *      @ai: contains information about the adapter type and properties
4456  *
4457  *      Initialize adapter SW state for the various HW modules, set initial
4458  *      values for some adapter tunables, take PHYs out of reset, and
4459  *      initialize the MDIO interface.
4460  */
4461 int __devinit t3_prep_adapter(adapter_t *adapter,
4462                               const struct adapter_info *ai, int reset)
4463 {
4464         int ret;
4465         unsigned int i, j = 0;
4466
4467         get_pci_mode(adapter, &adapter->params.pci);
4468
4469         adapter->params.info = ai;
4470         adapter->params.nports = ai->nports0 + ai->nports1;
4471         adapter->params.chan_map = (!!ai->nports0) | (!!ai->nports1 << 1);
4472         adapter->params.rev = t3_read_reg(adapter, A_PL_REV);
4473
4474         /*
4475          * We used to only run the "adapter check task" once a second if
4476          * we had PHYs which didn't support interrupts (we would check
4477          * their link status once a second).  Now we check other conditions
4478          * in that routine which would [potentially] impose a very high
4479          * interrupt load on the system.  As such, we now always scan the
4480          * adapter state once a second ...
4481          */
4482         adapter->params.linkpoll_period = 10;
4483
4484         if (adapter->params.nports > 2)
4485                 adapter->params.stats_update_period = VSC_STATS_ACCUM_SECS;
4486         else
4487                 adapter->params.stats_update_period = is_10G(adapter) ?
4488                         MAC_STATS_ACCUM_SECS : (MAC_STATS_ACCUM_SECS * 10);
4489         adapter->params.pci.vpd_cap_addr =
4490                 t3_os_find_pci_capability(adapter, PCI_CAP_ID_VPD);
4491
4492         ret = get_vpd_params(adapter, &adapter->params.vpd);
4493         if (ret < 0)
4494                 return ret;
4495
4496         if (reset && t3_reset_adapter(adapter))
4497                 return -1;
4498
4499         if (adapter->params.vpd.mclk) {
4500                 struct tp_params *p = &adapter->params.tp;
4501
4502                 mc7_prep(adapter, &adapter->pmrx, MC7_PMRX_BASE_ADDR, "PMRX");
4503                 mc7_prep(adapter, &adapter->pmtx, MC7_PMTX_BASE_ADDR, "PMTX");
4504                 mc7_prep(adapter, &adapter->cm, MC7_CM_BASE_ADDR, "CM");
4505
4506                 p->nchan = adapter->params.chan_map == 3 ? 2 : 1;
4507                 p->pmrx_size = t3_mc7_size(&adapter->pmrx);
4508                 p->pmtx_size = t3_mc7_size(&adapter->pmtx);
4509                 p->cm_size = t3_mc7_size(&adapter->cm);
4510                 p->chan_rx_size = p->pmrx_size / 2;     /* only 1 Rx channel */
4511                 p->chan_tx_size = p->pmtx_size / p->nchan;
4512                 p->rx_pg_size = 64 * 1024;
4513                 p->tx_pg_size = is_10G(adapter) ? 64 * 1024 : 16 * 1024;
4514                 p->rx_num_pgs = pm_num_pages(p->chan_rx_size, p->rx_pg_size);
4515                 p->tx_num_pgs = pm_num_pages(p->chan_tx_size, p->tx_pg_size);
4516                 p->ntimer_qs = p->cm_size >= (128 << 20) ||
4517                                adapter->params.rev > 0 ? 12 : 6;
4518                 p->tre = fls(adapter->params.vpd.cclk / (1000 / TP_TMR_RES)) -
4519                          1;
4520                 p->dack_re = fls(adapter->params.vpd.cclk / 10) - 1; /* 100us */
4521         }
4522
4523         adapter->params.offload = t3_mc7_size(&adapter->pmrx) &&
4524                                   t3_mc7_size(&adapter->pmtx) &&
4525                                   t3_mc7_size(&adapter->cm);
4526
4527         t3_sge_prep(adapter, &adapter->params.sge);
4528
4529         if (is_offload(adapter)) {
4530                 adapter->params.mc5.nservers = DEFAULT_NSERVERS;
4531                 /* PR 6487. TOE and filtering are mutually exclusive */
4532                 adapter->params.mc5.nfilters = 0;
4533                 adapter->params.mc5.nroutes = 0;
4534                 t3_mc5_prep(adapter, &adapter->mc5, MC5_MODE_144_BIT);
4535
4536                 init_mtus(adapter->params.mtus);
4537                 init_cong_ctrl(adapter->params.a_wnd, adapter->params.b_wnd);
4538         }
4539
4540         early_hw_init(adapter, ai);
4541         ret = init_parity(adapter);
4542         if (ret)
4543                 return ret;
4544
4545         if (adapter->params.nports > 2 &&
4546             (ret = t3_vsc7323_init(adapter, adapter->params.nports)))
4547                 return ret;
4548
4549         for_each_port(adapter, i) {
4550                 u8 hw_addr[6];
4551                 const struct port_type_info *pti;
4552                 struct port_info *p = adap2pinfo(adapter, i);
4553
4554                 for (;;) {
4555                         unsigned port_type = adapter->params.vpd.port_type[j];
4556                         if (port_type) {
4557                                 if (port_type < ARRAY_SIZE(port_types)) {
4558                                         pti = &port_types[port_type];
4559                                         break;
4560                                 } else
4561                                         return -EINVAL;
4562                         }
4563                         j++;
4564                         if (j >= ARRAY_SIZE(adapter->params.vpd.port_type))
4565                                 return -EINVAL;
4566                 }
4567                 ret = pti->phy_prep(p, ai->phy_base_addr + j,
4568                                     ai->mdio_ops);
4569                 if (ret)
4570                         return ret;
4571                 mac_prep(&p->mac, adapter, j);
4572                 ++j;
4573
4574                 /*
4575                  * The VPD EEPROM stores the base Ethernet address for the
4576                  * card.  A port's address is derived from the base by adding
4577                  * the port's index to the base's low octet.
4578                  */
4579                 memcpy(hw_addr, adapter->params.vpd.eth_base, 5);
4580                 hw_addr[5] = adapter->params.vpd.eth_base[5] + i;
4581
4582                 t3_os_set_hw_addr(adapter, i, hw_addr);
4583                 init_link_config(&p->link_config, p->phy.caps);
4584                 p->phy.ops->power_down(&p->phy, 1);
4585
4586                 /*
4587                  * If the PHY doesn't support interrupts for link status
4588                  * changes, schedule a scan of the adapter links at least
4589                  * once a second.
4590                  */
4591                 if (!(p->phy.caps & SUPPORTED_IRQ) &&
4592                     adapter->params.linkpoll_period > 10)
4593                         adapter->params.linkpoll_period = 10;
4594         }
4595
4596         return 0;
4597 }
4598
4599 /**
4600  *      t3_reinit_adapter - prepare HW for operation again
4601  *      @adapter: the adapter
4602  *
4603  *      Put HW in the same state as @t3_prep_adapter without any changes to
4604  *      SW state.  This is a cut down version of @t3_prep_adapter intended
4605  *      to be used after events that wipe out HW state but preserve SW state,
4606  *      e.g., EEH.  The device must be reset before calling this.
4607  */
4608 int t3_reinit_adapter(adapter_t *adap)
4609 {
4610         unsigned int i;
4611         int ret, j = 0;
4612
4613         early_hw_init(adap, adap->params.info);
4614         ret = init_parity(adap);
4615         if (ret)
4616                 return ret;
4617
4618         if (adap->params.nports > 2 &&
4619             (ret = t3_vsc7323_init(adap, adap->params.nports)))
4620                 return ret;
4621
4622         for_each_port(adap, i) {
4623                 const struct port_type_info *pti;
4624                 struct port_info *p = adap2pinfo(adap, i);
4625
4626                 for (;;) {
4627                         unsigned port_type = adap->params.vpd.port_type[j];
4628                         if (port_type) {
4629                                 if (port_type < ARRAY_SIZE(port_types)) {
4630                                         pti = &port_types[port_type];
4631                                         break;
4632                                 } else
4633                                         return -EINVAL;
4634                         }
4635                         j++;
4636                         if (j >= ARRAY_SIZE(adap->params.vpd.port_type))
4637                                 return -EINVAL;
4638                 }
4639                 ret = pti->phy_prep(p, p->phy.addr, NULL);
4640                 if (ret)
4641                         return ret;
4642                 p->phy.ops->power_down(&p->phy, 1);
4643         }
4644         return 0;
4645 }
4646
4647 void t3_led_ready(adapter_t *adapter)
4648 {
4649         t3_set_reg_field(adapter, A_T3DBG_GPIO_EN, F_GPIO0_OUT_VAL,
4650                          F_GPIO0_OUT_VAL);
4651 }
4652
4653 void t3_port_failover(adapter_t *adapter, int port)
4654 {
4655         u32 val;
4656
4657         val = port ? F_PORT1ACTIVE : F_PORT0ACTIVE;
4658         t3_set_reg_field(adapter, A_MPS_CFG, F_PORT0ACTIVE | F_PORT1ACTIVE,
4659                          val);
4660 }
4661
4662 void t3_failover_done(adapter_t *adapter, int port)
4663 {
4664         t3_set_reg_field(adapter, A_MPS_CFG, F_PORT0ACTIVE | F_PORT1ACTIVE,
4665                          F_PORT0ACTIVE | F_PORT1ACTIVE);
4666 }
4667
4668 void t3_failover_clear(adapter_t *adapter)
4669 {
4670         t3_set_reg_field(adapter, A_MPS_CFG, F_PORT0ACTIVE | F_PORT1ACTIVE,
4671                          F_PORT0ACTIVE | F_PORT1ACTIVE);
4672 }
4673
4674 static int t3_cim_hac_read(adapter_t *adapter, u32 addr, u32 *val)
4675 {
4676         u32 v;
4677
4678         t3_write_reg(adapter, A_CIM_HOST_ACC_CTRL, addr);
4679         if (t3_wait_op_done_val(adapter, A_CIM_HOST_ACC_CTRL,
4680                                 F_HOSTBUSY, 0, 10, 10, &v))
4681                 return -EIO;
4682
4683         *val = t3_read_reg(adapter, A_CIM_HOST_ACC_DATA);
4684
4685         return 0;
4686 }
4687
4688 static int t3_cim_hac_write(adapter_t *adapter, u32 addr, u32 val)
4689 {
4690         u32 v;
4691
4692         t3_write_reg(adapter, A_CIM_HOST_ACC_DATA, val);
4693
4694         addr |= F_HOSTWRITE;
4695         t3_write_reg(adapter, A_CIM_HOST_ACC_CTRL, addr);
4696
4697         if (t3_wait_op_done_val(adapter, A_CIM_HOST_ACC_CTRL,
4698                                 F_HOSTBUSY, 0, 10, 5, &v))
4699                 return -EIO;
4700         return 0;
4701 }
4702
4703 int t3_get_up_la(adapter_t *adapter, u32 *stopped, u32 *index,
4704                  u32 *size, void *data)
4705 {
4706         u32 v, *buf = data;
4707         int i, cnt,  ret;
4708
4709         if (*size < LA_ENTRIES * 4)
4710                 return -EINVAL;
4711
4712         ret = t3_cim_hac_read(adapter, LA_CTRL, &v);
4713         if (ret)
4714                 goto out;
4715
4716         *stopped = !(v & 1);
4717
4718         /* Freeze LA */
4719         if (!*stopped) {
4720                 ret = t3_cim_hac_write(adapter, LA_CTRL, 0);
4721                 if (ret)
4722                         goto out;
4723         }
4724
4725         for (i = 0; i < LA_ENTRIES; i++) {
4726                 v = (i << 2) | (1 << 1);
4727                 ret = t3_cim_hac_write(adapter, LA_CTRL, v);
4728                 if (ret)
4729                         goto out;
4730
4731                 ret = t3_cim_hac_read(adapter, LA_CTRL, &v);
4732                 if (ret)
4733                         goto out;
4734
4735                 cnt = 20;
4736                 while ((v & (1 << 1)) && cnt) {
4737                         udelay(5);
4738                         --cnt;
4739                         ret = t3_cim_hac_read(adapter, LA_CTRL, &v);
4740                         if (ret)
4741                                 goto out;
4742                 }
4743
4744                 if (v & (1 << 1))
4745                         return -EIO;
4746
4747                 ret = t3_cim_hac_read(adapter, LA_DATA, &v);
4748                 if (ret)
4749                         goto out;
4750
4751                 *buf++ = v;
4752         }
4753
4754         ret = t3_cim_hac_read(adapter, LA_CTRL, &v);
4755         if (ret)
4756                 goto out;
4757
4758         *index = (v >> 16) + 4;
4759         *size = LA_ENTRIES * 4;
4760 out:
4761         /* Unfreeze LA */
4762         t3_cim_hac_write(adapter, LA_CTRL, 1);
4763         return ret;
4764 }
4765
4766 int t3_get_up_ioqs(adapter_t *adapter, u32 *size, void *data)
4767 {
4768         u32 v, *buf = data;
4769         int i, j, ret;
4770
4771         if (*size < IOQ_ENTRIES * sizeof(struct t3_ioq_entry))
4772                 return -EINVAL;
4773
4774         for (i = 0; i < 4; i++) {
4775                 ret = t3_cim_hac_read(adapter, (4 * i), &v);
4776                 if (ret)
4777                         goto out;
4778
4779                 *buf++ = v;
4780         }
4781
4782         for (i = 0; i < IOQ_ENTRIES; i++) {
4783                 u32 base_addr = 0x10 * (i + 1);
4784
4785                 for (j = 0; j < 4; j++) {
4786                         ret = t3_cim_hac_read(adapter, base_addr + 4 * j, &v);
4787                         if (ret)
4788                                 goto out;
4789
4790                         *buf++ = v;
4791                 }
4792         }
4793
4794         *size = IOQ_ENTRIES * sizeof(struct t3_ioq_entry);
4795
4796 out:
4797         return ret;
4798 }
4799