cxgb4: Add support for T4 configuration file

Starting with T4 firmware version 1.3.11.0 the firmware now supports device
configuration via a Firmware Configuration File. The Firmware Configuration
File was primarily developed in order to centralize all of the configuration,
resource allocation, etc. for Unified Wire operation where multiple
Physical / Virtual Function Drivers would be using a T4 adapter simultaneously.

The Firmware Configuration file can live in three locations as shown below
in order of precedence.
1) User defined configuration file: /lib/firmware/cxgb4/t4-config.txt
2) Factory Default configuration file written to FLASH within
   the manufacturing process.
3) Hardwired driver configuration.

Signed-off-by: Jay Hernandez <jay@chelsio.com>
Signed-off-by: Vipul Pandya <vipul@chelsio.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

6 files changed, 920 insertions, 133 deletions

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
index ae040cf255a4..777cbb4f62bb 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
@@ -211,6 +211,9 @@ struct tp_err_stats {
 struct tp_params {
         unsigned int ntxchan;        /* # of Tx channels */
         unsigned int tre;            /* log2 of core clocks per TP tick */
+
+        uint32_t dack_re;            /* DACK timer resolution */
+        unsigned short tx_modq[NCHAN];  /* channel to modulation queue map */
 };
 
 struct vpd_params {
@@ -519,6 +522,8 @@ struct adapter {
         struct net_device *port[MAX_NPORTS];
         u8 chan_map[NCHAN];                   /* channel -> port map */
 
+        unsigned int l2t_start;
+        unsigned int l2t_end;
         struct l2t_data *l2t;
         void *uld_handle[CXGB4_ULD_MAX];
         struct list_head list_node;
@@ -683,7 +688,9 @@ int t4_restart_aneg(struct adapter *adap, unsigned int mbox, unsigned int port);
 int t4_memory_write(struct adapter *adap, int mtype, u32 addr, u32 len,
                     __be32 *buf);
 int t4_seeprom_wp(struct adapter *adapter, bool enable);
+int get_vpd_params(struct adapter *adapter, struct vpd_params *p);
 int t4_load_fw(struct adapter *adapter, const u8 *fw_data, unsigned int size);
+unsigned int t4_flash_cfg_addr(struct adapter *adapter);
 int t4_check_fw_version(struct adapter *adapter);
 int t4_prep_adapter(struct adapter *adapter);
 int t4_port_init(struct adapter *adap, int mbox, int pf, int vf);
@@ -698,6 +705,8 @@ int t4_edc_read(struct adapter *adap, int idx, u32 addr, __be32 *data,
 
 void t4_get_port_stats(struct adapter *adap, int idx, struct port_stats *p);
 void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log);
+void t4_tp_wr_bits_indirect(struct adapter *adap, unsigned int addr,
+                            unsigned int mask, unsigned int val);
 void t4_tp_get_tcp_stats(struct adapter *adap, struct tp_tcp_stats *v4,
                          struct tp_tcp_stats *v6);
 void t4_load_mtus(struct adapter *adap, const unsigned short *mtus,
@@ -713,6 +722,12 @@ int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox,
 int t4_fw_bye(struct adapter *adap, unsigned int mbox);
 int t4_early_init(struct adapter *adap, unsigned int mbox);
 int t4_fw_reset(struct adapter *adap, unsigned int mbox, int reset);
+int t4_fw_config_file(struct adapter *adap, unsigned int mbox,
+                      unsigned int mtype, unsigned int maddr,
+                      u32 *finiver, u32 *finicsum, u32 *cfcsum);
+int t4_fixup_host_params(struct adapter *adap, unsigned int page_size,
+                          unsigned int cache_line_size);
+int t4_fw_initialize(struct adapter *adap, unsigned int mbox);
 int t4_query_params(struct adapter *adap, unsigned int mbox, unsigned int pf,
                     unsigned int vf, unsigned int nparams, const u32 *params,
                     u32 *val);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
index 34d510dd56a8..cb3e663c30dc 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
@@ -193,6 +193,7 @@ static DEFINE_PCI_DEVICE_TABLE(cxgb4_pci_tbl) = {
 };
 
 #define FW_FNAME "cxgb4/t4fw.bin"
+#define FW_CFNAME "cxgb4/t4-config.txt"
 
 MODULE_DESCRIPTION(DRV_DESC);
 MODULE_AUTHOR("Chelsio Communications");
@@ -201,6 +202,17 @@ MODULE_VERSION(DRV_VERSION);
 MODULE_DEVICE_TABLE(pci, cxgb4_pci_tbl);
 MODULE_FIRMWARE(FW_FNAME);
 
+/*
+ * Normally we're willing to become the firmware's Master PF but will be happy
+ * if another PF has already become the Master and initialized the adapter.
+ * Setting "force_init" will cause this driver to forcibly establish itself as
+ * the Master PF and initialize the adapter.
+ */
+static uint force_init;
+
+module_param(force_init, uint, 0644);
+MODULE_PARM_DESC(force_init, "Forcibly become Master PF and initialize adapter");
+
 static int dflt_msg_enable = DFLT_MSG_ENABLE;
 
 module_param(dflt_msg_enable, int, 0644);
@@ -236,6 +248,20 @@ module_param_array(intr_cnt, uint, NULL, 0644);
 MODULE_PARM_DESC(intr_cnt,
                  "thresholds 1..3 for queue interrupt packet counters");
 
+/*
+ * Normally we tell the chip to deliver Ingress Packets into our DMA buffers
+ * offset by 2 bytes in order to have the IP headers line up on 4-byte
+ * boundaries.  This is a requirement for many architectures which will throw
+ * a machine check fault if an attempt is made to access one of the 4-byte IP
+ * header fields on a non-4-byte boundary.  And it's a major performance issue
+ * even on some architectures which allow it like some implementations of the
+ * x86 ISA.  However, some architectures don't mind this and for some very
+ * edge-case performance sensitive applications (like forwarding large volumes
+ * of small packets), setting this DMA offset to 0 will decrease the number of
+ * PCI-E Bus transfers enough to measurably affect performance.
+ */
+static int rx_dma_offset = 2;
+
 static bool vf_acls;
 
 #ifdef CONFIG_PCI_IOV
@@ -3076,6 +3102,10 @@ static void setup_memwin(struct adapter *adap)
         t4_write_reg(adap, PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, 2),
                      (bar0 + MEMWIN2_BASE) | BIR(0) |
                      WINDOW(ilog2(MEMWIN2_APERTURE) - 10));
+}
+
+static void setup_memwin_rdma(struct adapter *adap)
+{
         if (adap->vres.ocq.size) {
                 unsigned int start, sz_kb;
 
@@ -3155,6 +3185,232 @@ static int adap_init1(struct adapter *adap, struct fw_caps_config_cmd *c)
 
 /*
  * Phase 0 of initialization: contact FW, obtain config, perform basic init.
+ *
+ * If the firmware we're dealing with has Configuration File support, then
+ * we use that to perform all configuration
+ */
+
+/*
+ * Tweak configuration based on module parameters, etc.  Most of these have
+ * defaults assigned to them by Firmware Configuration Files (if we're using
+ * them) but need to be explicitly set if we're using hard-coded
+ * initialization.  But even in the case of using Firmware Configuration
+ * Files, we'd like to expose the ability to change these via module
+ * parameters so these are essentially common tweaks/settings for
+ * Configuration Files and hard-coded initialization ...
+ */
+static int adap_init0_tweaks(struct adapter *adapter)
+{
+        /*
+         * Fix up various Host-Dependent Parameters like Page Size, Cache
+         * Line Size, etc.  The firmware default is for a 4KB Page Size and
+         * 64B Cache Line Size ...
+         */
+        t4_fixup_host_params(adapter, PAGE_SIZE, L1_CACHE_BYTES);
+
+        /*
+         * Process module parameters which affect early initialization.
+         */
+        if (rx_dma_offset != 2 && rx_dma_offset != 0) {
+                dev_err(&adapter->pdev->dev,
+                        "Ignoring illegal rx_dma_offset=%d, using 2\n",
+                        rx_dma_offset);
+                rx_dma_offset = 2;
+        }
+        t4_set_reg_field(adapter, SGE_CONTROL,
+                         PKTSHIFT_MASK,
+                         PKTSHIFT(rx_dma_offset));
+
+        /*
+         * Don't include the "IP Pseudo Header" in CPL_RX_PKT checksums: Linux
+         * adds the pseudo header itself.
+         */
+        t4_tp_wr_bits_indirect(adapter, TP_INGRESS_CONFIG,
+                               CSUM_HAS_PSEUDO_HDR, 0);
+
+        return 0;
+}
+
+/*
+ * Attempt to initialize the adapter via a Firmware Configuration File.
+ */
+static int adap_init0_config(struct adapter *adapter, int reset)
+{
+        struct fw_caps_config_cmd caps_cmd;
+        const struct firmware *cf;
+        unsigned long mtype = 0, maddr = 0;
+        u32 finiver, finicsum, cfcsum;
+        int ret, using_flash;
+
+        /*
+         * Reset device if necessary.
+         */
+        if (reset) {
+                ret = t4_fw_reset(adapter, adapter->mbox,
+                                  PIORSTMODE | PIORST);
+                if (ret < 0)
+                        goto bye;
+        }
+
+        /*
+         * If we have a T4 configuration file under /lib/firmware/cxgb4/,
+         * then use that.  Otherwise, use the configuration file stored
+         * in the adapter flash ...
+         */
+        ret = request_firmware(&cf, FW_CFNAME, adapter->pdev_dev);
+        if (ret < 0) {
+                using_flash = 1;
+                mtype = FW_MEMTYPE_CF_FLASH;
+                maddr = t4_flash_cfg_addr(adapter);
+        } else {
+                u32 params[7], val[7];
+
+                using_flash = 0;
+                if (cf->size >= FLASH_CFG_MAX_SIZE)
+                        ret = -ENOMEM;
+                else {
+                        params[0] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
+                             FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_CF));
+                        ret = t4_query_params(adapter, adapter->mbox,
+                                              adapter->fn, 0, 1, params, val);
+                        if (ret == 0) {
+                                /*
+                                 * For t4_memory_write() below addresses and
+                                 * sizes have to be in terms of multiples of 4
+                                 * bytes.  So, if the Configuration File isn't
+                                 * a multiple of 4 bytes in length we'll have
+                                 * to write that out separately since we can't
+                                 * guarantee that the bytes following the
+                                 * residual byte in the buffer returned by
+                                 * request_firmware() are zeroed out ...
+                                 */
+                                size_t resid = cf->size & 0x3;
+                                size_t size = cf->size & ~0x3;
+                                __be32 *data = (__be32 *)cf->data;
+
+                                mtype = FW_PARAMS_PARAM_Y_GET(val[0]);
+                                maddr = FW_PARAMS_PARAM_Z_GET(val[0]) << 16;
+
+                                ret = t4_memory_write(adapter, mtype, maddr,
+                                                      size, data);
+                                if (ret == 0 && resid != 0) {
+                                        union {
+                                                __be32 word;
+                                                char buf[4];
+                                        } last;
+                                        int i;
+
+                                        last.word = data[size >> 2];
+                                        for (i = resid; i < 4; i++)
+                                                last.buf[i] = 0;
+                                        ret = t4_memory_write(adapter, mtype,
+                                                              maddr + size,
+                                                              4, &last.word);
+                                }
+                        }
+                }
+
+                release_firmware(cf);
+                if (ret)
+                        goto bye;
+        }
+
+        /*
+         * Issue a Capability Configuration command to the firmware to get it
+         * to parse the Configuration File.  We don't use t4_fw_config_file()
+         * because we want the ability to modify various features after we've
+         * processed the configuration file ...
+         */
+        memset(&caps_cmd, 0, sizeof(caps_cmd));
+        caps_cmd.op_to_write =
+                htonl(FW_CMD_OP(FW_CAPS_CONFIG_CMD) |
+                      FW_CMD_REQUEST |
+                      FW_CMD_READ);
+        caps_cmd.retval_len16 =
+                htonl(FW_CAPS_CONFIG_CMD_CFVALID |
+                      FW_CAPS_CONFIG_CMD_MEMTYPE_CF(mtype) |
+                      FW_CAPS_CONFIG_CMD_MEMADDR64K_CF(maddr >> 16) |
+                      FW_LEN16(caps_cmd));
+        ret = t4_wr_mbox(adapter, adapter->mbox, &caps_cmd, sizeof(caps_cmd),
+                         &caps_cmd);
+        if (ret < 0)
+                goto bye;
+
+        finiver = ntohl(caps_cmd.finiver);
+        finicsum = ntohl(caps_cmd.finicsum);
+        cfcsum = ntohl(caps_cmd.cfcsum);
+        if (finicsum != cfcsum)
+                dev_warn(adapter->pdev_dev, "Configuration File checksum "\
+                         "mismatch: [fini] csum=%#x, computed csum=%#x\n",
+                         finicsum, cfcsum);
+
+        /*
+         * If we're a pure NIC driver then disable all offloading facilities.
+         * This will allow the firmware to optimize aspects of the hardware
+         * configuration which will result in improved performance.
+         */
+        caps_cmd.ofldcaps = 0;
+        caps_cmd.iscsicaps = 0;
+        caps_cmd.rdmacaps = 0;
+        caps_cmd.fcoecaps = 0;
+
+        /*
+         * And now tell the firmware to use the configuration we just loaded.
+         */
+        caps_cmd.op_to_write =
+                htonl(FW_CMD_OP(FW_CAPS_CONFIG_CMD) |
+                      FW_CMD_REQUEST |
+                      FW_CMD_WRITE);
+        caps_cmd.retval_len16 = htonl(FW_LEN16(caps_cmd));
+        ret = t4_wr_mbox(adapter, adapter->mbox, &caps_cmd, sizeof(caps_cmd),
+                         NULL);
+        if (ret < 0)
+                goto bye;
+
+        /*
+         * Tweak configuration based on system architecture, module
+         * parameters, etc.
+         */
+        ret = adap_init0_tweaks(adapter);
+        if (ret < 0)
+                goto bye;
+
+        /*
+         * And finally tell the firmware to initialize itself using the
+         * parameters from the Configuration File.
+         */
+        ret = t4_fw_initialize(adapter, adapter->mbox);
+        if (ret < 0)
+                goto bye;
+
+        /*
+         * Return successfully and note that we're operating with parameters
+         * not supplied by the driver, rather than from hard-wired
+         * initialization constants burried in the driver.
+         */
+        adapter->flags |= USING_SOFT_PARAMS;
+        dev_info(adapter->pdev_dev, "Successfully configured using Firmware "\
+                 "Configuration File %s, version %#x, computed checksum %#x\n",
+                 (using_flash
+                  ? "in device FLASH"
+                  : "/lib/firmware/" FW_CFNAME),
+                 finiver, cfcsum);
+        return 0;
+
+        /*
+         * Something bad happened.  Return the error ...  (If the "error"
+         * is that there's no Configuration File on the adapter we don't
+         * want to issue a warning since this is fairly common.)
+         */
+bye:
+        if (ret != -ENOENT)
+                dev_warn(adapter->pdev_dev, "Configuration file error %d\n",
+                         -ret);
+        return ret;
+}
+
+/*
+ * Phase 0 of initialization: contact FW, obtain config, perform basic init.
  */
 static int adap_init0(struct adapter *adap)
 {
@@ -3162,72 +3418,197 @@ static int adap_init0(struct adapter *adap)
         u32 v, port_vec;
         enum dev_state state;
         u32 params[7], val[7];
-        struct fw_caps_config_cmd c;
+        int reset = 1, j;
 
-        ret = t4_check_fw_version(adap);
-        if (ret == -EINVAL || ret > 0) {
-                if (upgrade_fw(adap) >= 0)             /* recache FW version */
-                        ret = t4_check_fw_version(adap);
-        }
-        if (ret < 0)
-                return ret;
-
-        /* contact FW, request master */
-        ret = t4_fw_hello(adap, adap->fn, adap->fn, MASTER_MUST, &state);
+        /*
+         * Contact FW, advertising Master capability (and potentially forcing
+         * ourselves as the Master PF if our module parameter force_init is
+         * set).
+         */
+        ret = t4_fw_hello(adap, adap->mbox, adap->fn,
+                          force_init ? MASTER_MUST : MASTER_MAY,
+                          &state);
         if (ret < 0) {
                 dev_err(adap->pdev_dev, "could not connect to FW, error %d\n",
                         ret);
                 return ret;
         }
+        if (ret == adap->mbox)
+                adap->flags |= MASTER_PF;
+        if (force_init && state == DEV_STATE_INIT)
+                state = DEV_STATE_UNINIT;
 
-        /* reset device */
-        ret = t4_fw_reset(adap, adap->fn, PIORSTMODE | PIORST);
-        if (ret < 0)
-                goto bye;
-
-        for (v = 0; v < SGE_NTIMERS - 1; v++)
-                adap->sge.timer_val[v] = min(intr_holdoff[v], MAX_SGE_TIMERVAL);
-        adap->sge.timer_val[SGE_NTIMERS - 1] = MAX_SGE_TIMERVAL;
-        adap->sge.counter_val[0] = 1;
-        for (v = 1; v < SGE_NCOUNTERS; v++)
-                adap->sge.counter_val[v] = min(intr_cnt[v - 1],
-                                               THRESHOLD_3_MASK);
-#define FW_PARAM_DEV(param) \
-        (FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) | \
-         FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_##param))
+        /*
+         * If we're the Master PF Driver and the device is uninitialized,
+         * then let's consider upgrading the firmware ...  (We always want
+         * to check the firmware version number in order to A. get it for
+         * later reporting and B. to warn if the currently loaded firmware
+         * is excessively mismatched relative to the driver.)
+         */
+        ret = t4_check_fw_version(adap);
+        if ((adap->flags & MASTER_PF) && state != DEV_STATE_INIT) {
+                if (ret == -EINVAL || ret > 0) {
+                        if (upgrade_fw(adap) >= 0) {
+                                /*
+                                 * Note that the chip was reset as part of the
+                                 * firmware upgrade so we don't reset it again
+                                 * below and grab the new firmware version.
+                                 */
+                                reset = 0;
+                                ret = t4_check_fw_version(adap);
+                        }
+                }
+                if (ret < 0)
+                        return ret;
+        }
 
-        params[0] = FW_PARAM_DEV(CCLK);
-        ret = t4_query_params(adap, adap->fn, adap->fn, 0, 1, params, val);
+        /*
+         * Grab VPD parameters.  This should be done after we establish a
+         * connection to the firmware since some of the VPD parameters
+         * (notably the Core Clock frequency) are retrieved via requests to
+         * the firmware.  On the other hand, we need these fairly early on
+         * so we do this right after getting ahold of the firmware.
+         */
+        ret = get_vpd_params(adap, &adap->params.vpd);
         if (ret < 0)
                 goto bye;
-        adap->params.vpd.cclk = val[0];
 
-        ret = adap_init1(adap, &c);
+        /*
+         * Find out what ports are available to us.
+         */
+        v =
+            FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
+            FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_PORTVEC);
+        ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 1, &v, &port_vec);
         if (ret < 0)
                 goto bye;
 
+        adap->params.nports = hweight32(port_vec);
+        adap->params.portvec = port_vec;
+
+        /*
+         * If the firmware is initialized already (and we're not forcing a
+         * master initialization), note that we're living with existing
+         * adapter parameters.  Otherwise, it's time to try initializing the
+         * adapter ...
+         */
+        if (state == DEV_STATE_INIT) {
+                dev_info(adap->pdev_dev, "Coming up as %s: "\
+                         "Adapter already initialized\n",
+                         adap->flags & MASTER_PF ? "MASTER" : "SLAVE");
+                adap->flags |= USING_SOFT_PARAMS;
+        } else {
+                dev_info(adap->pdev_dev, "Coming up as MASTER: "\
+                         "Initializing adapter\n");
+                /*
+                 * Find out whether we're dealing with a version of
+                 * the firmware which has configuration file support.
+                 */
+                params[0] = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
+                             FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_CF));
+                ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 1,
+                                      params, val);
+
+                /*
+                 * If the firmware doesn't support Configuration
+                 * Files warn user and exit,
+                 */
+                if (ret < 0)
+                        dev_warn(adap->pdev_dev, "Firmware doesn't support "\
+                                 "configuration file.\n");
+                else {
+                        /*
+                         * The firmware provides us with a memory
+                         * buffer where we can load a Configuration
+                         * File from the host if we want to override
+                         * the Configuration File in flash.
+                         */
+
+                        ret = adap_init0_config(adap, reset);
+                        if (ret == -ENOENT) {
+                                dev_info(adap->pdev_dev,
+                                    "No Configuration File present "
+                                    "on adapter.\n");
+                        }
+                }
+                if (ret < 0) {
+                        dev_err(adap->pdev_dev,
+                                "could not initialize adapter, error %d\n",
+                                -ret);
+                        goto bye;
+                }
+        }
+
+        /*
+         * If we're living with non-hard-coded parameters (either from a
+         * Firmware Configuration File or values programmed by a different PF
+         * Driver), give the SGE code a chance to pull in anything that it
+         * needs ...  Note that this must be called after we retrieve our VPD
+         * parameters in order to know how to convert core ticks to seconds.
+         */
+        if (adap->flags & USING_SOFT_PARAMS) {
+                ret = t4_sge_init(adap);
+                if (ret < 0)
+                        goto bye;
+        }
+
+        /*
+         * Grab some of our basic fundamental operating parameters.
+         */
+#define FW_PARAM_DEV(param) \
+        (FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) | \
+        FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_##param))
+
 #define FW_PARAM_PFVF(param) \
