chelsio/cxgb4/cxgb4_cudbg.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  Copyright (C) 2017 Chelsio Communications.  All rights reserved.
0004  */
0005
0006 #include "t4_regs.h"
0007 #include "cxgb4.h"
0008 #include "cxgb4_cudbg.h"
0009 #include "cudbg_zlib.h"
0010
0011 static const struct cxgb4_collect_entity cxgb4_collect_mem_dump[] = {
0012     { CUDBG_EDC0, cudbg_collect_edc0_meminfo },
0013     { CUDBG_EDC1, cudbg_collect_edc1_meminfo },
0014     { CUDBG_MC0, cudbg_collect_mc0_meminfo },
0015     { CUDBG_MC1, cudbg_collect_mc1_meminfo },
0016     { CUDBG_HMA, cudbg_collect_hma_meminfo },
0017 };
0018
0019 static const struct cxgb4_collect_entity cxgb4_collect_hw_dump[] = {
0020     { CUDBG_MBOX_LOG, cudbg_collect_mbox_log },
0021     { CUDBG_QDESC, cudbg_collect_qdesc },
0022     { CUDBG_DEV_LOG, cudbg_collect_fw_devlog },
0023     { CUDBG_REG_DUMP, cudbg_collect_reg_dump },
0024     { CUDBG_CIM_LA, cudbg_collect_cim_la },
0025     { CUDBG_CIM_MA_LA, cudbg_collect_cim_ma_la },
0026     { CUDBG_CIM_QCFG, cudbg_collect_cim_qcfg },
0027     { CUDBG_CIM_IBQ_TP0, cudbg_collect_cim_ibq_tp0 },
0028     { CUDBG_CIM_IBQ_TP1, cudbg_collect_cim_ibq_tp1 },
0029     { CUDBG_CIM_IBQ_ULP, cudbg_collect_cim_ibq_ulp },
0030     { CUDBG_CIM_IBQ_SGE0, cudbg_collect_cim_ibq_sge0 },
0031     { CUDBG_CIM_IBQ_SGE1, cudbg_collect_cim_ibq_sge1 },
0032     { CUDBG_CIM_IBQ_NCSI, cudbg_collect_cim_ibq_ncsi },
0033     { CUDBG_CIM_OBQ_ULP0, cudbg_collect_cim_obq_ulp0 },
0034     { CUDBG_CIM_OBQ_ULP1, cudbg_collect_cim_obq_ulp1 },
0035     { CUDBG_CIM_OBQ_ULP2, cudbg_collect_cim_obq_ulp2 },
0036     { CUDBG_CIM_OBQ_ULP3, cudbg_collect_cim_obq_ulp3 },
0037     { CUDBG_CIM_OBQ_SGE, cudbg_collect_cim_obq_sge },
0038     { CUDBG_CIM_OBQ_NCSI, cudbg_collect_cim_obq_ncsi },
0039     { CUDBG_RSS, cudbg_collect_rss },
0040     { CUDBG_RSS_VF_CONF, cudbg_collect_rss_vf_config },
0041     { CUDBG_PATH_MTU, cudbg_collect_path_mtu },
0042     { CUDBG_PM_STATS, cudbg_collect_pm_stats },
0043     { CUDBG_HW_SCHED, cudbg_collect_hw_sched },
0044     { CUDBG_TP_INDIRECT, cudbg_collect_tp_indirect },
0045     { CUDBG_SGE_INDIRECT, cudbg_collect_sge_indirect },
0046     { CUDBG_ULPRX_LA, cudbg_collect_ulprx_la },
0047     { CUDBG_TP_LA, cudbg_collect_tp_la },
0048     { CUDBG_MEMINFO, cudbg_collect_meminfo },
0049     { CUDBG_CIM_PIF_LA, cudbg_collect_cim_pif_la },
0050     { CUDBG_CLK, cudbg_collect_clk_info },
0051     { CUDBG_CIM_OBQ_RXQ0, cudbg_collect_obq_sge_rx_q0 },
0052     { CUDBG_CIM_OBQ_RXQ1, cudbg_collect_obq_sge_rx_q1 },
0053     { CUDBG_PCIE_INDIRECT, cudbg_collect_pcie_indirect },
0054     { CUDBG_PM_INDIRECT, cudbg_collect_pm_indirect },
0055     { CUDBG_TID_INFO, cudbg_collect_tid },
0056     { CUDBG_PCIE_CONFIG, cudbg_collect_pcie_config },
0057     { CUDBG_DUMP_CONTEXT, cudbg_collect_dump_context },
0058     { CUDBG_MPS_TCAM, cudbg_collect_mps_tcam },
0059     { CUDBG_VPD_DATA, cudbg_collect_vpd_data },
0060     { CUDBG_LE_TCAM, cudbg_collect_le_tcam },
0061     { CUDBG_CCTRL, cudbg_collect_cctrl },
0062     { CUDBG_MA_INDIRECT, cudbg_collect_ma_indirect },
0063     { CUDBG_ULPTX_LA, cudbg_collect_ulptx_la },
0064     { CUDBG_UP_CIM_INDIRECT, cudbg_collect_up_cim_indirect },
0065     { CUDBG_PBT_TABLE, cudbg_collect_pbt_tables },
0066     { CUDBG_HMA_INDIRECT, cudbg_collect_hma_indirect },
0067 };
0068
0069 static const struct cxgb4_collect_entity cxgb4_collect_flash_dump[] = {
0070     { CUDBG_FLASH, cudbg_collect_flash },
0071 };
0072
0073 u32 cxgb4_get_dump_length(struct adapter *adap, u32 flag)
0074 {
0075     u32 i, entity;
0076     u32 len = 0;
0077     u32 wsize;
0078
0079     if (flag & CXGB4_ETH_DUMP_HW) {
0080         for (i = 0; i < ARRAY_SIZE(cxgb4_collect_hw_dump); i++) {
0081             entity = cxgb4_collect_hw_dump[i].entity;
0082             len += cudbg_get_entity_length(adap, entity);
0083         }
0084     }
0085
0086     if (flag & CXGB4_ETH_DUMP_MEM) {
0087         for (i = 0; i < ARRAY_SIZE(cxgb4_collect_mem_dump); i++) {
0088             entity = cxgb4_collect_mem_dump[i].entity;
0089             len += cudbg_get_entity_length(adap, entity);
0090         }
0091     }
0092
0093     if (flag & CXGB4_ETH_DUMP_FLASH)
0094         len += adap->params.sf_size;
0095
0096     /* If compression is enabled, a smaller destination buffer is enough */
0097     wsize = cudbg_get_workspace_size();
0098     if (wsize && len > CUDBG_DUMP_BUFF_SIZE)
0099         len = CUDBG_DUMP_BUFF_SIZE;
0100
0101     return len;
0102 }
0103
0104 static void cxgb4_cudbg_collect_entity(struct cudbg_init *pdbg_init,
0105                        struct cudbg_buffer *dbg_buff,
0106                        const struct cxgb4_collect_entity *e_arr,
0107                        u32 arr_size, void *buf, u32 *tot_size)
0108 {
0109     struct cudbg_error cudbg_err = { 0 };
0110     struct cudbg_entity_hdr *entity_hdr;
0111     u32 i, total_size = 0;
0112     int ret;
0113
0114     for (i = 0; i < arr_size; i++) {
0115         const struct cxgb4_collect_entity *e = &e_arr[i];
0116
0117         entity_hdr = cudbg_get_entity_hdr(buf, e->entity);
0118         entity_hdr->entity_type = e->entity;
0119         entity_hdr->start_offset = dbg_buff->offset;
0120         memset(&cudbg_err, 0, sizeof(struct cudbg_error));
0121         ret = e->collect_cb(pdbg_init, dbg_buff, &cudbg_err);
0122         if (ret) {
0123             entity_hdr->size = 0;
0124             dbg_buff->offset = entity_hdr->start_offset;
0125         } else {
0126             cudbg_align_debug_buffer(dbg_buff, entity_hdr);
0127         }
0128
0129         /* Log error and continue with next entity */
0130         if (cudbg_err.sys_err)
0131             ret = CUDBG_SYSTEM_ERROR;
0132
0133         entity_hdr->hdr_flags = ret;
0134         entity_hdr->sys_err = cudbg_err.sys_err;
0135         entity_hdr->sys_warn = cudbg_err.sys_warn;
0136         total_size += entity_hdr->size;
0137     }
0138
0139     *tot_size += total_size;
0140 }
0141
0142 static int cudbg_alloc_compress_buff(struct cudbg_init *pdbg_init)
0143 {
0144     u32 workspace_size;
0145
0146     workspace_size = cudbg_get_workspace_size();
0147     pdbg_init->compress_buff = vzalloc(CUDBG_COMPRESS_BUFF_SIZE +
0148                        workspace_size);
0149     if (!pdbg_init->compress_buff)
0150         return -ENOMEM;
0151
0152     pdbg_init->compress_buff_size = CUDBG_COMPRESS_BUFF_SIZE;
0153     pdbg_init->workspace = (u8 *)pdbg_init->compress_buff +
0154                    CUDBG_COMPRESS_BUFF_SIZE - workspace_size;
0155     return 0;
0156 }
0157
0158 static void cudbg_free_compress_buff(struct cudbg_init *pdbg_init)
0159 {
0160     vfree(pdbg_init->compress_buff);
0161 }
0162
0163 int cxgb4_cudbg_collect(struct adapter *adap, void *buf, u32 *buf_size,
0164             u32 flag)
0165 {
0166     struct cudbg_buffer dbg_buff = { 0 };
0167     u32 size, min_size, total_size = 0;
0168     struct cudbg_init cudbg_init;
0169     struct cudbg_hdr *cudbg_hdr;
0170     int rc;
0171
0172     size = *buf_size;
0173
0174     memset(&cudbg_init, 0, sizeof(struct cudbg_init));
0175     cudbg_init.adap = adap;
0176     cudbg_init.outbuf = buf;
0177     cudbg_init.outbuf_size = size;
0178
0179     dbg_buff.data = buf;
0180     dbg_buff.size = size;
0181     dbg_buff.offset = 0;
0182
0183     cudbg_hdr = (struct cudbg_hdr *)buf;
0184     cudbg_hdr->signature = CUDBG_SIGNATURE;
0185     cudbg_hdr->hdr_len = sizeof(struct cudbg_hdr);
0186     cudbg_hdr->major_ver = CUDBG_MAJOR_VERSION;
0187     cudbg_hdr->minor_ver = CUDBG_MINOR_VERSION;
0188     cudbg_hdr->max_entities = CUDBG_MAX_ENTITY;
0189     cudbg_hdr->chip_ver = adap->params.chip;
0190     cudbg_hdr->dump_type = CUDBG_DUMP_TYPE_MINI;
0191
0192     min_size = sizeof(struct cudbg_hdr) +
0193            sizeof(struct cudbg_entity_hdr) *
0194            cudbg_hdr->max_entities;
0195     if (size < min_size)
0196         return -ENOMEM;
0197
0198     rc = cudbg_get_workspace_size();
0199     if (rc) {
0200         /* Zlib available.  So, use zlib deflate */
0201         cudbg_init.compress_type = CUDBG_COMPRESSION_ZLIB;
0202         rc = cudbg_alloc_compress_buff(&cudbg_init);
0203         if (rc) {
0204             /* Ignore error and continue without compression. */
0205             dev_warn(adap->pdev_dev,
0206                  "Fail allocating compression buffer ret: %d.  Continuing without compression.\n",
0207                  rc);
0208             cudbg_init.compress_type = CUDBG_COMPRESSION_NONE;
0209             rc = 0;
0210         }
0211     } else {
0212         cudbg_init.compress_type = CUDBG_COMPRESSION_NONE;
0213     }
0214
0215     cudbg_hdr->compress_type = cudbg_init.compress_type;
0216     dbg_buff.offset += min_size;
0217     total_size = dbg_buff.offset;
0218
0219     if (flag & CXGB4_ETH_DUMP_HW)
0220         cxgb4_cudbg_collect_entity(&cudbg_init, &dbg_buff,
0221                        cxgb4_collect_hw_dump,
0222                        ARRAY_SIZE(cxgb4_collect_hw_dump),
0223                        buf,
0224                        &total_size);
0225
0226     if (flag & CXGB4_ETH_DUMP_MEM)
0227         cxgb4_cudbg_collect_entity(&cudbg_init, &dbg_buff,
0228                        cxgb4_collect_mem_dump,
0229                        ARRAY_SIZE(cxgb4_collect_mem_dump),
0230                        buf,
0231                        &total_size);
0232
0233     if (flag & CXGB4_ETH_DUMP_FLASH)
0234         cxgb4_cudbg_collect_entity(&cudbg_init, &dbg_buff,
0235                        cxgb4_collect_flash_dump,
0236                        ARRAY_SIZE(cxgb4_collect_flash_dump),
0237                        buf,
0238                        &total_size);
0239
0240     cudbg_free_compress_buff(&cudbg_init);
0241     cudbg_hdr->data_len = total_size;
0242     if (cudbg_init.compress_type != CUDBG_COMPRESSION_NONE)
0243         *buf_size = size;
0244     else
0245         *buf_size = total_size;
0246     return 0;
0247 }
0248
0249 void cxgb4_init_ethtool_dump(struct adapter *adapter)
0250 {
0251     adapter->eth_dump.flag = CXGB4_ETH_DUMP_NONE;
0252     adapter->eth_dump.version = adapter->params.fw_vers;
0253     adapter->eth_dump.len = 0;
0254 }
0255
0256 static int cxgb4_cudbg_vmcoredd_collect(struct vmcoredd_data *data, void *buf)
0257 {
0258     struct adapter *adap = container_of(data, struct adapter, vmcoredd);
0259     u32 len = data->size;
0260
0261     return cxgb4_cudbg_collect(adap, buf, &len, CXGB4_ETH_DUMP_ALL);
0262 }
0263
0264 int cxgb4_cudbg_vmcore_add_dump(struct adapter *adap)
0265 {
0266     struct vmcoredd_data *data = &adap->vmcoredd;
0267     u32 len;
0268
0269     len = sizeof(struct cudbg_hdr) +
0270           sizeof(struct cudbg_entity_hdr) * CUDBG_MAX_ENTITY;
0271     len += CUDBG_DUMP_BUFF_SIZE;
0272
0273     data->size = len;
0274     snprintf(data->dump_name, sizeof(data->dump_name), "%s_%s",
0275          cxgb4_driver_name, adap->name);
0276     data->vmcoredd_callback = cxgb4_cudbg_vmcoredd_collect;
0277
0278     return vmcore_add_device_dump(data);
0279 }