cxgb4: update dump collection logic to use compression

Update firmware dump collection logic to use compression when available.
Let collection logic attempt to do compression, instead of returning out
of memory early.

Signed-off-by: Rahul Lakkireddy <rahul.lakkireddy@chelsio.com>
Signed-off-by: Vishal Kulkarni <vishal@chelsio.com>
Signed-off-by: Ganesh Goudar <ganeshgr@chelsio.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cudbg_common.c b/drivers/net/ethernet/chelsio/cxgb4/cudbg_common.c
index f78ba1743b5aff182db14581981e4ccc005239b6..8edc49827af0ba3b816084e15adb42cb770e60fb 100644 (file)
--- a/drivers/net/ethernet/chelsio/cxgb4/cudbg_common.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cudbg_common.c
@@ -19,7 +19,8 @@
 #include "cudbg_if.h"
 #include "cudbg_lib_common.h"
 
-int cudbg_get_buff(struct cudbg_buffer *pdbg_buff, u32 size,
+int cudbg_get_buff(struct cudbg_init *pdbg_init,
+                  struct cudbg_buffer *pdbg_buff, u32 size,
                   struct cudbg_buffer *pin_buff)
 {
        u32 offset;
@@ -28,17 +29,30 @@ int cudbg_get_buff(struct cudbg_buffer *pdbg_buff, u32 size,
        if (offset + size > pdbg_buff->size)
                return CUDBG_STATUS_NO_MEM;
 
+       if (pdbg_init->compress_type != CUDBG_COMPRESSION_NONE) {
+               if (size > pdbg_init->compress_buff_size)
+                       return CUDBG_STATUS_NO_MEM;
+
+               pin_buff->data = (char *)pdbg_init->compress_buff;
+               pin_buff->offset = 0;
+               pin_buff->size = size;
+               return 0;
+       }
+
        pin_buff->data = (char *)pdbg_buff->data + offset;
        pin_buff->offset = offset;
        pin_buff->size = size;
-       pdbg_buff->size -= size;
        return 0;
 }
 
-void cudbg_put_buff(struct cudbg_buffer *pin_buff,
-                   struct cudbg_buffer *pdbg_buff)
+void cudbg_put_buff(struct cudbg_init *pdbg_init,
+                   struct cudbg_buffer *pin_buff)
 {
-       pdbg_buff->size += pin_buff->size;
+       /* Clear compression buffer for re-use */
+       if (pdbg_init->compress_type != CUDBG_COMPRESSION_NONE)
+               memset(pdbg_init->compress_buff, 0,
+                      pdbg_init->compress_buff_size);
+
        pin_buff->data = NULL;
        pin_buff->offset = 0;
        pin_buff->size = 0;

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cudbg_if.h b/drivers/net/ethernet/chelsio/cxgb4/cudbg_if.h
index 88e740082a02becd10ad6abec6ce354f7f5e3e40..eb1d2f48ebd38eb81731001907e72cc7e19aa4c6 100644 (file)
--- a/drivers/net/ethernet/chelsio/cxgb4/cudbg_if.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cudbg_if.h
@@ -87,6 +87,9 @@ struct cudbg_init {
        struct adapter *adap; /* Pointer to adapter structure */
        void *outbuf; /* Output buffer */
        u32 outbuf_size;  /* Output buffer size */
+       u8 compress_type; /* Type of compression to use */
+       void *compress_buff; /* Compression buffer */
+       u32 compress_buff_size; /* Compression buffer size */
 };
 
 static inline unsigned int cudbg_mbytes_to_bytes(unsigned int size)

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c b/drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c
index 0a3871f10787fb845c50976d4a386af869ae569b..8b95117c2923e683f0c6b36fbd27d263f435fb5e 100644 (file)
--- a/drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cudbg_lib.c
@@ -23,12 +23,57 @@
 #include "cudbg_lib_common.h"
 #include "cudbg_entity.h"
 #include "cudbg_lib.h"
+#include "cudbg_zlib.h"
 
-static void cudbg_write_and_release_buff(struct cudbg_buffer *pin_buff,
-                                        struct cudbg_buffer *dbg_buff)
+static int cudbg_do_compression(struct cudbg_init *pdbg_init,
+                               struct cudbg_buffer *pin_buff,
+                               struct cudbg_buffer *dbg_buff)
 {
-       cudbg_update_buff(pin_buff, dbg_buff);
-       cudbg_put_buff(pin_buff, dbg_buff);
+       struct cudbg_buffer temp_in_buff = { 0 };
+       int bytes_left, bytes_read, bytes;
+       u32 offset = dbg_buff->offset;
+       int rc;
+
+       temp_in_buff.offset = pin_buff->offset;
+       temp_in_buff.data = pin_buff->data;
+       temp_in_buff.size = pin_buff->size;
+
+       bytes_left = pin_buff->size;
+       bytes_read = 0;
+       while (bytes_left > 0) {
+               /* Do compression in smaller chunks */
+               bytes = min_t(unsigned long, bytes_left,
+                             (unsigned long)CUDBG_CHUNK_SIZE);
+               temp_in_buff.data = (char *)pin_buff->data + bytes_read;
+               temp_in_buff.size = bytes;
+               rc = cudbg_compress_buff(pdbg_init, &temp_in_buff, dbg_buff);
+               if (rc)
+                       return rc;
+               bytes_left -= bytes;
+               bytes_read += bytes;
+       }
+
+       pin_buff->size = dbg_buff->offset - offset;
+       return 0;
+}
+
+static int cudbg_write_and_release_buff(struct cudbg_init *pdbg_init,
+                                       struct cudbg_buffer *pin_buff,
+                                       struct cudbg_buffer *dbg_buff)
+{
+       int rc = 0;
+
+       if (pdbg_init->compress_type == CUDBG_COMPRESSION_NONE) {
+               cudbg_update_buff(pin_buff, dbg_buff);
+       } else {
+               rc = cudbg_do_compression(pdbg_init, pin_buff, dbg_buff);
+               if (rc)
+                       goto out;
+       }
+
+out:
+       cudbg_put_buff(pdbg_init, pin_buff);
+       return rc;
 }
 
 static int is_fw_attached(struct cudbg_init *pdbg_init)
@@ -371,12 +416,11 @@ int cudbg_collect_reg_dump(struct cudbg_init *pdbg_init,
        else if (is_t5(padap->params.chip) || is_t6(padap->params.chip))
                buf_size = T5_REGMAP_SIZE;
 
-       rc = cudbg_get_buff(dbg_buff, buf_size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, buf_size, &temp_buff);
        if (rc)
                return rc;
        t4_get_regs(padap, (void *)temp_buff.data, temp_buff.size);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_fw_devlog(struct cudbg_init *pdbg_init,
@@ -395,7 +439,7 @@ int cudbg_collect_fw_devlog(struct cudbg_init *pdbg_init,
        }
 
        dparams = &padap->params.devlog;
-       rc = cudbg_get_buff(dbg_buff, dparams->size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, dparams->size, &temp_buff);
        if (rc)
                return rc;
 
@@ -410,12 +454,11 @@ int cudbg_collect_fw_devlog(struct cudbg_init *pdbg_init,
                spin_unlock(&padap->win0_lock);
                if (rc) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_cim_la(struct cudbg_init *pdbg_init,
@@ -436,14 +479,14 @@ int cudbg_collect_cim_la(struct cudbg_init *pdbg_init,
        }
 
        size += sizeof(cfg);
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
        rc = t4_cim_read(padap, UP_UP_DBG_LA_CFG_A, 1, &cfg);
        if (rc) {
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
 
@@ -453,11 +496,10 @@ int cudbg_collect_cim_la(struct cudbg_init *pdbg_init,
                            NULL);
        if (rc < 0) {
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_cim_ma_la(struct cudbg_init *pdbg_init,
@@ -469,7 +511,7 @@ int cudbg_collect_cim_ma_la(struct cudbg_init *pdbg_init,
        int size, rc;
 
        size = 2 * CIM_MALA_SIZE * 5 * sizeof(u32);
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -477,8 +519,7 @@ int cudbg_collect_cim_ma_la(struct cudbg_init *pdbg_init,
                          (u32 *)temp_buff.data,
                          (u32 *)((char *)temp_buff.data +
                                  5 * CIM_MALA_SIZE));
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_cim_qcfg(struct cudbg_init *pdbg_init,
@@ -490,7 +531,7 @@ int cudbg_collect_cim_qcfg(struct cudbg_init *pdbg_init,
        struct cudbg_cim_qcfg *cim_qcfg_data;
        int rc;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_cim_qcfg),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(struct cudbg_cim_qcfg),
                            &temp_buff);
        if (rc)
                return rc;
@@ -501,7 +542,7 @@ int cudbg_collect_cim_qcfg(struct cudbg_init *pdbg_init,
                         ARRAY_SIZE(cim_qcfg_data->stat), cim_qcfg_data->stat);
        if (rc) {
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
 
@@ -510,14 +551,13 @@ int cudbg_collect_cim_qcfg(struct cudbg_init *pdbg_init,
                         cim_qcfg_data->obq_wr);
        if (rc) {
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
 
        t4_read_cimq_cfg(padap, cim_qcfg_data->base, cim_qcfg_data->size,
                         cim_qcfg_data->thres);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 static int cudbg_read_cim_ibq(struct cudbg_init *pdbg_init,
@@ -531,7 +571,7 @@ static int cudbg_read_cim_ibq(struct cudbg_init *pdbg_init,
 
        /* collect CIM IBQ */
        qsize = CIM_IBQ_SIZE * 4 * sizeof(u32);
-       rc = cudbg_get_buff(dbg_buff, qsize, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, qsize, &temp_buff);
        if (rc)
                return rc;
 
@@ -545,11 +585,10 @@ static int cudbg_read_cim_ibq(struct cudbg_init *pdbg_init,
                else
                        rc = no_of_read_words;
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_cim_ibq_tp0(struct cudbg_init *pdbg_init,
@@ -616,7 +655,7 @@ static int cudbg_read_cim_obq(struct cudbg_init *pdbg_init,
 
        /* collect CIM OBQ */
        qsize =  cudbg_cim_obq_size(padap, qid);
-       rc = cudbg_get_buff(dbg_buff, qsize, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, qsize, &temp_buff);
        if (rc)
                return rc;
 
@@ -630,11 +669,10 @@ static int cudbg_read_cim_obq(struct cudbg_init *pdbg_init,
                else
                        rc = no_of_read_words;
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_cim_obq_ulp0(struct cudbg_init *pdbg_init,
@@ -887,7 +925,7 @@ static int cudbg_read_fw_mem(struct cudbg_init *pdbg_init,
 
                bytes = min_t(unsigned long, bytes_left,
                              (unsigned long)CUDBG_CHUNK_SIZE);
-               rc = cudbg_get_buff(dbg_buff, bytes, &temp_buff);
+               rc = cudbg_get_buff(pdbg_init, dbg_buff, bytes, &temp_buff);
                if (rc)
                        return rc;
 
@@ -906,14 +944,19 @@ static int cudbg_read_fw_mem(struct cudbg_init *pdbg_init,
                spin_unlock(&padap->win0_lock);
                if (rc) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
 
 skip_read:
                bytes_left -= bytes;
                bytes_read += bytes;
-               cudbg_write_and_release_buff(&temp_buff, dbg_buff);
+               rc = cudbg_write_and_release_buff(pdbg_init, &temp_buff,
+                                                 dbg_buff);
+               if (rc) {
+                       cudbg_put_buff(pdbg_init, &temp_buff);
+                       return rc;
+               }
        }
        return rc;
 }
@@ -1007,18 +1050,18 @@ int cudbg_collect_rss(struct cudbg_init *pdbg_init,
        int rc, nentries;
 
        nentries = t4_chip_rss_size(padap);
-       rc = cudbg_get_buff(dbg_buff, nentries * sizeof(u16), &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, nentries * sizeof(u16),
+                           &temp_buff);
        if (rc)
                return rc;
 
        rc = t4_read_rss(padap, (u16 *)temp_buff.data);
        if (rc) {
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_rss_vf_config(struct cudbg_init *pdbg_init,
@@ -1031,7 +1074,7 @@ int cudbg_collect_rss_vf_config(struct cudbg_init *pdbg_init,
        int vf, rc, vf_count;
 
        vf_count = padap->params.arch.vfcount;
-       rc = cudbg_get_buff(dbg_buff,
+       rc = cudbg_get_buff(pdbg_init, dbg_buff,
                            vf_count * sizeof(struct cudbg_rss_vf_conf),
                            &temp_buff);
        if (rc)
@@ -1041,8 +1084,7 @@ int cudbg_collect_rss_vf_config(struct cudbg_init *pdbg_init,
        for (vf = 0; vf < vf_count; vf++)
                t4_read_rss_vf_config(padap, vf, &vfconf[vf].rss_vf_vfl,
                                      &vfconf[vf].rss_vf_vfh, true);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_path_mtu(struct cudbg_init *pdbg_init,
@@ -1053,13 +1095,13 @@ int cudbg_collect_path_mtu(struct cudbg_init *pdbg_init,
        struct cudbg_buffer temp_buff = { 0 };
        int rc;
 
-       rc = cudbg_get_buff(dbg_buff, NMTUS * sizeof(u16), &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, NMTUS * sizeof(u16),
+                           &temp_buff);
        if (rc)
                return rc;
 
        t4_read_mtu_tbl(padap, (u16 *)temp_buff.data, NULL);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_pm_stats(struct cudbg_init *pdbg_init,
@@ -1071,7 +1113,7 @@ int cudbg_collect_pm_stats(struct cudbg_init *pdbg_init,
        struct cudbg_pm_stats *pm_stats_buff;
        int rc;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_pm_stats),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(struct cudbg_pm_stats),
                            &temp_buff);
        if (rc)
                return rc;
@@ -1079,8 +1121,7 @@ int cudbg_collect_pm_stats(struct cudbg_init *pdbg_init,
        pm_stats_buff = (struct cudbg_pm_stats *)temp_buff.data;
        t4_pmtx_get_stats(padap, pm_stats_buff->tx_cnt, pm_stats_buff->tx_cyc);
        t4_pmrx_get_stats(padap, pm_stats_buff->rx_cnt, pm_stats_buff->rx_cyc);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_hw_sched(struct cudbg_init *pdbg_init,
@@ -1095,7 +1136,7 @@ int cudbg_collect_hw_sched(struct cudbg_init *pdbg_init,
        if (!padap->params.vpd.cclk)
                return CUDBG_STATUS_CCLK_NOT_DEFINED;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_hw_sched),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(struct cudbg_hw_sched),
                            &temp_buff);
        hw_sched_buff = (struct cudbg_hw_sched *)temp_buff.data;
        hw_sched_buff->map = t4_read_reg(padap, TP_TX_MOD_QUEUE_REQ_MAP_A);
@@ -1104,8 +1145,7 @@ int cudbg_collect_hw_sched(struct cudbg_init *pdbg_init,
        for (i = 0; i < NTX_SCHED; ++i)
                t4_get_tx_sched(padap, i, &hw_sched_buff->kbps[i],
                                &hw_sched_buff->ipg[i], true);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_tp_indirect(struct cudbg_init *pdbg_init,
@@ -1129,7 +1169,7 @@ int cudbg_collect_tp_indirect(struct cudbg_init *pdbg_init,
 
        n = n / (IREG_NUM_ELEM * sizeof(u32));
        size = sizeof(struct ireg_buf) * n;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -1218,8 +1258,7 @@ int cudbg_collect_tp_indirect(struct cudbg_init *pdbg_init,
                               tp_pio->ireg_local_offset, true);
                ch_tp_pio++;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_sge_indirect(struct cudbg_init *pdbg_init,
@@ -1231,7 +1270,8 @@ int cudbg_collect_sge_indirect(struct cudbg_init *pdbg_init,
        struct ireg_buf *ch_sge_dbg;
        int i, rc;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(*ch_sge_dbg) * 2, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(*ch_sge_dbg) * 2,
+                           &temp_buff);
        if (rc)
                return rc;
 
@@ -1252,8 +1292,7 @@ int cudbg_collect_sge_indirect(struct cudbg_init *pdbg_init,
                                 sge_pio->ireg_local_offset);
                ch_sge_dbg++;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_ulprx_la(struct cudbg_init *pdbg_init,
@@ -1265,7 +1304,7 @@ int cudbg_collect_ulprx_la(struct cudbg_init *pdbg_init,
        struct cudbg_ulprx_la *ulprx_la_buff;
        int rc;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_ulprx_la),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(struct cudbg_ulprx_la),
                            &temp_buff);
        if (rc)
                return rc;
@@ -1273,8 +1312,7 @@ int cudbg_collect_ulprx_la(struct cudbg_init *pdbg_init,
        ulprx_la_buff = (struct cudbg_ulprx_la *)temp_buff.data;
        t4_ulprx_read_la(padap, (u32 *)ulprx_la_buff->data);
        ulprx_la_buff->size = ULPRX_LA_SIZE;
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_tp_la(struct cudbg_init *pdbg_init,
@@ -1287,15 +1325,14 @@ int cudbg_collect_tp_la(struct cudbg_init *pdbg_init,
        int size, rc;
 
        size = sizeof(struct cudbg_tp_la) + TPLA_SIZE *  sizeof(u64);
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
        tp_la_buff = (struct cudbg_tp_la *)temp_buff.data;
        tp_la_buff->mode = DBGLAMODE_G(t4_read_reg(padap, TP_DBG_LA_CONFIG_A));
        t4_tp_read_la(padap, (u64 *)tp_la_buff->data, NULL);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_meminfo(struct cudbg_init *pdbg_init,
@@ -1307,7 +1344,8 @@ int cudbg_collect_meminfo(struct cudbg_init *pdbg_init,
        struct cudbg_meminfo *meminfo_buff;
        int rc;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_meminfo), &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(struct cudbg_meminfo),
+                           &temp_buff);
        if (rc)
                return rc;
 
@@ -1315,12 +1353,11 @@ int cudbg_collect_meminfo(struct cudbg_init *pdbg_init,
        rc = cudbg_fill_meminfo(padap, meminfo_buff);
        if (rc) {
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
 
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_cim_pif_la(struct cudbg_init *pdbg_init,
@@ -1334,7 +1371,7 @@ int cudbg_collect_cim_pif_la(struct cudbg_init *pdbg_init,
 
        size = sizeof(struct cudbg_cim_pif_la) +
               2 * CIM_PIFLA_SIZE * 6 * sizeof(u32);
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -1343,8 +1380,7 @@ int cudbg_collect_cim_pif_la(struct cudbg_init *pdbg_init,
        t4_cim_read_pif_la(padap, (u32 *)cim_pif_la_buff->data,
                           (u32 *)cim_pif_la_buff->data + 6 * CIM_PIFLA_SIZE,
                           NULL, NULL);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_clk_info(struct cudbg_init *pdbg_init,
@@ -1360,7 +1396,7 @@ int cudbg_collect_clk_info(struct cudbg_init *pdbg_init,
        if (!padap->params.vpd.cclk)
                return CUDBG_STATUS_CCLK_NOT_DEFINED;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_clk_info),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(struct cudbg_clk_info),
                            &temp_buff);
        if (rc)
                return rc;
@@ -1392,8 +1428,7 @@ int cudbg_collect_clk_info(struct cudbg_init *pdbg_init,
        clk_info_buff->finwait2_timer =
                tp_tick_us * t4_read_reg(padap, TP_FINWAIT2_TIMER_A);
 
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_pcie_indirect(struct cudbg_init *pdbg_init,
@@ -1408,7 +1443,7 @@ int cudbg_collect_pcie_indirect(struct cudbg_init *pdbg_init,
 
        n = sizeof(t5_pcie_pdbg_array) / (IREG_NUM_ELEM * sizeof(u32));
        size = sizeof(struct ireg_buf) * n * 2;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -1449,8 +1484,7 @@ int cudbg_collect_pcie_indirect(struct cudbg_init *pdbg_init,
                                 pcie_pio->ireg_local_offset);
                ch_pcie++;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_pm_indirect(struct cudbg_init *pdbg_init,
@@ -1465,7 +1499,7 @@ int cudbg_collect_pm_indirect(struct cudbg_init *pdbg_init,
 
        n = sizeof(t5_pm_rx_array) / (IREG_NUM_ELEM * sizeof(u32));
        size = sizeof(struct ireg_buf) * n * 2;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -1506,8 +1540,7 @@ int cudbg_collect_pm_indirect(struct cudbg_init *pdbg_init,
                                 pm_pio->ireg_local_offset);
                ch_pm++;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_tid(struct cudbg_init *pdbg_init,
@@ -1521,7 +1554,8 @@ int cudbg_collect_tid(struct cudbg_init *pdbg_init,
        u32 para[2], val[2];
        int rc;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_tid_info_region_rev1),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff,
+                           sizeof(struct cudbg_tid_info_region_rev1),
                            &temp_buff);
        if (rc)
                return rc;
@@ -1544,7 +1578,7 @@ int cudbg_collect_tid(struct cudbg_init *pdbg_init,
        rc = t4_query_params(padap, padap->mbox, padap->pf, 0, 2, para, val);
        if (rc <  0) {
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
        tid->uotid_base = val[0];
@@ -1563,7 +1597,7 @@ int cudbg_collect_tid(struct cudbg_init *pdbg_init,
                                     para, val);
                if (rc < 0) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
                tid->hpftid_base = val[0];
@@ -1591,8 +1625,7 @@ int cudbg_collect_tid(struct cudbg_init *pdbg_init,
 
 #undef FW_PARAM_PFVF_A
 
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_pcie_config(struct cudbg_init *pdbg_init,
@@ -1606,7 +1639,7 @@ int cudbg_collect_pcie_config(struct cudbg_init *pdbg_init,
 
        size = sizeof(u32) * CUDBG_NUM_PCIE_CONFIG_REGS;
        n = sizeof(t5_pcie_config_array) / (2 * sizeof(u32));
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -1618,8 +1651,7 @@ int cudbg_collect_pcie_config(struct cudbg_init *pdbg_init,
                        value++;
                }
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 static int cudbg_sge_ctxt_check_valid(u32 *buf, int type)
@@ -1799,7 +1831,7 @@ int cudbg_collect_dump_context(struct cudbg_init *pdbg_init,
                return CUDBG_STATUS_ENTITY_NOT_FOUND;
 
        size = rc;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -1813,7 +1845,7 @@ int cudbg_collect_dump_context(struct cudbg_init *pdbg_init,
 
        ctx_buf = kvzalloc(max_ctx_size, GFP_KERNEL);
        if (!ctx_buf) {
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return -ENOMEM;
        }
 
@@ -1876,8 +1908,7 @@ int cudbg_collect_dump_context(struct cudbg_init *pdbg_init,
         */
        cudbg_get_sge_ctxt_fw(pdbg_init, max_ctx_qid, CTXT_FLM, &buff);
 
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 static inline void cudbg_tcamxy2valmask(u64 x, u64 y, u8 *addr, u64 *mask)
@@ -2038,7 +2069,7 @@ int cudbg_collect_mps_tcam(struct cudbg_init *pdbg_init,
 
        n = padap->params.arch.mps_tcam_size;
        size = sizeof(struct cudbg_mps_tcam) * n;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -2047,7 +2078,7 @@ int cudbg_collect_mps_tcam(struct cudbg_init *pdbg_init,
                rc = cudbg_collect_tcam_index(padap, tcam, i);
                if (rc) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
                total_size += sizeof(struct cudbg_mps_tcam);
@@ -2057,11 +2088,10 @@ int cudbg_collect_mps_tcam(struct cudbg_init *pdbg_init,
        if (!total_size) {
                rc = CUDBG_SYSTEM_ERROR;
                cudbg_err->sys_err = rc;
-               cudbg_put_buff(&temp_buff, dbg_buff);
+               cudbg_put_buff(pdbg_init, &temp_buff);
                return rc;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_vpd_data(struct cudbg_init *pdbg_init,
@@ -2112,7 +2142,7 @@ int cudbg_collect_vpd_data(struct cudbg_init *pdbg_init,
        if (rc)
                return rc;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_vpd_data),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(struct cudbg_vpd_data),
                            &temp_buff);
        if (rc)
                return rc;
@@ -2128,8 +2158,7 @@ int cudbg_collect_vpd_data(struct cudbg_init *pdbg_init,
        vpd_data->fw_minor = FW_HDR_FW_VER_MINOR_G(fw_vers);
        vpd_data->fw_micro = FW_HDR_FW_VER_MICRO_G(fw_vers);
        vpd_data->fw_build = FW_HDR_FW_VER_BUILD_G(fw_vers);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 static int cudbg_read_tid(struct cudbg_init *pdbg_init, u32 tid,
@@ -2280,7 +2309,7 @@ int cudbg_collect_le_tcam(struct cudbg_init *pdbg_init,
 
        size = sizeof(struct cudbg_tid_data) * tcam_region.max_tid;
        size += sizeof(struct cudbg_tcam);
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -2292,7 +2321,7 @@ int cudbg_collect_le_tcam(struct cudbg_init *pdbg_init,
                rc = cudbg_read_tid(pdbg_init, i, tid_data);
                if (rc) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
 
@@ -2303,8 +2332,7 @@ int cudbg_collect_le_tcam(struct cudbg_init *pdbg_init,
                bytes += sizeof(struct cudbg_tid_data);
        }
 
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_cctrl(struct cudbg_init *pdbg_init,
@@ -2317,13 +2345,12 @@ int cudbg_collect_cctrl(struct cudbg_init *pdbg_init,
        int rc;
 
        size = sizeof(u16) * NMTUS * NCCTRL_WIN;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
        t4_read_cong_tbl(padap, (void *)temp_buff.data);
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_ma_indirect(struct cudbg_init *pdbg_init,
@@ -2341,7 +2368,7 @@ int cudbg_collect_ma_indirect(struct cudbg_init *pdbg_init,
 
        n = sizeof(t6_ma_ireg_array) / (IREG_NUM_ELEM * sizeof(u32));
        size = sizeof(struct ireg_buf) * n * 2;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -2377,8 +2404,7 @@ int cudbg_collect_ma_indirect(struct cudbg_init *pdbg_init,
                }
                ma_indr++;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_ulptx_la(struct cudbg_init *pdbg_init,
@@ -2391,7 +2417,7 @@ int cudbg_collect_ulptx_la(struct cudbg_init *pdbg_init,
        u32 i, j;
        int rc;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_ulptx_la),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, sizeof(struct cudbg_ulptx_la),
                            &temp_buff);
        if (rc)
                return rc;
@@ -2412,8 +2438,7 @@ int cudbg_collect_ulptx_la(struct cudbg_init *pdbg_init,
                                t4_read_reg(padap,
                                            ULP_TX_LA_RDDATA_0_A + 0x10 * i);
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_up_cim_indirect(struct cudbg_init *pdbg_init,
@@ -2438,7 +2463,7 @@ int cudbg_collect_up_cim_indirect(struct cudbg_init *pdbg_init,
                return CUDBG_STATUS_NOT_IMPLEMENTED;
 
        size = sizeof(struct ireg_buf) * n;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -2488,14 +2513,13 @@ int cudbg_collect_up_cim_indirect(struct cudbg_init *pdbg_init,
                                         up_cim_reg->ireg_local_offset +
                                         (j * local_offset), local_range, buff);
                        if (rc) {
-                               cudbg_put_buff(&temp_buff, dbg_buff);
+                               cudbg_put_buff(pdbg_init, &temp_buff);
                                return rc;
                        }
                }
                up_cim++;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_pbt_tables(struct cudbg_init *pdbg_init,
@@ -2508,7 +2532,8 @@ int cudbg_collect_pbt_tables(struct cudbg_init *pdbg_init,
        int i, rc;
        u32 addr;
 
-       rc = cudbg_get_buff(dbg_buff, sizeof(struct cudbg_pbt_tables),
+       rc = cudbg_get_buff(pdbg_init, dbg_buff,
+                           sizeof(struct cudbg_pbt_tables),
                            &temp_buff);
        if (rc)
                return rc;
@@ -2521,7 +2546,7 @@ int cudbg_collect_pbt_tables(struct cudbg_init *pdbg_init,
                                 &pbt->pbt_dynamic[i]);
                if (rc) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
        }
@@ -2534,7 +2559,7 @@ int cudbg_collect_pbt_tables(struct cudbg_init *pdbg_init,
                                 &pbt->pbt_static[i]);
                if (rc) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
        }
@@ -2546,7 +2571,7 @@ int cudbg_collect_pbt_tables(struct cudbg_init *pdbg_init,
                                 &pbt->lrf_table[i]);
                if (rc) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
        }
@@ -2558,12 +2583,11 @@ int cudbg_collect_pbt_tables(struct cudbg_init *pdbg_init,
                                 &pbt->pbt_data[i]);
                if (rc) {
                        cudbg_err->sys_err = rc;
-                       cudbg_put_buff(&temp_buff, dbg_buff);
+                       cudbg_put_buff(pdbg_init, &temp_buff);
                        return rc;
                }
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_mbox_log(struct cudbg_init *pdbg_init,
@@ -2584,7 +2608,7 @@ int cudbg_collect_mbox_log(struct cudbg_init *pdbg_init,
        log = padap->mbox_log;
        mbox_cmds = padap->mbox_log->size;
        size = sizeof(struct cudbg_mbox_log) * mbox_cmds;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -2607,8 +2631,7 @@ int cudbg_collect_mbox_log(struct cudbg_init *pdbg_init,
                }
                mboxlog++;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }
 
 int cudbg_collect_hma_indirect(struct cudbg_init *pdbg_init,
@@ -2626,7 +2649,7 @@ int cudbg_collect_hma_indirect(struct cudbg_init *pdbg_init,
 
        n = sizeof(t6_hma_ireg_array) / (IREG_NUM_ELEM * sizeof(u32));
        size = sizeof(struct ireg_buf) * n;
-       rc = cudbg_get_buff(dbg_buff, size, &temp_buff);
+       rc = cudbg_get_buff(pdbg_init, dbg_buff, size, &temp_buff);
        if (rc)
                return rc;
 
@@ -2644,6 +2667,5 @@ int cudbg_collect_hma_indirect(struct cudbg_init *pdbg_init,
                                 hma_fli->ireg_local_offset);
                hma_indr++;
        }
-       cudbg_write_and_release_buff(&temp_buff, dbg_buff);
-       return rc;
+       return cudbg_write_and_release_buff(pdbg_init, &temp_buff, dbg_buff);
 }

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cudbg_lib_common.h b/drivers/net/ethernet/chelsio/cxgb4/cudbg_lib_common.h
index 24b33f28e548cc41419b22fd37729ceb2d27367d..2e1c8e87c9bdc4f6a0803f9578ec07db48ce88c6 100644 (file)
--- a/drivers/net/ethernet/chelsio/cxgb4/cudbg_lib_common.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cudbg_lib_common.h
@@ -78,10 +78,11 @@ struct cudbg_error {
 #define CDUMP_MAX_COMP_BUF_SIZE ((64 * 1024) - 1)
 #define CUDBG_CHUNK_SIZE ((CDUMP_MAX_COMP_BUF_SIZE / 1024) * 1024)
 
-int cudbg_get_buff(struct cudbg_buffer *pdbg_buff, u32 size,
+int cudbg_get_buff(struct cudbg_init *pdbg_init,
+                  struct cudbg_buffer *pdbg_buff, u32 size,
                   struct cudbg_buffer *pin_buff);
-void cudbg_put_buff(struct cudbg_buffer *pin_buff,
-                   struct cudbg_buffer *pdbg_buff);
+void cudbg_put_buff(struct cudbg_init *pdbg_init,
+                   struct cudbg_buffer *pin_buff);
 void cudbg_update_buff(struct cudbg_buffer *pin_buff,
                       struct cudbg_buffer *pout_buff);
 #endif /* __CUDBG_LIB_COMMON_H__ */

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cudbg_zlib.h b/drivers/net/ethernet/chelsio/cxgb4/cudbg_zlib.h
new file mode 100644 (file)
index 0000000..f4b4a4a
--- /dev/null
+++ b/drivers/net/ethernet/chelsio/cxgb4/cudbg_zlib.h
@@ -0,0 +1,27 @@
+/*
+ *  Copyright (C) 2018 Chelsio Communications.  All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms and conditions of the GNU General Public License,
+ *  version 2, as published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ *  more details.
+ *
+ *  The full GNU General Public License is included in this distribution in
+ *  the file called "COPYING".
+ *
+ */
+
+#ifndef __CUDBG_ZLIB_H__
+#define __CUDBG_ZLIB_H__
+
+static inline int cudbg_compress_buff(struct cudbg_init *pdbg_init,
+                                     struct cudbg_buffer *pin_buff,
+                                     struct cudbg_buffer *pout_buff)
+{
+       return 0;
+}
+#endif /* __CUDBG_ZLIB_H__ */

diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_cudbg.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_cudbg.c
index a2d6c8a69c52bc0bef98e123b049ccd078da8488..bf1732da8c6da079b8c74f633464198914f0701d 100644 (file)
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_cudbg.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_cudbg.c
@@ -341,22 +341,14 @@ static void cxgb4_cudbg_collect_entity(struct cudbg_init *pdbg_init,
                                       const struct cxgb4_collect_entity *e_arr,
                                       u32 arr_size, void *buf, u32 *tot_size)
 {
-       struct adapter *adap = pdbg_init->adap;
        struct cudbg_error cudbg_err = { 0 };
        struct cudbg_entity_hdr *entity_hdr;
-       u32 entity_size, i;
-       u32 total_size = 0;
+       u32 i, total_size = 0;
        int ret;
 
        for (i = 0; i < arr_size; i++) {
                const struct cxgb4_collect_entity *e = &e_arr[i];
 
-               /* Skip entities that won't fit in output buffer */
-               entity_size = cxgb4_get_entity_length(adap, e->entity);
-               if (entity_size >
-                   pdbg_init->outbuf_size - *tot_size - total_size)
-                       continue;
-
                entity_hdr = cudbg_get_entity_hdr(buf, e->entity);
                entity_hdr->entity_type = e->entity;
                entity_hdr->start_offset = dbg_buff->offset;
@@ -408,7 +400,8 @@ int cxgb4_cudbg_collect(struct adapter *adap, void *buf, u32 *buf_size,
        cudbg_hdr->max_entities = CUDBG_MAX_ENTITY;
        cudbg_hdr->chip_ver = adap->params.chip;
        cudbg_hdr->dump_type = CUDBG_DUMP_TYPE_MINI;
-       cudbg_hdr->compress_type = CUDBG_COMPRESSION_NONE;
+       cudbg_init.compress_type = CUDBG_COMPRESSION_NONE;
+       cudbg_hdr->compress_type = cudbg_init.compress_type;
 
        min_size = sizeof(struct cudbg_hdr) +
                   sizeof(struct cudbg_entity_hdr) *