-        (FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) | \
-         FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_##param) | \
-         FW_PARAMS_PARAM_Y(adap->fn))
+        FW_PARAMS_MNEM(FW_PARAMS_MNEM_PFVF) | \
+        FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_PFVF_##param)|  \
+        FW_PARAMS_PARAM_Y(0) | \
+        FW_PARAMS_PARAM_Z(0)
 
-        params[0] = FW_PARAM_DEV(PORTVEC);
+        params[0] = FW_PARAM_PFVF(EQ_START);
         params[1] = FW_PARAM_PFVF(L2T_START);
         params[2] = FW_PARAM_PFVF(L2T_END);
         params[3] = FW_PARAM_PFVF(FILTER_START);
         params[4] = FW_PARAM_PFVF(FILTER_END);
         params[5] = FW_PARAM_PFVF(IQFLINT_START);
-        params[6] = FW_PARAM_PFVF(EQ_START);
-        ret = t4_query_params(adap, adap->fn, adap->fn, 0, 7, params, val);
+        ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 6, params, val);
         if (ret < 0)
                 goto bye;
-        port_vec = val[0];
+        adap->sge.egr_start = val[0];
+        adap->l2t_start = val[1];
+        adap->l2t_end = val[2];
         adap->tids.ftid_base = val[3];
         adap->tids.nftids = val[4] - val[3] + 1;
         adap->sge.ingr_start = val[5];
