kernel/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c

   1 /*
   2  * This file is part of the Chelsio T4 Ethernet driver for Linux.
   3  *
   4  * Copyright (c) 2003-2014 Chelsio Communications, Inc. All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  */
  34
  35 #include <linux/delay.h>
  36 #include "cxgb4.h"
  37 #include "t4_regs.h"
  38 #include "t4_values.h"
  39 #include "t4fw_api.h"
  40
  41 /**
  42  *      t4_wait_op_done_val - wait until an operation is completed
  43  *      @adapter: the adapter performing the operation
  44  *      @reg: the register to check for completion
  45  *      @mask: a single-bit field within @reg that indicates completion
  46  *      @polarity: the value of the field when the operation is completed
  47  *      @attempts: number of check iterations
  48  *      @delay: delay in usecs between iterations
  49  *      @valp: where to store the value of the register at completion time
  50  *
  51  *      Wait until an operation is completed by checking a bit in a register
  52  *      up to @attempts times.  If @valp is not NULL the value of the register
  53  *      at the time it indicated completion is stored there.  Returns 0 if the
  54  *      operation completes and -EAGAIN otherwise.
  55  */
  56 static int t4_wait_op_done_val(struct adapter *adapter, int reg, u32 mask,
  57                                int polarity, int attempts, int delay, u32 *valp)
  58 {
  59         while (1) {
  60                 u32 val = t4_read_reg(adapter, reg);
  61
  62                 if (!!(val & mask) == polarity) {
  63                         if (valp)
  64                                 *valp = val;
  65                         return 0;
  66                 }
  67                 if (--attempts == 0)
  68                         return -EAGAIN;
  69                 if (delay)
  70                         udelay(delay);
  71         }
  72 }
  73
  74 static inline int t4_wait_op_done(struct adapter *adapter, int reg, u32 mask,
  75                                   int polarity, int attempts, int delay)
  76 {
  77         return t4_wait_op_done_val(adapter, reg, mask, polarity, attempts,
  78                                    delay, NULL);
  79 }
  80
  81 /**
  82  *      t4_set_reg_field - set a register field to a value
  83  *      @adapter: the adapter to program
  84  *      @addr: the register address
  85  *      @mask: specifies the portion of the register to modify
  86  *      @val: the new value for the register field
  87  *
  88  *      Sets a register field specified by the supplied mask to the
  89  *      given value.
  90  */
  91 void t4_set_reg_field(struct adapter *adapter, unsigned int addr, u32 mask,
  92                       u32 val)
  93 {
  94         u32 v = t4_read_reg(adapter, addr) & ~mask;
  95
  96         t4_write_reg(adapter, addr, v | val);
  97         (void) t4_read_reg(adapter, addr);      /* flush */
  98 }
  99
 100 /**
 101  *      t4_read_indirect - read indirectly addressed registers
 102  *      @adap: the adapter
 103  *      @addr_reg: register holding the indirect address
 104  *      @data_reg: register holding the value of the indirect register
 105  *      @vals: where the read register values are stored
 106  *      @nregs: how many indirect registers to read
 107  *      @start_idx: index of first indirect register to read
 108  *
 109  *      Reads registers that are accessed indirectly through an address/data
 110  *      register pair.
 111  */
 112 void t4_read_indirect(struct adapter *adap, unsigned int addr_reg,
 113                              unsigned int data_reg, u32 *vals,
 114                              unsigned int nregs, unsigned int start_idx)
 115 {
 116         while (nregs--) {
 117                 t4_write_reg(adap, addr_reg, start_idx);
 118                 *vals++ = t4_read_reg(adap, data_reg);
 119                 start_idx++;
 120         }
 121 }
 122
 123 /**
 124  *      t4_write_indirect - write indirectly addressed registers
 125  *      @adap: the adapter
 126  *      @addr_reg: register holding the indirect addresses
 127  *      @data_reg: register holding the value for the indirect registers
 128  *      @vals: values to write
 129  *      @nregs: how many indirect registers to write
 130  *      @start_idx: address of first indirect register to write
 131  *
 132  *      Writes a sequential block of registers that are accessed indirectly
 133  *      through an address/data register pair.
 134  */
 135 void t4_write_indirect(struct adapter *adap, unsigned int addr_reg,
 136                        unsigned int data_reg, const u32 *vals,
 137                        unsigned int nregs, unsigned int start_idx)
 138 {
 139         while (nregs--) {
 140                 t4_write_reg(adap, addr_reg, start_idx++);
 141                 t4_write_reg(adap, data_reg, *vals++);
 142         }
 143 }
 144
 145 /*
 146  * Read a 32-bit PCI Configuration Space register via the PCI-E backdoor
 147  * mechanism.  This guarantees that we get the real value even if we're
 148  * operating within a Virtual Machine and the Hypervisor is trapping our
 149  * Configuration Space accesses.
 150  */
 151 void t4_hw_pci_read_cfg4(struct adapter *adap, int reg, u32 *val)
 152 {
 153         u32 req = ENABLE_F | FUNCTION_V(adap->fn) | REGISTER_V(reg);
 154
 155         if (is_t4(adap->params.chip))
 156                 req |= LOCALCFG_F;
 157
 158         t4_write_reg(adap, PCIE_CFG_SPACE_REQ_A, req);
 159         *val = t4_read_reg(adap, PCIE_CFG_SPACE_DATA_A);
 160
 161         /* Reset ENABLE to 0 so reads of PCIE_CFG_SPACE_DATA won't cause a
 162          * Configuration Space read.  (None of the other fields matter when
 163          * ENABLE is 0 so a simple register write is easier than a
 164          * read-modify-write via t4_set_reg_field().)
 165          */
 166         t4_write_reg(adap, PCIE_CFG_SPACE_REQ_A, 0);
 167 }
 168
 169 /*
 170  * t4_report_fw_error - report firmware error
 171  * @adap: the adapter
 172  *
 173  * The adapter firmware can indicate error conditions to the host.
 174  * If the firmware has indicated an error, print out the reason for
 175  * the firmware error.
 176  */
 177 static void t4_report_fw_error(struct adapter *adap)
 178 {
 179         static const char *const reason[] = {
 180                 "Crash",                        /* PCIE_FW_EVAL_CRASH */
 181                 "During Device Preparation",    /* PCIE_FW_EVAL_PREP */
 182                 "During Device Configuration",  /* PCIE_FW_EVAL_CONF */
 183                 "During Device Initialization", /* PCIE_FW_EVAL_INIT */
 184                 "Unexpected Event",             /* PCIE_FW_EVAL_UNEXPECTEDEVENT */
 185                 "Insufficient Airflow",         /* PCIE_FW_EVAL_OVERHEAT */
 186                 "Device Shutdown",              /* PCIE_FW_EVAL_DEVICESHUTDOWN */
 187                 "Reserved",                     /* reserved */
 188         };
 189         u32 pcie_fw;
 190
 191         pcie_fw = t4_read_reg(adap, PCIE_FW_A);
 192         if (pcie_fw & PCIE_FW_ERR_F)
 193                 dev_err(adap->pdev_dev, "Firmware reports adapter error: %s\n",
 194                         reason[PCIE_FW_EVAL_G(pcie_fw)]);
 195 }
 196
 197 /*
 198  * Get the reply to a mailbox command and store it in @rpl in big-endian order.
 199  */
 200 static void get_mbox_rpl(struct adapter *adap, __be64 *rpl, int nflit,
 201                          u32 mbox_addr)
 202 {
 203         for ( ; nflit; nflit--, mbox_addr += 8)
 204                 *rpl++ = cpu_to_be64(t4_read_reg64(adap, mbox_addr));
 205 }
 206
 207 /*
 208  * Handle a FW assertion reported in a mailbox.
 209  */
 210 static void fw_asrt(struct adapter *adap, u32 mbox_addr)
 211 {
 212         struct fw_debug_cmd asrt;
 213
 214         get_mbox_rpl(adap, (__be64 *)&asrt, sizeof(asrt) / 8, mbox_addr);
 215         dev_alert(adap->pdev_dev,
 216                   "FW assertion at %.16s:%u, val0 %#x, val1 %#x\n",
 217                   asrt.u.assert.filename_0_7, ntohl(asrt.u.assert.line),
 218                   ntohl(asrt.u.assert.x), ntohl(asrt.u.assert.y));
 219 }
 220
 221 static void dump_mbox(struct adapter *adap, int mbox, u32 data_reg)
 222 {
 223         dev_err(adap->pdev_dev,
 224                 "mbox %d: %llx %llx %llx %llx %llx %llx %llx %llx\n", mbox,
 225                 (unsigned long long)t4_read_reg64(adap, data_reg),
 226                 (unsigned long long)t4_read_reg64(adap, data_reg + 8),
 227                 (unsigned long long)t4_read_reg64(adap, data_reg + 16),
 228                 (unsigned long long)t4_read_reg64(adap, data_reg + 24),
 229                 (unsigned long long)t4_read_reg64(adap, data_reg + 32),
 230                 (unsigned long long)t4_read_reg64(adap, data_reg + 40),
 231                 (unsigned long long)t4_read_reg64(adap, data_reg + 48),
 232                 (unsigned long long)t4_read_reg64(adap, data_reg + 56));
 233 }
 234
 235 /**
 236  *      t4_wr_mbox_meat - send a command to FW through the given mailbox
 237  *      @adap: the adapter
 238  *      @mbox: index of the mailbox to use
 239  *      @cmd: the command to write
 240  *      @size: command length in bytes
 241  *      @rpl: where to optionally store the reply
 242  *      @sleep_ok: if true we may sleep while awaiting command completion
 243  *
 244  *      Sends the given command to FW through the selected mailbox and waits
 245  *      for the FW to execute the command.  If @rpl is not %NULL it is used to
 246  *      store the FW's reply to the command.  The command and its optional
 247  *      reply are of the same length.  FW can take up to %FW_CMD_MAX_TIMEOUT ms
 248  *      to respond.  @sleep_ok determines whether we may sleep while awaiting
 249  *      the response.  If sleeping is allowed we use progressive backoff
 250  *      otherwise we spin.
 251  *
 252  *      The return value is 0 on success or a negative errno on failure.  A
 253  *      failure can happen either because we are not able to execute the
 254  *      command or FW executes it but signals an error.  In the latter case
 255  *      the return value is the error code indicated by FW (negated).
 256  */
 257 int t4_wr_mbox_meat(struct adapter *adap, int mbox, const void *cmd, int size,
 258                     void *rpl, bool sleep_ok)
 259 {
 260         static const int delay[] = {
 261                 1, 1, 3, 5, 10, 10, 20, 50, 100, 200
 262         };
 263
 264         u32 v;
 265         u64 res;
 266         int i, ms, delay_idx;
 267         const __be64 *p = cmd;
 268         u32 data_reg = PF_REG(mbox, CIM_PF_MAILBOX_DATA_A);
 269         u32 ctl_reg = PF_REG(mbox, CIM_PF_MAILBOX_CTRL_A);
 270
 271         if ((size & 15) || size > MBOX_LEN)
 272                 return -EINVAL;
 273
 274         /*
 275          * If the device is off-line, as in EEH, commands will time out.
 276          * Fail them early so we don't waste time waiting.
 277          */
 278         if (adap->pdev->error_state != pci_channel_io_normal)
 279                 return -EIO;
 280
 281         v = MBOWNER_G(t4_read_reg(adap, ctl_reg));
 282         for (i = 0; v == MBOX_OWNER_NONE && i < 3; i++)
 283                 v = MBOWNER_G(t4_read_reg(adap, ctl_reg));
 284
 285         if (v != MBOX_OWNER_DRV)
 286                 return v ? -EBUSY : -ETIMEDOUT;
 287
 288         for (i = 0; i < size; i += 8)
 289                 t4_write_reg64(adap, data_reg + i, be64_to_cpu(*p++));
 290
 291         t4_write_reg(adap, ctl_reg, MBMSGVALID_F | MBOWNER_V(MBOX_OWNER_FW));
 292         t4_read_reg(adap, ctl_reg);          /* flush write */
 293
 294         delay_idx = 0;
 295         ms = delay[0];
 296
 297         for (i = 0; i < FW_CMD_MAX_TIMEOUT; i += ms) {
 298                 if (sleep_ok) {
 299                         ms = delay[delay_idx];  /* last element may repeat */
 300                         if (delay_idx < ARRAY_SIZE(delay) - 1)
 301                                 delay_idx++;
 302                         msleep(ms);
 303                 } else
 304                         mdelay(ms);
 305
 306                 v = t4_read_reg(adap, ctl_reg);
 307                 if (MBOWNER_G(v) == MBOX_OWNER_DRV) {
 308                         if (!(v & MBMSGVALID_F)) {
 309                                 t4_write_reg(adap, ctl_reg, 0);
 310                                 continue;
 311                         }
 312
 313                         res = t4_read_reg64(adap, data_reg);
 314                         if (FW_CMD_OP_G(res >> 32) == FW_DEBUG_CMD) {
 315                                 fw_asrt(adap, data_reg);
 316                                 res = FW_CMD_RETVAL_V(EIO);
 317                         } else if (rpl) {
 318                                 get_mbox_rpl(adap, rpl, size / 8, data_reg);
 319                         }
 320
 321                         if (FW_CMD_RETVAL_G((int)res))
 322                                 dump_mbox(adap, mbox, data_reg);
 323                         t4_write_reg(adap, ctl_reg, 0);
 324                         return -FW_CMD_RETVAL_G((int)res);
 325                 }
 326         }
 327
 328         dump_mbox(adap, mbox, data_reg);
 329         dev_err(adap->pdev_dev, "command %#x in mailbox %d timed out\n",
 330                 *(const u8 *)cmd, mbox);
 331         t4_report_fw_error(adap);
 332         return -ETIMEDOUT;
 333 }
 334
 335 /**
 336  *      t4_mc_read - read from MC through backdoor accesses
 337  *      @adap: the adapter
 338  *      @addr: address of first byte requested
 339  *      @idx: which MC to access
 340  *      @data: 64 bytes of data containing the requested address
 341  *      @ecc: where to store the corresponding 64-bit ECC word
 342  *
 343  *      Read 64 bytes of data from MC starting at a 64-byte-aligned address
 344  *      that covers the requested address @addr.  If @parity is not %NULL it
 345  *      is assigned the 64-bit ECC word for the read data.
 346  */
 347 int t4_mc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
 348 {
 349         int i;
 350         u32 mc_bist_cmd, mc_bist_cmd_addr, mc_bist_cmd_len;
 351         u32 mc_bist_status_rdata, mc_bist_data_pattern;
 352
 353         if (is_t4(adap->params.chip)) {
 354                 mc_bist_cmd = MC_BIST_CMD_A;
 355                 mc_bist_cmd_addr = MC_BIST_CMD_ADDR_A;
 356                 mc_bist_cmd_len = MC_BIST_CMD_LEN_A;
 357                 mc_bist_status_rdata = MC_BIST_STATUS_RDATA_A;
 358                 mc_bist_data_pattern = MC_BIST_DATA_PATTERN_A;
 359         } else {
 360                 mc_bist_cmd = MC_REG(MC_P_BIST_CMD_A, idx);
 361                 mc_bist_cmd_addr = MC_REG(MC_P_BIST_CMD_ADDR_A, idx);
 362                 mc_bist_cmd_len = MC_REG(MC_P_BIST_CMD_LEN_A, idx);
 363                 mc_bist_status_rdata = MC_REG(MC_P_BIST_STATUS_RDATA_A, idx);
 364                 mc_bist_data_pattern = MC_REG(MC_P_BIST_DATA_PATTERN_A, idx);
 365         }
 366
 367         if (t4_read_reg(adap, mc_bist_cmd) & START_BIST_F)
 368                 return -EBUSY;
 369         t4_write_reg(adap, mc_bist_cmd_addr, addr & ~0x3fU);
 370         t4_write_reg(adap, mc_bist_cmd_len, 64);
 371         t4_write_reg(adap, mc_bist_data_pattern, 0xc);
 372         t4_write_reg(adap, mc_bist_cmd, BIST_OPCODE_V(1) | START_BIST_F |
 373                      BIST_CMD_GAP_V(1));
 374         i = t4_wait_op_done(adap, mc_bist_cmd, START_BIST_F, 0, 10, 1);
 375         if (i)
 376                 return i;
 377
 378 #define MC_DATA(i) MC_BIST_STATUS_REG(mc_bist_status_rdata, i)
 379
 380         for (i = 15; i >= 0; i--)
 381                 *data++ = htonl(t4_read_reg(adap, MC_DATA(i)));
 382         if (ecc)
 383                 *ecc = t4_read_reg64(adap, MC_DATA(16));
 384 #undef MC_DATA
 385         return 0;
 386 }
 387
 388 /**
 389  *      t4_edc_read - read from EDC through backdoor accesses
 390  *      @adap: the adapter
 391  *      @idx: which EDC to access
 392  *      @addr: address of first byte requested
 393  *      @data: 64 bytes of data containing the requested address
 394  *      @ecc: where to store the corresponding 64-bit ECC word
 395  *
 396  *      Read 64 bytes of data from EDC starting at a 64-byte-aligned address
 397  *      that covers the requested address @addr.  If @parity is not %NULL it
 398  *      is assigned the 64-bit ECC word for the read data.
 399  */
 400 int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data, u64 *ecc)
 401 {
 402         int i;
 403         u32 edc_bist_cmd, edc_bist_cmd_addr, edc_bist_cmd_len;
 404         u32 edc_bist_cmd_data_pattern, edc_bist_status_rdata;
 405
 406         if (is_t4(adap->params.chip)) {
 407                 edc_bist_cmd = EDC_REG(EDC_BIST_CMD_A, idx);
 408                 edc_bist_cmd_addr = EDC_REG(EDC_BIST_CMD_ADDR_A, idx);
 409                 edc_bist_cmd_len = EDC_REG(EDC_BIST_CMD_LEN_A, idx);
 410                 edc_bist_cmd_data_pattern = EDC_REG(EDC_BIST_DATA_PATTERN_A,
 411                                                     idx);
 412                 edc_bist_status_rdata = EDC_REG(EDC_BIST_STATUS_RDATA_A,
 413                                                 idx);
 414         } else {
 415                 edc_bist_cmd = EDC_REG_T5(EDC_H_BIST_CMD_A, idx);
 416                 edc_bist_cmd_addr = EDC_REG_T5(EDC_H_BIST_CMD_ADDR_A, idx);
 417                 edc_bist_cmd_len = EDC_REG_T5(EDC_H_BIST_CMD_LEN_A, idx);
 418                 edc_bist_cmd_data_pattern =
 419                         EDC_REG_T5(EDC_H_BIST_DATA_PATTERN_A, idx);
 420                 edc_bist_status_rdata =
 421                          EDC_REG_T5(EDC_H_BIST_STATUS_RDATA_A, idx);
 422         }
 423
 424         if (t4_read_reg(adap, edc_bist_cmd) & START_BIST_F)
 425                 return -EBUSY;
 426         t4_write_reg(adap, edc_bist_cmd_addr, addr & ~0x3fU);
 427         t4_write_reg(adap, edc_bist_cmd_len, 64);
 428         t4_write_reg(adap, edc_bist_cmd_data_pattern, 0xc);
 429         t4_write_reg(adap, edc_bist_cmd,
 430                      BIST_OPCODE_V(1) | BIST_CMD_GAP_V(1) | START_BIST_F);
 431         i = t4_wait_op_done(adap, edc_bist_cmd, START_BIST_F, 0, 10, 1);
 432         if (i)
 433                 return i;
 434
 435 #define EDC_DATA(i) (EDC_BIST_STATUS_REG(edc_bist_status_rdata, i))
 436
 437         for (i = 15; i >= 0; i--)
 438                 *data++ = htonl(t4_read_reg(adap, EDC_DATA(i)));
 439         if (ecc)
 440                 *ecc = t4_read_reg64(adap, EDC_DATA(16));
 441 #undef EDC_DATA
 442         return 0;
 443 }
 444
 445 /**
 446  *      t4_memory_rw - read/write EDC 0, EDC 1 or MC via PCIE memory window
 447  *      @adap: the adapter
 448  *      @win: PCI-E Memory Window to use
 449  *      @mtype: memory type: MEM_EDC0, MEM_EDC1 or MEM_MC
 450  *      @addr: address within indicated memory type
 451  *      @len: amount of memory to transfer
 452  *      @hbuf: host memory buffer
 453  *      @dir: direction of transfer T4_MEMORY_READ (1) or T4_MEMORY_WRITE (0)
 454  *
 455  *      Reads/writes an [almost] arbitrary memory region in the firmware: the
 456  *      firmware memory address and host buffer must be aligned on 32-bit
 457  *      boudaries; the length may be arbitrary.  The memory is transferred as
 458  *      a raw byte sequence from/to the firmware's memory.  If this memory
 459  *      contains data structures which contain multi-byte integers, it's the
 460  *      caller's responsibility to perform appropriate byte order conversions.
 461  */
 462 int t4_memory_rw(struct adapter *adap, int win, int mtype, u32 addr,
 463                  u32 len, void *hbuf, int dir)
 464 {
 465         u32 pos, offset, resid, memoffset;
 466         u32 edc_size, mc_size, win_pf, mem_reg, mem_aperture, mem_base;
 467         u32 *buf;
 468
 469         /* Argument sanity checks ...
 470          */
 471         if (addr & 0x3 || (uintptr_t)hbuf & 0x3)
 472                 return -EINVAL;
 473         buf = (u32 *)hbuf;
 474
 475         /* It's convenient to be able to handle lengths which aren't a
 476          * multiple of 32-bits because we often end up transferring files to
 477          * the firmware.  So we'll handle that by normalizing the length here
 478          * and then handling any residual transfer at the end.
 479          */
 480         resid = len & 0x3;
 481         len -= resid;
 482
 483         /* Offset into the region of memory which is being accessed
 484          * MEM_EDC0 = 0
 485          * MEM_EDC1 = 1
 486          * MEM_MC   = 2 -- T4
 487          * MEM_MC0  = 2 -- For T5
 488          * MEM_MC1  = 3 -- For T5
 489          */
 490         edc_size  = EDRAM0_SIZE_G(t4_read_reg(adap, MA_EDRAM0_BAR_A));
 491         if (mtype != MEM_MC1)
 492                 memoffset = (mtype * (edc_size * 1024 * 1024));
 493         else {
 494                 mc_size = EXT_MEM0_SIZE_G(t4_read_reg(adap,
 495                                                       MA_EXT_MEMORY0_BAR_A));
 496                 memoffset = (MEM_MC0 * edc_size + mc_size) * 1024 * 1024;
 497         }
 498
 499         /* Determine the PCIE_MEM_ACCESS_OFFSET */
 500         addr = addr + memoffset;
 501
 502         /* Each PCI-E Memory Window is programmed with a window size -- or
 503          * "aperture" -- which controls the granularity of its mapping onto
 504          * adapter memory.  We need to grab that aperture in order to know
 505          * how to use the specified window.  The window is also programmed
 506          * with the base address of the Memory Window in BAR0's address
 507          * space.  For T4 this is an absolute PCI-E Bus Address.  For T5
 508          * the address is relative to BAR0.
 509          */
 510         mem_reg = t4_read_reg(adap,
 511                               PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A,
 512                                                   win));
 513         mem_aperture = 1 << (WINDOW_G(mem_reg) + WINDOW_SHIFT_X);
 514         mem_base = PCIEOFST_G(mem_reg) << PCIEOFST_SHIFT_X;
 515         if (is_t4(adap->params.chip))
 516                 mem_base -= adap->t4_bar0;
 517         win_pf = is_t4(adap->params.chip) ? 0 : PFNUM_V(adap->fn);
 518
 519         /* Calculate our initial PCI-E Memory Window Position and Offset into
 520          * that Window.
 521          */
 522         pos = addr & ~(mem_aperture-1);
 523         offset = addr - pos;
 524
 525         /* Set up initial PCI-E Memory Window to cover the start of our
 526          * transfer.  (Read it back to ensure that changes propagate before we
 527          * attempt to use the new value.)
 528          */
 529         t4_write_reg(adap,
 530                      PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, win),
 531                      pos | win_pf);
 532         t4_read_reg(adap,
 533                     PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, win));
 534
 535         /* Transfer data to/from the adapter as long as there's an integral
 536          * number of 32-bit transfers to complete.
 537          *
 538          * A note on Endianness issues:
 539          *
 540          * The "register" reads and writes below from/to the PCI-E Memory
 541          * Window invoke the standard adapter Big-Endian to PCI-E Link
 542          * Little-Endian "swizzel."  As a result, if we have the following
 543          * data in adapter memory:
 544          *
 545          *     Memory:  ... | b0 | b1 | b2 | b3 | ...
 546          *     Address:      i+0  i+1  i+2  i+3
 547          *
 548          * Then a read of the adapter memory via the PCI-E Memory Window
 549          * will yield:
 550          *
 551          *     x = readl(i)
 552          *         31                  0
 553          *         [ b3 | b2 | b1 | b0 ]
 554          *
 555          * If this value is stored into local memory on a Little-Endian system
 556          * it will show up correctly in local memory as:
 557          *
 558          *     ( ..., b0, b1, b2, b3, ... )
 559          *
 560          * But on a Big-Endian system, the store will show up in memory
 561          * incorrectly swizzled as:
 562          *
 563          *     ( ..., b3, b2, b1, b0, ... )
 564          *
 565          * So we need to account for this in the reads and writes to the
 566          * PCI-E Memory Window below by undoing the register read/write
 567          * swizzels.
 568          */
 569         while (len > 0) {
 570                 if (dir == T4_MEMORY_READ)
 571                         *buf++ = le32_to_cpu((__force __le32)t4_read_reg(adap,
 572                                                 mem_base + offset));
 573                 else
 574                         t4_write_reg(adap, mem_base + offset,
 575                                      (__force u32)cpu_to_le32(*buf++));
 576                 offset += sizeof(__be32);
 577                 len -= sizeof(__be32);
 578
 579                 /* If we've reached the end of our current window aperture,
 580                  * move the PCI-E Memory Window on to the next.  Note that
 581                  * doing this here after "len" may be 0 allows us to set up
 582                  * the PCI-E Memory Window for a possible final residual
 583                  * transfer below ...
 584                  */
 585                 if (offset == mem_aperture) {
 586                         pos += mem_aperture;
 587                         offset = 0;
 588                         t4_write_reg(adap,
 589                                 PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A,
 590                                                     win), pos | win_pf);
 591                         t4_read_reg(adap,
 592                                 PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A,
 593                                                     win));
 594                 }
 595         }
 596
 597         /* If the original transfer had a length which wasn't a multiple of
 598          * 32-bits, now's where we need to finish off the transfer of the
 599          * residual amount.  The PCI-E Memory Window has already been moved
 600          * above (if necessary) to cover this final transfer.
 601          */
 602         if (resid) {
 603                 union {
 604                         u32 word;
 605                         char byte[4];
 606                 } last;
 607                 unsigned char *bp;
 608                 int i;
 609
 610                 if (dir == T4_MEMORY_READ) {
 611                         last.word = le32_to_cpu(
 612                                         (__force __le32)t4_read_reg(adap,
 613                                                 mem_base + offset));
 614                         for (bp = (unsigned char *)buf, i = resid; i < 4; i++)
 615                                 bp[i] = last.byte[i];
 616                 } else {
 617                         last.word = *buf;
 618                         for (i = resid; i < 4; i++)
 619                                 last.byte[i] = 0;
 620                         t4_write_reg(adap, mem_base + offset,
 621                                      (__force u32)cpu_to_le32(last.word));
 622                 }
 623         }
 624
 625         return 0;
 626 }
 627
 628 /**
 629  *      t4_get_regs_len - return the size of the chips register set
 630  *      @adapter: the adapter
 631  *
 632  *      Returns the size of the chip's BAR0 register space.
 633  */
 634 unsigned int t4_get_regs_len(struct adapter *adapter)
 635 {
 636         unsigned int chip_version = CHELSIO_CHIP_VERSION(adapter->params.chip);
 637
 638         switch (chip_version) {
 639         case CHELSIO_T4:
 640                 return T4_REGMAP_SIZE;
 641
 642         case CHELSIO_T5:
 643                 return T5_REGMAP_SIZE;
 644         }
 645
 646         dev_err(adapter->pdev_dev,
 647                 "Unsupported chip version %d\n", chip_version);
 648         return 0;
 649 }
 650
 651 /**
 652  *      t4_get_regs - read chip registers into provided buffer
 653  *      @adap: the adapter
 654  *      @buf: register buffer
 655  *      @buf_size: size (in bytes) of register buffer
 656  *
 657  *      If the provided register buffer isn't large enough for the chip's
 658  *      full register range, the register dump will be truncated to the
 659  *      register buffer's size.
 660  */
 661 void t4_get_regs(struct adapter *adap, void *buf, size_t buf_size)
 662 {
 663         static const unsigned int t4_reg_ranges[] = {
 664                 0x1008, 0x1108,
 665                 0x1180, 0x11b4,
 666                 0x11fc, 0x123c,
 667                 0x1300, 0x173c,
 668                 0x1800, 0x18fc,
 669                 0x3000, 0x30d8,
 670                 0x30e0, 0x5924,
 671                 0x5960, 0x59d4,
 672                 0x5a00, 0x5af8,
 673                 0x6000, 0x6098,
 674                 0x6100, 0x6150,
 675                 0x6200, 0x6208,
 676                 0x6240, 0x6248,
 677                 0x6280, 0x6338,
 678                 0x6370, 0x638c,
 679                 0x6400, 0x643c,
 680                 0x6500, 0x6524,
 681                 0x6a00, 0x6a38,
 682                 0x6a60, 0x6a78,
 683                 0x6b00, 0x6b84,
 684                 0x6bf0, 0x6c84,
 685                 0x6cf0, 0x6d84,
 686                 0x6df0, 0x6e84,
 687                 0x6ef0, 0x6f84,
 688                 0x6ff0, 0x7084,
 689                 0x70f0, 0x7184,
 690                 0x71f0, 0x7284,
 691                 0x72f0, 0x7384,
 692                 0x73f0, 0x7450,
 693                 0x7500, 0x7530,
 694                 0x7600, 0x761c,
 695                 0x7680, 0x76cc,
 696                 0x7700, 0x7798,
 697                 0x77c0, 0x77fc,
 698                 0x7900, 0x79fc,
 699                 0x7b00, 0x7c38,
 700                 0x7d00, 0x7efc,
 701                 0x8dc0, 0x8e1c,
 702                 0x8e30, 0x8e78,
 703                 0x8ea0, 0x8f6c,
 704                 0x8fc0, 0x9074,
 705                 0x90fc, 0x90fc,
 706                 0x9400, 0x9458,
 707                 0x9600, 0x96bc,
 708                 0x9800, 0x9808,
 709                 0x9820, 0x983c,
 710                 0x9850, 0x9864,
 711                 0x9c00, 0x9c6c,
 712                 0x9c80, 0x9cec,
 713                 0x9d00, 0x9d6c,
 714                 0x9d80, 0x9dec,
 715                 0x9e00, 0x9e6c,
 716                 0x9e80, 0x9eec,
 717                 0x9f00, 0x9f6c,
 718                 0x9f80, 0x9fec,
 719                 0xd004, 0xd03c,
 720                 0xdfc0, 0xdfe0,
 721                 0xe000, 0xea7c,
 722                 0xf000, 0x11110,
 723                 0x11118, 0x11190,
 724                 0x19040, 0x1906c,
 725                 0x19078, 0x19080,
 726                 0x1908c, 0x19124,
 727                 0x19150, 0x191b0,
 728                 0x191d0, 0x191e8,
 729                 0x19238, 0x1924c,
 730                 0x193f8, 0x19474,
 731                 0x19490, 0x194f8,
 732                 0x19800, 0x19f30,
 733                 0x1a000, 0x1a06c,
 734                 0x1a0b0, 0x1a120,
 735                 0x1a128, 0x1a138,
 736                 0x1a190, 0x1a1c4,
 737                 0x1a1fc, 0x1a1fc,
 738                 0x1e040, 0x1e04c,
 739                 0x1e284, 0x1e28c,
 740                 0x1e2c0, 0x1e2c0,
 741                 0x1e2e0, 0x1e2e0,
 742                 0x1e300, 0x1e384,
 743                 0x1e3c0, 0x1e3c8,
 744                 0x1e440, 0x1e44c,
 745                 0x1e684, 0x1e68c,
 746                 0x1e6c0, 0x1e6c0,
 747                 0x1e6e0, 0x1e6e0,
 748                 0x1e700, 0x1e784,
 749                 0x1e7c0, 0x1e7c8,
 750                 0x1e840, 0x1e84c,
 751                 0x1ea84, 0x1ea8c,
 752                 0x1eac0, 0x1eac0,
 753                 0x1eae0, 0x1eae0,
 754                 0x1eb00, 0x1eb84,
 755                 0x1ebc0, 0x1ebc8,
 756                 0x1ec40, 0x1ec4c,
 757                 0x1ee84, 0x1ee8c,
 758                 0x1eec0, 0x1eec0,
 759                 0x1eee0, 0x1eee0,
 760                 0x1ef00, 0x1ef84,
 761                 0x1efc0, 0x1efc8,
 762                 0x1f040, 0x1f04c,
 763                 0x1f284, 0x1f28c,
 764                 0x1f2c0, 0x1f2c0,
 765                 0x1f2e0, 0x1f2e0,
 766                 0x1f300, 0x1f384,
 767                 0x1f3c0, 0x1f3c8,
 768                 0x1f440, 0x1f44c,
 769                 0x1f684, 0x1f68c,
 770                 0x1f6c0, 0x1f6c0,
 771                 0x1f6e0, 0x1f6e0,
 772                 0x1f700, 0x1f784,
 773                 0x1f7c0, 0x1f7c8,
 774                 0x1f840, 0x1f84c,
 775                 0x1fa84, 0x1fa8c,
 776                 0x1fac0, 0x1fac0,
 777                 0x1fae0, 0x1fae0,
 778                 0x1fb00, 0x1fb84,
 779                 0x1fbc0, 0x1fbc8,
 780                 0x1fc40, 0x1fc4c,
 781                 0x1fe84, 0x1fe8c,
 782                 0x1fec0, 0x1fec0,
 783                 0x1fee0, 0x1fee0,
 784                 0x1ff00, 0x1ff84,
 785                 0x1ffc0, 0x1ffc8,
 786                 0x20000, 0x2002c,
 787                 0x20100, 0x2013c,
 788                 0x20190, 0x201c8,
 789                 0x20200, 0x20318,
 790                 0x20400, 0x20528,
 791                 0x20540, 0x20614,
 792                 0x21000, 0x21040,
 793                 0x2104c, 0x21060,
 794                 0x210c0, 0x210ec,
 795                 0x21200, 0x21268,
 796                 0x21270, 0x21284,
 797                 0x212fc, 0x21388,
 798                 0x21400, 0x21404,
 799                 0x21500, 0x21518,
 800                 0x2152c, 0x2153c,
 801                 0x21550, 0x21554,
 802                 0x21600, 0x21600,
 803                 0x21608, 0x21628,
 804                 0x21630, 0x2163c,
 805                 0x21700, 0x2171c,
 806                 0x21780, 0x2178c,
 807                 0x21800, 0x21c38,
 808                 0x21c80, 0x21d7c,
 809                 0x21e00, 0x21e04,
 810                 0x22000, 0x2202c,
 811                 0x22100, 0x2213c,
 812                 0x22190, 0x221c8,
 813                 0x22200, 0x22318,
 814                 0x22400, 0x22528,
 815                 0x22540, 0x22614,
 816                 0x23000, 0x23040,
 817                 0x2304c, 0x23060,
 818                 0x230c0, 0x230ec,
 819                 0x23200, 0x23268,
 820                 0x23270, 0x23284,
 821                 0x232fc, 0x23388,
 822                 0x23400, 0x23404,
 823                 0x23500, 0x23518,
 824                 0x2352c, 0x2353c,
 825                 0x23550, 0x23554,
 826                 0x23600, 0x23600,
 827                 0x23608, 0x23628,
 828                 0x23630, 0x2363c,
 829                 0x23700, 0x2371c,
 830                 0x23780, 0x2378c,
 831                 0x23800, 0x23c38,
 832                 0x23c80, 0x23d7c,
 833                 0x23e00, 0x23e04,
 834                 0x24000, 0x2402c,
 835                 0x24100, 0x2413c,
 836                 0x24190, 0x241c8,
 837                 0x24200, 0x24318,
 838                 0x24400, 0x24528,
 839                 0x24540, 0x24614,
 840                 0x25000, 0x25040,
 841                 0x2504c, 0x25060,
 842                 0x250c0, 0x250ec,
 843                 0x25200, 0x25268,
 844                 0x25270, 0x25284,
 845                 0x252fc, 0x25388,
 846                 0x25400, 0x25404,
 847                 0x25500, 0x25518,
 848                 0x2552c, 0x2553c,
 849                 0x25550, 0x25554,
 850                 0x25600, 0x25600,
 851                 0x25608, 0x25628,
 852                 0x25630, 0x2563c,
 853                 0x25700, 0x2571c,
 854                 0x25780, 0x2578c,
 855                 0x25800, 0x25c38,
 856                 0x25c80, 0x25d7c,
 857                 0x25e00, 0x25e04,
 858                 0x26000, 0x2602c,
 859                 0x26100, 0x2613c,
 860                 0x26190, 0x261c8,
 861                 0x26200, 0x26318,
 862                 0x26400, 0x26528,
 863                 0x26540, 0x26614,
 864                 0x27000, 0x27040,
 865                 0x2704c, 0x27060,
 866                 0x270c0, 0x270ec,
 867                 0x27200, 0x27268,
 868                 0x27270, 0x27284,
 869                 0x272fc, 0x27388,
 870                 0x27400, 0x27404,
 871                 0x27500, 0x27518,
 872                 0x2752c, 0x2753c,
 873                 0x27550, 0x27554,
 874                 0x27600, 0x27600,
 875                 0x27608, 0x27628,
 876                 0x27630, 0x2763c,
 877                 0x27700, 0x2771c,
 878                 0x27780, 0x2778c,
 879                 0x27800, 0x27c38,
 880                 0x27c80, 0x27d7c,
 881                 0x27e00, 0x27e04
 882         };
 883
 884         static const unsigned int t5_reg_ranges[] = {
 885                 0x1008, 0x1148,
 886                 0x1180, 0x11b4,
 887                 0x11fc, 0x123c,
 888                 0x1280, 0x173c,
 889                 0x1800, 0x18fc,
 890                 0x3000, 0x3028,
 891                 0x3060, 0x30d8,
 892                 0x30e0, 0x30fc,
 893                 0x3140, 0x357c,
 894                 0x35a8, 0x35cc,
 895                 0x35ec, 0x35ec,
 896                 0x3600, 0x5624,
 897                 0x56cc, 0x575c,
 898                 0x580c, 0x5814,
 899                 0x5890, 0x58bc,
 900                 0x5940, 0x59dc,
 901                 0x59fc, 0x5a18,
 902                 0x5a60, 0x5a9c,
 903                 0x5b9c, 0x5bfc,
 904                 0x6000, 0x6040,
 905                 0x6058, 0x614c,
 906                 0x7700, 0x7798,
 907                 0x77c0, 0x78fc,
 908                 0x7b00, 0x7c54,
 909                 0x7d00, 0x7efc,
 910                 0x8dc0, 0x8de0,
 911                 0x8df8, 0x8e84,
 912                 0x8ea0, 0x8f84,
 913                 0x8fc0, 0x90f8,
 914                 0x9400, 0x9470,
 915                 0x9600, 0x96f4,
 916                 0x9800, 0x9808,
 917                 0x9820, 0x983c,
 918                 0x9850, 0x9864,
 919                 0x9c00, 0x9c6c,
 920                 0x9c80, 0x9cec,
 921                 0x9d00, 0x9d6c,
 922                 0x9d80, 0x9dec,
 923                 0x9e00, 0x9e6c,
 924                 0x9e80, 0x9eec,
 925                 0x9f00, 0x9f6c,
 926                 0x9f80, 0xa020,
 927                 0xd004, 0xd03c,
 928                 0xdfc0, 0xdfe0,
 929                 0xe000, 0x11088,
 930                 0x1109c, 0x11110,
 931                 0x11118, 0x1117c,
 932                 0x11190, 0x11204,
 933                 0x19040, 0x1906c,
 934                 0x19078, 0x19080,
 935                 0x1908c, 0x19124,
 936                 0x19150, 0x191b0,
 937                 0x191d0, 0x191e8,
 938                 0x19238, 0x19290,
 939                 0x193f8, 0x19474,
 940                 0x19490, 0x194cc,
 941                 0x194f0, 0x194f8,
 942                 0x19c00, 0x19c60,
 943                 0x19c94, 0x19e10,
 944                 0x19e50, 0x19f34,
 945                 0x19f40, 0x19f50,
 946                 0x19f90, 0x19fe4,
 947                 0x1a000, 0x1a06c,
 948                 0x1a0b0, 0x1a120,
 949                 0x1a128, 0x1a138,
 950                 0x1a190, 0x1a1c4,
 951                 0x1a1fc, 0x1a1fc,
 952                 0x1e008, 0x1e00c,
 953                 0x1e040, 0x1e04c,
 954                 0x1e284, 0x1e290,
 955                 0x1e2c0, 0x1e2c0,
 956                 0x1e2e0, 0x1e2e0,
 957                 0x1e300, 0x1e384,
 958                 0x1e3c0, 0x1e3c8,
 959                 0x1e408, 0x1e40c,
 960                 0x1e440, 0x1e44c,
 961                 0x1e684, 0x1e690,
 962                 0x1e6c0, 0x1e6c0,
 963                 0x1e6e0, 0x1e6e0,
 964                 0x1e700, 0x1e784,
 965                 0x1e7c0, 0x1e7c8,
 966                 0x1e808, 0x1e80c,
 967                 0x1e840, 0x1e84c,
 968                 0x1ea84, 0x1ea90,
 969                 0x1eac0, 0x1eac0,
 970                 0x1eae0, 0x1eae0,
 971                 0x1eb00, 0x1eb84,
 972                 0x1ebc0, 0x1ebc8,
 973                 0x1ec08, 0x1ec0c,
 974                 0x1ec40, 0x1ec4c,
 975                 0x1ee84, 0x1ee90,
 976                 0x1eec0, 0x1eec0,
 977                 0x1eee0, 0x1eee0,
 978                 0x1ef00, 0x1ef84,
 979                 0x1efc0, 0x1efc8,
 980                 0x1f008, 0x1f00c,
 981                 0x1f040, 0x1f04c,
 982                 0x1f284, 0x1f290,
 983                 0x1f2c0, 0x1f2c0,
 984                 0x1f2e0, 0x1f2e0,
 985                 0x1f300, 0x1f384,
 986                 0x1f3c0, 0x1f3c8,
 987                 0x1f408, 0x1f40c,
 988                 0x1f440, 0x1f44c,
 989                 0x1f684, 0x1f690,
 990                 0x1f6c0, 0x1f6c0,
 991                 0x1f6e0, 0x1f6e0,
 992                 0x1f700, 0x1f784,
 993                 0x1f7c0, 0x1f7c8,
 994                 0x1f808, 0x1f80c,
 995                 0x1f840, 0x1f84c,
 996                 0x1fa84, 0x1fa90,
 997                 0x1fac0, 0x1fac0,
 998                 0x1fae0, 0x1fae0,
 999                 0x1fb00, 0x1fb84,
1000                 0x1fbc0, 0x1fbc8,
1001                 0x1fc08, 0x1fc0c,
1002                 0x1fc40, 0x1fc4c,
1003                 0x1fe84, 0x1fe90,
1004                 0x1fec0, 0x1fec0,
1005                 0x1fee0, 0x1fee0,
1006                 0x1ff00, 0x1ff84,
1007                 0x1ffc0, 0x1ffc8,
1008                 0x30000, 0x30030,
1009                 0x30100, 0x30144,
1010                 0x30190, 0x301d0,
1011                 0x30200, 0x30318,
1012                 0x30400, 0x3052c,
1013                 0x30540, 0x3061c,
1014                 0x30800, 0x30834,
1015                 0x308c0, 0x30908,
1016                 0x30910, 0x309ac,
1017                 0x30a00, 0x30a04,
1018                 0x30a0c, 0x30a2c,
1019                 0x30a44, 0x30a50,
1020                 0x30a74, 0x30c24,
1021                 0x30d08, 0x30d14,
1022                 0x30d1c, 0x30d20,
1023                 0x30d3c, 0x30d50,
1024                 0x31200, 0x3120c,
1025                 0x31220, 0x31220,
1026                 0x31240, 0x31240,
1027                 0x31600, 0x31600,
1028                 0x31608, 0x3160c,
1029                 0x31a00, 0x31a1c,
1030                 0x31e04, 0x31e20,
1031                 0x31e38, 0x31e3c,
1032                 0x31e80, 0x31e80,
1033                 0x31e88, 0x31ea8,
1034                 0x31eb0, 0x31eb4,
1035                 0x31ec8, 0x31ed4,
1036                 0x31fb8, 0x32004,
1037                 0x32208, 0x3223c,
1038                 0x32600, 0x32630,
1039                 0x32a00, 0x32abc,
1040                 0x32b00, 0x32b70,
1041                 0x33000, 0x33048,
1042                 0x33060, 0x3309c,
1043                 0x330f0, 0x33148,
1044                 0x33160, 0x3319c,
1045                 0x331f0, 0x332e4,
1046                 0x332f8, 0x333e4,
1047                 0x333f8, 0x33448,
1048                 0x33460, 0x3349c,
1049                 0x334f0, 0x33548,
1050                 0x33560, 0x3359c,
1051                 0x335f0, 0x336e4,
1052                 0x336f8, 0x337e4,
1053                 0x337f8, 0x337fc,
1054                 0x33814, 0x33814,
1055                 0x3382c, 0x3382c,
1056                 0x33880, 0x3388c,
1057                 0x338e8, 0x338ec,
1058                 0x33900, 0x33948,
1059                 0x33960, 0x3399c,
1060                 0x339f0, 0x33ae4,
1061                 0x33af8, 0x33b10,
1062                 0x33b28, 0x33b28,
1063                 0x33b3c, 0x33b50,
1064                 0x33bf0, 0x33c10,
1065                 0x33c28, 0x33c28,
1066                 0x33c3c, 0x33c50,
1067                 0x33cf0, 0x33cfc,
1068                 0x34000, 0x34030,
1069                 0x34100, 0x34144,
1070                 0x34190, 0x341d0,
1071                 0x34200, 0x34318,
1072                 0x34400, 0x3452c,
1073                 0x34540, 0x3461c,
1074                 0x34800, 0x34834,
1075                 0x348c0, 0x34908,
1076                 0x34910, 0x349ac,
1077                 0x34a00, 0x34a04,
1078                 0x34a0c, 0x34a2c,
1079                 0x34a44, 0x34a50,
1080                 0x34a74, 0x34c24,
1081                 0x34d08, 0x34d14,
1082                 0x34d1c, 0x34d20,
1083                 0x34d3c, 0x34d50,
1084                 0x35200, 0x3520c,
1085                 0x35220, 0x35220,
1086                 0x35240, 0x35240,
1087                 0x35600, 0x35600,
1088                 0x35608, 0x3560c,
1089                 0x35a00, 0x35a1c,
1090                 0x35e04, 0x35e20,
1091                 0x35e38, 0x35e3c,
1092                 0x35e80, 0x35e80,
1093                 0x35e88, 0x35ea8,
1094                 0x35eb0, 0x35eb4,
1095                 0x35ec8, 0x35ed4,
1096                 0x35fb8, 0x36004,
1097                 0x36208, 0x3623c,
1098                 0x36600, 0x36630,
1099                 0x36a00, 0x36abc,
1100                 0x36b00, 0x36b70,
1101                 0x37000, 0x37048,
1102                 0x37060, 0x3709c,
1103                 0x370f0, 0x37148,
1104                 0x37160, 0x3719c,
1105                 0x371f0, 0x372e4,
1106                 0x372f8, 0x373e4,
1107                 0x373f8, 0x37448,
1108                 0x37460, 0x3749c,
1109                 0x374f0, 0x37548,
1110                 0x37560, 0x3759c,
1111                 0x375f0, 0x376e4,
1112                 0x376f8, 0x377e4,
1113                 0x377f8, 0x377fc,
1114                 0x37814, 0x37814,
1115                 0x3782c, 0x3782c,
1116                 0x37880, 0x3788c,
1117                 0x378e8, 0x378ec,
1118                 0x37900, 0x37948,
1119                 0x37960, 0x3799c,
1120                 0x379f0, 0x37ae4,
1121                 0x37af8, 0x37b10,
1122                 0x37b28, 0x37b28,
1123                 0x37b3c, 0x37b50,
1124                 0x37bf0, 0x37c10,
1125                 0x37c28, 0x37c28,
1126                 0x37c3c, 0x37c50,
1127                 0x37cf0, 0x37cfc,
1128                 0x38000, 0x38030,
1129                 0x38100, 0x38144,
1130                 0x38190, 0x381d0,
1131                 0x38200, 0x38318,
1132                 0x38400, 0x3852c,
1133                 0x38540, 0x3861c,
1134                 0x38800, 0x38834,
1135                 0x388c0, 0x38908,
1136                 0x38910, 0x389ac,
1137                 0x38a00, 0x38a04,
1138                 0x38a0c, 0x38a2c,
1139                 0x38a44, 0x38a50,
1140                 0x38a74, 0x38c24,
1141                 0x38d08, 0x38d14,
1142                 0x38d1c, 0x38d20,
1143                 0x38d3c, 0x38d50,
1144                 0x39200, 0x3920c,
1145                 0x39220, 0x39220,
1146                 0x39240, 0x39240,
1147                 0x39600, 0x39600,
1148                 0x39608, 0x3960c,
1149                 0x39a00, 0x39a1c,
1150                 0x39e04, 0x39e20,
1151                 0x39e38, 0x39e3c,
1152                 0x39e80, 0x39e80,
1153                 0x39e88, 0x39ea8,
1154                 0x39eb0, 0x39eb4,
1155                 0x39ec8, 0x39ed4,
1156                 0x39fb8, 0x3a004,
1157                 0x3a208, 0x3a23c,
1158                 0x3a600, 0x3a630,
1159                 0x3aa00, 0x3aabc,
1160                 0x3ab00, 0x3ab70,
1161                 0x3b000, 0x3b048,
1162                 0x3b060, 0x3b09c,
1163                 0x3b0f0, 0x3b148,
1164                 0x3b160, 0x3b19c,
1165                 0x3b1f0, 0x3b2e4,
1166                 0x3b2f8, 0x3b3e4,
1167                 0x3b3f8, 0x3b448,
1168                 0x3b460, 0x3b49c,
1169                 0x3b4f0, 0x3b548,
1170                 0x3b560, 0x3b59c,
1171                 0x3b5f0, 0x3b6e4,
1172                 0x3b6f8, 0x3b7e4,
1173                 0x3b7f8, 0x3b7fc,
1174                 0x3b814, 0x3b814,
1175                 0x3b82c, 0x3b82c,
1176                 0x3b880, 0x3b88c,
1177                 0x3b8e8, 0x3b8ec,
1178                 0x3b900, 0x3b948,
1179                 0x3b960, 0x3b99c,
1180                 0x3b9f0, 0x3bae4,
1181                 0x3baf8, 0x3bb10,
1182                 0x3bb28, 0x3bb28,
1183                 0x3bb3c, 0x3bb50,
1184                 0x3bbf0, 0x3bc10,
1185                 0x3bc28, 0x3bc28,
1186                 0x3bc3c, 0x3bc50,
1187                 0x3bcf0, 0x3bcfc,
1188                 0x3c000, 0x3c030,
1189                 0x3c100, 0x3c144,
1190                 0x3c190, 0x3c1d0,
1191                 0x3c200, 0x3c318,
1192                 0x3c400, 0x3c52c,
1193                 0x3c540, 0x3c61c,
1194                 0x3c800, 0x3c834,
1195                 0x3c8c0, 0x3c908,
1196                 0x3c910, 0x3c9ac,
1197                 0x3ca00, 0x3ca04,
1198                 0x3ca0c, 0x3ca2c,
1199                 0x3ca44, 0x3ca50,
1200                 0x3ca74, 0x3cc24,
1201                 0x3cd08, 0x3cd14,
1202                 0x3cd1c, 0x3cd20,
1203                 0x3cd3c, 0x3cd50,
1204                 0x3d200, 0x3d20c,
1205                 0x3d220, 0x3d220,
1206                 0x3d240, 0x3d240,
1207                 0x3d600, 0x3d600,
1208                 0x3d608, 0x3d60c,
1209                 0x3da00, 0x3da1c,
1210                 0x3de04, 0x3de20,
1211                 0x3de38, 0x3de3c,
1212                 0x3de80, 0x3de80,
1213                 0x3de88, 0x3dea8,
1214                 0x3deb0, 0x3deb4,
1215                 0x3dec8, 0x3ded4,
1216                 0x3dfb8, 0x3e004,
1217                 0x3e208, 0x3e23c,
1218                 0x3e600, 0x3e630,
1219                 0x3ea00, 0x3eabc,
1220                 0x3eb00, 0x3eb70,
1221                 0x3f000, 0x3f048,
1222                 0x3f060, 0x3f09c,
1223                 0x3f0f0, 0x3f148,
1224                 0x3f160, 0x3f19c,
1225                 0x3f1f0, 0x3f2e4,
1226                 0x3f2f8, 0x3f3e4,
1227                 0x3f3f8, 0x3f448,
1228                 0x3f460, 0x3f49c,
1229                 0x3f4f0, 0x3f548,
1230                 0x3f560, 0x3f59c,
1231                 0x3f5f0, 0x3f6e4,
1232                 0x3f6f8, 0x3f7e4,
1233                 0x3f7f8, 0x3f7fc,
1234                 0x3f814, 0x3f814,
1235                 0x3f82c, 0x3f82c,
1236                 0x3f880, 0x3f88c,
1237                 0x3f8e8, 0x3f8ec,
1238                 0x3f900, 0x3f948,
1239                 0x3f960, 0x3f99c,
1240                 0x3f9f0, 0x3fae4,
1241                 0x3faf8, 0x3fb10,
1242                 0x3fb28, 0x3fb28,
1243                 0x3fb3c, 0x3fb50,
1244                 0x3fbf0, 0x3fc10,
1245                 0x3fc28, 0x3fc28,
1246                 0x3fc3c, 0x3fc50,
1247                 0x3fcf0, 0x3fcfc,
1248                 0x40000, 0x4000c,
1249                 0x40040, 0x40068,
1250                 0x40080, 0x40144,
1251                 0x40180, 0x4018c,
1252                 0x40200, 0x40298,
1253                 0x402ac, 0x4033c,
1254                 0x403f8, 0x403fc,
1255                 0x41304, 0x413c4,
1256                 0x41400, 0x4141c,
1257                 0x41480, 0x414d0,
1258                 0x44000, 0x44078,
1259                 0x440c0, 0x44278,
1260                 0x442c0, 0x44478,
1261                 0x444c0, 0x44678,
1262                 0x446c0, 0x44878,
1263                 0x448c0, 0x449fc,
1264                 0x45000, 0x45068,
1265                 0x45080, 0x45084,
1266                 0x450a0, 0x450b0,
1267                 0x45200, 0x45268,
1268                 0x45280, 0x45284,
1269                 0x452a0, 0x452b0,
1270                 0x460c0, 0x460e4,
1271                 0x47000, 0x4708c,
1272                 0x47200, 0x47250,
1273                 0x47400, 0x47420,
1274                 0x47600, 0x47618,
1275                 0x47800, 0x47814,
1276                 0x48000, 0x4800c,
1277                 0x48040, 0x48068,
1278                 0x48080, 0x48144,
1279                 0x48180, 0x4818c,
1280                 0x48200, 0x48298,
1281                 0x482ac, 0x4833c,
1282                 0x483f8, 0x483fc,
1283                 0x49304, 0x493c4,
1284                 0x49400, 0x4941c,
1285                 0x49480, 0x494d0,
1286                 0x4c000, 0x4c078,
1287                 0x4c0c0, 0x4c278,
1288                 0x4c2c0, 0x4c478,
1289                 0x4c4c0, 0x4c678,
1290                 0x4c6c0, 0x4c878,
1291                 0x4c8c0, 0x4c9fc,
1292                 0x4d000, 0x4d068,
1293                 0x4d080, 0x4d084,
1294                 0x4d0a0, 0x4d0b0,
1295                 0x4d200, 0x4d268,
1296                 0x4d280, 0x4d284,
1297                 0x4d2a0, 0x4d2b0,
1298                 0x4e0c0, 0x4e0e4,
1299                 0x4f000, 0x4f08c,
1300                 0x4f200, 0x4f250,
1301                 0x4f400, 0x4f420,
1302                 0x4f600, 0x4f618,
1303                 0x4f800, 0x4f814,
1304                 0x50000, 0x500cc,
1305                 0x50400, 0x50400,
1306                 0x50800, 0x508cc,
1307                 0x50c00, 0x50c00,
1308                 0x51000, 0x5101c,
1309                 0x51300, 0x51308,
1310         };
1311
1312         u32 *buf_end = (u32 *)((char *)buf + buf_size);
1313         const unsigned int *reg_ranges;
1314         int reg_ranges_size, range;
1315         unsigned int chip_version = CHELSIO_CHIP_VERSION(adap->params.chip);
1316
1317         /* Select the right set of register ranges to dump depending on the
1318          * adapter chip type.
1319          */
1320         switch (chip_version) {
1321         case CHELSIO_T4:
1322                 reg_ranges = t4_reg_ranges;
1323                 reg_ranges_size = ARRAY_SIZE(t4_reg_ranges);
1324                 break;
1325
1326         case CHELSIO_T5:
1327                 reg_ranges = t5_reg_ranges;
1328                 reg_ranges_size = ARRAY_SIZE(t5_reg_ranges);
1329                 break;
1330
1331         default:
1332                 dev_err(adap->pdev_dev,
1333                         "Unsupported chip version %d\n", chip_version);
1334                 return;
1335         }
1336
1337         /* Clear the register buffer and insert the appropriate register
1338          * values selected by the above register ranges.
1339          */
1340         memset(buf, 0, buf_size);
1341         for (range = 0; range < reg_ranges_size; range += 2) {
1342                 unsigned int reg = reg_ranges[range];
1343                 unsigned int last_reg = reg_ranges[range + 1];
1344                 u32 *bufp = (u32 *)((char *)buf + reg);
1345
1346                 /* Iterate across the register range filling in the register
1347                  * buffer but don't write past the end of the register buffer.
1348                  */
1349                 while (reg <= last_reg && bufp < buf_end) {
1350                         *bufp++ = t4_read_reg(adap, reg);
1351                         reg += sizeof(u32);
1352                 }
1353         }
1354 }
1355
1356 #define EEPROM_STAT_ADDR   0x7bfc
1357 #define VPD_BASE           0x400
1358 #define VPD_BASE_OLD       0
1359 #define VPD_LEN            1024
1360 #define CHELSIO_VPD_UNIQUE_ID 0x82
1361
1362 /**
1363  *      t4_seeprom_wp - enable/disable EEPROM write protection
1364  *      @adapter: the adapter
1365  *      @enable: whether to enable or disable write protection
1366  *
1367  *      Enables or disables write protection on the serial EEPROM.
1368  */
1369 int t4_seeprom_wp(struct adapter *adapter, bool enable)
1370 {
1371         unsigned int v = enable ? 0xc : 0;
1372         int ret = pci_write_vpd(adapter->pdev, EEPROM_STAT_ADDR, 4, &v);
1373         return ret < 0 ? ret : 0;
1374 }
1375
1376 /**
1377  *      get_vpd_params - read VPD parameters from VPD EEPROM
1378  *      @adapter: adapter to read
1379  *      @p: where to store the parameters
1380  *
1381  *      Reads card parameters stored in VPD EEPROM.
1382  */
1383 int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
1384 {
1385         u32 cclk_param, cclk_val;
1386         int i, ret, addr;
1387         int ec, sn, pn;
1388         u8 *vpd, csum;
1389         unsigned int vpdr_len, kw_offset, id_len;
1390
1391         vpd = vmalloc(VPD_LEN);
1392         if (!vpd)
1393                 return -ENOMEM;
1394
1395         ret = pci_read_vpd(adapter->pdev, VPD_BASE, sizeof(u32), vpd);
1396         if (ret < 0)
1397                 goto out;
1398
1399         /* The VPD shall have a unique identifier specified by the PCI SIG.
1400          * For chelsio adapters, the identifier is 0x82. The first byte of a VPD
1401          * shall be CHELSIO_VPD_UNIQUE_ID (0x82). The VPD programming software
1402          * is expected to automatically put this entry at the
1403          * beginning of the VPD.
1404          */
1405         addr = *vpd == CHELSIO_VPD_UNIQUE_ID ? VPD_BASE : VPD_BASE_OLD;
1406
1407         ret = pci_read_vpd(adapter->pdev, addr, VPD_LEN, vpd);
1408         if (ret < 0)
1409                 goto out;
1410
1411         if (vpd[0] != PCI_VPD_LRDT_ID_STRING) {
1412                 dev_err(adapter->pdev_dev, "missing VPD ID string\n");
1413                 ret = -EINVAL;
1414                 goto out;
1415         }
1416
1417         id_len = pci_vpd_lrdt_size(vpd);
1418         if (id_len > ID_LEN)
1419                 id_len = ID_LEN;
1420
1421         i = pci_vpd_find_tag(vpd, 0, VPD_LEN, PCI_VPD_LRDT_RO_DATA);
1422         if (i < 0) {
1423                 dev_err(adapter->pdev_dev, "missing VPD-R section\n");
1424                 ret = -EINVAL;
1425                 goto out;
1426         }
1427
1428         vpdr_len = pci_vpd_lrdt_size(&vpd[i]);
1429         kw_offset = i + PCI_VPD_LRDT_TAG_SIZE;
1430         if (vpdr_len + kw_offset > VPD_LEN) {
1431                 dev_err(adapter->pdev_dev, "bad VPD-R length %u\n", vpdr_len);
1432                 ret = -EINVAL;
1433                 goto out;
1434         }
1435
1436 #define FIND_VPD_KW(var, name) do { \
1437         var = pci_vpd_find_info_keyword(vpd, kw_offset, vpdr_len, name); \
1438         if (var < 0) { \
1439                 dev_err(adapter->pdev_dev, "missing VPD keyword " name "\n"); \
1440                 ret = -EINVAL; \
1441                 goto out; \
1442         } \
1443         var += PCI_VPD_INFO_FLD_HDR_SIZE; \
1444 } while (0)
1445
1446         FIND_VPD_KW(i, "RV");
1447         for (csum = 0; i >= 0; i--)
1448                 csum += vpd[i];
1449
1450         if (csum) {
1451                 dev_err(adapter->pdev_dev,
1452                         "corrupted VPD EEPROM, actual csum %u\n", csum);
1453                 ret = -EINVAL;
1454                 goto out;
1455         }
1456
1457         FIND_VPD_KW(ec, "EC");
1458         FIND_VPD_KW(sn, "SN");
1459         FIND_VPD_KW(pn, "PN");
1460 #undef FIND_VPD_KW
1461
1462         memcpy(p->id, vpd + PCI_VPD_LRDT_TAG_SIZE, id_len);
1463         strim(p->id);
1464         memcpy(p->ec, vpd + ec, EC_LEN);
1465         strim(p->ec);
1466         i = pci_vpd_info_field_size(vpd + sn - PCI_VPD_INFO_FLD_HDR_SIZE);
1467         memcpy(p->sn, vpd + sn, min(i, SERNUM_LEN));
1468         strim(p->sn);
1469         i = pci_vpd_info_field_size(vpd + pn - PCI_VPD_INFO_FLD_HDR_SIZE);
1470         memcpy(p->pn, vpd + pn, min(i, PN_LEN));
1471         strim(p->pn);
1472
1473         /*
1474          * Ask firmware for the Core Clock since it knows how to translate the
1475          * Reference Clock ('V2') VPD field into a Core Clock value ...
1476          */
1477         cclk_param = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
1478                       FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_CCLK));
1479         ret = t4_query_params(adapter, adapter->mbox, 0, 0,
1480                               1, &cclk_param, &cclk_val);
1481
1482 out:
1483         vfree(vpd);
1484         if (ret)
1485                 return ret;
1486         p->cclk = cclk_val;
1487
1488         return 0;
1489 }
1490
1491 /* serial flash and firmware constants */
1492 enum {
1493         SF_ATTEMPTS = 10,             /* max retries for SF operations */
1494
1495         /* flash command opcodes */
1496         SF_PROG_PAGE    = 2,          /* program page */
1497         SF_WR_DISABLE   = 4,          /* disable writes */
1498         SF_RD_STATUS    = 5,          /* read status register */
1499         SF_WR_ENABLE    = 6,          /* enable writes */
1500         SF_RD_DATA_FAST = 0xb,        /* read flash */
1501         SF_RD_ID        = 0x9f,       /* read ID */
1502         SF_ERASE_SECTOR = 0xd8,       /* erase sector */
1503
1504         FW_MAX_SIZE = 16 * SF_SEC_SIZE,
1505 };
1506
1507 /**
1508  *      sf1_read - read data from the serial flash
1509  *      @adapter: the adapter
1510  *      @byte_cnt: number of bytes to read
1511  *      @cont: whether another operation will be chained
1512  *      @lock: whether to lock SF for PL access only
1513  *      @valp: where to store the read data
1514  *
1515  *      Reads up to 4 bytes of data from the serial flash.  The location of
1516  *      the read needs to be specified prior to calling this by issuing the
1517  *      appropriate commands to the serial flash.
1518  */
1519 static int sf1_read(struct adapter *adapter, unsigned int byte_cnt, int cont,
1520                     int lock, u32 *valp)
1521 {
1522         int ret;
1523
1524         if (!byte_cnt || byte_cnt > 4)
1525                 return -EINVAL;
1526         if (t4_read_reg(adapter, SF_OP_A) & SF_BUSY_F)
1527                 return -EBUSY;
1528         t4_write_reg(adapter, SF_OP_A, SF_LOCK_V(lock) |
1529                      SF_CONT_V(cont) | BYTECNT_V(byte_cnt - 1));
1530         ret = t4_wait_op_done(adapter, SF_OP_A, SF_BUSY_F, 0, SF_ATTEMPTS, 5);
1531         if (!ret)
1532                 *valp = t4_read_reg(adapter, SF_DATA_A);
1533         return ret;
1534 }
1535
1536 /**
1537  *      sf1_write - write data to the serial flash
1538  *      @adapter: the adapter
1539  *      @byte_cnt: number of bytes to write
1540  *      @cont: whether another operation will be chained
1541  *      @lock: whether to lock SF for PL access only
1542  *      @val: value to write
1543  *
1544  *      Writes up to 4 bytes of data to the serial flash.  The location of
1545  *      the write needs to be specified prior to calling this by issuing the
1546  *      appropriate commands to the serial flash.
1547  */
1548 static int sf1_write(struct adapter *adapter, unsigned int byte_cnt, int cont,
1549                      int lock, u32 val)
1550 {
1551         if (!byte_cnt || byte_cnt > 4)
1552                 return -EINVAL;
1553         if (t4_read_reg(adapter, SF_OP_A) & SF_BUSY_F)
1554                 return -EBUSY;
1555         t4_write_reg(adapter, SF_DATA_A, val);
1556         t4_write_reg(adapter, SF_OP_A, SF_LOCK_V(lock) |
1557                      SF_CONT_V(cont) | BYTECNT_V(byte_cnt - 1) | OP_V(1));
1558         return t4_wait_op_done(adapter, SF_OP_A, SF_BUSY_F, 0, SF_ATTEMPTS, 5);
1559 }
1560
1561 /**
1562  *      flash_wait_op - wait for a flash operation to complete
1563  *      @adapter: the adapter
1564  *      @attempts: max number of polls of the status register
1565  *      @delay: delay between polls in ms
1566  *
1567  *      Wait for a flash operation to complete by polling the status register.
1568  */
1569 static int flash_wait_op(struct adapter *adapter, int attempts, int delay)
1570 {
1571         int ret;
1572         u32 status;
1573
1574         while (1) {
1575                 if ((ret = sf1_write(adapter, 1, 1, 1, SF_RD_STATUS)) != 0 ||
1576                     (ret = sf1_read(adapter, 1, 0, 1, &status)) != 0)
1577                         return ret;
1578                 if (!(status & 1))
1579                         return 0;
1580                 if (--attempts == 0)
1581                         return -EAGAIN;
1582                 if (delay)
1583                         msleep(delay);
1584         }
1585 }
1586
1587 /**
1588  *      t4_read_flash - read words from serial flash
1589  *      @adapter: the adapter
1590  *      @addr: the start address for the read
1591  *      @nwords: how many 32-bit words to read
1592  *      @data: where to store the read data
1593  *      @byte_oriented: whether to store data as bytes or as words
1594  *
1595  *      Read the specified number of 32-bit words from the serial flash.
1596  *      If @byte_oriented is set the read data is stored as a byte array
1597  *      (i.e., big-endian), otherwise as 32-bit words in the platform's
1598  *      natural endianness.
1599  */
1600 int t4_read_flash(struct adapter *adapter, unsigned int addr,
1601                   unsigned int nwords, u32 *data, int byte_oriented)
1602 {
1603         int ret;
1604
1605         if (addr + nwords * sizeof(u32) > adapter->params.sf_size || (addr & 3))
1606                 return -EINVAL;
1607
1608         addr = swab32(addr) | SF_RD_DATA_FAST;
1609
1610         if ((ret = sf1_write(adapter, 4, 1, 0, addr)) != 0 ||
1611             (ret = sf1_read(adapter, 1, 1, 0, data)) != 0)
1612                 return ret;
1613
1614         for ( ; nwords; nwords--, data++) {
1615                 ret = sf1_read(adapter, 4, nwords > 1, nwords == 1, data);
1616                 if (nwords == 1)
1617                         t4_write_reg(adapter, SF_OP_A, 0);    /* unlock SF */
1618                 if (ret)
1619                         return ret;
1620                 if (byte_oriented)
1621                         *data = (__force __u32) (htonl(*data));
1622         }
1623         return 0;
1624 }
1625
1626 /**
1627  *      t4_write_flash - write up to a page of data to the serial flash
1628  *      @adapter: the adapter
1629  *      @addr: the start address to write
1630  *      @n: length of data to write in bytes
1631  *      @data: the data to write
1632  *
1633  *      Writes up to a page of data (256 bytes) to the serial flash starting
1634  *      at the given address.  All the data must be written to the same page.
1635  */
1636 static int t4_write_flash(struct adapter *adapter, unsigned int addr,
1637                           unsigned int n, const u8 *data)
1638 {
1639         int ret;
1640         u32 buf[64];
1641         unsigned int i, c, left, val, offset = addr & 0xff;
1642
1643         if (addr >= adapter->params.sf_size || offset + n > SF_PAGE_SIZE)
1644                 return -EINVAL;
1645
1646         val = swab32(addr) | SF_PROG_PAGE;
1647
1648         if ((ret = sf1_write(adapter, 1, 0, 1, SF_WR_ENABLE)) != 0 ||
1649             (ret = sf1_write(adapter, 4, 1, 1, val)) != 0)
1650                 goto unlock;
1651
1652         for (left = n; left; left -= c) {
1653                 c = min(left, 4U);
1654                 for (val = 0, i = 0; i < c; ++i)
1655                         val = (val << 8) + *data++;
1656
1657                 ret = sf1_write(adapter, c, c != left, 1, val);
1658                 if (ret)
1659                         goto unlock;
1660         }
1661         ret = flash_wait_op(adapter, 8, 1);
1662         if (ret)
1663                 goto unlock;
1664
1665         t4_write_reg(adapter, SF_OP_A, 0);    /* unlock SF */
1666
1667         /* Read the page to verify the write succeeded */
1668         ret = t4_read_flash(adapter, addr & ~0xff, ARRAY_SIZE(buf), buf, 1);
1669         if (ret)
1670                 return ret;
1671
1672         if (memcmp(data - n, (u8 *)buf + offset, n)) {
1673                 dev_err(adapter->pdev_dev,
1674                         "failed to correctly write the flash page at %#x\n",
1675                         addr);
1676                 return -EIO;
1677         }
1678         return 0;
1679
1680 unlock:
1681         t4_write_reg(adapter, SF_OP_A, 0);    /* unlock SF */
1682         return ret;
1683 }
1684
1685 /**
1686  *      t4_get_fw_version - read the firmware version
1687  *      @adapter: the adapter
1688  *      @vers: where to place the version
1689  *
1690  *      Reads the FW version from flash.
1691  */
1692 int t4_get_fw_version(struct adapter *adapter, u32 *vers)
1693 {
1694         return t4_read_flash(adapter, FLASH_FW_START +
1695                              offsetof(struct fw_hdr, fw_ver), 1,
1696                              vers, 0);
1697 }
1698
1699 /**
1700  *      t4_get_tp_version - read the TP microcode version
1701  *      @adapter: the adapter
1702  *      @vers: where to place the version
1703  *
1704  *      Reads the TP microcode version from flash.
1705  */
1706 int t4_get_tp_version(struct adapter *adapter, u32 *vers)
1707 {
1708         return t4_read_flash(adapter, FLASH_FW_START +
1709                              offsetof(struct fw_hdr, tp_microcode_ver),
1710                              1, vers, 0);
1711 }
1712
1713 /**
1714  *      t4_get_exprom_version - return the Expansion ROM version (if any)
1715  *      @adapter: the adapter
1716  *      @vers: where to place the version
1717  *
1718  *      Reads the Expansion ROM header from FLASH and returns the version
1719  *      number (if present) through the @vers return value pointer.  We return
1720  *      this in the Firmware Version Format since it's convenient.  Return
1721  *      0 on success, -ENOENT if no Expansion ROM is present.
1722  */
1723 int t4_get_exprom_version(struct adapter *adap, u32 *vers)
1724 {
1725         struct exprom_header {
1726                 unsigned char hdr_arr[16];      /* must start with 0x55aa */
1727                 unsigned char hdr_ver[4];       /* Expansion ROM version */
1728         } *hdr;
1729         u32 exprom_header_buf[DIV_ROUND_UP(sizeof(struct exprom_header),
1730                                            sizeof(u32))];
1731         int ret;
1732
1733         ret = t4_read_flash(adap, FLASH_EXP_ROM_START,
1734                             ARRAY_SIZE(exprom_header_buf), exprom_header_buf,
1735                             0);
1736         if (ret)
1737                 return ret;
1738
1739         hdr = (struct exprom_header *)exprom_header_buf;
1740         if (hdr->hdr_arr[0] != 0x55 || hdr->hdr_arr[1] != 0xaa)
1741                 return -ENOENT;
1742
1743         *vers = (FW_HDR_FW_VER_MAJOR_V(hdr->hdr_ver[0]) |
1744                  FW_HDR_FW_VER_MINOR_V(hdr->hdr_ver[1]) |
1745                  FW_HDR_FW_VER_MICRO_V(hdr->hdr_ver[2]) |
1746                  FW_HDR_FW_VER_BUILD_V(hdr->hdr_ver[3]));
1747         return 0;
1748 }
1749
1750 /* Is the given firmware API compatible with the one the driver was compiled
1751  * with?
1752  */
1753 static int fw_compatible(const struct fw_hdr *hdr1, const struct fw_hdr *hdr2)
1754 {
1755
1756         /* short circuit if it's the exact same firmware version */
1757         if (hdr1->chip == hdr2->chip && hdr1->fw_ver == hdr2->fw_ver)
1758                 return 1;
1759
1760 #define SAME_INTF(x) (hdr1->intfver_##x == hdr2->intfver_##x)
1761         if (hdr1->chip == hdr2->chip && SAME_INTF(nic) && SAME_INTF(vnic) &&
1762             SAME_INTF(ri) && SAME_INTF(iscsi) && SAME_INTF(fcoe))
1763                 return 1;
1764 #undef SAME_INTF
1765
1766         return 0;
1767 }
1768
1769 /* The firmware in the filesystem is usable, but should it be installed?
1770  * This routine explains itself in detail if it indicates the filesystem
1771  * firmware should be installed.
1772  */
1773 static int should_install_fs_fw(struct adapter *adap, int card_fw_usable,
1774                                 int k, int c)
1775 {
1776         const char *reason;
1777
1778         if (!card_fw_usable) {
1779                 reason = "incompatible or unusable";
1780                 goto install;
1781         }
1782
1783         if (k > c) {
1784                 reason = "older than the version supported with this driver";
1785                 goto install;
1786         }
1787
1788         return 0;
1789
1790 install:
1791         dev_err(adap->pdev_dev, "firmware on card (%u.%u.%u.%u) is %s, "
1792                 "installing firmware %u.%u.%u.%u on card.\n",
1793                 FW_HDR_FW_VER_MAJOR_G(c), FW_HDR_FW_VER_MINOR_G(c),
1794                 FW_HDR_FW_VER_MICRO_G(c), FW_HDR_FW_VER_BUILD_G(c), reason,
1795                 FW_HDR_FW_VER_MAJOR_G(k), FW_HDR_FW_VER_MINOR_G(k),
1796                 FW_HDR_FW_VER_MICRO_G(k), FW_HDR_FW_VER_BUILD_G(k));
1797
1798         return 1;
1799 }
1800
1801 int t4_prep_fw(struct adapter *adap, struct fw_info *fw_info,
1802                const u8 *fw_data, unsigned int fw_size,
1803                struct fw_hdr *card_fw, enum dev_state state,
1804                int *reset)
1805 {
1806         int ret, card_fw_usable, fs_fw_usable;
1807         const struct fw_hdr *fs_fw;
1808         const struct fw_hdr *drv_fw;
1809
1810         drv_fw = &fw_info->fw_hdr;
1811
1812         /* Read the header of the firmware on the card */
1813         ret = -t4_read_flash(adap, FLASH_FW_START,
1814                             sizeof(*card_fw) / sizeof(uint32_t),
1815                             (uint32_t *)card_fw, 1);
1816         if (ret == 0) {
1817                 card_fw_usable = fw_compatible(drv_fw, (const void *)card_fw);
1818         } else {
1819                 dev_err(adap->pdev_dev,
1820                         "Unable to read card's firmware header: %d\n", ret);
1821                 card_fw_usable = 0;
1822         }
1823
1824         if (fw_data != NULL) {
1825                 fs_fw = (const void *)fw_data;
1826                 fs_fw_usable = fw_compatible(drv_fw, fs_fw);
1827         } else {
1828                 fs_fw = NULL;
1829                 fs_fw_usable = 0;
1830         }
1831
1832         if (card_fw_usable && card_fw->fw_ver == drv_fw->fw_ver &&
1833             (!fs_fw_usable || fs_fw->fw_ver == drv_fw->fw_ver)) {
1834                 /* Common case: the firmware on the card is an exact match and
1835                  * the filesystem one is an exact match too, or the filesystem
1836                  * one is absent/incompatible.
1837                  */
1838         } else if (fs_fw_usable && state == DEV_STATE_UNINIT &&
1839                    should_install_fs_fw(adap, card_fw_usable,
1840                                         be32_to_cpu(fs_fw->fw_ver),
1841                                         be32_to_cpu(card_fw->fw_ver))) {
1842                 ret = -t4_fw_upgrade(adap, adap->mbox, fw_data,
1843                                      fw_size, 0);
1844                 if (ret != 0) {
1845                         dev_err(adap->pdev_dev,
1846                                 "failed to install firmware: %d\n", ret);
1847                         goto bye;
1848                 }
1849
1850                 /* Installed successfully, update the cached header too. */
1851                 *card_fw = *fs_fw;
1852                 card_fw_usable = 1;
1853                 *reset = 0;     /* already reset as part of load_fw */
1854         }
1855
1856         if (!card_fw_usable) {
1857                 uint32_t d, c, k;
1858
1859                 d = be32_to_cpu(drv_fw->fw_ver);
1860                 c = be32_to_cpu(card_fw->fw_ver);
1861                 k = fs_fw ? be32_to_cpu(fs_fw->fw_ver) : 0;
1862
1863                 dev_err(adap->pdev_dev, "Cannot find a usable firmware: "
1864                         "chip state %d, "
1865                         "driver compiled with %d.%d.%d.%d, "
1866                         "card has %d.%d.%d.%d, filesystem has %d.%d.%d.%d\n",
1867                         state,
1868                         FW_HDR_FW_VER_MAJOR_G(d), FW_HDR_FW_VER_MINOR_G(d),
1869                         FW_HDR_FW_VER_MICRO_G(d), FW_HDR_FW_VER_BUILD_G(d),
1870                         FW_HDR_FW_VER_MAJOR_G(c), FW_HDR_FW_VER_MINOR_G(c),
1871                         FW_HDR_FW_VER_MICRO_G(c), FW_HDR_FW_VER_BUILD_G(c),
1872                         FW_HDR_FW_VER_MAJOR_G(k), FW_HDR_FW_VER_MINOR_G(k),
1873                         FW_HDR_FW_VER_MICRO_G(k), FW_HDR_FW_VER_BUILD_G(k));
1874                 ret = EINVAL;
1875                 goto bye;
1876         }
1877
1878         /* We're using whatever's on the card and it's known to be good. */
1879         adap->params.fw_vers = be32_to_cpu(card_fw->fw_ver);
1880         adap->params.tp_vers = be32_to_cpu(card_fw->tp_microcode_ver);
1881
1882 bye:
1883         return ret;
1884 }
1885
1886 /**
1887  *      t4_flash_erase_sectors - erase a range of flash sectors
1888  *      @adapter: the adapter
1889  *      @start: the first sector to erase
1890  *      @end: the last sector to erase
1891  *
1892  *      Erases the sectors in the given inclusive range.
1893  */
1894 static int t4_flash_erase_sectors(struct adapter *adapter, int start, int end)
1895 {
1896         int ret = 0;
1897
1898         if (end >= adapter->params.sf_nsec)
1899                 return -EINVAL;
1900
1901         while (start <= end) {
1902                 if ((ret = sf1_write(adapter, 1, 0, 1, SF_WR_ENABLE)) != 0 ||
1903                     (ret = sf1_write(adapter, 4, 0, 1,
1904                                      SF_ERASE_SECTOR | (start << 8))) != 0 ||
1905                     (ret = flash_wait_op(adapter, 14, 500)) != 0) {
1906                         dev_err(adapter->pdev_dev,
1907                                 "erase of flash sector %d failed, error %d\n",
1908                                 start, ret);
1909                         break;
1910                 }
1911                 start++;
1912         }
1913         t4_write_reg(adapter, SF_OP_A, 0);    /* unlock SF */
1914         return ret;
1915 }
1916
1917 /**
1918  *      t4_flash_cfg_addr - return the address of the flash configuration file
1919  *      @adapter: the adapter
1920  *
1921  *      Return the address within the flash where the Firmware Configuration
1922  *      File is stored.
1923  */
1924 unsigned int t4_flash_cfg_addr(struct adapter *adapter)
1925 {
1926         if (adapter->params.sf_size == 0x100000)
1927                 return FLASH_FPGA_CFG_START;
1928         else
1929                 return FLASH_CFG_START;
1930 }
1931
1932 /* Return TRUE if the specified firmware matches the adapter.  I.e. T4
1933  * firmware for T4 adapters, T5 firmware for T5 adapters, etc.  We go ahead
1934  * and emit an error message for mismatched firmware to save our caller the
1935  * effort ...
1936  */
1937 static bool t4_fw_matches_chip(const struct adapter *adap,
1938                                const struct fw_hdr *hdr)
1939 {
1940         /* The expression below will return FALSE for any unsupported adapter
1941          * which will keep us "honest" in the future ...
1942          */
1943         if ((is_t4(adap->params.chip) && hdr->chip == FW_HDR_CHIP_T4) ||
1944             (is_t5(adap->params.chip) && hdr->chip == FW_HDR_CHIP_T5))
1945                 return true;
1946
1947         dev_err(adap->pdev_dev,
1948                 "FW image (%d) is not suitable for this adapter (%d)\n",
1949                 hdr->chip, CHELSIO_CHIP_VERSION(adap->params.chip));
1950         return false;
1951 }
1952
1953 /**
1954  *      t4_load_fw - download firmware
1955  *      @adap: the adapter
1956  *      @fw_data: the firmware image to write
1957  *      @size: image size
1958  *
1959  *      Write the supplied firmware image to the card's serial flash.
1960  */
1961 int t4_load_fw(struct adapter *adap, const u8 *fw_data, unsigned int size)
1962 {
1963         u32 csum;
1964         int ret, addr;
1965         unsigned int i;
1966         u8 first_page[SF_PAGE_SIZE];
1967         const __be32 *p = (const __be32 *)fw_data;
1968         const struct fw_hdr *hdr = (const struct fw_hdr *)fw_data;
1969         unsigned int sf_sec_size = adap->params.sf_size / adap->params.sf_nsec;
1970         unsigned int fw_img_start = adap->params.sf_fw_start;
1971         unsigned int fw_start_sec = fw_img_start / sf_sec_size;
1972
1973         if (!size) {
1974                 dev_err(adap->pdev_dev, "FW image has no data\n");
1975                 return -EINVAL;
1976         }
1977         if (size & 511) {
1978                 dev_err(adap->pdev_dev,
1979                         "FW image size not multiple of 512 bytes\n");
1980                 return -EINVAL;
1981         }
1982         if (ntohs(hdr->len512) * 512 != size) {
1983                 dev_err(adap->pdev_dev,
1984                         "FW image size differs from size in FW header\n");
1985                 return -EINVAL;
1986         }
1987         if (size > FW_MAX_SIZE) {
1988                 dev_err(adap->pdev_dev, "FW image too large, max is %u bytes\n",
1989                         FW_MAX_SIZE);
1990                 return -EFBIG;
1991         }
1992         if (!t4_fw_matches_chip(adap, hdr))
1993                 return -EINVAL;
1994
1995         for (csum = 0, i = 0; i < size / sizeof(csum); i++)
1996                 csum += ntohl(p[i]);
1997
1998         if (csum != 0xffffffff) {
1999                 dev_err(adap->pdev_dev,
2000                         "corrupted firmware image, checksum %#x\n", csum);
2001                 return -EINVAL;
2002         }
2003
2004         i = DIV_ROUND_UP(size, sf_sec_size);        /* # of sectors spanned */
2005         ret = t4_flash_erase_sectors(adap, fw_start_sec, fw_start_sec + i - 1);
2006         if (ret)
2007                 goto out;
2008
2009         /*
2010          * We write the correct version at the end so the driver can see a bad
2011          * version if the FW write fails.  Start by writing a copy of the
2012          * first page with a bad version.
2013          */
2014         memcpy(first_page, fw_data, SF_PAGE_SIZE);
2015         ((struct fw_hdr *)first_page)->fw_ver = htonl(0xffffffff);
2016         ret = t4_write_flash(adap, fw_img_start, SF_PAGE_SIZE, first_page);
2017         if (ret)
2018                 goto out;
2019
2020         addr = fw_img_start;
2021         for (size -= SF_PAGE_SIZE; size; size -= SF_PAGE_SIZE) {
2022                 addr += SF_PAGE_SIZE;
2023                 fw_data += SF_PAGE_SIZE;
2024                 ret = t4_write_flash(adap, addr, SF_PAGE_SIZE, fw_data);
2025                 if (ret)
2026                         goto out;
2027         }
2028
2029         ret = t4_write_flash(adap,
2030                              fw_img_start + offsetof(struct fw_hdr, fw_ver),
2031                              sizeof(hdr->fw_ver), (const u8 *)&hdr->fw_ver);
2032 out:
2033         if (ret)
2034                 dev_err(adap->pdev_dev, "firmware download failed, error %d\n",
2035                         ret);
2036         else
2037                 ret = t4_get_fw_version(adap, &adap->params.fw_vers);
2038         return ret;
2039 }
2040
2041 /**
2042  *      t4_fwcache - firmware cache operation
2043  *      @adap: the adapter
2044  *      @op  : the operation (flush or flush and invalidate)
2045  */
2046 int t4_fwcache(struct adapter *adap, enum fw_params_param_dev_fwcache op)
2047 {
2048         struct fw_params_cmd c;
2049
2050         memset(&c, 0, sizeof(c));
2051         c.op_to_vfn =
2052                 cpu_to_be32(FW_CMD_OP_V(FW_PARAMS_CMD) |
2053                             FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
2054                             FW_PARAMS_CMD_PFN_V(adap->fn) |
2055                             FW_PARAMS_CMD_VFN_V(0));
2056         c.retval_len16 = cpu_to_be32(FW_LEN16(c));
2057         c.param[0].mnem =
2058                 cpu_to_be32(FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_DEV) |
2059                             FW_PARAMS_PARAM_X_V(FW_PARAMS_PARAM_DEV_FWCACHE));
2060         c.param[0].val = (__force __be32)op;
2061
2062         return t4_wr_mbox(adap, adap->mbox, &c, sizeof(c), NULL);
2063 }
2064
2065 void t4_ulprx_read_la(struct adapter *adap, u32 *la_buf)
2066 {
2067         unsigned int i, j;
2068
2069         for (i = 0; i < 8; i++) {
2070                 u32 *p = la_buf + i;
2071
2072                 t4_write_reg(adap, ULP_RX_LA_CTL_A, i);
2073                 j = t4_read_reg(adap, ULP_RX_LA_WRPTR_A);
2074                 t4_write_reg(adap, ULP_RX_LA_RDPTR_A, j);
2075                 for (j = 0; j < ULPRX_LA_SIZE; j++, p += 8)
2076                         *p = t4_read_reg(adap, ULP_RX_LA_RDDATA_A);
2077         }
2078 }
2079
2080 #define ADVERT_MASK (FW_PORT_CAP_SPEED_100M | FW_PORT_CAP_SPEED_1G |\
2081                      FW_PORT_CAP_SPEED_10G | FW_PORT_CAP_SPEED_40G | \
2082                      FW_PORT_CAP_ANEG)
2083
2084 /**
2085  *      t4_link_start - apply link configuration to MAC/PHY
2086  *      @phy: the PHY to setup
2087  *      @mac: the MAC to setup
2088  *      @lc: the requested link configuration
2089  *
2090  *      Set up a port's MAC and PHY according to a desired link configuration.
2091  *      - If the PHY can auto-negotiate first decide what to advertise, then
2092  *        enable/disable auto-negotiation as desired, and reset.
2093  *      - If the PHY does not auto-negotiate just reset it.
2094  *      - If auto-negotiation is off set the MAC to the proper speed/duplex/FC,
2095  *        otherwise do it later based on the outcome of auto-negotiation.
2096  */
2097 int t4_link_start(struct adapter *adap, unsigned int mbox, unsigned int port,
2098                   struct link_config *lc)
2099 {
2100         struct fw_port_cmd c;
2101         unsigned int fc = 0, mdi = FW_PORT_CAP_MDI_V(FW_PORT_CAP_MDI_AUTO);
2102
2103         lc->link_ok = 0;
2104         if (lc->requested_fc & PAUSE_RX)
2105                 fc |= FW_PORT_CAP_FC_RX;
2106         if (lc->requested_fc & PAUSE_TX)
2107                 fc |= FW_PORT_CAP_FC_TX;
2108
2109         memset(&c, 0, sizeof(c));
2110         c.op_to_portid = htonl(FW_CMD_OP_V(FW_PORT_CMD) | FW_CMD_REQUEST_F |
2111                                FW_CMD_EXEC_F | FW_PORT_CMD_PORTID_V(port));
2112         c.action_to_len16 = htonl(FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_L1_CFG) |
2113                                   FW_LEN16(c));
2114
2115         if (!(lc->supported & FW_PORT_CAP_ANEG)) {
2116                 c.u.l1cfg.rcap = htonl((lc->supported & ADVERT_MASK) | fc);
2117                 lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
2118         } else if (lc->autoneg == AUTONEG_DISABLE) {
2119                 c.u.l1cfg.rcap = htonl(lc->requested_speed | fc | mdi);
2120                 lc->fc = lc->requested_fc & (PAUSE_RX | PAUSE_TX);
2121         } else
2122                 c.u.l1cfg.rcap = htonl(lc->advertising | fc | mdi);
2123
2124         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
2125 }
2126
2127 /**
2128  *      t4_restart_aneg - restart autonegotiation
2129  *      @adap: the adapter
2130  *      @mbox: mbox to use for the FW command
2131  *      @port: the port id
2132  *
2133  *      Restarts autonegotiation for the selected port.
2134  */
2135 int t4_restart_aneg(struct adapter *adap, unsigned int mbox, unsigned int port)
2136 {
2137         struct fw_port_cmd c;
2138
2139         memset(&c, 0, sizeof(c));
2140         c.op_to_portid = htonl(FW_CMD_OP_V(FW_PORT_CMD) | FW_CMD_REQUEST_F |
2141                                FW_CMD_EXEC_F | FW_PORT_CMD_PORTID_V(port));
2142         c.action_to_len16 = htonl(FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_L1_CFG) |
2143                                   FW_LEN16(c));
2144         c.u.l1cfg.rcap = htonl(FW_PORT_CAP_ANEG);
2145         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
2146 }
2147
2148 typedef void (*int_handler_t)(struct adapter *adap);
2149
2150 struct intr_info {
2151         unsigned int mask;       /* bits to check in interrupt status */
2152         const char *msg;         /* message to print or NULL */
2153         short stat_idx;          /* stat counter to increment or -1 */
2154         unsigned short fatal;    /* whether the condition reported is fatal */
2155         int_handler_t int_handler; /* platform-specific int handler */
2156 };
2157
2158 /**
2159  *      t4_handle_intr_status - table driven interrupt handler
2160  *      @adapter: the adapter that generated the interrupt
2161  *      @reg: the interrupt status register to process
2162  *      @acts: table of interrupt actions
2163  *
2164  *      A table driven interrupt handler that applies a set of masks to an
2165  *      interrupt status word and performs the corresponding actions if the
2166  *      interrupts described by the mask have occurred.  The actions include
2167  *      optionally emitting a warning or alert message.  The table is terminated
2168  *      by an entry specifying mask 0.  Returns the number of fatal interrupt
2169  *      conditions.
2170  */
2171 static int t4_handle_intr_status(struct adapter *adapter, unsigned int reg,
2172                                  const struct intr_info *acts)
2173 {
2174         int fatal = 0;
2175         unsigned int mask = 0;
2176         unsigned int status = t4_read_reg(adapter, reg);
2177
2178         for ( ; acts->mask; ++acts) {
2179                 if (!(status & acts->mask))
2180                         continue;
2181                 if (acts->fatal) {
2182                         fatal++;
2183                         dev_alert(adapter->pdev_dev, "%s (0x%x)\n", acts->msg,
2184                                   status & acts->mask);
2185                 } else if (acts->msg && printk_ratelimit())
2186                         dev_warn(adapter->pdev_dev, "%s (0x%x)\n", acts->msg,
2187                                  status & acts->mask);
2188                 if (acts->int_handler)
2189                         acts->int_handler(adapter);
2190                 mask |= acts->mask;
2191         }
2192         status &= mask;
2193         if (status)                           /* clear processed interrupts */
2194                 t4_write_reg(adapter, reg, status);
2195         return fatal;
2196 }
2197
2198 /*
2199  * Interrupt handler for the PCIE module.
2200  */
2201 static void pcie_intr_handler(struct adapter *adapter)
2202 {
2203         static const struct intr_info sysbus_intr_info[] = {
2204                 { RNPP_F, "RXNP array parity error", -1, 1 },
2205                 { RPCP_F, "RXPC array parity error", -1, 1 },
2206                 { RCIP_F, "RXCIF array parity error", -1, 1 },
2207                 { RCCP_F, "Rx completions control array parity error", -1, 1 },
2208                 { RFTP_F, "RXFT array parity error", -1, 1 },
2209                 { 0 }
2210         };
2211         static const struct intr_info pcie_port_intr_info[] = {
2212                 { TPCP_F, "TXPC array parity error", -1, 1 },
2213                 { TNPP_F, "TXNP array parity error", -1, 1 },
2214                 { TFTP_F, "TXFT array parity error", -1, 1 },
2215                 { TCAP_F, "TXCA array parity error", -1, 1 },
2216                 { TCIP_F, "TXCIF array parity error", -1, 1 },
2217                 { RCAP_F, "RXCA array parity error", -1, 1 },
2218                 { OTDD_F, "outbound request TLP discarded", -1, 1 },
2219                 { RDPE_F, "Rx data parity error", -1, 1 },
2220                 { TDUE_F, "Tx uncorrectable data error", -1, 1 },
2221                 { 0 }
2222         };
2223         static const struct intr_info pcie_intr_info[] = {
2224                 { MSIADDRLPERR_F, "MSI AddrL parity error", -1, 1 },
2225                 { MSIADDRHPERR_F, "MSI AddrH parity error", -1, 1 },
2226                 { MSIDATAPERR_F, "MSI data parity error", -1, 1 },
2227                 { MSIXADDRLPERR_F, "MSI-X AddrL parity error", -1, 1 },
2228                 { MSIXADDRHPERR_F, "MSI-X AddrH parity error", -1, 1 },
2229                 { MSIXDATAPERR_F, "MSI-X data parity error", -1, 1 },
2230                 { MSIXDIPERR_F, "MSI-X DI parity error", -1, 1 },
2231                 { PIOCPLPERR_F, "PCI PIO completion FIFO parity error", -1, 1 },
2232                 { PIOREQPERR_F, "PCI PIO request FIFO parity error", -1, 1 },
2233                 { TARTAGPERR_F, "PCI PCI target tag FIFO parity error", -1, 1 },
2234                 { CCNTPERR_F, "PCI CMD channel count parity error", -1, 1 },
2235                 { CREQPERR_F, "PCI CMD channel request parity error", -1, 1 },
2236                 { CRSPPERR_F, "PCI CMD channel response parity error", -1, 1 },
2237                 { DCNTPERR_F, "PCI DMA channel count parity error", -1, 1 },
2238                 { DREQPERR_F, "PCI DMA channel request parity error", -1, 1 },
2239                 { DRSPPERR_F, "PCI DMA channel response parity error", -1, 1 },
2240                 { HCNTPERR_F, "PCI HMA channel count parity error", -1, 1 },
2241                 { HREQPERR_F, "PCI HMA channel request parity error", -1, 1 },
2242                 { HRSPPERR_F, "PCI HMA channel response parity error", -1, 1 },
2243                 { CFGSNPPERR_F, "PCI config snoop FIFO parity error", -1, 1 },
2244                 { FIDPERR_F, "PCI FID parity error", -1, 1 },
2245                 { INTXCLRPERR_F, "PCI INTx clear parity error", -1, 1 },
2246                 { MATAGPERR_F, "PCI MA tag parity error", -1, 1 },
2247                 { PIOTAGPERR_F, "PCI PIO tag parity error", -1, 1 },
2248                 { RXCPLPERR_F, "PCI Rx completion parity error", -1, 1 },
2249                 { RXWRPERR_F, "PCI Rx write parity error", -1, 1 },
2250                 { RPLPERR_F, "PCI replay buffer parity error", -1, 1 },
2251                 { PCIESINT_F, "PCI core secondary fault", -1, 1 },
2252                 { PCIEPINT_F, "PCI core primary fault", -1, 1 },
2253                 { UNXSPLCPLERR_F, "PCI unexpected split completion error",
2254                   -1, 0 },
2255                 { 0 }
2256         };
2257
2258         static struct intr_info t5_pcie_intr_info[] = {
2259                 { MSTGRPPERR_F, "Master Response Read Queue parity error",
2260                   -1, 1 },
2261                 { MSTTIMEOUTPERR_F, "Master Timeout FIFO parity error", -1, 1 },
2262                 { MSIXSTIPERR_F, "MSI-X STI SRAM parity error", -1, 1 },
2263                 { MSIXADDRLPERR_F, "MSI-X AddrL parity error", -1, 1 },
2264                 { MSIXADDRHPERR_F, "MSI-X AddrH parity error", -1, 1 },
2265                 { MSIXDATAPERR_F, "MSI-X data parity error", -1, 1 },
2266                 { MSIXDIPERR_F, "MSI-X DI parity error", -1, 1 },
2267                 { PIOCPLGRPPERR_F, "PCI PIO completion Group FIFO parity error",
2268                   -1, 1 },
2269                 { PIOREQGRPPERR_F, "PCI PIO request Group FIFO parity error",
2270                   -1, 1 },
2271                 { TARTAGPERR_F, "PCI PCI target tag FIFO parity error", -1, 1 },
2272                 { MSTTAGQPERR_F, "PCI master tag queue parity error", -1, 1 },
2273                 { CREQPERR_F, "PCI CMD channel request parity error", -1, 1 },
2274                 { CRSPPERR_F, "PCI CMD channel response parity error", -1, 1 },
2275                 { DREQWRPERR_F, "PCI DMA channel write request parity error",
2276                   -1, 1 },
2277                 { DREQPERR_F, "PCI DMA channel request parity error", -1, 1 },
2278                 { DRSPPERR_F, "PCI DMA channel response parity error", -1, 1 },
2279                 { HREQWRPERR_F, "PCI HMA channel count parity error", -1, 1 },
2280                 { HREQPERR_F, "PCI HMA channel request parity error", -1, 1 },
2281                 { HRSPPERR_F, "PCI HMA channel response parity error", -1, 1 },
2282                 { CFGSNPPERR_F, "PCI config snoop FIFO parity error", -1, 1 },
2283                 { FIDPERR_F, "PCI FID parity error", -1, 1 },
2284                 { VFIDPERR_F, "PCI INTx clear parity error", -1, 1 },
2285                 { MAGRPPERR_F, "PCI MA group FIFO parity error", -1, 1 },
2286                 { PIOTAGPERR_F, "PCI PIO tag parity error", -1, 1 },
2287                 { IPRXHDRGRPPERR_F, "PCI IP Rx header group parity error",
2288                   -1, 1 },
2289                 { IPRXDATAGRPPERR_F, "PCI IP Rx data group parity error",
2290                   -1, 1 },
2291                 { RPLPERR_F, "PCI IP replay buffer parity error", -1, 1 },
2292                 { IPSOTPERR_F, "PCI IP SOT buffer parity error", -1, 1 },
2293                 { TRGT1GRPPERR_F, "PCI TRGT1 group FIFOs parity error", -1, 1 },
2294                 { READRSPERR_F, "Outbound read error", -1, 0 },
2295                 { 0 }
2296         };
2297
2298         int fat;
2299
2300         if (is_t4(adapter->params.chip))
2301                 fat = t4_handle_intr_status(adapter,
2302                                 PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS_A,
2303                                 sysbus_intr_info) +
2304                         t4_handle_intr_status(adapter,
2305                                         PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS_A,
2306                                         pcie_port_intr_info) +
2307                         t4_handle_intr_status(adapter, PCIE_INT_CAUSE_A,
2308                                               pcie_intr_info);
2309         else
2310                 fat = t4_handle_intr_status(adapter, PCIE_INT_CAUSE_A,
2311                                             t5_pcie_intr_info);
2312
2313         if (fat)
2314                 t4_fatal_err(adapter);
2315 }
2316
2317 /*
2318  * TP interrupt handler.
2319  */
2320 static void tp_intr_handler(struct adapter *adapter)
2321 {
2322         static const struct intr_info tp_intr_info[] = {
2323                 { 0x3fffffff, "TP parity error", -1, 1 },
2324                 { FLMTXFLSTEMPTY_F, "TP out of Tx pages", -1, 1 },
2325                 { 0 }
2326         };
2327
2328         if (t4_handle_intr_status(adapter, TP_INT_CAUSE_A, tp_intr_info))
2329                 t4_fatal_err(adapter);
2330 }
2331
2332 /*
2333  * SGE interrupt handler.
2334  */
2335 static void sge_intr_handler(struct adapter *adapter)
2336 {
2337         u64 v;
2338
2339         static const struct intr_info sge_intr_info[] = {
2340                 { ERR_CPL_EXCEED_IQE_SIZE_F,
2341                   "SGE received CPL exceeding IQE size", -1, 1 },
2342                 { ERR_INVALID_CIDX_INC_F,
2343                   "SGE GTS CIDX increment too large", -1, 0 },
2344                 { ERR_CPL_OPCODE_0_F, "SGE received 0-length CPL", -1, 0 },
2345                 { DBFIFO_LP_INT_F, NULL, -1, 0, t4_db_full },
2346                 { DBFIFO_HP_INT_F, NULL, -1, 0, t4_db_full },
2347                 { ERR_DROPPED_DB_F, NULL, -1, 0, t4_db_dropped },
2348                 { ERR_DATA_CPL_ON_HIGH_QID1_F | ERR_DATA_CPL_ON_HIGH_QID0_F,
2349                   "SGE IQID > 1023 received CPL for FL", -1, 0 },
2350                 { ERR_BAD_DB_PIDX3_F, "SGE DBP 3 pidx increment too large", -1,
2351                   0 },
2352                 { ERR_BAD_DB_PIDX2_F, "SGE DBP 2 pidx increment too large", -1,
2353                   0 },
2354                 { ERR_BAD_DB_PIDX1_F, "SGE DBP 1 pidx increment too large", -1,
2355                   0 },
2356                 { ERR_BAD_DB_PIDX0_F, "SGE DBP 0 pidx increment too large", -1,
2357                   0 },
2358                 { ERR_ING_CTXT_PRIO_F,
2359                   "SGE too many priority ingress contexts", -1, 0 },
2360                 { ERR_EGR_CTXT_PRIO_F,
2361                   "SGE too many priority egress contexts", -1, 0 },
2362                 { INGRESS_SIZE_ERR_F, "SGE illegal ingress QID", -1, 0 },
2363                 { EGRESS_SIZE_ERR_F, "SGE illegal egress QID", -1, 0 },
2364                 { 0 }
2365         };
2366
2367         v = (u64)t4_read_reg(adapter, SGE_INT_CAUSE1_A) |
2368                 ((u64)t4_read_reg(adapter, SGE_INT_CAUSE2_A) << 32);
2369         if (v) {
2370                 dev_alert(adapter->pdev_dev, "SGE parity error (%#llx)\n",
2371                                 (unsigned long long)v);
2372                 t4_write_reg(adapter, SGE_INT_CAUSE1_A, v);
2373                 t4_write_reg(adapter, SGE_INT_CAUSE2_A, v >> 32);
2374         }
2375
2376         if (t4_handle_intr_status(adapter, SGE_INT_CAUSE3_A, sge_intr_info) ||
2377             v != 0)
2378                 t4_fatal_err(adapter);
2379 }
2380
2381 #define CIM_OBQ_INTR (OBQULP0PARERR_F | OBQULP1PARERR_F | OBQULP2PARERR_F |\
2382                       OBQULP3PARERR_F | OBQSGEPARERR_F | OBQNCSIPARERR_F)
2383 #define CIM_IBQ_INTR (IBQTP0PARERR_F | IBQTP1PARERR_F | IBQULPPARERR_F |\
2384                       IBQSGEHIPARERR_F | IBQSGELOPARERR_F | IBQNCSIPARERR_F)
2385
2386 /*
2387  * CIM interrupt handler.
2388  */
2389 static void cim_intr_handler(struct adapter *adapter)
2390 {
2391         static const struct intr_info cim_intr_info[] = {
2392                 { PREFDROPINT_F, "CIM control register prefetch drop", -1, 1 },
2393                 { CIM_OBQ_INTR, "CIM OBQ parity error", -1, 1 },
2394                 { CIM_IBQ_INTR, "CIM IBQ parity error", -1, 1 },
2395                 { MBUPPARERR_F, "CIM mailbox uP parity error", -1, 1 },
2396                 { MBHOSTPARERR_F, "CIM mailbox host parity error", -1, 1 },
2397                 { TIEQINPARERRINT_F, "CIM TIEQ outgoing parity error", -1, 1 },
2398                 { TIEQOUTPARERRINT_F, "CIM TIEQ incoming parity error", -1, 1 },
2399                 { 0 }
2400         };
2401         static const struct intr_info cim_upintr_info[] = {
2402                 { RSVDSPACEINT_F, "CIM reserved space access", -1, 1 },
2403                 { ILLTRANSINT_F, "CIM illegal transaction", -1, 1 },
2404                 { ILLWRINT_F, "CIM illegal write", -1, 1 },
2405                 { ILLRDINT_F, "CIM illegal read", -1, 1 },
2406                 { ILLRDBEINT_F, "CIM illegal read BE", -1, 1 },
2407                 { ILLWRBEINT_F, "CIM illegal write BE", -1, 1 },
2408                 { SGLRDBOOTINT_F, "CIM single read from boot space", -1, 1 },
2409                 { SGLWRBOOTINT_F, "CIM single write to boot space", -1, 1 },
2410                 { BLKWRBOOTINT_F, "CIM block write to boot space", -1, 1 },
2411                 { SGLRDFLASHINT_F, "CIM single read from flash space", -1, 1 },
2412                 { SGLWRFLASHINT_F, "CIM single write to flash space", -1, 1 },
2413                 { BLKWRFLASHINT_F, "CIM block write to flash space", -1, 1 },
2414                 { SGLRDEEPROMINT_F, "CIM single EEPROM read", -1, 1 },
2415                 { SGLWREEPROMINT_F, "CIM single EEPROM write", -1, 1 },
2416                 { BLKRDEEPROMINT_F, "CIM block EEPROM read", -1, 1 },
2417                 { BLKWREEPROMINT_F, "CIM block EEPROM write", -1, 1 },
2418                 { SGLRDCTLINT_F, "CIM single read from CTL space", -1, 1 },
2419                 { SGLWRCTLINT_F, "CIM single write to CTL space", -1, 1 },
2420                 { BLKRDCTLINT_F, "CIM block read from CTL space", -1, 1 },
2421                 { BLKWRCTLINT_F, "CIM block write to CTL space", -1, 1 },
2422                 { SGLRDPLINT_F, "CIM single read from PL space", -1, 1 },
2423                 { SGLWRPLINT_F, "CIM single write to PL space", -1, 1 },
2424                 { BLKRDPLINT_F, "CIM block read from PL space", -1, 1 },
2425                 { BLKWRPLINT_F, "CIM block write to PL space", -1, 1 },
2426                 { REQOVRLOOKUPINT_F, "CIM request FIFO overwrite", -1, 1 },
2427                 { RSPOVRLOOKUPINT_F, "CIM response FIFO overwrite", -1, 1 },
2428                 { TIMEOUTINT_F, "CIM PIF timeout", -1, 1 },
2429                 { TIMEOUTMAINT_F, "CIM PIF MA timeout", -1, 1 },
2430                 { 0 }
2431         };
2432
2433         int fat;
2434
2435         if (t4_read_reg(adapter, PCIE_FW_A) & PCIE_FW_ERR_F)
2436                 t4_report_fw_error(adapter);
2437
2438         fat = t4_handle_intr_status(adapter, CIM_HOST_INT_CAUSE_A,
2439                                     cim_intr_info) +
2440               t4_handle_intr_status(adapter, CIM_HOST_UPACC_INT_CAUSE_A,
2441                                     cim_upintr_info);
2442         if (fat)
2443                 t4_fatal_err(adapter);
2444 }
2445
2446 /*
2447  * ULP RX interrupt handler.
2448  */
2449 static void ulprx_intr_handler(struct adapter *adapter)
2450 {
2451         static const struct intr_info ulprx_intr_info[] = {
2452                 { 0x1800000, "ULPRX context error", -1, 1 },
2453                 { 0x7fffff, "ULPRX parity error", -1, 1 },
2454                 { 0 }
2455         };
2456
2457         if (t4_handle_intr_status(adapter, ULP_RX_INT_CAUSE_A, ulprx_intr_info))
2458                 t4_fatal_err(adapter);
2459 }
2460
2461 /*
2462  * ULP TX interrupt handler.
2463  */
2464 static void ulptx_intr_handler(struct adapter *adapter)
2465 {
2466         static const struct intr_info ulptx_intr_info[] = {
2467                 { PBL_BOUND_ERR_CH3_F, "ULPTX channel 3 PBL out of bounds", -1,
2468                   0 },
2469                 { PBL_BOUND_ERR_CH2_F, "ULPTX channel 2 PBL out of bounds", -1,
2470                   0 },
2471                 { PBL_BOUND_ERR_CH1_F, "ULPTX channel 1 PBL out of bounds", -1,
2472                   0 },
2473                 { PBL_BOUND_ERR_CH0_F, "ULPTX channel 0 PBL out of bounds", -1,
2474                   0 },
2475                 { 0xfffffff, "ULPTX parity error", -1, 1 },
2476                 { 0 }
2477         };
2478
2479         if (t4_handle_intr_status(adapter, ULP_TX_INT_CAUSE_A, ulptx_intr_info))
2480                 t4_fatal_err(adapter);
2481 }
2482
2483 /*
2484  * PM TX interrupt handler.
2485  */
2486 static void pmtx_intr_handler(struct adapter *adapter)
2487 {
2488         static const struct intr_info pmtx_intr_info[] = {
2489                 { PCMD_LEN_OVFL0_F, "PMTX channel 0 pcmd too large", -1, 1 },
2490                 { PCMD_LEN_OVFL1_F, "PMTX channel 1 pcmd too large", -1, 1 },
2491                 { PCMD_LEN_OVFL2_F, "PMTX channel 2 pcmd too large", -1, 1 },
2492                 { ZERO_C_CMD_ERROR_F, "PMTX 0-length pcmd", -1, 1 },
2493                 { PMTX_FRAMING_ERROR_F, "PMTX framing error", -1, 1 },
2494                 { OESPI_PAR_ERROR_F, "PMTX oespi parity error", -1, 1 },
2495                 { DB_OPTIONS_PAR_ERROR_F, "PMTX db_options parity error",
2496                   -1, 1 },
2497                 { ICSPI_PAR_ERROR_F, "PMTX icspi parity error", -1, 1 },
2498                 { PMTX_C_PCMD_PAR_ERROR_F, "PMTX c_pcmd parity error", -1, 1},
2499                 { 0 }
2500         };
2501
2502         if (t4_handle_intr_status(adapter, PM_TX_INT_CAUSE_A, pmtx_intr_info))
2503                 t4_fatal_err(adapter);
2504 }
2505
2506 /*
2507  * PM RX interrupt handler.
2508  */
2509 static void pmrx_intr_handler(struct adapter *adapter)
2510 {
2511         static const struct intr_info pmrx_intr_info[] = {
2512                 { ZERO_E_CMD_ERROR_F, "PMRX 0-length pcmd", -1, 1 },
2513                 { PMRX_FRAMING_ERROR_F, "PMRX framing error", -1, 1 },
2514                 { OCSPI_PAR_ERROR_F, "PMRX ocspi parity error", -1, 1 },
2515                 { DB_OPTIONS_PAR_ERROR_F, "PMRX db_options parity error",
2516                   -1, 1 },
2517                 { IESPI_PAR_ERROR_F, "PMRX iespi parity error", -1, 1 },
2518                 { PMRX_E_PCMD_PAR_ERROR_F, "PMRX e_pcmd parity error", -1, 1},
2519                 { 0 }
2520         };
2521
2522         if (t4_handle_intr_status(adapter, PM_RX_INT_CAUSE_A, pmrx_intr_info))
2523                 t4_fatal_err(adapter);
2524 }
2525
2526 /*
2527  * CPL switch interrupt handler.
2528  */
2529 static void cplsw_intr_handler(struct adapter *adapter)
2530 {
2531         static const struct intr_info cplsw_intr_info[] = {
2532                 { CIM_OP_MAP_PERR_F, "CPLSW CIM op_map parity error", -1, 1 },
2533                 { CIM_OVFL_ERROR_F, "CPLSW CIM overflow", -1, 1 },
2534                 { TP_FRAMING_ERROR_F, "CPLSW TP framing error", -1, 1 },
2535                 { SGE_FRAMING_ERROR_F, "CPLSW SGE framing error", -1, 1 },
2536                 { CIM_FRAMING_ERROR_F, "CPLSW CIM framing error", -1, 1 },
2537                 { ZERO_SWITCH_ERROR_F, "CPLSW no-switch error", -1, 1 },
2538                 { 0 }
2539         };
2540
2541         if (t4_handle_intr_status(adapter, CPL_INTR_CAUSE_A, cplsw_intr_info))
2542                 t4_fatal_err(adapter);
2543 }
2544
2545 /*
2546  * LE interrupt handler.
2547  */
2548 static void le_intr_handler(struct adapter *adap)
2549 {
2550         static const struct intr_info le_intr_info[] = {
2551                 { LIPMISS_F, "LE LIP miss", -1, 0 },
2552                 { LIP0_F, "LE 0 LIP error", -1, 0 },
2553                 { PARITYERR_F, "LE parity error", -1, 1 },
2554                 { UNKNOWNCMD_F, "LE unknown command", -1, 1 },
2555                 { REQQPARERR_F, "LE request queue parity error", -1, 1 },
2556                 { 0 }
2557         };
2558
2559         if (t4_handle_intr_status(adap, LE_DB_INT_CAUSE_A, le_intr_info))
2560                 t4_fatal_err(adap);
2561 }
2562
2563 /*
2564  * MPS interrupt handler.
2565  */
2566 static void mps_intr_handler(struct adapter *adapter)
2567 {
2568         static const struct intr_info mps_rx_intr_info[] = {
2569                 { 0xffffff, "MPS Rx parity error", -1, 1 },
2570                 { 0 }
2571         };
2572         static const struct intr_info mps_tx_intr_info[] = {
2573                 { TPFIFO_V(TPFIFO_M), "MPS Tx TP FIFO parity error", -1, 1 },
2574                 { NCSIFIFO_F, "MPS Tx NC-SI FIFO parity error", -1, 1 },
2575                 { TXDATAFIFO_V(TXDATAFIFO_M), "MPS Tx data FIFO parity error",
2576                   -1, 1 },
2577                 { TXDESCFIFO_V(TXDESCFIFO_M), "MPS Tx desc FIFO parity error",
2578                   -1, 1 },
2579                 { BUBBLE_F, "MPS Tx underflow", -1, 1 },
2580                 { SECNTERR_F, "MPS Tx SOP/EOP error", -1, 1 },
2581                 { FRMERR_F, "MPS Tx framing error", -1, 1 },
2582                 { 0 }
2583         };
2584         static const struct intr_info mps_trc_intr_info[] = {
2585                 { FILTMEM_V(FILTMEM_M), "MPS TRC filter parity error", -1, 1 },
2586                 { PKTFIFO_V(PKTFIFO_M), "MPS TRC packet FIFO parity error",
2587                   -1, 1 },
2588                 { MISCPERR_F, "MPS TRC misc parity error", -1, 1 },
2589                 { 0 }
2590         };
2591         static const struct intr_info mps_stat_sram_intr_info[] = {
2592                 { 0x1fffff, "MPS statistics SRAM parity error", -1, 1 },
2593                 { 0 }
2594         };
2595         static const struct intr_info mps_stat_tx_intr_info[] = {
2596                 { 0xfffff, "MPS statistics Tx FIFO parity error", -1, 1 },
2597                 { 0 }
2598         };
2599         static const struct intr_info mps_stat_rx_intr_info[] = {
2600                 { 0xffffff, "MPS statistics Rx FIFO parity error", -1, 1 },
2601                 { 0 }
2602         };
2603         static const struct intr_info mps_cls_intr_info[] = {
2604                 { MATCHSRAM_F, "MPS match SRAM parity error", -1, 1 },
2605                 { MATCHTCAM_F, "MPS match TCAM parity error", -1, 1 },
2606                 { HASHSRAM_F, "MPS hash SRAM parity error", -1, 1 },
2607                 { 0 }
2608         };
2609
2610         int fat;
2611
2612         fat = t4_handle_intr_status(adapter, MPS_RX_PERR_INT_CAUSE_A,
2613                                     mps_rx_intr_info) +
2614               t4_handle_intr_status(adapter, MPS_TX_INT_CAUSE_A,
2615                                     mps_tx_intr_info) +
2616               t4_handle_intr_status(adapter, MPS_TRC_INT_CAUSE_A,
2617                                     mps_trc_intr_info) +
2618               t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_SRAM_A,
2619                                     mps_stat_sram_intr_info) +
2620               t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_TX_FIFO_A,
2621                                     mps_stat_tx_intr_info) +
2622               t4_handle_intr_status(adapter, MPS_STAT_PERR_INT_CAUSE_RX_FIFO_A,
2623                                     mps_stat_rx_intr_info) +
2624               t4_handle_intr_status(adapter, MPS_CLS_INT_CAUSE_A,
2625                                     mps_cls_intr_info);
2626
2627         t4_write_reg(adapter, MPS_INT_CAUSE_A, 0);
2628         t4_read_reg(adapter, MPS_INT_CAUSE_A);                    /* flush */
2629         if (fat)
2630                 t4_fatal_err(adapter);
2631 }
2632
2633 #define MEM_INT_MASK (PERR_INT_CAUSE_F | ECC_CE_INT_CAUSE_F | \
2634                       ECC_UE_INT_CAUSE_F)
2635
2636 /*
2637  * EDC/MC interrupt handler.
2638  */
2639 static void mem_intr_handler(struct adapter *adapter, int idx)
2640 {
2641         static const char name[4][7] = { "EDC0", "EDC1", "MC/MC0", "MC1" };
2642
2643         unsigned int addr, cnt_addr, v;
2644
2645         if (idx <= MEM_EDC1) {
2646                 addr = EDC_REG(EDC_INT_CAUSE_A, idx);
2647                 cnt_addr = EDC_REG(EDC_ECC_STATUS_A, idx);
2648         } else if (idx == MEM_MC) {
2649                 if (is_t4(adapter->params.chip)) {
2650                         addr = MC_INT_CAUSE_A;
2651                         cnt_addr = MC_ECC_STATUS_A;
2652                 } else {
2653                         addr = MC_P_INT_CAUSE_A;
2654                         cnt_addr = MC_P_ECC_STATUS_A;
2655                 }
2656         } else {
2657                 addr = MC_REG(MC_P_INT_CAUSE_A, 1);
2658                 cnt_addr = MC_REG(MC_P_ECC_STATUS_A, 1);
2659         }
2660
2661         v = t4_read_reg(adapter, addr) & MEM_INT_MASK;
2662         if (v & PERR_INT_CAUSE_F)
2663                 dev_alert(adapter->pdev_dev, "%s FIFO parity error\n",
2664                           name[idx]);
2665         if (v & ECC_CE_INT_CAUSE_F) {
2666                 u32 cnt = ECC_CECNT_G(t4_read_reg(adapter, cnt_addr));
2667
2668                 t4_write_reg(adapter, cnt_addr, ECC_CECNT_V(ECC_CECNT_M));
2669                 if (printk_ratelimit())
2670                         dev_warn(adapter->pdev_dev,
2671                                  "%u %s correctable ECC data error%s\n",
2672                                  cnt, name[idx], cnt > 1 ? "s" : "");
2673         }
2674         if (v & ECC_UE_INT_CAUSE_F)
2675                 dev_alert(adapter->pdev_dev,
2676                           "%s uncorrectable ECC data error\n", name[idx]);
2677
2678         t4_write_reg(adapter, addr, v);
2679         if (v & (PERR_INT_CAUSE_F | ECC_UE_INT_CAUSE_F))
2680                 t4_fatal_err(adapter);
2681 }
2682
2683 /*
2684  * MA interrupt handler.
2685  */
2686 static void ma_intr_handler(struct adapter *adap)
2687 {
2688         u32 v, status = t4_read_reg(adap, MA_INT_CAUSE_A);
2689
2690         if (status & MEM_PERR_INT_CAUSE_F) {
2691                 dev_alert(adap->pdev_dev,
2692                           "MA parity error, parity status %#x\n",
2693                           t4_read_reg(adap, MA_PARITY_ERROR_STATUS1_A));
2694                 if (is_t5(adap->params.chip))
2695                         dev_alert(adap->pdev_dev,
2696                                   "MA parity error, parity status %#x\n",
2697                                   t4_read_reg(adap,
2698                                               MA_PARITY_ERROR_STATUS2_A));
2699         }
2700         if (status & MEM_WRAP_INT_CAUSE_F) {
2701                 v = t4_read_reg(adap, MA_INT_WRAP_STATUS_A);
2702                 dev_alert(adap->pdev_dev, "MA address wrap-around error by "
2703                           "client %u to address %#x\n",
2704                           MEM_WRAP_CLIENT_NUM_G(v),
2705                           MEM_WRAP_ADDRESS_G(v) << 4);
2706         }
2707         t4_write_reg(adap, MA_INT_CAUSE_A, status);
2708         t4_fatal_err(adap);
2709 }
2710
2711 /*
2712  * SMB interrupt handler.
2713  */
2714 static void smb_intr_handler(struct adapter *adap)
2715 {
2716         static const struct intr_info smb_intr_info[] = {
2717                 { MSTTXFIFOPARINT_F, "SMB master Tx FIFO parity error", -1, 1 },
2718                 { MSTRXFIFOPARINT_F, "SMB master Rx FIFO parity error", -1, 1 },
2719                 { SLVFIFOPARINT_F, "SMB slave FIFO parity error", -1, 1 },
2720                 { 0 }
2721         };
2722
2723         if (t4_handle_intr_status(adap, SMB_INT_CAUSE_A, smb_intr_info))
2724                 t4_fatal_err(adap);
2725 }
2726
2727 /*
2728  * NC-SI interrupt handler.
2729  */
2730 static void ncsi_intr_handler(struct adapter *adap)
2731 {
2732         static const struct intr_info ncsi_intr_info[] = {
2733                 { CIM_DM_PRTY_ERR_F, "NC-SI CIM parity error", -1, 1 },
2734                 { MPS_DM_PRTY_ERR_F, "NC-SI MPS parity error", -1, 1 },
2735                 { TXFIFO_PRTY_ERR_F, "NC-SI Tx FIFO parity error", -1, 1 },
2736                 { RXFIFO_PRTY_ERR_F, "NC-SI Rx FIFO parity error", -1, 1 },
2737                 { 0 }
2738         };
2739
2740         if (t4_handle_intr_status(adap, NCSI_INT_CAUSE_A, ncsi_intr_info))
2741                 t4_fatal_err(adap);
2742 }
2743
2744 /*
2745  * XGMAC interrupt handler.
2746  */
2747 static void xgmac_intr_handler(struct adapter *adap, int port)
2748 {
2749         u32 v, int_cause_reg;
2750
2751         if (is_t4(adap->params.chip))
2752                 int_cause_reg = PORT_REG(port, XGMAC_PORT_INT_CAUSE_A);
2753         else
2754                 int_cause_reg = T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A);
2755
2756         v = t4_read_reg(adap, int_cause_reg);
2757
2758         v &= TXFIFO_PRTY_ERR_F | RXFIFO_PRTY_ERR_F;
2759         if (!v)
2760                 return;
2761
2762         if (v & TXFIFO_PRTY_ERR_F)
2763                 dev_alert(adap->pdev_dev, "XGMAC %d Tx FIFO parity error\n",
2764                           port);
2765         if (v & RXFIFO_PRTY_ERR_F)
2766                 dev_alert(adap->pdev_dev, "XGMAC %d Rx FIFO parity error\n",
2767                           port);
2768         t4_write_reg(adap, PORT_REG(port, XGMAC_PORT_INT_CAUSE_A), v);
2769         t4_fatal_err(adap);
2770 }
2771
2772 /*
2773  * PL interrupt handler.
2774  */
2775 static void pl_intr_handler(struct adapter *adap)
2776 {
2777         static const struct intr_info pl_intr_info[] = {
2778                 { FATALPERR_F, "T4 fatal parity error", -1, 1 },
2779                 { PERRVFID_F, "PL VFID_MAP parity error", -1, 1 },
2780                 { 0 }
2781         };
2782
2783         if (t4_handle_intr_status(adap, PL_PL_INT_CAUSE_A, pl_intr_info))
2784                 t4_fatal_err(adap);
2785 }
2786
2787 #define PF_INTR_MASK (PFSW_F)
2788 #define GLBL_INTR_MASK (CIM_F | MPS_F | PL_F | PCIE_F | MC_F | EDC0_F | \
2789                 EDC1_F | LE_F | TP_F | MA_F | PM_TX_F | PM_RX_F | ULP_RX_F | \
2790                 CPL_SWITCH_F | SGE_F | ULP_TX_F)
2791
2792 /**
2793  *      t4_slow_intr_handler - control path interrupt handler
2794  *      @adapter: the adapter
2795  *
2796  *      T4 interrupt handler for non-data global interrupt events, e.g., errors.
2797  *      The designation 'slow' is because it involves register reads, while
2798  *      data interrupts typically don't involve any MMIOs.
2799  */
2800 int t4_slow_intr_handler(struct adapter *adapter)
2801 {
2802         u32 cause = t4_read_reg(adapter, PL_INT_CAUSE_A);
2803
2804         if (!(cause & GLBL_INTR_MASK))
2805                 return 0;
2806         if (cause & CIM_F)
2807                 cim_intr_handler(adapter);
2808         if (cause & MPS_F)
2809                 mps_intr_handler(adapter);
2810         if (cause & NCSI_F)
2811                 ncsi_intr_handler(adapter);
2812         if (cause & PL_F)
2813                 pl_intr_handler(adapter);
2814         if (cause & SMB_F)
2815                 smb_intr_handler(adapter);
2816         if (cause & XGMAC0_F)
2817                 xgmac_intr_handler(adapter, 0);
2818         if (cause & XGMAC1_F)
2819                 xgmac_intr_handler(adapter, 1);
2820         if (cause & XGMAC_KR0_F)
2821                 xgmac_intr_handler(adapter, 2);
2822         if (cause & XGMAC_KR1_F)
2823                 xgmac_intr_handler(adapter, 3);
2824         if (cause & PCIE_F)
2825                 pcie_intr_handler(adapter);
2826         if (cause & MC_F)
2827                 mem_intr_handler(adapter, MEM_MC);
2828         if (!is_t4(adapter->params.chip) && (cause & MC1_S))
2829                 mem_intr_handler(adapter, MEM_MC1);
2830         if (cause & EDC0_F)
2831                 mem_intr_handler(adapter, MEM_EDC0);
2832         if (cause & EDC1_F)
2833                 mem_intr_handler(adapter, MEM_EDC1);
2834         if (cause & LE_F)
2835                 le_intr_handler(adapter);
2836         if (cause & TP_F)
2837                 tp_intr_handler(adapter);
2838         if (cause & MA_F)
2839                 ma_intr_handler(adapter);
2840         if (cause & PM_TX_F)
2841                 pmtx_intr_handler(adapter);
2842         if (cause & PM_RX_F)
2843                 pmrx_intr_handler(adapter);
2844         if (cause & ULP_RX_F)
2845                 ulprx_intr_handler(adapter);
2846         if (cause & CPL_SWITCH_F)
2847                 cplsw_intr_handler(adapter);
2848         if (cause & SGE_F)
2849                 sge_intr_handler(adapter);
2850         if (cause & ULP_TX_F)
2851                 ulptx_intr_handler(adapter);
2852
2853         /* Clear the interrupts just processed for which we are the master. */
2854         t4_write_reg(adapter, PL_INT_CAUSE_A, cause & GLBL_INTR_MASK);
2855         (void)t4_read_reg(adapter, PL_INT_CAUSE_A); /* flush */
2856         return 1;
2857 }
2858
2859 /**
2860  *      t4_intr_enable - enable interrupts
2861  *      @adapter: the adapter whose interrupts should be enabled
2862  *
2863  *      Enable PF-specific interrupts for the calling function and the top-level
2864  *      interrupt concentrator for global interrupts.  Interrupts are already
2865  *      enabled at each module, here we just enable the roots of the interrupt
2866  *      hierarchies.
2867  *
2868  *      Note: this function should be called only when the driver manages
2869  *      non PF-specific interrupts from the various HW modules.  Only one PCI
2870  *      function at a time should be doing this.
2871  */
2872 void t4_intr_enable(struct adapter *adapter)
2873 {
2874         u32 pf = SOURCEPF_G(t4_read_reg(adapter, PL_WHOAMI_A));
2875
2876         t4_write_reg(adapter, SGE_INT_ENABLE3_A, ERR_CPL_EXCEED_IQE_SIZE_F |
2877                      ERR_INVALID_CIDX_INC_F | ERR_CPL_OPCODE_0_F |
2878                      ERR_DROPPED_DB_F | ERR_DATA_CPL_ON_HIGH_QID1_F |
2879                      ERR_DATA_CPL_ON_HIGH_QID0_F | ERR_BAD_DB_PIDX3_F |
2880                      ERR_BAD_DB_PIDX2_F | ERR_BAD_DB_PIDX1_F |
2881                      ERR_BAD_DB_PIDX0_F | ERR_ING_CTXT_PRIO_F |
2882                      ERR_EGR_CTXT_PRIO_F | INGRESS_SIZE_ERR_F |
2883                      DBFIFO_HP_INT_F | DBFIFO_LP_INT_F |
2884                      EGRESS_SIZE_ERR_F);
2885         t4_write_reg(adapter, MYPF_REG(PL_PF_INT_ENABLE_A), PF_INTR_MASK);
2886         t4_set_reg_field(adapter, PL_INT_MAP0_A, 0, 1 << pf);
2887 }
2888
2889 /**
2890  *      t4_intr_disable - disable interrupts
2891  *      @adapter: the adapter whose interrupts should be disabled
2892  *
2893  *      Disable interrupts.  We only disable the top-level interrupt
2894  *      concentrators.  The caller must be a PCI function managing global
2895  *      interrupts.
2896  */
2897 void t4_intr_disable(struct adapter *adapter)
2898 {
2899         u32 pf = SOURCEPF_G(t4_read_reg(adapter, PL_WHOAMI_A));
2900
2901         t4_write_reg(adapter, MYPF_REG(PL_PF_INT_ENABLE_A), 0);
2902         t4_set_reg_field(adapter, PL_INT_MAP0_A, 1 << pf, 0);
2903 }
2904
2905 /**
2906  *      hash_mac_addr - return the hash value of a MAC address
2907  *      @addr: the 48-bit Ethernet MAC address
2908  *
2909  *      Hashes a MAC address according to the hash function used by HW inexact
2910  *      (hash) address matching.
2911  */
2912 static int hash_mac_addr(const u8 *addr)
2913 {
2914         u32 a = ((u32)addr[0] << 16) | ((u32)addr[1] << 8) | addr[2];
2915         u32 b = ((u32)addr[3] << 16) | ((u32)addr[4] << 8) | addr[5];
2916         a ^= b;
2917         a ^= (a >> 12);
2918         a ^= (a >> 6);
2919         return a & 0x3f;
2920 }
2921
2922 /**
2923  *      t4_config_rss_range - configure a portion of the RSS mapping table
2924  *      @adapter: the adapter
2925  *      @mbox: mbox to use for the FW command
2926  *      @viid: virtual interface whose RSS subtable is to be written
2927  *      @start: start entry in the table to write
2928  *      @n: how many table entries to write
2929  *      @rspq: values for the response queue lookup table
2930  *      @nrspq: number of values in @rspq
2931  *
2932  *      Programs the selected part of the VI's RSS mapping table with the
2933  *      provided values.  If @nrspq < @n the supplied values are used repeatedly
2934  *      until the full table range is populated.
2935  *
2936  *      The caller must ensure the values in @rspq are in the range allowed for
2937  *      @viid.
2938  */
2939 int t4_config_rss_range(struct adapter *adapter, int mbox, unsigned int viid,
2940                         int start, int n, const u16 *rspq, unsigned int nrspq)
2941 {
2942         int ret;
2943         const u16 *rsp = rspq;
2944         const u16 *rsp_end = rspq + nrspq;
2945         struct fw_rss_ind_tbl_cmd cmd;
2946
2947         memset(&cmd, 0, sizeof(cmd));
2948         cmd.op_to_viid = htonl(FW_CMD_OP_V(FW_RSS_IND_TBL_CMD) |
2949                                FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
2950                                FW_RSS_IND_TBL_CMD_VIID_V(viid));
2951         cmd.retval_len16 = htonl(FW_LEN16(cmd));
2952
2953         /* each fw_rss_ind_tbl_cmd takes up to 32 entries */
2954         while (n > 0) {
2955                 int nq = min(n, 32);
2956                 __be32 *qp = &cmd.iq0_to_iq2;
2957
2958                 cmd.niqid = htons(nq);
2959                 cmd.startidx = htons(start);
2960
2961                 start += nq;
2962                 n -= nq;
2963
2964                 while (nq > 0) {
2965                         unsigned int v;
2966
2967                         v = FW_RSS_IND_TBL_CMD_IQ0_V(*rsp);
2968                         if (++rsp >= rsp_end)
2969                                 rsp = rspq;
2970                         v |= FW_RSS_IND_TBL_CMD_IQ1_V(*rsp);
2971                         if (++rsp >= rsp_end)
2972                                 rsp = rspq;
2973                         v |= FW_RSS_IND_TBL_CMD_IQ2_V(*rsp);
2974                         if (++rsp >= rsp_end)
2975                                 rsp = rspq;
2976
2977                         *qp++ = htonl(v);
2978                         nq -= 3;
2979                 }
2980
2981                 ret = t4_wr_mbox(adapter, mbox, &cmd, sizeof(cmd), NULL);
2982                 if (ret)
2983                         return ret;
2984         }
2985         return 0;
2986 }
2987
2988 /**
2989  *      t4_config_glbl_rss - configure the global RSS mode
2990  *      @adapter: the adapter
2991  *      @mbox: mbox to use for the FW command
2992  *      @mode: global RSS mode
2993  *      @flags: mode-specific flags
2994  *
2995  *      Sets the global RSS mode.
2996  */
2997 int t4_config_glbl_rss(struct adapter *adapter, int mbox, unsigned int mode,
2998                        unsigned int flags)
2999 {
3000         struct fw_rss_glb_config_cmd c;
3001
3002         memset(&c, 0, sizeof(c));
3003         c.op_to_write = htonl(FW_CMD_OP_V(FW_RSS_GLB_CONFIG_CMD) |
3004                               FW_CMD_REQUEST_F | FW_CMD_WRITE_F);
3005         c.retval_len16 = htonl(FW_LEN16(c));
3006         if (mode == FW_RSS_GLB_CONFIG_CMD_MODE_MANUAL) {
3007                 c.u.manual.mode_pkd = htonl(FW_RSS_GLB_CONFIG_CMD_MODE_V(mode));
3008         } else if (mode == FW_RSS_GLB_CONFIG_CMD_MODE_BASICVIRTUAL) {
3009                 c.u.basicvirtual.mode_pkd =
3010                         htonl(FW_RSS_GLB_CONFIG_CMD_MODE_V(mode));
3011                 c.u.basicvirtual.synmapen_to_hashtoeplitz = htonl(flags);
3012         } else
3013                 return -EINVAL;
3014         return t4_wr_mbox(adapter, mbox, &c, sizeof(c), NULL);
3015 }
3016
3017 /* Read an RSS table row */
3018 static int rd_rss_row(struct adapter *adap, int row, u32 *val)
3019 {
3020         t4_write_reg(adap, TP_RSS_LKP_TABLE_A, 0xfff00000 | row);
3021         return t4_wait_op_done_val(adap, TP_RSS_LKP_TABLE_A, LKPTBLROWVLD_F, 1,
3022                                    5, 0, val);
3023 }
3024
3025 /**
3026  *      t4_read_rss - read the contents of the RSS mapping table
3027  *      @adapter: the adapter
3028  *      @map: holds the contents of the RSS mapping table
3029  *
3030  *      Reads the contents of the RSS hash->queue mapping table.
3031  */
3032 int t4_read_rss(struct adapter *adapter, u16 *map)
3033 {
3034         u32 val;
3035         int i, ret;
3036
3037         for (i = 0; i < RSS_NENTRIES / 2; ++i) {
3038                 ret = rd_rss_row(adapter, i, &val);
3039                 if (ret)
3040                         return ret;
3041                 *map++ = LKPTBLQUEUE0_G(val);
3042                 *map++ = LKPTBLQUEUE1_G(val);
3043         }
3044         return 0;
3045 }
3046
3047 /**
3048  *      t4_read_rss_key - read the global RSS key
3049  *      @adap: the adapter
3050  *      @key: 10-entry array holding the 320-bit RSS key
3051  *
3052  *      Reads the global 320-bit RSS key.
3053  */
3054 void t4_read_rss_key(struct adapter *adap, u32 *key)
3055 {
3056         t4_read_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A, key, 10,
3057                          TP_RSS_SECRET_KEY0_A);
3058 }
3059
3060 /**
3061  *      t4_write_rss_key - program one of the RSS keys
3062  *      @adap: the adapter
3063  *      @key: 10-entry array holding the 320-bit RSS key
3064  *      @idx: which RSS key to write
3065  *
3066  *      Writes one of the RSS keys with the given 320-bit value.  If @idx is
3067  *      0..15 the corresponding entry in the RSS key table is written,
3068  *      otherwise the global RSS key is written.
3069  */
3070 void t4_write_rss_key(struct adapter *adap, const u32 *key, int idx)
3071 {
3072         t4_write_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A, key, 10,
3073                           TP_RSS_SECRET_KEY0_A);
3074         if (idx >= 0 && idx < 16)
3075                 t4_write_reg(adap, TP_RSS_CONFIG_VRT_A,
3076                              KEYWRADDR_V(idx) | KEYWREN_F);
3077 }
3078
3079 /**
3080  *      t4_read_rss_pf_config - read PF RSS Configuration Table
3081  *      @adapter: the adapter
3082  *      @index: the entry in the PF RSS table to read
3083  *      @valp: where to store the returned value
3084  *
3085  *      Reads the PF RSS Configuration Table at the specified index and returns
3086  *      the value found there.
3087  */
3088 void t4_read_rss_pf_config(struct adapter *adapter, unsigned int index,
3089                            u32 *valp)
3090 {
3091         t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
3092                          valp, 1, TP_RSS_PF0_CONFIG_A + index);
3093 }
3094
3095 /**
3096  *      t4_read_rss_vf_config - read VF RSS Configuration Table
3097  *      @adapter: the adapter
3098  *      @index: the entry in the VF RSS table to read
3099  *      @vfl: where to store the returned VFL
3100  *      @vfh: where to store the returned VFH
3101  *
3102  *      Reads the VF RSS Configuration Table at the specified index and returns
3103  *      the (VFL, VFH) values found there.
3104  */
3105 void t4_read_rss_vf_config(struct adapter *adapter, unsigned int index,
3106                            u32 *vfl, u32 *vfh)
3107 {
3108         u32 vrt, mask, data;
3109
3110         mask = VFWRADDR_V(VFWRADDR_M);
3111         data = VFWRADDR_V(index);
3112
3113         /* Request that the index'th VF Table values be read into VFL/VFH.
3114          */
3115         vrt = t4_read_reg(adapter, TP_RSS_CONFIG_VRT_A);
3116         vrt &= ~(VFRDRG_F | VFWREN_F | KEYWREN_F | mask);
3117         vrt |= data | VFRDEN_F;
3118         t4_write_reg(adapter, TP_RSS_CONFIG_VRT_A, vrt);
3119
3120         /* Grab the VFL/VFH values ...
3121          */
3122         t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
3123                          vfl, 1, TP_RSS_VFL_CONFIG_A);
3124         t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
3125                          vfh, 1, TP_RSS_VFH_CONFIG_A);
3126 }
3127
3128 /**
3129  *      t4_read_rss_pf_map - read PF RSS Map
3130  *      @adapter: the adapter
3131  *
3132  *      Reads the PF RSS Map register and returns its value.
3133  */
3134 u32 t4_read_rss_pf_map(struct adapter *adapter)
3135 {
3136         u32 pfmap;
3137
3138         t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
3139                          &pfmap, 1, TP_RSS_PF_MAP_A);
3140         return pfmap;
3141 }
3142
3143 /**
3144  *      t4_read_rss_pf_mask - read PF RSS Mask
3145  *      @adapter: the adapter
3146  *
3147  *      Reads the PF RSS Mask register and returns its value.
3148  */
3149 u32 t4_read_rss_pf_mask(struct adapter *adapter)
3150 {
3151         u32 pfmask;
3152
3153         t4_read_indirect(adapter, TP_PIO_ADDR_A, TP_PIO_DATA_A,
3154                          &pfmask, 1, TP_RSS_PF_MSK_A);
3155         return pfmask;
3156 }
3157
3158 /**
3159  *      t4_tp_get_tcp_stats - read TP's TCP MIB counters
3160  *      @adap: the adapter
3161  *      @v4: holds the TCP/IP counter values
3162  *      @v6: holds the TCP/IPv6 counter values
3163  *
3164  *      Returns the values of TP's TCP/IP and TCP/IPv6 MIB counters.
3165  *      Either @v4 or @v6 may be %NULL to skip the corresponding stats.
3166  */
3167 void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4,
3168                          struct tp_tcp_stats *v6)
3169 {
3170         u32 val[TP_MIB_TCP_RXT_SEG_LO_A - TP_MIB_TCP_OUT_RST_A + 1];
3171
3172 #define STAT_IDX(x) ((TP_MIB_TCP_##x##_A) - TP_MIB_TCP_OUT_RST_A)
3173 #define STAT(x)     val[STAT_IDX(x)]
3174 #define STAT64(x)   (((u64)STAT(x##_HI) << 32) | STAT(x##_LO))
3175
3176         if (v4) {
3177                 t4_read_indirect(adap, TP_MIB_INDEX_A, TP_MIB_DATA_A, val,
3178                                  ARRAY_SIZE(val), TP_MIB_TCP_OUT_RST_A);
3179                 v4->tcpOutRsts = STAT(OUT_RST);
3180                 v4->tcpInSegs  = STAT64(IN_SEG);
3181                 v4->tcpOutSegs = STAT64(OUT_SEG);
3182                 v4->tcpRetransSegs = STAT64(RXT_SEG);
3183         }
3184         if (v6) {
3185                 t4_read_indirect(adap, TP_MIB_INDEX_A, TP_MIB_DATA_A, val,
3186                                  ARRAY_SIZE(val), TP_MIB_TCP_V6OUT_RST_A);
3187                 v6->tcpOutRsts = STAT(OUT_RST);
3188                 v6->tcpInSegs  = STAT64(IN_SEG);
3189                 v6->tcpOutSegs = STAT64(OUT_SEG);
3190                 v6->tcpRetransSegs = STAT64(RXT_SEG);
3191         }
3192 #undef STAT64
3193 #undef STAT
3194 #undef STAT_IDX
3195 }
3196
3197 /**
3198  *      t4_read_mtu_tbl - returns the values in the HW path MTU table
3199  *      @adap: the adapter
3200  *      @mtus: where to store the MTU values
3201  *      @mtu_log: where to store the MTU base-2 log (may be %NULL)
3202  *
3203  *      Reads the HW path MTU table.
3204  */
3205 void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log)
3206 {
3207         u32 v;
3208         int i;
3209
3210         for (i = 0; i < NMTUS; ++i) {
3211                 t4_write_reg(adap, TP_MTU_TABLE_A,
3212                              MTUINDEX_V(0xff) | MTUVALUE_V(i));
3213                 v = t4_read_reg(adap, TP_MTU_TABLE_A);
3214                 mtus[i] = MTUVALUE_G(v);
3215                 if (mtu_log)
3216                         mtu_log[i] = MTUWIDTH_G(v);
3217         }
3218 }
3219
3220 /**
3221  *      t4_read_cong_tbl - reads the congestion control table
3222  *      @adap: the adapter
3223  *      @incr: where to store the alpha values
3224  *
3225  *      Reads the additive increments programmed into the HW congestion
3226  *      control table.
3227  */
3228 void t4_read_cong_tbl(struct adapter *adap, u16 incr[NMTUS][NCCTRL_WIN])
3229 {
3230         unsigned int mtu, w;
3231
3232         for (mtu = 0; mtu < NMTUS; ++mtu)
3233                 for (w = 0; w < NCCTRL_WIN; ++w) {
3234                         t4_write_reg(adap, TP_CCTRL_TABLE_A,
3235                                      ROWINDEX_V(0xffff) | (mtu << 5) | w);
3236                         incr[mtu][w] = (u16)t4_read_reg(adap,
3237                                                 TP_CCTRL_TABLE_A) & 0x1fff;
3238                 }
3239 }
3240
3241 /**
3242  *      t4_tp_wr_bits_indirect - set/clear bits in an indirect TP register
3243  *      @adap: the adapter
3244  *      @addr: the indirect TP register address
3245  *      @mask: specifies the field within the register to modify
3246  *      @val: new value for the field
3247  *
3248  *      Sets a field of an indirect TP register to the given value.
3249  */
3250 void t4_tp_wr_bits_indirect(struct adapter *adap, unsigned int addr,
3251                             unsigned int mask, unsigned int val)
3252 {
3253         t4_write_reg(adap, TP_PIO_ADDR_A, addr);
3254         val |= t4_read_reg(adap, TP_PIO_DATA_A) & ~mask;
3255         t4_write_reg(adap, TP_PIO_DATA_A, val);
3256 }
3257
3258 /**
3259  *      init_cong_ctrl - initialize congestion control parameters
3260  *      @a: the alpha values for congestion control
3261  *      @b: the beta values for congestion control
3262  *
3263  *      Initialize the congestion control parameters.
3264  */
3265 static void init_cong_ctrl(unsigned short *a, unsigned short *b)
3266 {
3267         a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = a[8] = 1;
3268         a[9] = 2;
3269         a[10] = 3;
3270         a[11] = 4;
3271         a[12] = 5;
3272         a[13] = 6;
3273         a[14] = 7;
3274         a[15] = 8;
3275         a[16] = 9;
3276         a[17] = 10;
3277         a[18] = 14;
3278         a[19] = 17;
3279         a[20] = 21;
3280         a[21] = 25;
3281         a[22] = 30;
3282         a[23] = 35;
3283         a[24] = 45;
3284         a[25] = 60;
3285         a[26] = 80;
3286         a[27] = 100;
3287         a[28] = 200;
3288         a[29] = 300;
3289         a[30] = 400;
3290         a[31] = 500;
3291
3292         b[0] = b[1] = b[2] = b[3] = b[4] = b[5] = b[6] = b[7] = b[8] = 0;
3293         b[9] = b[10] = 1;
3294         b[11] = b[12] = 2;
3295         b[13] = b[14] = b[15] = b[16] = 3;
3296         b[17] = b[18] = b[19] = b[20] = b[21] = 4;
3297         b[22] = b[23] = b[24] = b[25] = b[26] = b[27] = 5;
3298         b[28] = b[29] = 6;
3299         b[30] = b[31] = 7;
3300 }
3301
3302 /* The minimum additive increment value for the congestion control table */
3303 #define CC_MIN_INCR 2U
3304
3305 /**
3306  *      t4_load_mtus - write the MTU and congestion control HW tables
3307  *      @adap: the adapter
3308  *      @mtus: the values for the MTU table
3309  *      @alpha: the values for the congestion control alpha parameter
3310  *      @beta: the values for the congestion control beta parameter
3311  *
3312  *      Write the HW MTU table with the supplied MTUs and the high-speed
3313  *      congestion control table with the supplied alpha, beta, and MTUs.
3314  *      We write the two tables together because the additive increments
3315  *      depend on the MTUs.
3316  */
3317 void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
3318                   const unsigned short *alpha, const unsigned short *beta)
3319 {
3320         static const unsigned int avg_pkts[NCCTRL_WIN] = {
3321                 2, 6, 10, 14, 20, 28, 40, 56, 80, 112, 160, 224, 320, 448, 640,
3322                 896, 1281, 1792, 2560, 3584, 5120, 7168, 10240, 14336, 20480,
3323                 28672, 40960, 57344, 81920, 114688, 163840, 229376
3324         };
3325
3326         unsigned int i, w;
3327
3328         for (i = 0; i < NMTUS; ++i) {
3329                 unsigned int mtu = mtus[i];
3330                 unsigned int log2 = fls(mtu);
3331
3332                 if (!(mtu & ((1 << log2) >> 2)))     /* round */
3333                         log2--;
3334                 t4_write_reg(adap, TP_MTU_TABLE_A, MTUINDEX_V(i) |
3335                              MTUWIDTH_V(log2) | MTUVALUE_V(mtu));
3336
3337                 for (w = 0; w < NCCTRL_WIN; ++w) {
3338                         unsigned int inc;
3339
3340                         inc = max(((mtu - 40) * alpha[w]) / avg_pkts[w],
3341                                   CC_MIN_INCR);
3342
3343                         t4_write_reg(adap, TP_CCTRL_TABLE_A, (i << 21) |
3344                                      (w << 16) | (beta[w] << 13) | inc);
3345                 }
3346         }
3347 }
3348
3349 /**
3350  *      t4_pmtx_get_stats - returns the HW stats from PMTX
3351  *      @adap: the adapter
3352  *      @cnt: where to store the count statistics
3353  *      @cycles: where to store the cycle statistics
3354  *
3355  *      Returns performance statistics from PMTX.
3356  */
3357 void t4_pmtx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[])
3358 {
3359         int i;
3360         u32 data[2];
3361
3362         for (i = 0; i < PM_NSTATS; i++) {
3363                 t4_write_reg(adap, PM_TX_STAT_CONFIG_A, i + 1);
3364                 cnt[i] = t4_read_reg(adap, PM_TX_STAT_COUNT_A);
3365                 if (is_t4(adap->params.chip)) {
3366                         cycles[i] = t4_read_reg64(adap, PM_TX_STAT_LSB_A);
3367                 } else {
3368                         t4_read_indirect(adap, PM_TX_DBG_CTRL_A,
3369                                          PM_TX_DBG_DATA_A, data, 2,
3370                                          PM_TX_DBG_STAT_MSB_A);
3371                         cycles[i] = (((u64)data[0] << 32) | data[1]);
3372                 }
3373         }
3374 }
3375
3376 /**
3377  *      t4_pmrx_get_stats - returns the HW stats from PMRX
3378  *      @adap: the adapter
3379  *      @cnt: where to store the count statistics
3380  *      @cycles: where to store the cycle statistics
3381  *
3382  *      Returns performance statistics from PMRX.
3383  */
3384 void t4_pmrx_get_stats(struct adapter *adap, u32 cnt[], u64 cycles[])
3385 {
3386         int i;
3387         u32 data[2];
3388
3389         for (i = 0; i < PM_NSTATS; i++) {
3390                 t4_write_reg(adap, PM_RX_STAT_CONFIG_A, i + 1);
3391                 cnt[i] = t4_read_reg(adap, PM_RX_STAT_COUNT_A);
3392                 if (is_t4(adap->params.chip)) {
3393                         cycles[i] = t4_read_reg64(adap, PM_RX_STAT_LSB_A);
3394                 } else {
3395                         t4_read_indirect(adap, PM_RX_DBG_CTRL_A,
3396                                          PM_RX_DBG_DATA_A, data, 2,
3397                                          PM_RX_DBG_STAT_MSB_A);
3398                         cycles[i] = (((u64)data[0] << 32) | data[1]);
3399                 }
3400         }
3401 }
3402
3403 /**
3404  *      get_mps_bg_map - return the buffer groups associated with a port
3405  *      @adap: the adapter
3406  *      @idx: the port index
3407  *
3408  *      Returns a bitmap indicating which MPS buffer groups are associated
3409  *      with the given port.  Bit i is set if buffer group i is used by the
3410  *      port.
3411  */
3412 static unsigned int get_mps_bg_map(struct adapter *adap, int idx)
3413 {
3414         u32 n = NUMPORTS_G(t4_read_reg(adap, MPS_CMN_CTL_A));
3415
3416         if (n == 0)
3417                 return idx == 0 ? 0xf : 0;
3418         if (n == 1)
3419                 return idx < 2 ? (3 << (2 * idx)) : 0;
3420         return 1 << idx;
3421 }
3422
3423 /**
3424  *      t4_get_port_type_description - return Port Type string description
3425  *      @port_type: firmware Port Type enumeration
3426  */
3427 const char *t4_get_port_type_description(enum fw_port_type port_type)
3428 {
3429         static const char *const port_type_description[] = {
3430                 "R XFI",
3431                 "R XAUI",
3432                 "T SGMII",
3433                 "T XFI",
3434                 "T XAUI",
3435                 "KX4",
3436                 "CX4",
3437                 "KX",
3438                 "KR",
3439                 "R SFP+",
3440                 "KR/KX",
3441                 "KR/KX/KX4",
3442                 "R QSFP_10G",
3443                 "R QSA",
3444                 "R QSFP",
3445                 "R BP40_BA",
3446         };
3447
3448         if (port_type < ARRAY_SIZE(port_type_description))
3449                 return port_type_description[port_type];
3450         return "UNKNOWN";
3451 }
3452
3453 /**
3454  *      t4_get_port_stats - collect port statistics
3455  *      @adap: the adapter
3456  *      @idx: the port index
3457  *      @p: the stats structure to fill
3458  *
3459  *      Collect statistics related to the given port from HW.
3460  */
3461 void t4_get_port_stats(struct adapter *adap, int idx, struct port_stats *p)
3462 {
3463         u32 bgmap = get_mps_bg_map(adap, idx);
3464
3465 #define GET_STAT(name) \
3466         t4_read_reg64(adap, \
3467         (is_t4(adap->params.chip) ? PORT_REG(idx, MPS_PORT_STAT_##name##_L) : \
3468         T5_PORT_REG(idx, MPS_PORT_STAT_##name##_L)))
3469 #define GET_STAT_COM(name) t4_read_reg64(adap, MPS_STAT_##name##_L)
3470
3471         p->tx_octets           = GET_STAT(TX_PORT_BYTES);
3472         p->tx_frames           = GET_STAT(TX_PORT_FRAMES);
3473         p->tx_bcast_frames     = GET_STAT(TX_PORT_BCAST);
3474         p->tx_mcast_frames     = GET_STAT(TX_PORT_MCAST);
3475         p->tx_ucast_frames     = GET_STAT(TX_PORT_UCAST);
3476         p->tx_error_frames     = GET_STAT(TX_PORT_ERROR);
3477         p->tx_frames_64        = GET_STAT(TX_PORT_64B);
3478         p->tx_frames_65_127    = GET_STAT(TX_PORT_65B_127B);
3479         p->tx_frames_128_255   = GET_STAT(TX_PORT_128B_255B);
3480         p->tx_frames_256_511   = GET_STAT(TX_PORT_256B_511B);
3481         p->tx_frames_512_1023  = GET_STAT(TX_PORT_512B_1023B);
3482         p->tx_frames_1024_1518 = GET_STAT(TX_PORT_1024B_1518B);
3483         p->tx_frames_1519_max  = GET_STAT(TX_PORT_1519B_MAX);
3484         p->tx_drop             = GET_STAT(TX_PORT_DROP);
3485         p->tx_pause            = GET_STAT(TX_PORT_PAUSE);
3486         p->tx_ppp0             = GET_STAT(TX_PORT_PPP0);
3487         p->tx_ppp1             = GET_STAT(TX_PORT_PPP1);
3488         p->tx_ppp2             = GET_STAT(TX_PORT_PPP2);
3489         p->tx_ppp3             = GET_STAT(TX_PORT_PPP3);
3490         p->tx_ppp4             = GET_STAT(TX_PORT_PPP4);
3491         p->tx_ppp5             = GET_STAT(TX_PORT_PPP5);
3492         p->tx_ppp6             = GET_STAT(TX_PORT_PPP6);
3493         p->tx_ppp7             = GET_STAT(TX_PORT_PPP7);
3494
3495         p->rx_octets           = GET_STAT(RX_PORT_BYTES);
3496         p->rx_frames           = GET_STAT(RX_PORT_FRAMES);
3497         p->rx_bcast_frames     = GET_STAT(RX_PORT_BCAST);
3498         p->rx_mcast_frames     = GET_STAT(RX_PORT_MCAST);
3499         p->rx_ucast_frames     = GET_STAT(RX_PORT_UCAST);
3500         p->rx_too_long         = GET_STAT(RX_PORT_MTU_ERROR);
3501         p->rx_jabber           = GET_STAT(RX_PORT_MTU_CRC_ERROR);
3502         p->rx_fcs_err          = GET_STAT(RX_PORT_CRC_ERROR);
3503         p->rx_len_err          = GET_STAT(RX_PORT_LEN_ERROR);
3504         p->rx_symbol_err       = GET_STAT(RX_PORT_SYM_ERROR);
3505         p->rx_runt             = GET_STAT(RX_PORT_LESS_64B);
3506         p->rx_frames_64        = GET_STAT(RX_PORT_64B);
3507         p->rx_frames_65_127    = GET_STAT(RX_PORT_65B_127B);
3508         p->rx_frames_128_255   = GET_STAT(RX_PORT_128B_255B);
3509         p->rx_frames_256_511   = GET_STAT(RX_PORT_256B_511B);
3510         p->rx_frames_512_1023  = GET_STAT(RX_PORT_512B_1023B);
3511         p->rx_frames_1024_1518 = GET_STAT(RX_PORT_1024B_1518B);
3512         p->rx_frames_1519_max  = GET_STAT(RX_PORT_1519B_MAX);
3513         p->rx_pause            = GET_STAT(RX_PORT_PAUSE);
3514         p->rx_ppp0             = GET_STAT(RX_PORT_PPP0);
3515         p->rx_ppp1             = GET_STAT(RX_PORT_PPP1);
3516         p->rx_ppp2             = GET_STAT(RX_PORT_PPP2);
3517         p->rx_ppp3             = GET_STAT(RX_PORT_PPP3);
3518         p->rx_ppp4             = GET_STAT(RX_PORT_PPP4);
3519         p->rx_ppp5             = GET_STAT(RX_PORT_PPP5);
3520         p->rx_ppp6             = GET_STAT(RX_PORT_PPP6);
3521         p->rx_ppp7             = GET_STAT(RX_PORT_PPP7);
3522
3523         p->rx_ovflow0 = (bgmap & 1) ? GET_STAT_COM(RX_BG_0_MAC_DROP_FRAME) : 0;
3524         p->rx_ovflow1 = (bgmap & 2) ? GET_STAT_COM(RX_BG_1_MAC_DROP_FRAME) : 0;
3525         p->rx_ovflow2 = (bgmap & 4) ? GET_STAT_COM(RX_BG_2_MAC_DROP_FRAME) : 0;
3526         p->rx_ovflow3 = (bgmap & 8) ? GET_STAT_COM(RX_BG_3_MAC_DROP_FRAME) : 0;
3527         p->rx_trunc0 = (bgmap & 1) ? GET_STAT_COM(RX_BG_0_MAC_TRUNC_FRAME) : 0;
3528         p->rx_trunc1 = (bgmap & 2) ? GET_STAT_COM(RX_BG_1_MAC_TRUNC_FRAME) : 0;
3529         p->rx_trunc2 = (bgmap & 4) ? GET_STAT_COM(RX_BG_2_MAC_TRUNC_FRAME) : 0;
3530         p->rx_trunc3 = (bgmap & 8) ? GET_STAT_COM(RX_BG_3_MAC_TRUNC_FRAME) : 0;
3531
3532 #undef GET_STAT
3533 #undef GET_STAT_COM
3534 }
3535
3536 /**
3537  *      t4_wol_magic_enable - enable/disable magic packet WoL
3538  *      @adap: the adapter
3539  *      @port: the physical port index
3540  *      @addr: MAC address expected in magic packets, %NULL to disable
3541  *
3542  *      Enables/disables magic packet wake-on-LAN for the selected port.
3543  */
3544 void t4_wol_magic_enable(struct adapter *adap, unsigned int port,
3545                          const u8 *addr)
3546 {
3547         u32 mag_id_reg_l, mag_id_reg_h, port_cfg_reg;
3548
3549         if (is_t4(adap->params.chip)) {
3550                 mag_id_reg_l = PORT_REG(port, XGMAC_PORT_MAGIC_MACID_LO);
3551                 mag_id_reg_h = PORT_REG(port, XGMAC_PORT_MAGIC_MACID_HI);
3552                 port_cfg_reg = PORT_REG(port, XGMAC_PORT_CFG2_A);
3553         } else {
3554                 mag_id_reg_l = T5_PORT_REG(port, MAC_PORT_MAGIC_MACID_LO);
3555                 mag_id_reg_h = T5_PORT_REG(port, MAC_PORT_MAGIC_MACID_HI);
3556                 port_cfg_reg = T5_PORT_REG(port, MAC_PORT_CFG2_A);
3557         }
3558
3559         if (addr) {
3560                 t4_write_reg(adap, mag_id_reg_l,
3561                              (addr[2] << 24) | (addr[3] << 16) |
3562                              (addr[4] << 8) | addr[5]);
3563                 t4_write_reg(adap, mag_id_reg_h,
3564                              (addr[0] << 8) | addr[1]);
3565         }
3566         t4_set_reg_field(adap, port_cfg_reg, MAGICEN_F,
3567                          addr ? MAGICEN_F : 0);
3568 }
3569
3570 /**
3571  *      t4_wol_pat_enable - enable/disable pattern-based WoL
3572  *      @adap: the adapter
3573  *      @port: the physical port index
3574  *      @map: bitmap of which HW pattern filters to set
3575  *      @mask0: byte mask for bytes 0-63 of a packet
3576  *      @mask1: byte mask for bytes 64-127 of a packet
3577  *      @crc: Ethernet CRC for selected bytes
3578  *      @enable: enable/disable switch
3579  *
3580  *      Sets the pattern filters indicated in @map to mask out the bytes
3581  *      specified in @mask0/@mask1 in received packets and compare the CRC of
3582  *      the resulting packet against @crc.  If @enable is %true pattern-based
3583  *      WoL is enabled, otherwise disabled.
3584  */
3585 int t4_wol_pat_enable(struct adapter *adap, unsigned int port, unsigned int map,
3586                       u64 mask0, u64 mask1, unsigned int crc, bool enable)
3587 {
3588         int i;
3589         u32 port_cfg_reg;
3590
3591         if (is_t4(adap->params.chip))
3592                 port_cfg_reg = PORT_REG(port, XGMAC_PORT_CFG2_A);
3593         else
3594                 port_cfg_reg = T5_PORT_REG(port, MAC_PORT_CFG2_A);
3595
3596         if (!enable) {
3597                 t4_set_reg_field(adap, port_cfg_reg, PATEN_F, 0);
3598                 return 0;
3599         }
3600         if (map > 0xff)
3601                 return -EINVAL;
3602
3603 #define EPIO_REG(name) \
3604         (is_t4(adap->params.chip) ? \
3605          PORT_REG(port, XGMAC_PORT_EPIO_##name##_A) : \
3606          T5_PORT_REG(port, MAC_PORT_EPIO_##name##_A))
3607
3608         t4_write_reg(adap, EPIO_REG(DATA1), mask0 >> 32);
3609         t4_write_reg(adap, EPIO_REG(DATA2), mask1);
3610         t4_write_reg(adap, EPIO_REG(DATA3), mask1 >> 32);
3611
3612         for (i = 0; i < NWOL_PAT; i++, map >>= 1) {
3613                 if (!(map & 1))
3614                         continue;
3615
3616                 /* write byte masks */
3617                 t4_write_reg(adap, EPIO_REG(DATA0), mask0);
3618                 t4_write_reg(adap, EPIO_REG(OP), ADDRESS_V(i) | EPIOWR_F);
3619                 t4_read_reg(adap, EPIO_REG(OP));                /* flush */
3620                 if (t4_read_reg(adap, EPIO_REG(OP)) & SF_BUSY_F)
3621                         return -ETIMEDOUT;
3622
3623                 /* write CRC */
3624                 t4_write_reg(adap, EPIO_REG(DATA0), crc);
3625                 t4_write_reg(adap, EPIO_REG(OP), ADDRESS_V(i + 32) | EPIOWR_F);
3626                 t4_read_reg(adap, EPIO_REG(OP));                /* flush */
3627                 if (t4_read_reg(adap, EPIO_REG(OP)) & SF_BUSY_F)
3628                         return -ETIMEDOUT;
3629         }
3630 #undef EPIO_REG
3631
3632         t4_set_reg_field(adap, PORT_REG(port, XGMAC_PORT_CFG2_A), 0, PATEN_F);
3633         return 0;
3634 }
3635
3636 /*     t4_mk_filtdelwr - create a delete filter WR
3637  *     @ftid: the filter ID
3638  *     @wr: the filter work request to populate
3639  *     @qid: ingress queue to receive the delete notification
3640  *
3641  *     Creates a filter work request to delete the supplied filter.  If @qid is
3642  *     negative the delete notification is suppressed.
3643  */
3644 void t4_mk_filtdelwr(unsigned int ftid, struct fw_filter_wr *wr, int qid)
3645 {
3646         memset(wr, 0, sizeof(*wr));
3647         wr->op_pkd = htonl(FW_WR_OP_V(FW_FILTER_WR));
3648         wr->len16_pkd = htonl(FW_WR_LEN16_V(sizeof(*wr) / 16));
3649         wr->tid_to_iq = htonl(FW_FILTER_WR_TID_V(ftid) |
3650                         FW_FILTER_WR_NOREPLY_V(qid < 0));
3651         wr->del_filter_to_l2tix = htonl(FW_FILTER_WR_DEL_FILTER_F);
3652         if (qid >= 0)
3653                 wr->rx_chan_rx_rpl_iq = htons(FW_FILTER_WR_RX_RPL_IQ_V(qid));
3654 }
3655
3656 #define INIT_CMD(var, cmd, rd_wr) do { \
3657         (var).op_to_write = htonl(FW_CMD_OP_V(FW_##cmd##_CMD) | \
3658                                   FW_CMD_REQUEST_F | FW_CMD_##rd_wr##_F); \
3659         (var).retval_len16 = htonl(FW_LEN16(var)); \
3660 } while (0)
3661
3662 int t4_fwaddrspace_write(struct adapter *adap, unsigned int mbox,
3663                           u32 addr, u32 val)
3664 {
3665         struct fw_ldst_cmd c;
3666
3667         memset(&c, 0, sizeof(c));
3668         c.op_to_addrspace = htonl(FW_CMD_OP_V(FW_LDST_CMD) | FW_CMD_REQUEST_F |
3669                             FW_CMD_WRITE_F |
3670                             FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_FIRMWARE));
3671         c.cycles_to_len16 = htonl(FW_LEN16(c));
3672         c.u.addrval.addr = htonl(addr);
3673         c.u.addrval.val = htonl(val);
3674
3675         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
3676 }
3677
3678 /**
3679  *      t4_mdio_rd - read a PHY register through MDIO
3680  *      @adap: the adapter
3681  *      @mbox: mailbox to use for the FW command
3682  *      @phy_addr: the PHY address
3683  *      @mmd: the PHY MMD to access (0 for clause 22 PHYs)
3684  *      @reg: the register to read
3685  *      @valp: where to store the value
3686  *
3687  *      Issues a FW command through the given mailbox to read a PHY register.
3688  */
3689 int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
3690                unsigned int mmd, unsigned int reg, u16 *valp)
3691 {
3692         int ret;
3693         struct fw_ldst_cmd c;
3694
3695         memset(&c, 0, sizeof(c));
3696         c.op_to_addrspace = htonl(FW_CMD_OP_V(FW_LDST_CMD) | FW_CMD_REQUEST_F |
3697                 FW_CMD_READ_F | FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MDIO));
3698         c.cycles_to_len16 = htonl(FW_LEN16(c));
3699         c.u.mdio.paddr_mmd = htons(FW_LDST_CMD_PADDR_V(phy_addr) |
3700                                    FW_LDST_CMD_MMD_V(mmd));
3701         c.u.mdio.raddr = htons(reg);
3702
3703         ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
3704         if (ret == 0)
3705                 *valp = ntohs(c.u.mdio.rval);
3706         return ret;
3707 }
3708
3709 /**
3710  *      t4_mdio_wr - write a PHY register through MDIO
3711  *      @adap: the adapter
3712  *      @mbox: mailbox to use for the FW command
3713  *      @phy_addr: the PHY address
3714  *      @mmd: the PHY MMD to access (0 for clause 22 PHYs)
3715  *      @reg: the register to write
3716  *      @valp: value to write
3717  *
3718  *      Issues a FW command through the given mailbox to write a PHY register.
3719  */
3720 int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
3721                unsigned int mmd, unsigned int reg, u16 val)
3722 {
3723         struct fw_ldst_cmd c;
3724
3725         memset(&c, 0, sizeof(c));
3726         c.op_to_addrspace = htonl(FW_CMD_OP_V(FW_LDST_CMD) | FW_CMD_REQUEST_F |
3727                 FW_CMD_WRITE_F | FW_LDST_CMD_ADDRSPACE_V(FW_LDST_ADDRSPC_MDIO));
3728         c.cycles_to_len16 = htonl(FW_LEN16(c));
3729         c.u.mdio.paddr_mmd = htons(FW_LDST_CMD_PADDR_V(phy_addr) |
3730                                    FW_LDST_CMD_MMD_V(mmd));
3731         c.u.mdio.raddr = htons(reg);
3732         c.u.mdio.rval = htons(val);
3733
3734         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
3735 }
3736
3737 /**
3738  *      t4_sge_decode_idma_state - decode the idma state
3739  *      @adap: the adapter
3740  *      @state: the state idma is stuck in
3741  */
3742 void t4_sge_decode_idma_state(struct adapter *adapter, int state)
3743 {
3744         static const char * const t4_decode[] = {
3745                 "IDMA_IDLE",
3746                 "IDMA_PUSH_MORE_CPL_FIFO",
3747                 "IDMA_PUSH_CPL_MSG_HEADER_TO_FIFO",
3748                 "Not used",
3749                 "IDMA_PHYSADDR_SEND_PCIEHDR",
3750                 "IDMA_PHYSADDR_SEND_PAYLOAD_FIRST",
3751                 "IDMA_PHYSADDR_SEND_PAYLOAD",
3752                 "IDMA_SEND_FIFO_TO_IMSG",
3753                 "IDMA_FL_REQ_DATA_FL_PREP",
3754                 "IDMA_FL_REQ_DATA_FL",
3755                 "IDMA_FL_DROP",
3756                 "IDMA_FL_H_REQ_HEADER_FL",
3757                 "IDMA_FL_H_SEND_PCIEHDR",
3758                 "IDMA_FL_H_PUSH_CPL_FIFO",
3759                 "IDMA_FL_H_SEND_CPL",
3760                 "IDMA_FL_H_SEND_IP_HDR_FIRST",
3761                 "IDMA_FL_H_SEND_IP_HDR",
3762                 "IDMA_FL_H_REQ_NEXT_HEADER_FL",
3763                 "IDMA_FL_H_SEND_NEXT_PCIEHDR",
3764                 "IDMA_FL_H_SEND_IP_HDR_PADDING",
3765                 "IDMA_FL_D_SEND_PCIEHDR",
3766                 "IDMA_FL_D_SEND_CPL_AND_IP_HDR",
3767                 "IDMA_FL_D_REQ_NEXT_DATA_FL",
3768                 "IDMA_FL_SEND_PCIEHDR",
3769                 "IDMA_FL_PUSH_CPL_FIFO",
3770                 "IDMA_FL_SEND_CPL",
3771                 "IDMA_FL_SEND_PAYLOAD_FIRST",
3772                 "IDMA_FL_SEND_PAYLOAD",
3773                 "IDMA_FL_REQ_NEXT_DATA_FL",
3774                 "IDMA_FL_SEND_NEXT_PCIEHDR",
3775                 "IDMA_FL_SEND_PADDING",
3776                 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
3777                 "IDMA_FL_SEND_FIFO_TO_IMSG",
3778                 "IDMA_FL_REQ_DATAFL_DONE",
3779                 "IDMA_FL_REQ_HEADERFL_DONE",
3780         };
3781         static const char * const t5_decode[] = {
3782                 "IDMA_IDLE",
3783                 "IDMA_ALMOST_IDLE",
3784                 "IDMA_PUSH_MORE_CPL_FIFO",
3785                 "IDMA_PUSH_CPL_MSG_HEADER_TO_FIFO",
3786                 "IDMA_SGEFLRFLUSH_SEND_PCIEHDR",
3787                 "IDMA_PHYSADDR_SEND_PCIEHDR",
3788                 "IDMA_PHYSADDR_SEND_PAYLOAD_FIRST",
3789                 "IDMA_PHYSADDR_SEND_PAYLOAD",
3790                 "IDMA_SEND_FIFO_TO_IMSG",
3791                 "IDMA_FL_REQ_DATA_FL",
3792                 "IDMA_FL_DROP",
3793                 "IDMA_FL_DROP_SEND_INC",
3794                 "IDMA_FL_H_REQ_HEADER_FL",
3795                 "IDMA_FL_H_SEND_PCIEHDR",
3796                 "IDMA_FL_H_PUSH_CPL_FIFO",
3797                 "IDMA_FL_H_SEND_CPL",
3798                 "IDMA_FL_H_SEND_IP_HDR_FIRST",
3799                 "IDMA_FL_H_SEND_IP_HDR",
3800                 "IDMA_FL_H_REQ_NEXT_HEADER_FL",
3801                 "IDMA_FL_H_SEND_NEXT_PCIEHDR",
3802                 "IDMA_FL_H_SEND_IP_HDR_PADDING",
3803                 "IDMA_FL_D_SEND_PCIEHDR",
3804                 "IDMA_FL_D_SEND_CPL_AND_IP_HDR",
3805                 "IDMA_FL_D_REQ_NEXT_DATA_FL",
3806                 "IDMA_FL_SEND_PCIEHDR",
3807                 "IDMA_FL_PUSH_CPL_FIFO",
3808                 "IDMA_FL_SEND_CPL",
3809                 "IDMA_FL_SEND_PAYLOAD_FIRST",
3810                 "IDMA_FL_SEND_PAYLOAD",
3811                 "IDMA_FL_REQ_NEXT_DATA_FL",
3812                 "IDMA_FL_SEND_NEXT_PCIEHDR",
3813                 "IDMA_FL_SEND_PADDING",
3814                 "IDMA_FL_SEND_COMPLETION_TO_IMSG",
3815         };
3816         static const u32 sge_regs[] = {
3817                 SGE_DEBUG_DATA_LOW_INDEX_2_A,
3818                 SGE_DEBUG_DATA_LOW_INDEX_3_A,
3819                 SGE_DEBUG_DATA_HIGH_INDEX_10_A,
3820         };
3821         const char **sge_idma_decode;
3822         int sge_idma_decode_nstates;
3823         int i;
3824
3825         if (is_t4(adapter->params.chip)) {
3826                 sge_idma_decode = (const char **)t4_decode;
3827                 sge_idma_decode_nstates = ARRAY_SIZE(t4_decode);
3828         } else {
3829                 sge_idma_decode = (const char **)t5_decode;
3830                 sge_idma_decode_nstates = ARRAY_SIZE(t5_decode);
3831         }
3832
3833         if (state < sge_idma_decode_nstates)
3834                 CH_WARN(adapter, "idma state %s\n", sge_idma_decode[state]);
3835         else
3836                 CH_WARN(adapter, "idma state %d unknown\n", state);
3837
3838         for (i = 0; i < ARRAY_SIZE(sge_regs); i++)
3839                 CH_WARN(adapter, "SGE register %#x value %#x\n",
3840                         sge_regs[i], t4_read_reg(adapter, sge_regs[i]));
3841 }
3842
3843 /**
3844  *      t4_fw_hello - establish communication with FW
3845  *      @adap: the adapter
3846  *      @mbox: mailbox to use for the FW command
3847  *      @evt_mbox: mailbox to receive async FW events
3848  *      @master: specifies the caller's willingness to be the device master
3849  *      @state: returns the current device state (if non-NULL)
3850  *
3851  *      Issues a command to establish communication with FW.  Returns either
3852  *      an error (negative integer) or the mailbox of the Master PF.
3853  */
3854 int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox,
3855                 enum dev_master master, enum dev_state *state)
3856 {
3857         int ret;
3858         struct fw_hello_cmd c;
3859         u32 v;
3860         unsigned int master_mbox;
3861         int retries = FW_CMD_HELLO_RETRIES;
3862
3863 retry:
3864         memset(&c, 0, sizeof(c));
3865         INIT_CMD(c, HELLO, WRITE);
3866         c.err_to_clearinit = htonl(
3867                 FW_HELLO_CMD_MASTERDIS_V(master == MASTER_CANT) |
3868                 FW_HELLO_CMD_MASTERFORCE_V(master == MASTER_MUST) |
3869                 FW_HELLO_CMD_MBMASTER_V(master == MASTER_MUST ? mbox :
3870                                       FW_HELLO_CMD_MBMASTER_M) |
3871                 FW_HELLO_CMD_MBASYNCNOT_V(evt_mbox) |
3872                 FW_HELLO_CMD_STAGE_V(fw_hello_cmd_stage_os) |
3873                 FW_HELLO_CMD_CLEARINIT_F);
3874
3875         /*
3876          * Issue the HELLO command to the firmware.  If it's not successful
3877          * but indicates that we got a "busy" or "timeout" condition, retry
3878          * the HELLO until we exhaust our retry limit.  If we do exceed our
3879          * retry limit, check to see if the firmware left us any error
3880          * information and report that if so.
3881          */
3882         ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
3883         if (ret < 0) {
3884                 if ((ret == -EBUSY || ret == -ETIMEDOUT) && retries-- > 0)
3885                         goto retry;
3886                 if (t4_read_reg(adap, PCIE_FW_A) & PCIE_FW_ERR_F)
3887                         t4_report_fw_error(adap);
3888                 return ret;
3889         }
3890
3891         v = ntohl(c.err_to_clearinit);
3892         master_mbox = FW_HELLO_CMD_MBMASTER_G(v);
3893         if (state) {
3894                 if (v & FW_HELLO_CMD_ERR_F)
3895                         *state = DEV_STATE_ERR;
3896                 else if (v & FW_HELLO_CMD_INIT_F)
3897                         *state = DEV_STATE_INIT;
3898                 else
3899                         *state = DEV_STATE_UNINIT;
3900         }
3901
3902         /*
3903          * If we're not the Master PF then we need to wait around for the
3904          * Master PF Driver to finish setting up the adapter.
3905          *
3906          * Note that we also do this wait if we're a non-Master-capable PF and
3907          * there is no current Master PF; a Master PF may show up momentarily
3908          * and we wouldn't want to fail pointlessly.  (This can happen when an
3909          * OS loads lots of different drivers rapidly at the same time).  In
3910          * this case, the Master PF returned by the firmware will be
3911          * PCIE_FW_MASTER_M so the test below will work ...
3912          */
3913         if ((v & (FW_HELLO_CMD_ERR_F|FW_HELLO_CMD_INIT_F)) == 0 &&
3914             master_mbox != mbox) {
3915                 int waiting = FW_CMD_HELLO_TIMEOUT;
3916
3917                 /*
3918                  * Wait for the firmware to either indicate an error or
3919                  * initialized state.  If we see either of these we bail out
3920                  * and report the issue to the caller.  If we exhaust the
3921                  * "hello timeout" and we haven't exhausted our retries, try
3922                  * again.  Otherwise bail with a timeout error.
3923                  */
3924                 for (;;) {
3925                         u32 pcie_fw;
3926
3927                         msleep(50);
3928                         waiting -= 50;
3929
3930                         /*
3931                          * If neither Error nor Initialialized are indicated
3932                          * by the firmware keep waiting till we exaust our
3933                          * timeout ... and then retry if we haven't exhausted
3934                          * our retries ...
3935                          */
3936                         pcie_fw = t4_read_reg(adap, PCIE_FW_A);
3937                         if (!(pcie_fw & (PCIE_FW_ERR_F|PCIE_FW_INIT_F))) {
3938                                 if (waiting <= 0) {
3939                                         if (retries-- > 0)
3940                                                 goto retry;
3941
3942                                         return -ETIMEDOUT;
3943                                 }
3944                                 continue;
3945                         }
3946
3947                         /*
3948                          * We either have an Error or Initialized condition
3949                          * report errors preferentially.
3950                          */
3951                         if (state) {
3952                                 if (pcie_fw & PCIE_FW_ERR_F)
3953                                         *state = DEV_STATE_ERR;
3954                                 else if (pcie_fw & PCIE_FW_INIT_F)
3955                                         *state = DEV_STATE_INIT;
3956                         }
3957
3958                         /*
3959                          * If we arrived before a Master PF was selected and
3960                          * there's not a valid Master PF, grab its identity
3961                          * for our caller.
3962                          */
3963                         if (master_mbox == PCIE_FW_MASTER_M &&
3964                             (pcie_fw & PCIE_FW_MASTER_VLD_F))
3965                                 master_mbox = PCIE_FW_MASTER_G(pcie_fw);
3966                         break;
3967                 }
3968         }
3969
3970         return master_mbox;
3971 }
3972
3973 /**
3974  *      t4_fw_bye - end communication with FW
3975  *      @adap: the adapter
3976  *      @mbox: mailbox to use for the FW command
3977  *
3978  *      Issues a command to terminate communication with FW.
3979  */
3980 int t4_fw_bye(struct adapter *adap, unsigned int mbox)
3981 {
3982         struct fw_bye_cmd c;
3983
3984         memset(&c, 0, sizeof(c));
3985         INIT_CMD(c, BYE, WRITE);
3986         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
3987 }
3988
3989 /**
3990  *      t4_init_cmd - ask FW to initialize the device
3991  *      @adap: the adapter
3992  *      @mbox: mailbox to use for the FW command
3993  *
3994  *      Issues a command to FW to partially initialize the device.  This
3995  *      performs initialization that generally doesn't depend on user input.
3996  */
3997 int t4_early_init(struct adapter *adap, unsigned int mbox)
3998 {
3999         struct fw_initialize_cmd c;
4000
4001         memset(&c, 0, sizeof(c));
4002         INIT_CMD(c, INITIALIZE, WRITE);
4003         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4004 }
4005
4006 /**
4007  *      t4_fw_reset - issue a reset to FW
4008  *      @adap: the adapter
4009  *      @mbox: mailbox to use for the FW command
4010  *      @reset: specifies the type of reset to perform
4011  *
4012  *      Issues a reset command of the specified type to FW.
4013  */
4014 int t4_fw_reset(struct adapter *adap, unsigned int mbox, int reset)
4015 {
4016         struct fw_reset_cmd c;
4017
4018         memset(&c, 0, sizeof(c));
4019         INIT_CMD(c, RESET, WRITE);
4020         c.val = htonl(reset);
4021         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4022 }
4023
4024 /**
4025  *      t4_fw_halt - issue a reset/halt to FW and put uP into RESET
4026  *      @adap: the adapter
4027  *      @mbox: mailbox to use for the FW RESET command (if desired)
4028  *      @force: force uP into RESET even if FW RESET command fails
4029  *
4030  *      Issues a RESET command to firmware (if desired) with a HALT indication
4031  *      and then puts the microprocessor into RESET state.  The RESET command
4032  *      will only be issued if a legitimate mailbox is provided (mbox <=
4033  *      PCIE_FW_MASTER_M).
4034  *
4035  *      This is generally used in order for the host to safely manipulate the
4036  *      adapter without fear of conflicting with whatever the firmware might
4037  *      be doing.  The only way out of this state is to RESTART the firmware
4038  *      ...
4039  */
4040 static int t4_fw_halt(struct adapter *adap, unsigned int mbox, int force)
4041 {
4042         int ret = 0;
4043
4044         /*
4045          * If a legitimate mailbox is provided, issue a RESET command
4046          * with a HALT indication.
4047          */
4048         if (mbox <= PCIE_FW_MASTER_M) {
4049                 struct fw_reset_cmd c;
4050
4051                 memset(&c, 0, sizeof(c));
4052                 INIT_CMD(c, RESET, WRITE);
4053                 c.val = htonl(PIORST_F | PIORSTMODE_F);
4054                 c.halt_pkd = htonl(FW_RESET_CMD_HALT_F);
4055                 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4056         }
4057
4058         /*
4059          * Normally we won't complete the operation if the firmware RESET
4060          * command fails but if our caller insists we'll go ahead and put the
4061          * uP into RESET.  This can be useful if the firmware is hung or even
4062          * missing ...  We'll have to take the risk of putting the uP into
4063          * RESET without the cooperation of firmware in that case.
4064          *
4065          * We also force the firmware's HALT flag to be on in case we bypassed
4066          * the firmware RESET command above or we're dealing with old firmware
4067          * which doesn't have the HALT capability.  This will serve as a flag
4068          * for the incoming firmware to know that it's coming out of a HALT
4069          * rather than a RESET ... if it's new enough to understand that ...
4070          */
4071         if (ret == 0 || force) {
4072                 t4_set_reg_field(adap, CIM_BOOT_CFG_A, UPCRST_F, UPCRST_F);
4073                 t4_set_reg_field(adap, PCIE_FW_A, PCIE_FW_HALT_F,
4074                                  PCIE_FW_HALT_F);
4075         }
4076
4077         /*
4078          * And we always return the result of the firmware RESET command
4079          * even when we force the uP into RESET ...
4080          */
4081         return ret;
4082 }
4083
4084 /**
4085  *      t4_fw_restart - restart the firmware by taking the uP out of RESET
4086  *      @adap: the adapter
4087  *      @reset: if we want to do a RESET to restart things
4088  *
4089  *      Restart firmware previously halted by t4_fw_halt().  On successful
4090  *      return the previous PF Master remains as the new PF Master and there
4091  *      is no need to issue a new HELLO command, etc.
4092  *
4093  *      We do this in two ways:
4094  *
4095  *       1. If we're dealing with newer firmware we'll simply want to take
4096  *          the chip's microprocessor out of RESET.  This will cause the
4097  *          firmware to start up from its start vector.  And then we'll loop
4098  *          until the firmware indicates it's started again (PCIE_FW.HALT
4099  *          reset to 0) or we timeout.
4100  *
4101  *       2. If we're dealing with older firmware then we'll need to RESET
4102  *          the chip since older firmware won't recognize the PCIE_FW.HALT
4103  *          flag and automatically RESET itself on startup.
4104  */
4105 static int t4_fw_restart(struct adapter *adap, unsigned int mbox, int reset)
4106 {
4107         if (reset) {
4108                 /*
4109                  * Since we're directing the RESET instead of the firmware
4110                  * doing it automatically, we need to clear the PCIE_FW.HALT
4111                  * bit.
4112                  */
4113                 t4_set_reg_field(adap, PCIE_FW_A, PCIE_FW_HALT_F, 0);
4114
4115                 /*
4116                  * If we've been given a valid mailbox, first try to get the
4117                  * firmware to do the RESET.  If that works, great and we can
4118                  * return success.  Otherwise, if we haven't been given a
4119                  * valid mailbox or the RESET command failed, fall back to
4120                  * hitting the chip with a hammer.
4121                  */
4122                 if (mbox <= PCIE_FW_MASTER_M) {
4123                         t4_set_reg_field(adap, CIM_BOOT_CFG_A, UPCRST_F, 0);
4124                         msleep(100);
4125                         if (t4_fw_reset(adap, mbox,
4126                                         PIORST_F | PIORSTMODE_F) == 0)
4127                                 return 0;
4128                 }
4129
4130                 t4_write_reg(adap, PL_RST_A, PIORST_F | PIORSTMODE_F);
4131                 msleep(2000);
4132         } else {
4133                 int ms;
4134
4135                 t4_set_reg_field(adap, CIM_BOOT_CFG_A, UPCRST_F, 0);
4136                 for (ms = 0; ms < FW_CMD_MAX_TIMEOUT; ) {
4137                         if (!(t4_read_reg(adap, PCIE_FW_A) & PCIE_FW_HALT_F))
4138                                 return 0;
4139                         msleep(100);
4140                         ms += 100;
4141                 }
4142                 return -ETIMEDOUT;
4143         }
4144         return 0;
4145 }
4146
4147 /**
4148  *      t4_fw_upgrade - perform all of the steps necessary to upgrade FW
4149  *      @adap: the adapter
4150  *      @mbox: mailbox to use for the FW RESET command (if desired)
4151  *      @fw_data: the firmware image to write
4152  *      @size: image size
4153  *      @force: force upgrade even if firmware doesn't cooperate
4154  *
4155  *      Perform all of the steps necessary for upgrading an adapter's
4156  *      firmware image.  Normally this requires the cooperation of the
4157  *      existing firmware in order to halt all existing activities
4158  *      but if an invalid mailbox token is passed in we skip that step
4159  *      (though we'll still put the adapter microprocessor into RESET in
4160  *      that case).
4161  *
4162  *      On successful return the new firmware will have been loaded and
4163  *      the adapter will have been fully RESET losing all previous setup
4164  *      state.  On unsuccessful return the adapter may be completely hosed ...
4165  *      positive errno indicates that the adapter is ~probably~ intact, a
4166  *      negative errno indicates that things are looking bad ...
4167  */
4168 int t4_fw_upgrade(struct adapter *adap, unsigned int mbox,
4169                   const u8 *fw_data, unsigned int size, int force)
4170 {
4171         const struct fw_hdr *fw_hdr = (const struct fw_hdr *)fw_data;
4172         int reset, ret;
4173
4174         if (!t4_fw_matches_chip(adap, fw_hdr))
4175                 return -EINVAL;
4176
4177         ret = t4_fw_halt(adap, mbox, force);
4178         if (ret < 0 && !force)
4179                 return ret;
4180
4181         ret = t4_load_fw(adap, fw_data, size);
4182         if (ret < 0)
4183                 return ret;
4184
4185         /*
4186          * Older versions of the firmware don't understand the new
4187          * PCIE_FW.HALT flag and so won't know to perform a RESET when they
4188          * restart.  So for newly loaded older firmware we'll have to do the
4189          * RESET for it so it starts up on a clean slate.  We can tell if
4190          * the newly loaded firmware will handle this right by checking
4191          * its header flags to see if it advertises the capability.
4192          */
4193         reset = ((ntohl(fw_hdr->flags) & FW_HDR_FLAGS_RESET_HALT) == 0);
4194         return t4_fw_restart(adap, mbox, reset);
4195 }
4196
4197 /**
4198  *      t4_fixup_host_params - fix up host-dependent parameters
4199  *      @adap: the adapter
4200  *      @page_size: the host's Base Page Size
4201  *      @cache_line_size: the host's Cache Line Size
4202  *
4203  *      Various registers in T4 contain values which are dependent on the
4204  *      host's Base Page and Cache Line Sizes.  This function will fix all of
4205  *      those registers with the appropriate values as passed in ...
4206  */
4207 int t4_fixup_host_params(struct adapter *adap, unsigned int page_size,
4208                          unsigned int cache_line_size)
4209 {
4210         unsigned int page_shift = fls(page_size) - 1;
4211         unsigned int sge_hps = page_shift - 10;
4212         unsigned int stat_len = cache_line_size > 64 ? 128 : 64;
4213         unsigned int fl_align = cache_line_size < 32 ? 32 : cache_line_size;
4214         unsigned int fl_align_log = fls(fl_align) - 1;
4215
4216         t4_write_reg(adap, SGE_HOST_PAGE_SIZE_A,
4217                      HOSTPAGESIZEPF0_V(sge_hps) |
4218                      HOSTPAGESIZEPF1_V(sge_hps) |
4219                      HOSTPAGESIZEPF2_V(sge_hps) |
4220                      HOSTPAGESIZEPF3_V(sge_hps) |
4221                      HOSTPAGESIZEPF4_V(sge_hps) |
4222                      HOSTPAGESIZEPF5_V(sge_hps) |
4223                      HOSTPAGESIZEPF6_V(sge_hps) |
4224                      HOSTPAGESIZEPF7_V(sge_hps));
4225
4226         if (is_t4(adap->params.chip)) {
4227                 t4_set_reg_field(adap, SGE_CONTROL_A,
4228                                  INGPADBOUNDARY_V(INGPADBOUNDARY_M) |
4229                                  EGRSTATUSPAGESIZE_F,
4230                                  INGPADBOUNDARY_V(fl_align_log -
4231                                                   INGPADBOUNDARY_SHIFT_X) |
4232                                  EGRSTATUSPAGESIZE_V(stat_len != 64));
4233         } else {
4234                 /* T5 introduced the separation of the Free List Padding and
4235                  * Packing Boundaries.  Thus, we can select a smaller Padding
4236                  * Boundary to avoid uselessly chewing up PCIe Link and Memory
4237                  * Bandwidth, and use a Packing Boundary which is large enough
4238                  * to avoid false sharing between CPUs, etc.
4239                  *
4240                  * For the PCI Link, the smaller the Padding Boundary the
4241                  * better.  For the Memory Controller, a smaller Padding
4242                  * Boundary is better until we cross under the Memory Line
4243                  * Size (the minimum unit of transfer to/from Memory).  If we
4244                  * have a Padding Boundary which is smaller than the Memory
4245                  * Line Size, that'll involve a Read-Modify-Write cycle on the
4246                  * Memory Controller which is never good.  For T5 the smallest
4247                  * Padding Boundary which we can select is 32 bytes which is
4248                  * larger than any known Memory Controller Line Size so we'll
4249                  * use that.
4250                  *
4251                  * T5 has a different interpretation of the "0" value for the
4252                  * Packing Boundary.  This corresponds to 16 bytes instead of
4253                  * the expected 32 bytes.  We never have a Packing Boundary
4254                  * less than 32 bytes so we can't use that special value but
4255                  * on the other hand, if we wanted 32 bytes, the best we can
4256                  * really do is 64 bytes.
4257                 */
4258                 if (fl_align <= 32) {
4259                         fl_align = 64;
4260                         fl_align_log = 6;
4261                 }
4262                 t4_set_reg_field(adap, SGE_CONTROL_A,
4263                                  INGPADBOUNDARY_V(INGPADBOUNDARY_M) |
4264                                  EGRSTATUSPAGESIZE_F,
4265                                  INGPADBOUNDARY_V(INGPCIEBOUNDARY_32B_X) |
4266                                  EGRSTATUSPAGESIZE_V(stat_len != 64));
4267                 t4_set_reg_field(adap, SGE_CONTROL2_A,
4268                                  INGPACKBOUNDARY_V(INGPACKBOUNDARY_M),
4269                                  INGPACKBOUNDARY_V(fl_align_log -
4270                                                    INGPACKBOUNDARY_SHIFT_X));
4271         }
4272         /*
4273          * Adjust various SGE Free List Host Buffer Sizes.
4274          *
4275          * This is something of a crock since we're using fixed indices into
4276          * the array which are also known by the sge.c code and the T4
4277          * Firmware Configuration File.  We need to come up with a much better
4278          * approach to managing this array.  For now, the first four entries
4279          * are:
4280          *
4281          *   0: Host Page Size
4282          *   1: 64KB
4283          *   2: Buffer size corresponding to 1500 byte MTU (unpacked mode)
4284          *   3: Buffer size corresponding to 9000 byte MTU (unpacked mode)
4285          *
4286          * For the single-MTU buffers in unpacked mode we need to include
4287          * space for the SGE Control Packet Shift, 14 byte Ethernet header,
4288          * possible 4 byte VLAN tag, all rounded up to the next Ingress Packet
4289          * Padding boundary.  All of these are accommodated in the Factory
4290          * Default Firmware Configuration File but we need to adjust it for
4291          * this host's cache line size.
4292          */
4293         t4_write_reg(adap, SGE_FL_BUFFER_SIZE0_A, page_size);
4294         t4_write_reg(adap, SGE_FL_BUFFER_SIZE2_A,
4295                      (t4_read_reg(adap, SGE_FL_BUFFER_SIZE2_A) + fl_align-1)
4296                      & ~(fl_align-1));
4297         t4_write_reg(adap, SGE_FL_BUFFER_SIZE3_A,
4298                      (t4_read_reg(adap, SGE_FL_BUFFER_SIZE3_A) + fl_align-1)
4299                      & ~(fl_align-1));
4300
4301         t4_write_reg(adap, ULP_RX_TDDP_PSZ_A, HPZ0_V(page_shift - 12));
4302
4303         return 0;
4304 }
4305
4306 /**
4307  *      t4_fw_initialize - ask FW to initialize the device
4308  *      @adap: the adapter
4309  *      @mbox: mailbox to use for the FW command
4310  *
4311  *      Issues a command to FW to partially initialize the device.  This
4312  *      performs initialization that generally doesn't depend on user input.
4313  */
4314 int t4_fw_initialize(struct adapter *adap, unsigned int mbox)
4315 {
4316         struct fw_initialize_cmd c;
4317
4318         memset(&c, 0, sizeof(c));
4319         INIT_CMD(c, INITIALIZE, WRITE);
4320         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4321 }
4322
4323 /**
4324  *      t4_query_params - query FW or device parameters
4325  *      @adap: the adapter
4326  *      @mbox: mailbox to use for the FW command
4327  *      @pf: the PF
4328  *      @vf: the VF
4329  *      @nparams: the number of parameters
4330  *      @params: the parameter names
4331  *      @val: the parameter values
4332  *
4333  *      Reads the value of FW or device parameters.  Up to 7 parameters can be
4334  *      queried at once.
4335  */
4336 int t4_query_params(struct adapter *adap, unsigned int mbox, unsigned int pf,
4337                     unsigned int vf, unsigned int nparams, const u32 *params,
4338                     u32 *val)
4339 {
4340         int i, ret;
4341         struct fw_params_cmd c;
4342         __be32 *p = &c.param[0].mnem;
4343
4344         if (nparams > 7)
4345                 return -EINVAL;
4346
4347         memset(&c, 0, sizeof(c));
4348         c.op_to_vfn = htonl(FW_CMD_OP_V(FW_PARAMS_CMD) | FW_CMD_REQUEST_F |
4349                             FW_CMD_READ_F | FW_PARAMS_CMD_PFN_V(pf) |
4350                             FW_PARAMS_CMD_VFN_V(vf));
4351         c.retval_len16 = htonl(FW_LEN16(c));
4352         for (i = 0; i < nparams; i++, p += 2)
4353                 *p = htonl(*params++);
4354
4355         ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
4356         if (ret == 0)
4357                 for (i = 0, p = &c.param[0].val; i < nparams; i++, p += 2)
4358                         *val++ = ntohl(*p);
4359         return ret;
4360 }
4361
4362 /**
4363  *      t4_set_params_nosleep - sets FW or device parameters
4364  *      @adap: the adapter
4365  *      @mbox: mailbox to use for the FW command
4366  *      @pf: the PF
4367  *      @vf: the VF
4368  *      @nparams: the number of parameters
4369  *      @params: the parameter names
4370  *      @val: the parameter values
4371  *
4372  *       Does not ever sleep
4373  *      Sets the value of FW or device parameters.  Up to 7 parameters can be
4374  *      specified at once.
4375  */
4376 int t4_set_params_nosleep(struct adapter *adap, unsigned int mbox,
4377                           unsigned int pf, unsigned int vf,
4378                           unsigned int nparams, const u32 *params,
4379                           const u32 *val)
4380 {
4381         struct fw_params_cmd c;
4382         __be32 *p = &c.param[0].mnem;
4383
4384         if (nparams > 7)
4385                 return -EINVAL;
4386
4387         memset(&c, 0, sizeof(c));
4388         c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_PARAMS_CMD) |
4389                                 FW_CMD_REQUEST_F | FW_CMD_WRITE_F |
4390                                 FW_PARAMS_CMD_PFN_V(pf) |
4391                                 FW_PARAMS_CMD_VFN_V(vf));
4392         c.retval_len16 = cpu_to_be32(FW_LEN16(c));
4393
4394         while (nparams--) {
4395                 *p++ = cpu_to_be32(*params++);
4396                 *p++ = cpu_to_be32(*val++);
4397         }
4398
4399         return t4_wr_mbox_ns(adap, mbox, &c, sizeof(c), NULL);
4400 }
4401
4402 /**
4403  *      t4_set_params - sets FW or device parameters
4404  *      @adap: the adapter
4405  *      @mbox: mailbox to use for the FW command
4406  *      @pf: the PF
4407  *      @vf: the VF
4408  *      @nparams: the number of parameters
4409  *      @params: the parameter names
4410  *      @val: the parameter values
4411  *
4412  *      Sets the value of FW or device parameters.  Up to 7 parameters can be
4413  *      specified at once.
4414  */
4415 int t4_set_params(struct adapter *adap, unsigned int mbox, unsigned int pf,
4416                   unsigned int vf, unsigned int nparams, const u32 *params,
4417                   const u32 *val)
4418 {
4419         struct fw_params_cmd c;
4420         __be32 *p = &c.param[0].mnem;
4421
4422         if (nparams > 7)
4423                 return -EINVAL;
4424
4425         memset(&c, 0, sizeof(c));
4426         c.op_to_vfn = htonl(FW_CMD_OP_V(FW_PARAMS_CMD) | FW_CMD_REQUEST_F |
4427                             FW_CMD_WRITE_F | FW_PARAMS_CMD_PFN_V(pf) |
4428                             FW_PARAMS_CMD_VFN_V(vf));
4429         c.retval_len16 = htonl(FW_LEN16(c));
4430         while (nparams--) {
4431                 *p++ = htonl(*params++);
4432                 *p++ = htonl(*val++);
4433         }
4434
4435         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4436 }
4437
4438 /**
4439  *      t4_cfg_pfvf - configure PF/VF resource limits
4440  *      @adap: the adapter
4441  *      @mbox: mailbox to use for the FW command
4442  *      @pf: the PF being configured
4443  *      @vf: the VF being configured
4444  *      @txq: the max number of egress queues
4445  *      @txq_eth_ctrl: the max number of egress Ethernet or control queues
4446  *      @rxqi: the max number of interrupt-capable ingress queues
4447  *      @rxq: the max number of interruptless ingress queues
4448  *      @tc: the PCI traffic class
4449  *      @vi: the max number of virtual interfaces
4450  *      @cmask: the channel access rights mask for the PF/VF
4451  *      @pmask: the port access rights mask for the PF/VF
4452  *      @nexact: the maximum number of exact MPS filters
4453  *      @rcaps: read capabilities
4454  *      @wxcaps: write/execute capabilities
4455  *
4456  *      Configures resource limits and capabilities for a physical or virtual
4457  *      function.
4458  */
4459 int t4_cfg_pfvf(struct adapter *adap, unsigned int mbox, unsigned int pf,
4460                 unsigned int vf, unsigned int txq, unsigned int txq_eth_ctrl,
4461                 unsigned int rxqi, unsigned int rxq, unsigned int tc,
4462                 unsigned int vi, unsigned int cmask, unsigned int pmask,
4463                 unsigned int nexact, unsigned int rcaps, unsigned int wxcaps)
4464 {
4465         struct fw_pfvf_cmd c;
4466
4467         memset(&c, 0, sizeof(c));
4468         c.op_to_vfn = htonl(FW_CMD_OP_V(FW_PFVF_CMD) | FW_CMD_REQUEST_F |
4469                             FW_CMD_WRITE_F | FW_PFVF_CMD_PFN_V(pf) |
4470                             FW_PFVF_CMD_VFN_V(vf));
4471         c.retval_len16 = htonl(FW_LEN16(c));
4472         c.niqflint_niq = htonl(FW_PFVF_CMD_NIQFLINT_V(rxqi) |
4473                                FW_PFVF_CMD_NIQ_V(rxq));
4474         c.type_to_neq = htonl(FW_PFVF_CMD_CMASK_V(cmask) |
4475                                FW_PFVF_CMD_PMASK_V(pmask) |
4476                                FW_PFVF_CMD_NEQ_V(txq));
4477         c.tc_to_nexactf = htonl(FW_PFVF_CMD_TC_V(tc) | FW_PFVF_CMD_NVI_V(vi) |
4478                                 FW_PFVF_CMD_NEXACTF_V(nexact));
4479         c.r_caps_to_nethctrl = htonl(FW_PFVF_CMD_R_CAPS_V(rcaps) |
4480                                      FW_PFVF_CMD_WX_CAPS_V(wxcaps) |
4481                                      FW_PFVF_CMD_NETHCTRL_V(txq_eth_ctrl));
4482         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4483 }
4484
4485 /**
4486  *      t4_alloc_vi - allocate a virtual interface
4487  *      @adap: the adapter
4488  *      @mbox: mailbox to use for the FW command
4489  *      @port: physical port associated with the VI
4490  *      @pf: the PF owning the VI
4491  *      @vf: the VF owning the VI
4492  *      @nmac: number of MAC addresses needed (1 to 5)
4493  *      @mac: the MAC addresses of the VI
4494  *      @rss_size: size of RSS table slice associated with this VI
4495  *
4496  *      Allocates a virtual interface for the given physical port.  If @mac is
4497  *      not %NULL it contains the MAC addresses of the VI as assigned by FW.
4498  *      @mac should be large enough to hold @nmac Ethernet addresses, they are
4499  *      stored consecutively so the space needed is @nmac * 6 bytes.
4500  *      Returns a negative error number or the non-negative VI id.
4501  */
4502 int t4_alloc_vi(struct adapter *adap, unsigned int mbox, unsigned int port,
4503                 unsigned int pf, unsigned int vf, unsigned int nmac, u8 *mac,
4504                 unsigned int *rss_size)
4505 {
4506         int ret;
4507         struct fw_vi_cmd c;
4508
4509         memset(&c, 0, sizeof(c));
4510         c.op_to_vfn = htonl(FW_CMD_OP_V(FW_VI_CMD) | FW_CMD_REQUEST_F |
4511                             FW_CMD_WRITE_F | FW_CMD_EXEC_F |
4512                             FW_VI_CMD_PFN_V(pf) | FW_VI_CMD_VFN_V(vf));
4513         c.alloc_to_len16 = htonl(FW_VI_CMD_ALLOC_F | FW_LEN16(c));
4514         c.portid_pkd = FW_VI_CMD_PORTID_V(port);
4515         c.nmac = nmac - 1;
4516
4517         ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
4518         if (ret)
4519                 return ret;
4520
4521         if (mac) {
4522                 memcpy(mac, c.mac, sizeof(c.mac));
4523                 switch (nmac) {
4524                 case 5:
4525                         memcpy(mac + 24, c.nmac3, sizeof(c.nmac3));
4526                 case 4:
4527                         memcpy(mac + 18, c.nmac2, sizeof(c.nmac2));
4528                 case 3:
4529                         memcpy(mac + 12, c.nmac1, sizeof(c.nmac1));
4530                 case 2:
4531                         memcpy(mac + 6,  c.nmac0, sizeof(c.nmac0));
4532                 }
4533         }
4534         if (rss_size)
4535                 *rss_size = FW_VI_CMD_RSSSIZE_G(ntohs(c.rsssize_pkd));
4536         return FW_VI_CMD_VIID_G(ntohs(c.type_viid));
4537 }
4538
4539 /**
4540  *      t4_set_rxmode - set Rx properties of a virtual interface
4541  *      @adap: the adapter
4542  *      @mbox: mailbox to use for the FW command
4543  *      @viid: the VI id
4544  *      @mtu: the new MTU or -1
4545  *      @promisc: 1 to enable promiscuous mode, 0 to disable it, -1 no change
4546  *      @all_multi: 1 to enable all-multi mode, 0 to disable it, -1 no change
4547  *      @bcast: 1 to enable broadcast Rx, 0 to disable it, -1 no change
4548  *      @vlanex: 1 to enable HW VLAN extraction, 0 to disable it, -1 no change
4549  *      @sleep_ok: if true we may sleep while awaiting command completion
4550  *
4551  *      Sets Rx properties of a virtual interface.
4552  */
4553 int t4_set_rxmode(struct adapter *adap, unsigned int mbox, unsigned int viid,
4554                   int mtu, int promisc, int all_multi, int bcast, int vlanex,
4555                   bool sleep_ok)
4556 {
4557         struct fw_vi_rxmode_cmd c;
4558
4559         /* convert to FW values */
4560         if (mtu < 0)
4561                 mtu = FW_RXMODE_MTU_NO_CHG;
4562         if (promisc < 0)
4563                 promisc = FW_VI_RXMODE_CMD_PROMISCEN_M;
4564         if (all_multi < 0)
4565                 all_multi = FW_VI_RXMODE_CMD_ALLMULTIEN_M;
4566         if (bcast < 0)
4567                 bcast = FW_VI_RXMODE_CMD_BROADCASTEN_M;
4568         if (vlanex < 0)
4569                 vlanex = FW_VI_RXMODE_CMD_VLANEXEN_M;
4570
4571         memset(&c, 0, sizeof(c));
4572         c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_RXMODE_CMD) | FW_CMD_REQUEST_F |
4573                              FW_CMD_WRITE_F | FW_VI_RXMODE_CMD_VIID_V(viid));
4574         c.retval_len16 = htonl(FW_LEN16(c));
4575         c.mtu_to_vlanexen = htonl(FW_VI_RXMODE_CMD_MTU_V(mtu) |
4576                                   FW_VI_RXMODE_CMD_PROMISCEN_V(promisc) |
4577                                   FW_VI_RXMODE_CMD_ALLMULTIEN_V(all_multi) |
4578                                   FW_VI_RXMODE_CMD_BROADCASTEN_V(bcast) |
4579                                   FW_VI_RXMODE_CMD_VLANEXEN_V(vlanex));
4580         return t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), NULL, sleep_ok);
4581 }
4582
4583 /**
4584  *      t4_alloc_mac_filt - allocates exact-match filters for MAC addresses
4585  *      @adap: the adapter
4586  *      @mbox: mailbox to use for the FW command
4587  *      @viid: the VI id
4588  *      @free: if true any existing filters for this VI id are first removed
4589  *      @naddr: the number of MAC addresses to allocate filters for (up to 7)
4590  *      @addr: the MAC address(es)
4591  *      @idx: where to store the index of each allocated filter
4592  *      @hash: pointer to hash address filter bitmap
4593  *      @sleep_ok: call is allowed to sleep
4594  *
4595  *      Allocates an exact-match filter for each of the supplied addresses and
4596  *      sets it to the corresponding address.  If @idx is not %NULL it should
4597  *      have at least @naddr entries, each of which will be set to the index of
4598  *      the filter allocated for the corresponding MAC address.  If a filter
4599  *      could not be allocated for an address its index is set to 0xffff.
4600  *      If @hash is not %NULL addresses that fail to allocate an exact filter
4601  *      are hashed and update the hash filter bitmap pointed at by @hash.
4602  *
4603  *      Returns a negative error number or the number of filters allocated.
4604  */
4605 int t4_alloc_mac_filt(struct adapter *adap, unsigned int mbox,
4606                       unsigned int viid, bool free, unsigned int naddr,
4607                       const u8 **addr, u16 *idx, u64 *hash, bool sleep_ok)
4608 {
4609         int i, ret;
4610         struct fw_vi_mac_cmd c;
4611         struct fw_vi_mac_exact *p;
4612         unsigned int max_naddr = is_t4(adap->params.chip) ?
4613                                        NUM_MPS_CLS_SRAM_L_INSTANCES :
4614                                        NUM_MPS_T5_CLS_SRAM_L_INSTANCES;
4615
4616         if (naddr > 7)
4617                 return -EINVAL;
4618
4619         memset(&c, 0, sizeof(c));
4620         c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_MAC_CMD) | FW_CMD_REQUEST_F |
4621                              FW_CMD_WRITE_F | (free ? FW_CMD_EXEC_F : 0) |
4622                              FW_VI_MAC_CMD_VIID_V(viid));
4623         c.freemacs_to_len16 = htonl(FW_VI_MAC_CMD_FREEMACS_V(free) |
4624                                     FW_CMD_LEN16_V((naddr + 2) / 2));
4625
4626         for (i = 0, p = c.u.exact; i < naddr; i++, p++) {
4627                 p->valid_to_idx = htons(FW_VI_MAC_CMD_VALID_F |
4628                                       FW_VI_MAC_CMD_IDX_V(FW_VI_MAC_ADD_MAC));
4629                 memcpy(p->macaddr, addr[i], sizeof(p->macaddr));
4630         }
4631
4632         ret = t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), &c, sleep_ok);
4633         if (ret)
4634                 return ret;
4635
4636         for (i = 0, p = c.u.exact; i < naddr; i++, p++) {
4637                 u16 index = FW_VI_MAC_CMD_IDX_G(ntohs(p->valid_to_idx));
4638
4639                 if (idx)
4640                         idx[i] = index >= max_naddr ? 0xffff : index;
4641                 if (index < max_naddr)
4642                         ret++;
4643                 else if (hash)
4644                         *hash |= (1ULL << hash_mac_addr(addr[i]));
4645         }
4646         return ret;
4647 }
4648
4649 /**
4650  *      t4_change_mac - modifies the exact-match filter for a MAC address
4651  *      @adap: the adapter
4652  *      @mbox: mailbox to use for the FW command
4653  *      @viid: the VI id
4654  *      @idx: index of existing filter for old value of MAC address, or -1
4655  *      @addr: the new MAC address value
4656  *      @persist: whether a new MAC allocation should be persistent
4657  *      @add_smt: if true also add the address to the HW SMT
4658  *
4659  *      Modifies an exact-match filter and sets it to the new MAC address.
4660  *      Note that in general it is not possible to modify the value of a given
4661  *      filter so the generic way to modify an address filter is to free the one
4662  *      being used by the old address value and allocate a new filter for the
4663  *      new address value.  @idx can be -1 if the address is a new addition.
4664  *
4665  *      Returns a negative error number or the index of the filter with the new
4666  *      MAC value.
4667  */
4668 int t4_change_mac(struct adapter *adap, unsigned int mbox, unsigned int viid,
4669                   int idx, const u8 *addr, bool persist, bool add_smt)
4670 {
4671         int ret, mode;
4672         struct fw_vi_mac_cmd c;
4673         struct fw_vi_mac_exact *p = c.u.exact;
4674         unsigned int max_mac_addr = is_t4(adap->params.chip) ?
4675                                     NUM_MPS_CLS_SRAM_L_INSTANCES :
4676                                     NUM_MPS_T5_CLS_SRAM_L_INSTANCES;
4677
4678         if (idx < 0)                             /* new allocation */
4679                 idx = persist ? FW_VI_MAC_ADD_PERSIST_MAC : FW_VI_MAC_ADD_MAC;
4680         mode = add_smt ? FW_VI_MAC_SMT_AND_MPSTCAM : FW_VI_MAC_MPS_TCAM_ENTRY;
4681
4682         memset(&c, 0, sizeof(c));
4683         c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_MAC_CMD) | FW_CMD_REQUEST_F |
4684                              FW_CMD_WRITE_F | FW_VI_MAC_CMD_VIID_V(viid));
4685         c.freemacs_to_len16 = htonl(FW_CMD_LEN16_V(1));
4686         p->valid_to_idx = htons(FW_VI_MAC_CMD_VALID_F |
4687                                 FW_VI_MAC_CMD_SMAC_RESULT_V(mode) |
4688                                 FW_VI_MAC_CMD_IDX_V(idx));
4689         memcpy(p->macaddr, addr, sizeof(p->macaddr));
4690
4691         ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
4692         if (ret == 0) {
4693                 ret = FW_VI_MAC_CMD_IDX_G(ntohs(p->valid_to_idx));
4694                 if (ret >= max_mac_addr)
4695                         ret = -ENOMEM;
4696         }
4697         return ret;
4698 }
4699
4700 /**
4701  *      t4_set_addr_hash - program the MAC inexact-match hash filter
4702  *      @adap: the adapter
4703  *      @mbox: mailbox to use for the FW command
4704  *      @viid: the VI id
4705  *      @ucast: whether the hash filter should also match unicast addresses
4706  *      @vec: the value to be written to the hash filter
4707  *      @sleep_ok: call is allowed to sleep
4708  *
4709  *      Sets the 64-bit inexact-match hash filter for a virtual interface.
4710  */
4711 int t4_set_addr_hash(struct adapter *adap, unsigned int mbox, unsigned int viid,
4712                      bool ucast, u64 vec, bool sleep_ok)
4713 {
4714         struct fw_vi_mac_cmd c;
4715
4716         memset(&c, 0, sizeof(c));
4717         c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_MAC_CMD) | FW_CMD_REQUEST_F |
4718                              FW_CMD_WRITE_F | FW_VI_ENABLE_CMD_VIID_V(viid));
4719         c.freemacs_to_len16 = htonl(FW_VI_MAC_CMD_HASHVECEN_F |
4720                                     FW_VI_MAC_CMD_HASHUNIEN_V(ucast) |
4721                                     FW_CMD_LEN16_V(1));
4722         c.u.hash.hashvec = cpu_to_be64(vec);
4723         return t4_wr_mbox_meat(adap, mbox, &c, sizeof(c), NULL, sleep_ok);
4724 }
4725
4726 /**
4727  *      t4_enable_vi_params - enable/disable a virtual interface
4728  *      @adap: the adapter
4729  *      @mbox: mailbox to use for the FW command
4730  *      @viid: the VI id
4731  *      @rx_en: 1=enable Rx, 0=disable Rx
4732  *      @tx_en: 1=enable Tx, 0=disable Tx
4733  *      @dcb_en: 1=enable delivery of Data Center Bridging messages.
4734  *
4735  *      Enables/disables a virtual interface.  Note that setting DCB Enable
4736  *      only makes sense when enabling a Virtual Interface ...
4737  */
4738 int t4_enable_vi_params(struct adapter *adap, unsigned int mbox,
4739                         unsigned int viid, bool rx_en, bool tx_en, bool dcb_en)
4740 {
4741         struct fw_vi_enable_cmd c;
4742
4743         memset(&c, 0, sizeof(c));
4744         c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_ENABLE_CMD) | FW_CMD_REQUEST_F |
4745                              FW_CMD_EXEC_F | FW_VI_ENABLE_CMD_VIID_V(viid));
4746
4747         c.ien_to_len16 = htonl(FW_VI_ENABLE_CMD_IEN_V(rx_en) |
4748                                FW_VI_ENABLE_CMD_EEN_V(tx_en) | FW_LEN16(c) |
4749                                FW_VI_ENABLE_CMD_DCB_INFO_V(dcb_en));
4750         return t4_wr_mbox_ns(adap, mbox, &c, sizeof(c), NULL);
4751 }
4752
4753 /**
4754  *      t4_enable_vi - enable/disable a virtual interface
4755  *      @adap: the adapter
4756  *      @mbox: mailbox to use for the FW command
4757  *      @viid: the VI id
4758  *      @rx_en: 1=enable Rx, 0=disable Rx
4759  *      @tx_en: 1=enable Tx, 0=disable Tx
4760  *
4761  *      Enables/disables a virtual interface.
4762  */
4763 int t4_enable_vi(struct adapter *adap, unsigned int mbox, unsigned int viid,
4764                  bool rx_en, bool tx_en)
4765 {
4766         return t4_enable_vi_params(adap, mbox, viid, rx_en, tx_en, 0);
4767 }
4768
4769 /**
4770  *      t4_identify_port - identify a VI's port by blinking its LED
4771  *      @adap: the adapter
4772  *      @mbox: mailbox to use for the FW command
4773  *      @viid: the VI id
4774  *      @nblinks: how many times to blink LED at 2.5 Hz
4775  *
4776  *      Identifies a VI's port by blinking its LED.
4777  */
4778 int t4_identify_port(struct adapter *adap, unsigned int mbox, unsigned int viid,
4779                      unsigned int nblinks)
4780 {
4781         struct fw_vi_enable_cmd c;
4782
4783         memset(&c, 0, sizeof(c));
4784         c.op_to_viid = htonl(FW_CMD_OP_V(FW_VI_ENABLE_CMD) | FW_CMD_REQUEST_F |
4785                              FW_CMD_EXEC_F | FW_VI_ENABLE_CMD_VIID_V(viid));
4786         c.ien_to_len16 = htonl(FW_VI_ENABLE_CMD_LED_F | FW_LEN16(c));
4787         c.blinkdur = htons(nblinks);
4788         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4789 }
4790
4791 /**
4792  *      t4_iq_free - free an ingress queue and its FLs
4793  *      @adap: the adapter
4794  *      @mbox: mailbox to use for the FW command
4795  *      @pf: the PF owning the queues
4796  *      @vf: the VF owning the queues
4797  *      @iqtype: the ingress queue type
4798  *      @iqid: ingress queue id
4799  *      @fl0id: FL0 queue id or 0xffff if no attached FL0
4800  *      @fl1id: FL1 queue id or 0xffff if no attached FL1
4801  *
4802  *      Frees an ingress queue and its associated FLs, if any.
4803  */
4804 int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
4805                unsigned int vf, unsigned int iqtype, unsigned int iqid,
4806                unsigned int fl0id, unsigned int fl1id)
4807 {
4808         struct fw_iq_cmd c;
4809
4810         memset(&c, 0, sizeof(c));
4811         c.op_to_vfn = htonl(FW_CMD_OP_V(FW_IQ_CMD) | FW_CMD_REQUEST_F |
4812                             FW_CMD_EXEC_F | FW_IQ_CMD_PFN_V(pf) |
4813                             FW_IQ_CMD_VFN_V(vf));
4814         c.alloc_to_len16 = htonl(FW_IQ_CMD_FREE_F | FW_LEN16(c));
4815         c.type_to_iqandstindex = htonl(FW_IQ_CMD_TYPE_V(iqtype));
4816         c.iqid = htons(iqid);
4817         c.fl0id = htons(fl0id);
4818         c.fl1id = htons(fl1id);
4819         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4820 }
4821
4822 /**
4823  *      t4_eth_eq_free - free an Ethernet egress queue
4824  *      @adap: the adapter
4825  *      @mbox: mailbox to use for the FW command
4826  *      @pf: the PF owning the queue
4827  *      @vf: the VF owning the queue
4828  *      @eqid: egress queue id
4829  *
4830  *      Frees an Ethernet egress queue.
4831  */
4832 int t4_eth_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
4833                    unsigned int vf, unsigned int eqid)
4834 {
4835         struct fw_eq_eth_cmd c;
4836
4837         memset(&c, 0, sizeof(c));
4838         c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_ETH_CMD) | FW_CMD_REQUEST_F |
4839                             FW_CMD_EXEC_F | FW_EQ_ETH_CMD_PFN_V(pf) |
4840                             FW_EQ_ETH_CMD_VFN_V(vf));
4841         c.alloc_to_len16 = htonl(FW_EQ_ETH_CMD_FREE_F | FW_LEN16(c));
4842         c.eqid_pkd = htonl(FW_EQ_ETH_CMD_EQID_V(eqid));
4843         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4844 }
4845
4846 /**
4847  *      t4_ctrl_eq_free - free a control egress queue
4848  *      @adap: the adapter
4849  *      @mbox: mailbox to use for the FW command
4850  *      @pf: the PF owning the queue
4851  *      @vf: the VF owning the queue
4852  *      @eqid: egress queue id
4853  *
4854  *      Frees a control egress queue.
4855  */
4856 int t4_ctrl_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
4857                     unsigned int vf, unsigned int eqid)
4858 {
4859         struct fw_eq_ctrl_cmd c;
4860
4861         memset(&c, 0, sizeof(c));
4862         c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_CTRL_CMD) | FW_CMD_REQUEST_F |
4863                             FW_CMD_EXEC_F | FW_EQ_CTRL_CMD_PFN_V(pf) |
4864                             FW_EQ_CTRL_CMD_VFN_V(vf));
4865         c.alloc_to_len16 = htonl(FW_EQ_CTRL_CMD_FREE_F | FW_LEN16(c));
4866         c.cmpliqid_eqid = htonl(FW_EQ_CTRL_CMD_EQID_V(eqid));
4867         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4868 }
4869
4870 /**
4871  *      t4_ofld_eq_free - free an offload egress queue
4872  *      @adap: the adapter
4873  *      @mbox: mailbox to use for the FW command
4874  *      @pf: the PF owning the queue
4875  *      @vf: the VF owning the queue
4876  *      @eqid: egress queue id
4877  *
4878  *      Frees a control egress queue.
4879  */
4880 int t4_ofld_eq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
4881                     unsigned int vf, unsigned int eqid)
4882 {
4883         struct fw_eq_ofld_cmd c;
4884
4885         memset(&c, 0, sizeof(c));
4886         c.op_to_vfn = htonl(FW_CMD_OP_V(FW_EQ_OFLD_CMD) | FW_CMD_REQUEST_F |
4887                             FW_CMD_EXEC_F | FW_EQ_OFLD_CMD_PFN_V(pf) |
4888                             FW_EQ_OFLD_CMD_VFN_V(vf));
4889         c.alloc_to_len16 = htonl(FW_EQ_OFLD_CMD_FREE_F | FW_LEN16(c));
4890         c.eqid_pkd = htonl(FW_EQ_OFLD_CMD_EQID_V(eqid));
4891         return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
4892 }
4893
4894 /**
4895  *      t4_handle_fw_rpl - process a FW reply message
4896  *      @adap: the adapter
4897  *      @rpl: start of the FW message
4898  *
4899  *      Processes a FW message, such as link state change messages.
4900  */
4901 int t4_handle_fw_rpl(struct adapter *adap, const __be64 *rpl)
4902 {
4903         u8 opcode = *(const u8 *)rpl;
4904
4905         if (opcode == FW_PORT_CMD) {    /* link/module state change message */
4906                 int speed = 0, fc = 0;
4907                 const struct fw_port_cmd *p = (void *)rpl;
4908                 int chan = FW_PORT_CMD_PORTID_G(ntohl(p->op_to_portid));
4909                 int port = adap->chan_map[chan];
4910                 struct port_info *pi = adap2pinfo(adap, port);
4911                 struct link_config *lc = &pi->link_cfg;
4912                 u32 stat = ntohl(p->u.info.lstatus_to_modtype);
4913                 int link_ok = (stat & FW_PORT_CMD_LSTATUS_F) != 0;
4914                 u32 mod = FW_PORT_CMD_MODTYPE_G(stat);
4915
4916                 if (stat & FW_PORT_CMD_RXPAUSE_F)
4917                         fc |= PAUSE_RX;
4918                 if (stat & FW_PORT_CMD_TXPAUSE_F)
4919                         fc |= PAUSE_TX;
4920                 if (stat & FW_PORT_CMD_LSPEED_V(FW_PORT_CAP_SPEED_100M))
4921                         speed = 100;
4922                 else if (stat & FW_PORT_CMD_LSPEED_V(FW_PORT_CAP_SPEED_1G))
4923                         speed = 1000;
4924                 else if (stat & FW_PORT_CMD_LSPEED_V(FW_PORT_CAP_SPEED_10G))
4925                         speed = 10000;
4926                 else if (stat & FW_PORT_CMD_LSPEED_V(FW_PORT_CAP_SPEED_40G))
4927                         speed = 40000;
4928
4929                 if (link_ok != lc->link_ok || speed != lc->speed ||
4930                     fc != lc->fc) {                    /* something changed */
4931                         lc->link_ok = link_ok;
4932                         lc->speed = speed;
4933                         lc->fc = fc;
4934                         lc->supported = be16_to_cpu(p->u.info.pcap);
4935                         t4_os_link_changed(adap, port, link_ok);
4936                 }
4937                 if (mod != pi->mod_type) {
4938                         pi->mod_type = mod;
4939                         t4_os_portmod_changed(adap, port);
4940                 }
4941         }
4942         return 0;
4943 }
4944
4945 static void get_pci_mode(struct adapter *adapter, struct pci_params *p)
4946 {
4947         u16 val;
4948
4949         if (pci_is_pcie(adapter->pdev)) {
4950                 pcie_capability_read_word(adapter->pdev, PCI_EXP_LNKSTA, &val);
4951                 p->speed = val & PCI_EXP_LNKSTA_CLS;
4952                 p->width = (val & PCI_EXP_LNKSTA_NLW) >> 4;
4953         }
4954 }
4955
4956 /**
4957  *      init_link_config - initialize a link's SW state
4958  *      @lc: structure holding the link state
4959  *      @caps: link capabilities
4960  *
4961  *      Initializes the SW state maintained for each link, including the link's
4962  *      capabilities and default speed/flow-control/autonegotiation settings.
4963  */
4964 static void init_link_config(struct link_config *lc, unsigned int caps)
4965 {
4966         lc->supported = caps;
4967         lc->requested_speed = 0;
4968         lc->speed = 0;
4969         lc->requested_fc = lc->fc = PAUSE_RX | PAUSE_TX;
4970         if (lc->supported & FW_PORT_CAP_ANEG) {
4971                 lc->advertising = lc->supported & ADVERT_MASK;
4972                 lc->autoneg = AUTONEG_ENABLE;
4973                 lc->requested_fc |= PAUSE_AUTONEG;
4974         } else {
4975                 lc->advertising = 0;
4976                 lc->autoneg = AUTONEG_DISABLE;
4977         }
4978 }
4979
4980 #define CIM_PF_NOACCESS 0xeeeeeeee
4981
4982 int t4_wait_dev_ready(void __iomem *regs)
4983 {
4984         u32 whoami;
4985
4986         whoami = readl(regs + PL_WHOAMI_A);
4987         if (whoami != 0xffffffff && whoami != CIM_PF_NOACCESS)
4988                 return 0;
4989
4990         msleep(500);
4991         whoami = readl(regs + PL_WHOAMI_A);
4992         return (whoami != 0xffffffff && whoami != CIM_PF_NOACCESS ? 0 : -EIO);
4993 }
4994
4995 struct flash_desc {
4996         u32 vendor_and_model_id;
4997         u32 size_mb;
4998 };
4999
5000 static int get_flash_params(struct adapter *adap)
5001 {
5002         /* Table for non-Numonix supported flash parts.  Numonix parts are left
5003          * to the preexisting code.  All flash parts have 64KB sectors.
5004          */
5005         static struct flash_desc supported_flash[] = {
5006                 { 0x150201, 4 << 20 },       /* Spansion 4MB S25FL032P */
5007         };
5008
5009         int ret;
5010         u32 info;
5011
5012         ret = sf1_write(adap, 1, 1, 0, SF_RD_ID);
5013         if (!ret)
5014                 ret = sf1_read(adap, 3, 0, 1, &info);
5015         t4_write_reg(adap, SF_OP_A, 0);                    /* unlock SF */
5016         if (ret)
5017                 return ret;
5018
5019         for (ret = 0; ret < ARRAY_SIZE(supported_flash); ++ret)
5020                 if (supported_flash[ret].vendor_and_model_id == info) {
5021                         adap->params.sf_size = supported_flash[ret].size_mb;
5022                         adap->params.sf_nsec =
5023                                 adap->params.sf_size / SF_SEC_SIZE;
5024                         return 0;
5025                 }
5026
5027         if ((info & 0xff) != 0x20)             /* not a Numonix flash */
5028                 return -EINVAL;
5029         info >>= 16;                           /* log2 of size */
5030         if (info >= 0x14 && info < 0x18)
5031                 adap->params.sf_nsec = 1 << (info - 16);
5032         else if (info == 0x18)
5033                 adap->params.sf_nsec = 64;
5034         else
5035                 return -EINVAL;
5036         adap->params.sf_size = 1 << info;
5037         adap->params.sf_fw_start =
5038                 t4_read_reg(adap, CIM_BOOT_CFG_A) & BOOTADDR_M;
5039
5040         if (adap->params.sf_size < FLASH_MIN_SIZE)
5041                 dev_warn(adap->pdev_dev, "WARNING!!! FLASH size %#x < %#x!!!\n",
5042                          adap->params.sf_size, FLASH_MIN_SIZE);
5043         return 0;
5044 }
5045
5046 /**
5047  *      t4_prep_adapter - prepare SW and HW for operation
5048  *      @adapter: the adapter
5049  *      @reset: if true perform a HW reset
5050  *
5051  *      Initialize adapter SW state for the various HW modules, set initial
5052  *      values for some adapter tunables, take PHYs out of reset, and
5053  *      initialize the MDIO interface.
5054  */
5055 int t4_prep_adapter(struct adapter *adapter)
5056 {
5057         int ret, ver;
5058         uint16_t device_id;
5059         u32 pl_rev;
5060
5061         get_pci_mode(adapter, &adapter->params.pci);
5062         pl_rev = REV_G(t4_read_reg(adapter, PL_REV_A));
5063
5064         ret = get_flash_params(adapter);
5065         if (ret < 0) {
5066                 dev_err(adapter->pdev_dev, "error %d identifying flash\n", ret);
5067                 return ret;
5068         }
5069
5070         /* Retrieve adapter's device ID
5071          */
5072         pci_read_config_word(adapter->pdev, PCI_DEVICE_ID, &device_id);
5073         ver = device_id >> 12;
5074         adapter->params.chip = 0;
5075         switch (ver) {
5076         case CHELSIO_T4:
5077                 adapter->params.chip |= CHELSIO_CHIP_CODE(CHELSIO_T4, pl_rev);
5078                 break;
5079         case CHELSIO_T5:
5080                 adapter->params.chip |= CHELSIO_CHIP_CODE(CHELSIO_T5, pl_rev);
5081                 break;
5082         default:
5083                 dev_err(adapter->pdev_dev, "Device %d is not supported\n",
5084                         device_id);
5085                 return -EINVAL;
5086         }
5087
5088         adapter->params.cim_la_size = CIMLA_SIZE;
5089         init_cong_ctrl(adapter->params.a_wnd, adapter->params.b_wnd);
5090
5091         /*
5092          * Default port for debugging in case we can't reach FW.
5093          */
5094         adapter->params.nports = 1;
5095         adapter->params.portvec = 1;
5096         adapter->params.vpd.cclk = 50000;
5097         return 0;
5098 }
5099
5100 /**
5101  *      cxgb4_t4_bar2_sge_qregs - return BAR2 SGE Queue register information
5102  *      @adapter: the adapter
5103  *      @qid: the Queue ID
5104  *      @qtype: the Ingress or Egress type for @qid
5105  *      @pbar2_qoffset: BAR2 Queue Offset
5106  *      @pbar2_qid: BAR2 Queue ID or 0 for Queue ID inferred SGE Queues
5107  *
5108  *      Returns the BAR2 SGE Queue Registers information associated with the
5109  *      indicated Absolute Queue ID.  These are passed back in return value
5110  *      pointers.  @qtype should be T4_BAR2_QTYPE_EGRESS for Egress Queue
5111  *      and T4_BAR2_QTYPE_INGRESS for Ingress Queues.
5112  *
5113  *      This may return an error which indicates that BAR2 SGE Queue
5114  *      registers aren't available.  If an error is not returned, then the
5115  *      following values are returned:
5116  *
5117  *        *@pbar2_qoffset: the BAR2 Offset of the @qid Registers
5118  *        *@pbar2_qid: the BAR2 SGE Queue ID or 0 of @qid
5119  *
5120  *      If the returned BAR2 Queue ID is 0, then BAR2 SGE registers which
5121  *      require the "Inferred Queue ID" ability may be used.  E.g. the
5122  *      Write Combining Doorbell Buffer. If the BAR2 Queue ID is not 0,
5123  *      then these "Inferred Queue ID" register may not be used.
5124  */
5125 int cxgb4_t4_bar2_sge_qregs(struct adapter *adapter,
5126                       unsigned int qid,
5127                       enum t4_bar2_qtype qtype,
5128                       u64 *pbar2_qoffset,
5129                       unsigned int *pbar2_qid)
5130 {
5131         unsigned int page_shift, page_size, qpp_shift, qpp_mask;
5132         u64 bar2_page_offset, bar2_qoffset;
5133         unsigned int bar2_qid, bar2_qid_offset, bar2_qinferred;
5134
5135         /* T4 doesn't support BAR2 SGE Queue registers.
5136          */
5137         if (is_t4(adapter->params.chip))
5138                 return -EINVAL;
5139
5140         /* Get our SGE Page Size parameters.
5141          */
5142         page_shift = adapter->params.sge.hps + 10;
5143         page_size = 1 << page_shift;
5144
5145         /* Get the right Queues per Page parameters for our Queue.
5146          */
5147         qpp_shift = (qtype == T4_BAR2_QTYPE_EGRESS
5148                      ? adapter->params.sge.eq_qpp
5149                      : adapter->params.sge.iq_qpp);
5150         qpp_mask = (1 << qpp_shift) - 1;
5151
5152         /*  Calculate the basics of the BAR2 SGE Queue register area:
5153          *  o The BAR2 page the Queue registers will be in.
5154          *  o The BAR2 Queue ID.
5155          *  o The BAR2 Queue ID Offset into the BAR2 page.
5156          */
5157         bar2_page_offset = ((qid >> qpp_shift) << page_shift);
5158         bar2_qid = qid & qpp_mask;
5159         bar2_qid_offset = bar2_qid * SGE_UDB_SIZE;
5160
5161         /* If the BAR2 Queue ID Offset is less than the Page Size, then the
5162          * hardware will infer the Absolute Queue ID simply from the writes to
5163          * the BAR2 Queue ID Offset within the BAR2 Page (and we need to use a
5164          * BAR2 Queue ID of 0 for those writes).  Otherwise, we'll simply
5165          * write to the first BAR2 SGE Queue Area within the BAR2 Page with
5166          * the BAR2 Queue ID and the hardware will infer the Absolute Queue ID
5167          * from the BAR2 Page and BAR2 Queue ID.
5168          *
5169          * One important censequence of this is that some BAR2 SGE registers
5170          * have a "Queue ID" field and we can write the BAR2 SGE Queue ID
5171          * there.  But other registers synthesize the SGE Queue ID purely
5172          * from the writes to the registers -- the Write Combined Doorbell
5173          * Buffer is a good example.  These BAR2 SGE Registers are only
5174          * available for those BAR2 SGE Register areas where the SGE Absolute
5175          * Queue ID can be inferred from simple writes.
5176          */
5177         bar2_qoffset = bar2_page_offset;
5178         bar2_qinferred = (bar2_qid_offset < page_size);
5179         if (bar2_qinferred) {
5180                 bar2_qoffset += bar2_qid_offset;
5181                 bar2_qid = 0;
5182         }
5183
5184         *pbar2_qoffset = bar2_qoffset;
5185         *pbar2_qid = bar2_qid;
5186         return 0;
5187 }
5188
5189 /**
5190  *      t4_init_devlog_params - initialize adapter->params.devlog
5191  *      @adap: the adapter
5192  *
5193  *      Initialize various fields of the adapter's Firmware Device Log
5194  *      Parameters structure.
5195  */
5196 int t4_init_devlog_params(struct adapter *adap)
5197 {
5198         struct devlog_params *dparams = &adap->params.devlog;
5199         u32 pf_dparams;
5200         unsigned int devlog_meminfo;
5201         struct fw_devlog_cmd devlog_cmd;
5202         int ret;
5203
5204         /* If we're dealing with newer firmware, the Device Log Paramerters
5205          * are stored in a designated register which allows us to access the
5206          * Device Log even if we can't talk to the firmware.
5207          */
5208         pf_dparams =
5209                 t4_read_reg(adap, PCIE_FW_REG(PCIE_FW_PF_A, PCIE_FW_PF_DEVLOG));
5210         if (pf_dparams) {
5211                 unsigned int nentries, nentries128;
5212
5213                 dparams->memtype = PCIE_FW_PF_DEVLOG_MEMTYPE_G(pf_dparams);
5214                 dparams->start = PCIE_FW_PF_DEVLOG_ADDR16_G(pf_dparams) << 4;
5215
5216                 nentries128 = PCIE_FW_PF_DEVLOG_NENTRIES128_G(pf_dparams);
5217                 nentries = (nentries128 + 1) * 128;
5218                 dparams->size = nentries * sizeof(struct fw_devlog_e);
5219
5220                 return 0;
5221         }
5222
5223         /* Otherwise, ask the firmware for it's Device Log Parameters.
5224          */
5225         memset(&devlog_cmd, 0, sizeof(devlog_cmd));
5226         devlog_cmd.op_to_write = htonl(FW_CMD_OP_V(FW_DEVLOG_CMD) |
5227                                        FW_CMD_REQUEST_F | FW_CMD_READ_F);
5228         devlog_cmd.retval_len16 = htonl(FW_LEN16(devlog_cmd));
5229         ret = t4_wr_mbox(adap, adap->mbox, &devlog_cmd, sizeof(devlog_cmd),
5230                          &devlog_cmd);
5231         if (ret)
5232                 return ret;
5233
5234         devlog_meminfo = ntohl(devlog_cmd.memtype_devlog_memaddr16_devlog);
5235         dparams->memtype = FW_DEVLOG_CMD_MEMTYPE_DEVLOG_G(devlog_meminfo);
5236         dparams->start = FW_DEVLOG_CMD_MEMADDR16_DEVLOG_G(devlog_meminfo) << 4;
5237         dparams->size = ntohl(devlog_cmd.memsize_devlog);
5238
5239         return 0;
5240 }
5241
5242 /**
5243  *      t4_init_sge_params - initialize adap->params.sge
5244  *      @adapter: the adapter
5245  *
5246  *      Initialize various fields of the adapter's SGE Parameters structure.
5247  */
5248 int t4_init_sge_params(struct adapter *adapter)
5249 {
5250         struct sge_params *sge_params = &adapter->params.sge;
5251         u32 hps, qpp;
5252         unsigned int s_hps, s_qpp;
5253
5254         /* Extract the SGE Page Size for our PF.
5255          */
5256         hps = t4_read_reg(adapter, SGE_HOST_PAGE_SIZE_A);
5257         s_hps = (HOSTPAGESIZEPF0_S +
5258                  (HOSTPAGESIZEPF1_S - HOSTPAGESIZEPF0_S) * adapter->fn);
5259         sge_params->hps = ((hps >> s_hps) & HOSTPAGESIZEPF0_M);
5260
5261         /* Extract the SGE Egress and Ingess Queues Per Page for our PF.
5262          */
5263         s_qpp = (QUEUESPERPAGEPF0_S +
5264                 (QUEUESPERPAGEPF1_S - QUEUESPERPAGEPF0_S) * adapter->fn);
5265         qpp = t4_read_reg(adapter, SGE_EGRESS_QUEUES_PER_PAGE_PF_A);
5266         sge_params->eq_qpp = ((qpp >> s_qpp) & QUEUESPERPAGEPF0_M);
5267         qpp = t4_read_reg(adapter, SGE_INGRESS_QUEUES_PER_PAGE_PF_A);
5268         sge_params->iq_qpp = ((qpp >> s_qpp) & QUEUESPERPAGEPF0_M);
5269
5270         return 0;
5271 }
5272
5273 /**
5274  *      t4_init_tp_params - initialize adap->params.tp
5275  *      @adap: the adapter
5276  *
5277  *      Initialize various fields of the adapter's TP Parameters structure.
5278  */
5279 int t4_init_tp_params(struct adapter *adap)
5280 {
5281         int chan;
5282         u32 v;
5283
5284         v = t4_read_reg(adap, TP_TIMER_RESOLUTION_A);
5285         adap->params.tp.tre = TIMERRESOLUTION_G(v);
5286         adap->params.tp.dack_re = DELAYEDACKRESOLUTION_G(v);
5287
5288         /* MODQ_REQ_MAP defaults to setting queues 0-3 to chan 0-3 */
5289         for (chan = 0; chan < NCHAN; chan++)
5290                 adap->params.tp.tx_modq[chan] = chan;
5291
5292         /* Cache the adapter's Compressed Filter Mode and global Incress
5293          * Configuration.
5294          */
5295         t4_read_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A,
5296                          &adap->params.tp.vlan_pri_map, 1,
5297                          TP_VLAN_PRI_MAP_A);
5298         t4_read_indirect(adap, TP_PIO_ADDR_A, TP_PIO_DATA_A,
5299                          &adap->params.tp.ingress_config, 1,
5300                          TP_INGRESS_CONFIG_A);
5301
5302         /* Now that we have TP_VLAN_PRI_MAP cached, we can calculate the field
5303          * shift positions of several elements of the Compressed Filter Tuple
5304          * for this adapter which we need frequently ...
5305          */
5306         adap->params.tp.vlan_shift = t4_filter_field_shift(adap, VLAN_F);
5307         adap->params.tp.vnic_shift = t4_filter_field_shift(adap, VNIC_ID_F);
5308         adap->params.tp.port_shift = t4_filter_field_shift(adap, PORT_F);
5309         adap->params.tp.protocol_shift = t4_filter_field_shift(adap,
5310                                                                PROTOCOL_F);
5311
5312         /* If TP_INGRESS_CONFIG.VNID == 0, then TP_VLAN_PRI_MAP.VNIC_ID
5313          * represents the presence of an Outer VLAN instead of a VNIC ID.
5314          */
5315         if ((adap->params.tp.ingress_config & VNIC_F) == 0)
5316                 adap->params.tp.vnic_shift = -1;
5317
5318         return 0;
5319 }
5320
5321 /**
5322  *      t4_filter_field_shift - calculate filter field shift
5323  *      @adap: the adapter
5324  *      @filter_sel: the desired field (from TP_VLAN_PRI_MAP bits)
5325  *
5326  *      Return the shift position of a filter field within the Compressed
5327  *      Filter Tuple.  The filter field is specified via its selection bit
5328  *      within TP_VLAN_PRI_MAL (filter mode).  E.g. F_VLAN.
5329  */
5330 int t4_filter_field_shift(const struct adapter *adap, int filter_sel)
5331 {
5332         unsigned int filter_mode = adap->params.tp.vlan_pri_map;
5333         unsigned int sel;
5334         int field_shift;
5335
5336         if ((filter_mode & filter_sel) == 0)
5337                 return -1;
5338
5339         for (sel = 1, field_shift = 0; sel < filter_sel; sel <<= 1) {
5340                 switch (filter_mode & sel) {
5341                 case FCOE_F:
5342                         field_shift += FT_FCOE_W;
5343                         break;
5344                 case PORT_F:
5345                         field_shift += FT_PORT_W;
5346                         break;
5347                 case VNIC_ID_F:
5348                         field_shift += FT_VNIC_ID_W;
5349                         break;
5350                 case VLAN_F:
5351                         field_shift += FT_VLAN_W;
5352                         break;
5353                 case TOS_F:
5354                         field_shift += FT_TOS_W;
5355                         break;
5356                 case PROTOCOL_F:
5357                         field_shift += FT_PROTOCOL_W;
5358                         break;
5359                 case ETHERTYPE_F:
5360                         field_shift += FT_ETHERTYPE_W;
5361                         break;
5362                 case MACMATCH_F:
5363                         field_shift += FT_MACMATCH_W;
5364                         break;
5365                 case MPSHITTYPE_F:
5366                         field_shift += FT_MPSHITTYPE_W;
5367                         break;
5368                 case FRAGMENTATION_F:
5369                         field_shift += FT_FRAGMENTATION_W;
5370                         break;
5371                 }
5372         }
5373         return field_shift;
5374 }
5375
5376 int t4_port_init(struct adapter *adap, int mbox, int pf, int vf)
5377 {
5378         u8 addr[6];
5379         int ret, i, j = 0;
5380         struct fw_port_cmd c;
5381         struct fw_rss_vi_config_cmd rvc;
5382
5383         memset(&c, 0, sizeof(c));
5384         memset(&rvc, 0, sizeof(rvc));
5385
5386         for_each_port(adap, i) {
5387                 unsigned int rss_size;
5388                 struct port_info *p = adap2pinfo(adap, i);
5389
5390                 while ((adap->params.portvec & (1 << j)) == 0)
5391                         j++;
5392
5393                 c.op_to_portid = htonl(FW_CMD_OP_V(FW_PORT_CMD) |
5394                                        FW_CMD_REQUEST_F | FW_CMD_READ_F |
5395                                        FW_PORT_CMD_PORTID_V(j));
5396                 c.action_to_len16 = htonl(
5397                         FW_PORT_CMD_ACTION_V(FW_PORT_ACTION_GET_PORT_INFO) |
5398                         FW_LEN16(c));
5399                 ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
5400                 if (ret)
5401                         return ret;
5402
5403                 ret = t4_alloc_vi(adap, mbox, j, pf, vf, 1, addr, &rss_size);
5404                 if (ret < 0)
5405                         return ret;
5406
5407                 p->viid = ret;
5408                 p->tx_chan = j;
5409                 p->lport = j;
5410                 p->rss_size = rss_size;
5411                 memcpy(adap->port[i]->dev_addr, addr, ETH_ALEN);
5412                 adap->port[i]->dev_port = j;
5413
5414                 ret = ntohl(c.u.info.lstatus_to_modtype);
5415                 p->mdio_addr = (ret & FW_PORT_CMD_MDIOCAP_F) ?
5416                         FW_PORT_CMD_MDIOADDR_G(ret) : -1;
5417                 p->port_type = FW_PORT_CMD_PTYPE_G(ret);
5418                 p->mod_type = FW_PORT_MOD_TYPE_NA;
5419
5420                 rvc.op_to_viid = htonl(FW_CMD_OP_V(FW_RSS_VI_CONFIG_CMD) |
5421                                        FW_CMD_REQUEST_F | FW_CMD_READ_F |
5422                                        FW_RSS_VI_CONFIG_CMD_VIID(p->viid));
5423                 rvc.retval_len16 = htonl(FW_LEN16(rvc));
5424                 ret = t4_wr_mbox(adap, mbox, &rvc, sizeof(rvc), &rvc);
5425                 if (ret)
5426                         return ret;
5427                 p->rss_mode = ntohl(rvc.u.basicvirtual.defaultq_to_udpen);
5428
5429                 init_link_config(&p->link_cfg, ntohs(c.u.info.pcap));
5430                 j++;
5431         }
5432         return 0;
5433 }
5434
5435 /**
5436  *      t4_read_cimq_cfg - read CIM queue configuration
5437  *      @adap: the adapter
5438  *      @base: holds the queue base addresses in bytes
5439  *      @size: holds the queue sizes in bytes
5440  *      @thres: holds the queue full thresholds in bytes
5441  *
5442  *      Returns the current configuration of the CIM queues, starting with
5443  *      the IBQs, then the OBQs.
5444  */
5445 void t4_read_cimq_cfg(struct adapter *adap, u16 *base, u16 *size, u16 *thres)
5446 {
5447         unsigned int i, v;
5448         int cim_num_obq = is_t4(adap->params.chip) ?
5449                                 CIM_NUM_OBQ : CIM_NUM_OBQ_T5;
5450
5451         for (i = 0; i < CIM_NUM_IBQ; i++) {
5452                 t4_write_reg(adap, CIM_QUEUE_CONFIG_REF_A, IBQSELECT_F |
5453                              QUENUMSELECT_V(i));
5454                 v = t4_read_reg(adap, CIM_QUEUE_CONFIG_CTRL_A);
5455                 /* value is in 256-byte units */
5456                 *base++ = CIMQBASE_G(v) * 256;
5457                 *size++ = CIMQSIZE_G(v) * 256;
5458                 *thres++ = QUEFULLTHRSH_G(v) * 8; /* 8-byte unit */
5459         }
5460         for (i = 0; i < cim_num_obq; i++) {
5461                 t4_write_reg(adap, CIM_QUEUE_CONFIG_REF_A, OBQSELECT_F |
5462                              QUENUMSELECT_V(i));
5463                 v = t4_read_reg(adap, CIM_QUEUE_CONFIG_CTRL_A);
5464                 /* value is in 256-byte units */
5465                 *base++ = CIMQBASE_G(v) * 256;
5466                 *size++ = CIMQSIZE_G(v) * 256;
5467         }
5468 }
5469
5470 /**
5471  *      t4_read_cim_ibq - read the contents of a CIM inbound queue
5472  *      @adap: the adapter
5473  *      @qid: the queue index
5474  *      @data: where to store the queue contents
5475  *      @n: capacity of @data in 32-bit words
5476  *
5477  *      Reads the contents of the selected CIM queue starting at address 0 up
5478  *      to the capacity of @data.  @n must be a multiple of 4.  Returns < 0 on
5479  *      error and the number of 32-bit words actually read on success.
5480  */
5481 int t4_read_cim_ibq(struct adapter *adap, unsigned int qid, u32 *data, size_t n)
5482 {
5483         int i, err, attempts;
5484         unsigned int addr;
5485         const unsigned int nwords = CIM_IBQ_SIZE * 4;
5486
5487         if (qid > 5 || (n & 3))
5488                 return -EINVAL;
5489
5490         addr = qid * nwords;
5491         if (n > nwords)
5492                 n = nwords;
5493
5494         /* It might take 3-10ms before the IBQ debug read access is allowed.
5495          * Wait for 1 Sec with a delay of 1 usec.
5496          */
5497         attempts = 1000000;
5498
5499         for (i = 0; i < n; i++, addr++) {
5500                 t4_write_reg(adap, CIM_IBQ_DBG_CFG_A, IBQDBGADDR_V(addr) |
5501                              IBQDBGEN_F);
5502                 err = t4_wait_op_done(adap, CIM_IBQ_DBG_CFG_A, IBQDBGBUSY_F, 0,
5503                                       attempts, 1);
5504                 if (err)
5505                         return err;
5506                 *data++ = t4_read_reg(adap, CIM_IBQ_DBG_DATA_A);
5507         }
5508         t4_write_reg(adap, CIM_IBQ_DBG_CFG_A, 0);
5509         return i;
5510 }
5511
5512 /**
5513  *      t4_read_cim_obq - read the contents of a CIM outbound queue
5514  *      @adap: the adapter
5515  *      @qid: the queue index
5516  *      @data: where to store the queue contents
5517  *      @n: capacity of @data in 32-bit words
5518  *
5519  *      Reads the contents of the selected CIM queue starting at address 0 up
5520  *      to the capacity of @data.  @n must be a multiple of 4.  Returns < 0 on
5521  *      error and the number of 32-bit words actually read on success.
5522  */
5523 int t4_read_cim_obq(struct adapter *adap, unsigned int qid, u32 *data, size_t n)
5524 {
5525         int i, err;
5526         unsigned int addr, v, nwords;
5527         int cim_num_obq = is_t4(adap->params.chip) ?
5528                                 CIM_NUM_OBQ : CIM_NUM_OBQ_T5;
5529
5530         if ((qid > (cim_num_obq - 1)) || (n & 3))
5531                 return -EINVAL;
5532
5533         t4_write_reg(adap, CIM_QUEUE_CONFIG_REF_A, OBQSELECT_F |
5534                      QUENUMSELECT_V(qid));
5535         v = t4_read_reg(adap, CIM_QUEUE_CONFIG_CTRL_A);
5536
5537         addr = CIMQBASE_G(v) * 64;    /* muliple of 256 -> muliple of 4 */
5538         nwords = CIMQSIZE_G(v) * 64;  /* same */
5539         if (n > nwords)
5540                 n = nwords;
5541
5542         for (i = 0; i < n; i++, addr++) {
5543                 t4_write_reg(adap, CIM_OBQ_DBG_CFG_A, OBQDBGADDR_V(addr) |
5544                              OBQDBGEN_F);
5545                 err = t4_wait_op_done(adap, CIM_OBQ_DBG_CFG_A, OBQDBGBUSY_F, 0,
5546                                       2, 1);
5547                 if (err)
5548                         return err;
5549                 *data++ = t4_read_reg(adap, CIM_OBQ_DBG_DATA_A);
5550         }
5551         t4_write_reg(adap, CIM_OBQ_DBG_CFG_A, 0);
5552         return i;
5553 }
5554
5555 /**
5556  *      t4_cim_read - read a block from CIM internal address space
5557  *      @adap: the adapter
5558  *      @addr: the start address within the CIM address space
5559  *      @n: number of words to read
5560  *      @valp: where to store the result
5561  *
5562  *      Reads a block of 4-byte words from the CIM intenal address space.
5563  */
5564 int t4_cim_read(struct adapter *adap, unsigned int addr, unsigned int n,
5565                 unsigned int *valp)
5566 {
5567         int ret = 0;
5568
5569         if (t4_read_reg(adap, CIM_HOST_ACC_CTRL_A) & HOSTBUSY_F)
5570                 return -EBUSY;
5571
5572         for ( ; !ret && n--; addr += 4) {
5573                 t4_write_reg(adap, CIM_HOST_ACC_CTRL_A, addr);
5574                 ret = t4_wait_op_done(adap, CIM_HOST_ACC_CTRL_A, HOSTBUSY_F,
5575                                       0, 5, 2);
5576                 if (!ret)
5577                         *valp++ = t4_read_reg(adap, CIM_HOST_ACC_DATA_A);
5578         }
5579         return ret;
5580 }
5581
5582 /**
5583  *      t4_cim_write - write a block into CIM internal address space
5584  *      @adap: the adapter
5585  *      @addr: the start address within the CIM address space
5586  *      @n: number of words to write
5587  *      @valp: set of values to write
5588  *
5589  *      Writes a block of 4-byte words into the CIM intenal address space.
5590  */
5591 int t4_cim_write(struct adapter *adap, unsigned int addr, unsigned int n,
5592                  const unsigned int *valp)
5593 {
5594         int ret = 0;
5595
5596         if (t4_read_reg(adap, CIM_HOST_ACC_CTRL_A) & HOSTBUSY_F)
5597                 return -EBUSY;
5598
5599         for ( ; !ret && n--; addr += 4) {
5600                 t4_write_reg(adap, CIM_HOST_ACC_DATA_A, *valp++);
5601                 t4_write_reg(adap, CIM_HOST_ACC_CTRL_A, addr | HOSTWRITE_F);
5602                 ret = t4_wait_op_done(adap, CIM_HOST_ACC_CTRL_A, HOSTBUSY_F,
5603                                       0, 5, 2);
5604         }
5605         return ret;
5606 }
5607
5608 static int t4_cim_write1(struct adapter *adap, unsigned int addr,
5609                          unsigned int val)
5610 {
5611         return t4_cim_write(adap, addr, 1, &val);
5612 }
5613
5614 /**
5615  *      t4_cim_read_la - read CIM LA capture buffer
5616  *      @adap: the adapter
5617  *      @la_buf: where to store the LA data
5618  *      @wrptr: the HW write pointer within the capture buffer
5619  *
5620  *      Reads the contents of the CIM LA buffer with the most recent entry at
5621  *      the end of the returned data and with the entry at @wrptr first.
5622  *      We try to leave the LA in the running state we find it in.
5623  */
5624 int t4_cim_read_la(struct adapter *adap, u32 *la_buf, unsigned int *wrptr)
5625 {
5626         int i, ret;
5627         unsigned int cfg, val, idx;
5628
5629         ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &cfg);
5630         if (ret)
5631                 return ret;
5632
5633         if (cfg & UPDBGLAEN_F) {        /* LA is running, freeze it */
5634                 ret = t4_cim_write1(adap, UP_UP_DBG_LA_CFG_A, 0);
5635                 if (ret)
5636                         return ret;
5637         }
5638
5639         ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &val);
5640         if (ret)
5641                 goto restart;
5642
5643         idx = UPDBGLAWRPTR_G(val);
5644         if (wrptr)
5645                 *wrptr = idx;
5646
5647         for (i = 0; i < adap->params.cim_la_size; i++) {
5648                 ret = t4_cim_write1(adap, UP_UP_DBG_LA_CFG_A,
5649                                     UPDBGLARDPTR_V(idx) | UPDBGLARDEN_F);
5650                 if (ret)
5651                         break;
5652                 ret = t4_cim_read(adap, UP_UP_DBG_LA_CFG_A, 1, &val);
5653                 if (ret)
5654                         break;
5655                 if (val & UPDBGLARDEN_F) {
5656                         ret = -ETIMEDOUT;
5657                         break;
5658                 }
5659                 ret = t4_cim_read(adap, UP_UP_DBG_LA_DATA_A, 1, &la_buf[i]);
5660                 if (ret)
5661                         break;
5662                 idx = (idx + 1) & UPDBGLARDPTR_M;
5663         }
5664 restart:
5665         if (cfg & UPDBGLAEN_F) {
5666                 int r = t4_cim_write1(adap, UP_UP_DBG_LA_CFG_A,
5667                                       cfg & ~UPDBGLARDEN_F);
5668                 if (!ret)
5669                         ret = r;
5670         }
5671         return ret;
5672 }
5673
5674 /**
5675  *      t4_tp_read_la - read TP LA capture buffer
5676  *      @adap: the adapter
5677  *      @la_buf: where to store the LA data
5678  *      @wrptr: the HW write pointer within the capture buffer
5679  *
5680  *      Reads the contents of the TP LA buffer with the most recent entry at
5681  *      the end of the returned data and with the entry at @wrptr first.
5682  *      We leave the LA in the running state we find it in.
5683  */
5684 void t4_tp_read_la(struct adapter *adap, u64 *la_buf, unsigned int *wrptr)
5685 {
5686         bool last_incomplete;
5687         unsigned int i, cfg, val, idx;
5688
5689         cfg = t4_read_reg(adap, TP_DBG_LA_CONFIG_A) & 0xffff;
5690         if (cfg & DBGLAENABLE_F)                        /* freeze LA */
5691                 t4_write_reg(adap, TP_DBG_LA_CONFIG_A,
5692                              adap->params.tp.la_mask | (cfg ^ DBGLAENABLE_F));
5693
5694         val = t4_read_reg(adap, TP_DBG_LA_CONFIG_A);
5695         idx = DBGLAWPTR_G(val);
5696         last_incomplete = DBGLAMODE_G(val) >= 2 && (val & DBGLAWHLF_F) == 0;
5697         if (last_incomplete)
5698                 idx = (idx + 1) & DBGLARPTR_M;
5699         if (wrptr)
5700                 *wrptr = idx;
5701
5702         val &= 0xffff;
5703         val &= ~DBGLARPTR_V(DBGLARPTR_M);
5704         val |= adap->params.tp.la_mask;
5705
5706         for (i = 0; i < TPLA_SIZE; i++) {
5707                 t4_write_reg(adap, TP_DBG_LA_CONFIG_A, DBGLARPTR_V(idx) | val);
5708                 la_buf[i] = t4_read_reg64(adap, TP_DBG_LA_DATAL_A);
5709                 idx = (idx + 1) & DBGLARPTR_M;
5710         }
5711
5712         /* Wipe out last entry if it isn't valid */
5713         if (last_incomplete)
5714                 la_buf[TPLA_SIZE - 1] = ~0ULL;
5715
5716         if (cfg & DBGLAENABLE_F)                    /* restore running state */
5717                 t4_write_reg(adap, TP_DBG_LA_CONFIG_A,
5718                              cfg | adap->params.tp.la_mask);
5719 }