1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2017 Chelsio Communications. All rights reserved. 4 */ 5 6 #include "t4_regs.h" 7 #include "cxgb4.h" 8 #include "cxgb4_cudbg.h" 9 #include "cudbg_zlib.h" 10 11 static const struct cxgb4_collect_entity cxgb4_collect_mem_dump[] = { 12 { CUDBG_EDC0, cudbg_collect_edc0_meminfo }, 13 { CUDBG_EDC1, cudbg_collect_edc1_meminfo }, 14 { CUDBG_MC0, cudbg_collect_mc0_meminfo }, 15 { CUDBG_MC1, cudbg_collect_mc1_meminfo }, 16 { CUDBG_HMA, cudbg_collect_hma_meminfo }, 17 }; 18 19 static const struct cxgb4_collect_entity cxgb4_collect_hw_dump[] = { 20 { CUDBG_MBOX_LOG, cudbg_collect_mbox_log }, 21 { CUDBG_QDESC, cudbg_collect_qdesc }, 22 { CUDBG_DEV_LOG, cudbg_collect_fw_devlog }, 23 { CUDBG_REG_DUMP, cudbg_collect_reg_dump }, 24 { CUDBG_CIM_LA, cudbg_collect_cim_la }, 25 { CUDBG_CIM_MA_LA, cudbg_collect_cim_ma_la }, 26 { CUDBG_CIM_QCFG, cudbg_collect_cim_qcfg }, 27 { CUDBG_CIM_IBQ_TP0, cudbg_collect_cim_ibq_tp0 }, 28 { CUDBG_CIM_IBQ_TP1, cudbg_collect_cim_ibq_tp1 }, 29 { CUDBG_CIM_IBQ_ULP, cudbg_collect_cim_ibq_ulp }, 30 { CUDBG_CIM_IBQ_SGE0, cudbg_collect_cim_ibq_sge0 }, 31 { CUDBG_CIM_IBQ_SGE1, cudbg_collect_cim_ibq_sge1 }, 32 { CUDBG_CIM_IBQ_NCSI, cudbg_collect_cim_ibq_ncsi }, 33 { CUDBG_CIM_OBQ_ULP0, cudbg_collect_cim_obq_ulp0 }, 34 { CUDBG_CIM_OBQ_ULP1, cudbg_collect_cim_obq_ulp1 }, 35 { CUDBG_CIM_OBQ_ULP2, cudbg_collect_cim_obq_ulp2 }, 36 { CUDBG_CIM_OBQ_ULP3, cudbg_collect_cim_obq_ulp3 }, 37 { CUDBG_CIM_OBQ_SGE, cudbg_collect_cim_obq_sge }, 38 { CUDBG_CIM_OBQ_NCSI, cudbg_collect_cim_obq_ncsi }, 39 { CUDBG_RSS, cudbg_collect_rss }, 40 { CUDBG_RSS_VF_CONF, cudbg_collect_rss_vf_config }, 41 { CUDBG_PATH_MTU, cudbg_collect_path_mtu }, 42 { CUDBG_PM_STATS, cudbg_collect_pm_stats }, 43 { CUDBG_HW_SCHED, cudbg_collect_hw_sched }, 44 { CUDBG_TP_INDIRECT, cudbg_collect_tp_indirect }, 45 { CUDBG_SGE_INDIRECT, cudbg_collect_sge_indirect }, 46 { CUDBG_ULPRX_LA, cudbg_collect_ulprx_la }, 47 { CUDBG_TP_LA, cudbg_collect_tp_la }, 48 { CUDBG_MEMINFO, cudbg_collect_meminfo }, 49 { CUDBG_CIM_PIF_LA, cudbg_collect_cim_pif_la }, 50 { CUDBG_CLK, cudbg_collect_clk_info }, 51 { CUDBG_CIM_OBQ_RXQ0, cudbg_collect_obq_sge_rx_q0 }, 52 { CUDBG_CIM_OBQ_RXQ1, cudbg_collect_obq_sge_rx_q1 }, 53 { CUDBG_PCIE_INDIRECT, cudbg_collect_pcie_indirect }, 54 { CUDBG_PM_INDIRECT, cudbg_collect_pm_indirect }, 55 { CUDBG_TID_INFO, cudbg_collect_tid }, 56 { CUDBG_PCIE_CONFIG, cudbg_collect_pcie_config }, 57 { CUDBG_DUMP_CONTEXT, cudbg_collect_dump_context }, 58 { CUDBG_MPS_TCAM, cudbg_collect_mps_tcam }, 59 { CUDBG_VPD_DATA, cudbg_collect_vpd_data }, 60 { CUDBG_LE_TCAM, cudbg_collect_le_tcam }, 61 { CUDBG_CCTRL, cudbg_collect_cctrl }, 62 { CUDBG_MA_INDIRECT, cudbg_collect_ma_indirect }, 63 { CUDBG_ULPTX_LA, cudbg_collect_ulptx_la }, 64 { CUDBG_UP_CIM_INDIRECT, cudbg_collect_up_cim_indirect }, 65 { CUDBG_PBT_TABLE, cudbg_collect_pbt_tables }, 66 { CUDBG_HMA_INDIRECT, cudbg_collect_hma_indirect }, 67 }; 68 69 static const struct cxgb4_collect_entity cxgb4_collect_flash_dump[] = { 70 { CUDBG_FLASH, cudbg_collect_flash }, 71 }; 72 73 u32 cxgb4_get_dump_length(struct adapter *adap, u32 flag) 74 { 75 u32 i, entity; 76 u32 len = 0; 77 u32 wsize; 78 79 if (flag & CXGB4_ETH_DUMP_HW) { 80 for (i = 0; i < ARRAY_SIZE(cxgb4_collect_hw_dump); i++) { 81 entity = cxgb4_collect_hw_dump[i].entity; 82 len += cudbg_get_entity_length(adap, entity); 83 } 84 } 85 86 if (flag & CXGB4_ETH_DUMP_MEM) { 87 for (i = 0; i < ARRAY_SIZE(cxgb4_collect_mem_dump); i++) { 88 entity = cxgb4_collect_mem_dump[i].entity; 89 len += cudbg_get_entity_length(adap, entity); 90 } 91 } 92 93 if (flag & CXGB4_ETH_DUMP_FLASH) 94 len += adap->params.sf_size; 95 96 /* If compression is enabled, a smaller destination buffer is enough */ 97 wsize = cudbg_get_workspace_size(); 98 if (wsize && len > CUDBG_DUMP_BUFF_SIZE) 99 len = CUDBG_DUMP_BUFF_SIZE; 100 101 return len; 102 } 103 104 static void cxgb4_cudbg_collect_entity(struct cudbg_init *pdbg_init, 105 struct cudbg_buffer *dbg_buff, 106 const struct cxgb4_collect_entity *e_arr, 107 u32 arr_size, void *buf, u32 *tot_size) 108 { 109 struct cudbg_error cudbg_err = { 0 }; 110 struct cudbg_entity_hdr *entity_hdr; 111 u32 i, total_size = 0; 112 int ret; 113 114 for (i = 0; i < arr_size; i++) { 115 const struct cxgb4_collect_entity *e = &e_arr[i]; 116 117 entity_hdr = cudbg_get_entity_hdr(buf, e->entity); 118 entity_hdr->entity_type = e->entity; 119 entity_hdr->start_offset = dbg_buff->offset; 120 memset(&cudbg_err, 0, sizeof(struct cudbg_error)); 121 ret = e->collect_cb(pdbg_init, dbg_buff, &cudbg_err); 122 if (ret) { 123 entity_hdr->size = 0; 124 dbg_buff->offset = entity_hdr->start_offset; 125 } else { 126 cudbg_align_debug_buffer(dbg_buff, entity_hdr); 127 } 128 129 /* Log error and continue with next entity */ 130 if (cudbg_err.sys_err) 131 ret = CUDBG_SYSTEM_ERROR; 132 133 entity_hdr->hdr_flags = ret; 134 entity_hdr->sys_err = cudbg_err.sys_err; 135 entity_hdr->sys_warn = cudbg_err.sys_warn; 136 total_size += entity_hdr->size; 137 } 138 139 *tot_size += total_size; 140 } 141 142 static int cudbg_alloc_compress_buff(struct cudbg_init *pdbg_init) 143 { 144 u32 workspace_size; 145 146 workspace_size = cudbg_get_workspace_size(); 147 pdbg_init->compress_buff = vzalloc(CUDBG_COMPRESS_BUFF_SIZE + 148 workspace_size); 149 if (!pdbg_init->compress_buff) 150 return -ENOMEM; 151 152 pdbg_init->compress_buff_size = CUDBG_COMPRESS_BUFF_SIZE; 153 pdbg_init->workspace = (u8 *)pdbg_init->compress_buff + 154 CUDBG_COMPRESS_BUFF_SIZE - workspace_size; 155 return 0; 156 } 157 158 static void cudbg_free_compress_buff(struct cudbg_init *pdbg_init) 159 { 160 vfree(pdbg_init->compress_buff); 161 } 162 163 int cxgb4_cudbg_collect(struct adapter *adap, void *buf, u32 *buf_size, 164 u32 flag) 165 { 166 struct cudbg_buffer dbg_buff = { 0 }; 167 u32 size, min_size, total_size = 0; 168 struct cudbg_init cudbg_init; 169 struct cudbg_hdr *cudbg_hdr; 170 int rc; 171 172 size = *buf_size; 173 174 memset(&cudbg_init, 0, sizeof(struct cudbg_init)); 175 cudbg_init.adap = adap; 176 cudbg_init.outbuf = buf; 177 cudbg_init.outbuf_size = size; 178 179 dbg_buff.data = buf; 180 dbg_buff.size = size; 181 dbg_buff.offset = 0; 182 183 cudbg_hdr = (struct cudbg_hdr *)buf; 184 cudbg_hdr->signature = CUDBG_SIGNATURE; 185 cudbg_hdr->hdr_len = sizeof(struct cudbg_hdr); 186 cudbg_hdr->major_ver = CUDBG_MAJOR_VERSION; 187 cudbg_hdr->minor_ver = CUDBG_MINOR_VERSION; 188 cudbg_hdr->max_entities = CUDBG_MAX_ENTITY; 189 cudbg_hdr->chip_ver = adap->params.chip; 190 cudbg_hdr->dump_type = CUDBG_DUMP_TYPE_MINI; 191 192 min_size = sizeof(struct cudbg_hdr) + 193 sizeof(struct cudbg_entity_hdr) * 194 cudbg_hdr->max_entities; 195 if (size < min_size) 196 return -ENOMEM; 197 198 rc = cudbg_get_workspace_size(); 199 if (rc) { 200 /* Zlib available. So, use zlib deflate */ 201 cudbg_init.compress_type = CUDBG_COMPRESSION_ZLIB; 202 rc = cudbg_alloc_compress_buff(&cudbg_init); 203 if (rc) { 204 /* Ignore error and continue without compression. */ 205 dev_warn(adap->pdev_dev, 206 "Fail allocating compression buffer ret: %d. Continuing without compression.\n", 207 rc); 208 cudbg_init.compress_type = CUDBG_COMPRESSION_NONE; 209 rc = 0; 210 } 211 } else { 212 cudbg_init.compress_type = CUDBG_COMPRESSION_NONE; 213 } 214 215 cudbg_hdr->compress_type = cudbg_init.compress_type; 216 dbg_buff.offset += min_size; 217 total_size = dbg_buff.offset; 218 219 if (flag & CXGB4_ETH_DUMP_HW) 220 cxgb4_cudbg_collect_entity(&cudbg_init, &dbg_buff, 221 cxgb4_collect_hw_dump, 222 ARRAY_SIZE(cxgb4_collect_hw_dump), 223 buf, 224 &total_size); 225 226 if (flag & CXGB4_ETH_DUMP_MEM) 227 cxgb4_cudbg_collect_entity(&cudbg_init, &dbg_buff, 228 cxgb4_collect_mem_dump, 229 ARRAY_SIZE(cxgb4_collect_mem_dump), 230 buf, 231 &total_size); 232 233 if (flag & CXGB4_ETH_DUMP_FLASH) 234 cxgb4_cudbg_collect_entity(&cudbg_init, &dbg_buff, 235 cxgb4_collect_flash_dump, 236 ARRAY_SIZE(cxgb4_collect_flash_dump), 237 buf, 238 &total_size); 239 240 cudbg_free_compress_buff(&cudbg_init); 241 cudbg_hdr->data_len = total_size; 242 if (cudbg_init.compress_type != CUDBG_COMPRESSION_NONE) 243 *buf_size = size; 244 else 245 *buf_size = total_size; 246 return 0; 247 } 248 249 void cxgb4_init_ethtool_dump(struct adapter *adapter) 250 { 251 adapter->eth_dump.flag = CXGB4_ETH_DUMP_NONE; 252 adapter->eth_dump.version = adapter->params.fw_vers; 253 adapter->eth_dump.len = 0; 254 } 255 256 static int cxgb4_cudbg_vmcoredd_collect(struct vmcoredd_data *data, void *buf) 257 { 258 struct adapter *adap = container_of(data, struct adapter, vmcoredd); 259 u32 len = data->size; 260 261 return cxgb4_cudbg_collect(adap, buf, &len, CXGB4_ETH_DUMP_ALL); 262 } 263 264 int cxgb4_cudbg_vmcore_add_dump(struct adapter *adap) 265 { 266 struct vmcoredd_data *data = &adap->vmcoredd; 267 u32 len; 268 269 len = sizeof(struct cudbg_hdr) + 270 sizeof(struct cudbg_entity_hdr) * CUDBG_MAX_ENTITY; 271 len += CUDBG_DUMP_BUFF_SIZE; 272 273 data->size = len; 274 snprintf(data->dump_name, sizeof(data->dump_name), "%s_%s", 275 cxgb4_driver_name, adap->name); 276 data->vmcoredd_callback = cxgb4_cudbg_vmcoredd_collect; 277 278 return vmcore_add_device_dump(data); 279 } 280