-        adap->sge.egr_start = val[6];
 
-        if (c.ofldcaps) {
+        /* query params related to active filter region */
+        params[0] = FW_PARAM_PFVF(ACTIVE_FILTER_START);
+        params[1] = FW_PARAM_PFVF(ACTIVE_FILTER_END);
+        ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2, params, val);
+        /* If Active filter size is set we enable establishing
+         * offload connection through firmware work request
+         */
+        if ((val[0] != val[1]) && (ret >= 0)) {
+                adap->flags |= FW_OFLD_CONN;
+                adap->tids.aftid_base = val[0];
+                adap->tids.aftid_end = val[1];
+        }
+
+#ifdef CONFIG_CHELSIO_T4_OFFLOAD
+        /*
+         * Get device capabilities so we can determine what resources we need
+         * to manage.
+         */
+        memset(&caps_cmd, 0, sizeof(caps_cmd));
+        caps_cmd.op_to_write = htonl(V_FW_CMD_OP(FW_CAPS_CONFIG_CMD) |
+                                     F_FW_CMD_REQUEST | F_FW_CMD_READ);
+        caps_cmd.cfvalid_to_len16 = htonl(FW_LEN16(caps_cmd));
+        ret = t4_wr_mbox(adap, adap->mbox, &caps_cmd, sizeof(caps_cmd),
+                         &caps_cmd);
+        if (ret < 0)
+                goto bye;
+
+        if (caps_cmd.toecaps) {
                 /* query offload-related parameters */
                 params[0] = FW_PARAM_DEV(NTID);
                 params[1] = FW_PARAM_PFVF(SERVER_START);
@@ -3235,28 +3616,55 @@ static int adap_init0(struct adapter *adap)
                 params[3] = FW_PARAM_PFVF(TDDP_START);
                 params[4] = FW_PARAM_PFVF(TDDP_END);
                 params[5] = FW_PARAM_DEV(FLOWC_BUFFIFO_SZ);
-                ret = t4_query_params(adap, adap->fn, adap->fn, 0, 6, params,
-                                      val);
+                ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 6,
+                                      params, val);
                 if (ret < 0)
                         goto bye;
                 adap->tids.ntids = val[0];
                 adap->tids.natids = min(adap->tids.ntids / 2, MAX_ATIDS);
                 adap->tids.stid_base = val[1];
                 adap->tids.nstids = val[2] - val[1] + 1;
+                /*
+                 * Setup server filter region. Divide the availble filter
+                 * region into two parts. Regular filters get 1/3rd and server
+                 * filters get 2/3rd part. This is only enabled if workarond
+                 * path is enabled.
+                 * 1. For regular filters.
+                 * 2. Server filter: This are special filters which are used
+                 * to redirect SYN packets to offload queue.
+                 */
+                if (adap->flags & FW_OFLD_CONN && !is_bypass(adap)) {
+                        adap->tids.sftid_base = adap->tids.ftid_base +
+                                        DIV_ROUND_UP(adap->tids.nftids, 3);
+                        adap->tids.nsftids = adap->tids.nftids -
+                                         DIV_ROUND_UP(adap->tids.nftids, 3);
+                        adap->tids.nftids = adap->tids.sftid_base -
+                                                adap->tids.ftid_base;
+                }
                 adap->vres.ddp.start = val[3];
                 adap->vres.ddp.size = val[4] - val[3] + 1;
                 adap->params.ofldq_wr_cred = val[5];
+
+                params[0] = FW_PARAM_PFVF(ETHOFLD_START);
+                params[1] = FW_PARAM_PFVF(ETHOFLD_END);
+                ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2,
+                                      params, val);
+                if ((val[0] != val[1]) && (ret >= 0)) {
+                        adap->tids.uotid_base = val[0];
+                        adap->tids.nuotids = val[1] - val[0] + 1;
+                }
+
                 adap->params.offload = 1;
         }
-        if (c.rdmacaps) {
+        if (caps_cmd.rdmacaps) {
                 params[0] = FW_PARAM_PFVF(STAG_START);
                 params[1] = FW_PARAM_PFVF(STAG_END);
                 params[2] = FW_PARAM_PFVF(RQ_START);
                 params[3] = FW_PARAM_PFVF(RQ_END);
                 params[4] = FW_PARAM_PFVF(PBL_START);
                 params[5] = FW_PARAM_PFVF(PBL_END);
-                ret = t4_query_params(adap, adap->fn, adap->fn, 0, 6, params,
-                                      val);
+                ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 6,
+                                      params, val);
                 if (ret < 0)
                         goto bye;
                 adap->vres.stag.start = val[0];
@@ -3272,8 +3680,7 @@ static int adap_init0(struct adapter *adap)
                 params[3] = FW_PARAM_PFVF(CQ_END);
                 params[4] = FW_PARAM_PFVF(OCQ_START);
                 params[5] = FW_PARAM_PFVF(OCQ_END);
-                ret = t4_query_params(adap, adap->fn, adap->fn, 0, 6, params,
-                                      val);
+                ret = t4_query_params(adap, 0, 0, 0, 6, params, val);
                 if (ret < 0)
                         goto bye;
                 adap->vres.qp.start = val[0];
@@ -3283,11 +3690,11 @@ static int adap_init0(struct adapter *adap)
                 adap->vres.ocq.start = val[4];
                 adap->vres.ocq.size = val[5] - val[4] + 1;
         }
-        if (c.iscsicaps) {
+        if (caps_cmd.iscsicaps) {
                 params[0] = FW_PARAM_PFVF(ISCSI_START);
                 params[1] = FW_PARAM_PFVF(ISCSI_END);
-                ret = t4_query_params(adap, adap->fn, adap->fn, 0, 2, params,
-                                      val);
+                ret = t4_query_params(adap, adap->mbox, adap->fn, 0, 2,
+                                      params, val);
                 if (ret < 0)
                         goto bye;
                 adap->vres.iscsi.start = val[0];
@@ -3295,63 +3702,33 @@ static int adap_init0(struct adapter *adap)
         }
 #undef FW_PARAM_PFVF
 #undef FW_PARAM_DEV
+#endif /* CONFIG_CHELSIO_T4_OFFLOAD */
 
-        adap->params.nports = hweight32(port_vec);
-        adap->params.portvec = port_vec;
-        adap->flags |= FW_OK;
-
-        /* These are finalized by FW initialization, load their values now */
+        /*
+         * These are finalized by FW initialization, load their values now.
+         */
         v = t4_read_reg(adap, TP_TIMER_RESOLUTION);
         adap->params.tp.tre = TIMERRESOLUTION_GET(v);
+        adap->params.tp.dack_re = DELAYEDACKRESOLUTION_GET(v);
         t4_read_mtu_tbl(adap, adap->params.mtus, NULL);
         t4_load_mtus(adap, adap->params.mtus, adap->params.a_wnd,
                      adap->params.b_wnd);
 
-#ifdef CONFIG_PCI_IOV
-        /*
-         * Provision resource limits for Virtual Functions.  We currently
-         * grant them all the same static resource limits except for the Port
-         * Access Rights Mask which we're assigning based on the PF.  All of
-         * the static provisioning stuff for both the PF and VF really needs
-         * to be managed in a persistent manner for each device which the
-         * firmware controls.
-         */
-        {
-                int pf, vf;
-
-                for (pf = 0; pf < ARRAY_SIZE(num_vf); pf++) {
-                        if (num_vf[pf] <= 0)
-                                continue;
-
-                        /* VF numbering starts at 1! */
-                        for (vf = 1; vf <= num_vf[pf]; vf++) {
-                                ret = t4_cfg_pfvf(adap, adap->fn, pf, vf,
-                                                  VFRES_NEQ, VFRES_NETHCTRL,
-                                                  VFRES_NIQFLINT, VFRES_NIQ,
-                                                  VFRES_TC, VFRES_NVI,
-                                                  FW_PFVF_CMD_CMASK_MASK,
-                                                  pfvfres_pmask(adap, pf, vf),
-                                                  VFRES_NEXACTF,
-                                                  VFRES_R_CAPS, VFRES_WX_CAPS);
-                                if (ret < 0)
-                                        dev_warn(adap->pdev_dev, "failed to "
-                                                 "provision pf/vf=%d/%d; "
-                                                 "err=%d\n", pf, vf, ret);
-                        }
-                }
-        }
-#endif
+        /* MODQ_REQ_MAP defaults to setting queues 0-3 to chan 0-3 */
+        for (j = 0; j < NCHAN; j++)
+                adap->params.tp.tx_modq[j] = j;
 
-        setup_memwin(adap);
+        adap->flags |= FW_OK;
         return 0;
 
         /*
-         * If a command timed out or failed with EIO FW does not operate within
-         * its spec or something catastrophic happened to HW/FW, stop issuing
-         * commands.
+         * Something bad happened.  If a command timed out or failed with EIO
+         * FW does not operate within its spec or something catastrophic
+         * happened to HW/FW, stop issuing commands.
          */
-bye:    if (ret != -ETIMEDOUT && ret != -EIO)
-                t4_fw_bye(adap, adap->fn);
+bye:
+        if (ret != -ETIMEDOUT && ret != -EIO)
+                t4_fw_bye(adap, adap->mbox);
         return ret;
 }
 
@@ -3814,7 +4191,9 @@ static int __devinit init_one(struct pci_dev *pdev,
         err = t4_prep_adapter(adapter);
         if (err)
                 goto out_unmap_bar;
+        setup_memwin(adapter);
         err = adap_init0(adapter);
+        setup_memwin_rdma(adapter);
         if (err)
                 goto out_unmap_bar;
 
@@ -3956,8 +4335,11 @@ static void __devexit remove_one(struct pci_dev *pdev)
 {
         struct adapter *adapter = pci_get_drvdata(pdev);
 
+#ifdef CONFIG_PCI_IOV
         pci_disable_sriov(pdev);
 
+#endif
+
         if (adapter) {
                 int i;
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
index d79980c5fc63..1b899fea1a91 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h
@@ -100,6 +100,8 @@ struct tid_info {
 
         unsigned int nftids;
         unsigned int ftid_base;
+        unsigned int aftid_base;
+        unsigned int aftid_end;
 
         spinlock_t atid_lock ____cacheline_aligned_in_smp;
         union aopen_entry *afree;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
index 259d0dcb0089..419432d42049 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
@@ -492,8 +492,9 @@ int t4_seeprom_wp(struct adapter *adapter, bool enable)
  *
  *      Reads card parameters stored in VPD EEPROM.
  */
-static int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
+int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
 {
+        u32 cclk_param, cclk_val;
         int i, ret;
         int ec, sn;
         u8 vpd[VPD_LEN], csum;
@@ -555,6 +556,19 @@ static int get_vpd_params(struct adapter *adapter, struct vpd_params *p)
         i = pci_vpd_info_field_size(vpd + sn - PCI_VPD_INFO_FLD_HDR_SIZE);
         memcpy(p->sn, vpd + sn, min(i, SERNUM_LEN));
         strim(p->sn);
+
+        /*
+         * Ask firmware for the Core Clock since it knows how to translate the
+         * Reference Clock ('V2') VPD field into a Core Clock value ...
+         */
+        cclk_param = (FW_PARAMS_MNEM(FW_PARAMS_MNEM_DEV) |
+                      FW_PARAMS_PARAM_X(FW_PARAMS_PARAM_DEV_CCLK));
+        ret = t4_query_params(adapter, adapter->mbox, 0, 0,
+                              1, &cclk_param, &cclk_val);
+        if (ret)
+                return ret;
+        p->cclk = cclk_val;
+
         return 0;
 }
 
@@ -855,6 +869,77 @@ static int t4_flash_erase_sectors(struct adapter *adapter, int start, int end)
 }
 
 /**
+ *      t4_flash_cfg_addr - return the address of the flash configuration file
+ *      @adapter: the adapter
+ *
+ *      Return the address within the flash where the Firmware Configuration
+ *      File is stored.
+ */
+unsigned int t4_flash_cfg_addr(struct adapter *adapter)
+{
+        if (adapter->params.sf_size == 0x100000)
+                return FLASH_FPGA_CFG_START;
+        else
+                return FLASH_CFG_START;
+}
+
+/**
+ *      t4_load_cfg - download config file
+ *      @adap: the adapter
+ *      @cfg_data: the cfg text file to write
+ *      @size: text file size
+ *
+ *      Write the supplied config text file to the card's serial flash.
+ */
+int t4_load_cfg(struct adapter *adap, const u8 *cfg_data, unsigned int size)
+{
+        int ret, i, n;
+        unsigned int addr;
+        unsigned int flash_cfg_start_sec;
+        unsigned int sf_sec_size = adap->params.sf_size / adap->params.sf_nsec;
+
+        addr = t4_flash_cfg_addr(adap);
+        flash_cfg_start_sec = addr / SF_SEC_SIZE;
+
+        if (size > FLASH_CFG_MAX_SIZE) {
+                dev_err(adap->pdev_dev, "cfg file too large, max is %u bytes\n",
+                        FLASH_CFG_MAX_SIZE);
+                return -EFBIG;
+        }
+
+        i = DIV_ROUND_UP(FLASH_CFG_MAX_SIZE,    /* # of sectors spanned */
+                         sf_sec_size);
+        ret = t4_flash_erase_sectors(adap, flash_cfg_start_sec,
+                                     flash_cfg_start_sec + i - 1);
+        /*
+         * If size == 0 then we're simply erasing the FLASH sectors associated
+         * with the on-adapter Firmware Configuration File.
+         */
+        if (ret || size == 0)
+                goto out;
+
+        /* this will write to the flash up to SF_PAGE_SIZE at a time */
+        for (i = 0; i < size; i += SF_PAGE_SIZE) {
+                if ((size - i) <  SF_PAGE_SIZE)
+                        n = size - i;
+                else
+                        n = SF_PAGE_SIZE;
+                ret = t4_write_flash(adap, addr, n, cfg_data);
+                if (ret)
+                        goto out;
+
+                addr += SF_PAGE_SIZE;
+                cfg_data += SF_PAGE_SIZE;
+        }
+
+out:
+        if (ret)
+                dev_err(adap->pdev_dev, "config file %s failed %d\n",
+                        (size == 0 ? "clear" : "download"), ret);
+        return ret;
+}
+
+/**
  *      t4_load_fw - download firmware
  *      @adap: the adapter
  *      @fw_data: the firmware image to write
@@ -1854,6 +1939,23 @@ void t4_read_mtu_tbl(struct adapter *adap, u16 *mtus, u8 *mtu_log)
 }
 
 /**
+ *      t4_tp_wr_bits_indirect - set/clear bits in an indirect TP register
+ *      @adap: the adapter
+ *      @addr: the indirect TP register address
+ *      @mask: specifies the field within the register to modify
+ *      @val: new value for the field
+ *
+ *      Sets a field of an indirect TP register to the given value.
+ */
+void t4_tp_wr_bits_indirect(struct adapter *adap, unsigned int addr,
+                            unsigned int mask, unsigned int val)
+{
+        t4_write_reg(adap, TP_PIO_ADDR, addr);
+        val |= t4_read_reg(adap, TP_PIO_DATA) & ~mask;
+        t4_write_reg(adap, TP_PIO_DATA, val);
+}
+
+/**
  *      init_cong_ctrl - initialize congestion control parameters
  *      @a: the alpha values for congestion control
  *      @b: the beta values for congestion control
@@ -2137,9 +2239,9 @@ int t4_fwaddrspace_write(struct adapter *adap, unsigned int mbox,
         struct fw_ldst_cmd c;
 
         memset(&c, 0, sizeof(c));
-        c.op_to_addrspace = htonl(V_FW_CMD_OP(FW_LDST_CMD) | F_FW_CMD_REQUEST |
-                            F_FW_CMD_WRITE |
-                            V_FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_FIRMWARE));
+        c.op_to_addrspace = htonl(FW_CMD_OP(FW_LDST_CMD) | FW_CMD_REQUEST |
+                            FW_CMD_WRITE |
+                            FW_LDST_CMD_ADDRSPACE(FW_LDST_ADDRSPC_FIRMWARE));
         c.cycles_to_len16 = htonl(FW_LEN16(c));
         c.u.addrval.addr = htonl(addr);
         c.u.addrval.val = htonl(val);
@@ -2239,39 +2341,129 @@ int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
 }
 
 /**
- *      t4_fw_hello - establish communication with FW
- *      @adap: the adapter
- *      @mbox: mailbox to use for the FW command
- *      @evt_mbox: mailbox to receive async FW events
- *      @master: specifies the caller's willingness to be the device master
- *      @state: returns the current device state
+ *      t4_fw_hello - establish communication with FW
+ *      @adap: the adapter
+ *      @mbox: mailbox to use for the FW command
+ *      @evt_mbox: mailbox to receive async FW events
+ *      @master: specifies the caller's willingness to be the device master
+ *      @state: returns the current device state (if non-NULL)
  *
- *      Issues a command to establish communication with FW.
+ *      Issues a command to establish communication with FW.  Returns either
+ *      an error (negative integer) or the mailbox of the Master PF.
  */
 int t4_fw_hello(struct adapter *adap, unsigned int mbox, unsigned int evt_mbox,
                 enum dev_master master, enum dev_state *state)
 {
         int ret;
         struct fw_hello_cmd c;
+        u32 v;
+        unsigned int master_mbox;
+        int retries = FW_CMD_HELLO_RETRIES;
 
+retry:
+        memset(&c, 0, sizeof(c));
         INIT_CMD(c, HELLO, WRITE);
         c.err_to_mbasyncnot = htonl(
                 FW_HELLO_CMD_MASTERDIS(master == MASTER_CANT) |
                 FW_HELLO_CMD_MASTERFORCE(master == MASTER_MUST) |
-                FW_HELLO_CMD_MBMASTER(master == MASTER_MUST ? mbox : 0xff) |
-                FW_HELLO_CMD_MBASYNCNOT(evt_mbox));
+                FW_HELLO_CMD_MBMASTER(master == MASTER_MUST ? mbox :
+                                      FW_HELLO_CMD_MBMASTER_MASK) |
+                FW_HELLO_CMD_MBASYNCNOT(evt_mbox) |
+                FW_HELLO_CMD_STAGE(fw_hello_cmd_stage_os) |
+                FW_HELLO_CMD_CLEARINIT);
 
+        /*
+         * Issue the HELLO command to the firmware.  If it's not successful
+         * but indicates that we got a "busy" or "timeout" condition, retry
+         * the HELLO until we exhaust our retry limit.
+         */
         ret = t4_wr_mbox(adap, mbox, &c, sizeof(c), &c);
-        if (ret == 0 && state) {
-                u32 v = ntohl(c.err_to_mbasyncnot);
-                if (v & FW_HELLO_CMD_INIT)
-                        *state = DEV_STATE_INIT;
-                else if (v & FW_HELLO_CMD_ERR)
+        if (ret < 0) {
+                if ((ret == -EBUSY || ret == -ETIMEDOUT) && retries-- > 0)
+                        goto retry;
+                return ret;
+        }
+
+        v = ntohl(c.err_to_mbasyncnot);
+        master_mbox = FW_HELLO_CMD_MBMASTER_GET(v);
+        if (state) {
+                if (v & FW_HELLO_CMD_ERR)
                         *state = DEV_STATE_ERR;
+                else if (v & FW_HELLO_CMD_INIT)
+                        *state = DEV_STATE_INIT;
                 else
                         *state = DEV_STATE_UNINIT;
         }
-        return ret;
+
+        /*
+         * If we're not the Master PF then we need to wait around for the
+         * Master PF Driver to finish setting up the adapter.
+         *
+         * Note that we also do this wait if we're a non-Master-capable PF and
+         * there is no current Master PF; a Master PF may show up momentarily
+         * and we wouldn't want to fail pointlessly.  (This can happen when an
+         * OS loads lots of different drivers rapidly at the same time).  In
+         * this case, the Master PF returned by the firmware will be
+         * FW_PCIE_FW_MASTER_MASK so the test below will work ...
+         */
+        if ((v & (FW_HELLO_CMD_ERR|FW_HELLO_CMD_INIT)) == 0 &&
+            master_mbox != mbox) {
+                int waiting = FW_CMD_HELLO_TIMEOUT;
+
+                /*
+                 * Wait for the firmware to either indicate an error or
+                 * initialized state.  If we see either of these we bail out
+                 * and report the issue to the caller.  If we exhaust the
+                 * "hello timeout" and we haven't exhausted our retries, try
+                 * again.  Otherwise bail with a timeout error.
+                 */
+                for (;;) {
+                        u32 pcie_fw;
+
+                        msleep(50);
+                        waiting -= 50;
+
+                        /*
+                         * If neither Error nor Initialialized are indicated
+                         * by the firmware keep waiting till we exaust our
+                         * timeout ... and then retry if we haven't exhausted
+                         * our retries ...
+                         */
+                        pcie_fw = t4_read_reg(adap, MA_PCIE_FW);
+                        if (!(pcie_fw & (FW_PCIE_FW_ERR|FW_PCIE_FW_INIT))) {
+                                if (waiting <= 0) {
+                                        if (retries-- > 0)
+                                                goto retry;
+
+                                        return -ETIMEDOUT;
+                                }
+                                continue;
+                        }
+
+                        /*
+                         * We either have an Error or Initialized condition
+                         * report errors preferentially.
+                         */
+                        if (state) {
+                                if (pcie_fw & FW_PCIE_FW_ERR)
+                                        *state = DEV_STATE_ERR;
+                                else if (pcie_fw & FW_PCIE_FW_INIT)
+                                        *state = DEV_STATE_INIT;
+                        }
+
+                        /*
+                         * If we arrived before a Master PF was selected and
+                         * there's not a valid Master PF, grab its identity
+                         * for our caller.
+                         */
+                        if (master_mbox == FW_PCIE_FW_MASTER_MASK &&
+                            (pcie_fw & FW_PCIE_FW_MASTER_VLD))
+                                master_mbox = FW_PCIE_FW_MASTER_GET(pcie_fw);
+                        break;
+                }
+        }
+
+        return master_mbox;
 }
 
 /**
@@ -2323,6 +2515,163 @@ int t4_fw_reset(struct adapter *adap, unsigned int mbox, int reset)
 }
 
 /**
+ *      t4_fw_config_file - setup an adapter via a Configuration File
+ *      @adap: the adapter
+ *      @mbox: mailbox to use for the FW command
+ *      @mtype: the memory type where the Configuration File is located
+ *      @maddr: the memory address where the Configuration File is located
+ *      @finiver: return value for CF [fini] version
+ *      @finicsum: return value for CF [fini] checksum
+ *      @cfcsum: return value for CF computed checksum
+ *
+ *      Issue a command to get the firmware to process the Configuration
+ *      File located at the specified mtype/maddress.  If the Configuration
+ *      File is processed successfully and return value pointers are
+ *      provided, the Configuration File "[fini] section version and
+ *      checksum values will be returned along with the computed checksum.
+ *      It's up to the caller to decide how it wants to respond to the
+ *      checksums not matching but it recommended that a prominant warning
+ *      be emitted in order to help people rapidly identify changed or
+ *      corrupted Configuration Files.
+ *
+ *      Also note that it's possible to modify things like "niccaps",
+ *      "toecaps",etc. between processing the Configuration File and telling
+ *      the firmware to use the new configuration.  Callers which want to
+ *      do this will need to "hand-roll" their own CAPS_CONFIGS commands for
+ *      Configuration Files if they want to do this.
+ */
+int t4_fw_config_file(struct adapter *adap, unsigned int mbox,
+                      unsigned int mtype, unsigned int maddr,
+                      u32 *finiver, u32 *finicsum, u32 *cfcsum)
+{
+        struct fw_caps_config_cmd caps_cmd;
+        int ret;
+
+        /*
+         * Tell the firmware to process the indicated Configuration File.
+         * If there are no errors and the caller has provided return value
+         * pointers for the [fini] section version, checksum and computed
+         * checksum, pass those back to the caller.
+         */
+        memset(&caps_cmd, 0, sizeof(caps_cmd));
+        caps_cmd.op_to_write =
+                htonl(FW_CMD_OP(FW_CAPS_CONFIG_CMD) |
+                      FW_CMD_REQUEST |
+                      FW_CMD_READ);
+        caps_cmd.retval_len16 =
+                htonl(FW_CAPS_CONFIG_CMD_CFVALID |
+                      FW_CAPS_CONFIG_CMD_MEMTYPE_CF(mtype) |
+                      FW_CAPS_CONFIG_CMD_MEMADDR64K_CF(maddr >> 16) |
+                      FW_LEN16(caps_cmd));
+        ret = t4_wr_mbox(adap, mbox, &caps_cmd, sizeof(caps_cmd), &caps_cmd);
+        if (ret < 0)
+                return ret;
+
+        if (finiver)
+                *finiver = ntohl(caps_cmd.finiver);
+        if (finicsum)
+                *finicsum = ntohl(caps_cmd.finicsum);
+        if (cfcsum)
+                *cfcsum = ntohl(caps_cmd.cfcsum);
+
+        /*
+         * And now tell the firmware to use the configuration we just loaded.
+         */
+        caps_cmd.op_to_write =
+                htonl(FW_CMD_OP(FW_CAPS_CONFIG_CMD) |
+                      FW_CMD_REQUEST |
+                      FW_CMD_WRITE);
+        caps_cmd.retval_len16 = htonl(FW_LEN16(caps_cmd));
+        return t4_wr_mbox(adap, mbox, &caps_cmd, sizeof(caps_cmd), NULL);
+}
+
+/**
+ *      t4_fixup_host_params - fix up host-dependent parameters
+ *      @adap: the adapter
+ *      @page_size: the host's Base Page Size
+ *      @cache_line_size: the host's Cache Line Size
+ *
+ *      Various registers in T4 contain values which are dependent on the
+ *      host's Base Page and Cache Line Sizes.  This function will fix all of
+ *      those registers with the appropriate values as passed in ...
+ */
+int t4_fixup_host_params(struct adapter *adap, unsigned int page_size,
+                         unsigned int cache_line_size)
+{
+        unsigned int page_shift = fls(page_size) - 1;
+        unsigned int sge_hps = page_shift - 10;
+        unsigned int stat_len = cache_line_size > 64 ? 128 : 64;
+        unsigned int fl_align = cache_line_size < 32 ? 32 : cache_line_size;
+        unsigned int fl_align_log = fls(fl_align) - 1;
+
+        t4_write_reg(adap, SGE_HOST_PAGE_SIZE,
+                     HOSTPAGESIZEPF0(sge_hps) |
+                     HOSTPAGESIZEPF1(sge_hps) |
+                     HOSTPAGESIZEPF2(sge_hps) |
+                     HOSTPAGESIZEPF3(sge_hps) |
+                     HOSTPAGESIZEPF4(sge_hps) |
+                     HOSTPAGESIZEPF5(sge_hps) |
+                     HOSTPAGESIZEPF6(sge_hps) |
+                     HOSTPAGESIZEPF7(sge_hps));
+
+        t4_set_reg_field(adap, SGE_CONTROL,
+                         INGPADBOUNDARY(INGPADBOUNDARY_MASK) |
+                         EGRSTATUSPAGESIZE_MASK,
+                         INGPADBOUNDARY(fl_align_log - 5) |
+                         EGRSTATUSPAGESIZE(stat_len != 64));
+
+        /*
+         * Adjust various SGE Free List Host Buffer Sizes.
+         *
+         * This is something of a crock since we're using fixed indices into
+         * the array which are also known by the sge.c code and the T4
+         * Firmware Configuration File.  We need to come up with a much better
+         * approach to managing this array.  For now, the first four entries
+         * are:
+         *
+         *   0: Host Page Size
+         *   1: 64KB
+         *   2: Buffer size corresponding to 1500 byte MTU (unpacked mode)
+         *   3: Buffer size corresponding to 9000 byte MTU (unpacked mode)
+         *
+         * For the single-MTU buffers in unpacked mode we need to include
+         * space for the SGE Control Packet Shift, 14 byte Ethernet header,
+         * possible 4 byte VLAN tag, all rounded up to the next Ingress Packet
+         * Padding boundry.  All of these are accommodated in the Factory
+         * Default Firmware Configuration File but we need to adjust it for
+         * this host's cache line size.
+         */
+        t4_write_reg(adap, SGE_FL_BUFFER_SIZE0, page_size);
+        t4_write_reg(adap, SGE_FL_BUFFER_SIZE2,
+                     (t4_read_reg(adap, SGE_FL_BUFFER_SIZE2) + fl_align-1)
+                     & ~(fl_align-1));
+        t4_write_reg(adap, SGE_FL_BUFFER_SIZE3,
+                     (t4_read_reg(adap, SGE_FL_BUFFER_SIZE3) + fl_align-1)
+                     & ~(fl_align-1));
+
+        t4_write_reg(adap, ULP_RX_TDDP_PSZ, HPZ0(page_shift - 12));
+
+        return 0;
+}
+
+/**
+ *      t4_fw_initialize - ask FW to initialize the device
+ *      @adap: the adapter
+ *      @mbox: mailbox to use for the FW command
+ *
+ *      Issues a command to FW to partially initialize the device.  This
+ *      performs initialization that generally doesn't depend on user input.
+ */
+int t4_fw_initialize(struct adapter *adap, unsigned int mbox)
+{
+        struct fw_initialize_cmd c;
+
+        memset(&c, 0, sizeof(c));
+        INIT_CMD(c, INITIALIZE, WRITE);
+        return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
+}
+
+/**
  *      t4_query_params - query FW or device parameters
  *      @adap: the adapter
  *      @mbox: mailbox to use for the FW command
@@ -2974,10 +3323,6 @@ int __devinit t4_prep_adapter(struct adapter *adapter)
                 return ret;
         }
 
-        ret = get_vpd_params(adapter, &adapter->params.vpd);
-        if (ret < 0)
-                return ret;
-
         init_cong_ctrl(adapter->params.a_wnd, adapter->params.b_wnd);
 
         /*
@@ -2985,6 +3330,7 @@ int __devinit t4_prep_adapter(struct adapter *adapter)
          */
         adapter->params.nports = 1;
         adapter->params.portvec = 1;
+        adapter->params.vpd.cclk = 50000;
         return 0;
 }
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h b/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
index 2767ca6dbe99..779b23f8f591 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_regs.h
@@ -115,6 +115,35 @@
 #define  GLOBALENABLE           0x00000001U
 
 #define SGE_HOST_PAGE_SIZE 0x100c
+
+#define  HOSTPAGESIZEPF7_MASK   0x0000000fU
+#define  HOSTPAGESIZEPF7_SHIFT  28
+#define  HOSTPAGESIZEPF7(x)     ((x) << HOSTPAGESIZEPF7_SHIFT)
+
+#define  HOSTPAGESIZEPF6_MASK   0x0000000fU
+#define  HOSTPAGESIZEPF6_SHIFT  24
+#define  HOSTPAGESIZEPF6(x)     ((x) << HOSTPAGESIZEPF6_SHIFT)
+
+#define  HOSTPAGESIZEPF5_MASK   0x0000000fU
+#define  HOSTPAGESIZEPF5_SHIFT  20
+#define  HOSTPAGESIZEPF5(x)     ((x) << HOSTPAGESIZEPF5_SHIFT)
+
+#define  HOSTPAGESIZEPF4_MASK   0x0000000fU
+#define  HOSTPAGESIZEPF4_SHIFT  16
+#define  HOSTPAGESIZEPF4(x)     ((x) << HOSTPAGESIZEPF4_SHIFT)
+
+#define  HOSTPAGESIZEPF3_MASK   0x0000000fU
+#define  HOSTPAGESIZEPF3_SHIFT  12
+#define  HOSTPAGESIZEPF3(x)     ((x) << HOSTPAGESIZEPF3_SHIFT)
+
+#define  HOSTPAGESIZEPF2_MASK   0x0000000fU
+#define  HOSTPAGESIZEPF2_SHIFT  8
+#define  HOSTPAGESIZEPF2(x)     ((x) << HOSTPAGESIZEPF2_SHIFT)
+
+#define  HOSTPAGESIZEPF1_MASK   0x0000000fU
+#define  HOSTPAGESIZEPF1_SHIFT  4
+#define  HOSTPAGESIZEPF1(x)     ((x) << HOSTPAGESIZEPF1_SHIFT)
+
 #define  HOSTPAGESIZEPF0_MASK   0x0000000fU
 #define  HOSTPAGESIZEPF0_SHIFT  0
 #define  HOSTPAGESIZEPF0(x)     ((x) << HOSTPAGESIZEPF0_SHIFT)
@@ -162,6 +191,8 @@
 #define SGE_INT_ENABLE3 0x1040
 #define SGE_FL_BUFFER_SIZE0 0x1044
 #define SGE_FL_BUFFER_SIZE1 0x1048
+#define SGE_FL_BUFFER_SIZE2 0x104c
+#define SGE_FL_BUFFER_SIZE3 0x1050
 #define SGE_INGRESS_RX_THRESHOLD 0x10a0
 #define  THRESHOLD_0_MASK   0x3f000000U
 #define  THRESHOLD_0_SHIFT  24
@@ -367,7 +398,7 @@
 #define  MEM_WRAP_CLIENT_NUM_MASK   0x0000000fU
 #define  MEM_WRAP_CLIENT_NUM_SHIFT  0
 #define  MEM_WRAP_CLIENT_NUM_GET(x) (((x) & MEM_WRAP_CLIENT_NUM_MASK) >> MEM_WRAP_CLIENT_NUM_SHIFT)
-
+#define MA_PCIE_FW 0x30b8
 #define MA_PARITY_ERROR_STATUS 0x77f4
 
 #define EDC_0_BASE_ADDR 0x7900
@@ -469,6 +500,10 @@
 #define  TIMERRESOLUTION_MASK   0x00ff0000U
 #define  TIMERRESOLUTION_SHIFT  16
 #define  TIMERRESOLUTION_GET(x) (((x) & TIMERRESOLUTION_MASK) >> TIMERRESOLUTION_SHIFT)
+#define  DELAYEDACKRESOLUTION_MASK 0x000000ffU
+#define  DELAYEDACKRESOLUTION_SHIFT     0
+#define  DELAYEDACKRESOLUTION_GET(x) \
+        (((x) & DELAYEDACKRESOLUTION_MASK) >> DELAYEDACKRESOLUTION_SHIFT)
 
 #define TP_SHIFT_CNT 0x7dc0
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
index 94e3484b7d93..3f85019106fa 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4fw_api.h
@@ -155,6 +155,17 @@ struct fw_eth_tx_pkt_vm_wr {
 
 #define FW_CMD_MAX_TIMEOUT 3000
 
+/*
+ * If a host driver does a HELLO and discovers that there's already a MASTER
+ * selected, we may have to wait for that MASTER to finish issuing RESET,
+ * configuration and INITIALIZE commands.  Also, there's a possibility that
+ * our own HELLO may get lost if it happens right as the MASTER is issuign a
+ * RESET command, so we need to be willing to make a few retries of our HELLO.
+ */
+#define FW_CMD_HELLO_TIMEOUT    (3 * FW_CMD_MAX_TIMEOUT)
+#define FW_CMD_HELLO_RETRIES    3
+
+
 enum fw_cmd_opcodes {
         FW_LDST_CMD                    = 0x01,
         FW_RESET_CMD                   = 0x03,
@@ -307,6 +318,10 @@ struct fw_reset_cmd {
         __be32 r3;
 };
 
+enum fw_hellow_cmd {
+        fw_hello_cmd_stage_os           = 0x0
+};
+
 struct fw_hello_cmd {
         __be32 op_to_write;
         __be32 retval_len16;
@@ -315,8 +330,14 @@ struct fw_hello_cmd {
 #define FW_HELLO_CMD_INIT           (1U << 30)
 #define FW_HELLO_CMD_MASTERDIS(x)   ((x) << 29)
 #define FW_HELLO_CMD_MASTERFORCE(x) ((x) << 28)
-#define FW_HELLO_CMD_MBMASTER(x)    ((x) << 24)
+#define FW_HELLO_CMD_MBMASTER_MASK   0xfU
+#define FW_HELLO_CMD_MBMASTER_SHIFT  24
+#define FW_HELLO_CMD_MBMASTER(x)     ((x) << FW_HELLO_CMD_MBMASTER_SHIFT)
+#define FW_HELLO_CMD_MBMASTER_GET(x) \
+        (((x) >> FW_HELLO_CMD_MBMASTER_SHIFT) & FW_HELLO_CMD_MBMASTER_MASK)
 #define FW_HELLO_CMD_MBASYNCNOT(x)  ((x) << 20)
+#define FW_HELLO_CMD_STAGE(x)       ((x) << 17)
+#define FW_HELLO_CMD_CLEARINIT      (1U << 16)
         __be32 fwrev;
 };
 
@@ -1654,18 +1675,4 @@ struct fw_hdr {
 #define FW_HDR_FW_VER_MICRO_GET(x) (((x) >> 8) & 0xff)
 #define FW_HDR_FW_VER_BUILD_GET(x) (((x) >> 0) & 0xff)
 
-#define S_FW_CMD_OP 24
-#define V_FW_CMD_OP(x) ((x) << S_FW_CMD_OP)
-
-#define S_FW_CMD_REQUEST 23
-#define V_FW_CMD_REQUEST(x) ((x) << S_FW_CMD_REQUEST)
-#define F_FW_CMD_REQUEST V_FW_CMD_REQUEST(1U)
-
-#define S_FW_CMD_WRITE 21
-#define V_FW_CMD_WRITE(x) ((x) << S_FW_CMD_WRITE)
-#define F_FW_CMD_WRITE V_FW_CMD_WRITE(1U)
-
-#define S_FW_LDST_CMD_ADDRSPACE 0
-#define V_FW_LDST_CMD_ADDRSPACE(x) ((x) << S_FW_LDST_CMD_ADDRSPACE)
-
 #endif /* _T4FW_INTERFACE_H_ */