1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /*- 13 * Copyright (c) 2019 Chelsio Communications, Inc. 14 * All rights reserved. 15 * * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions * are met: 17 * 1. Redistributions of source code must retain the above copyright 18 * notice, this list of conditions and the following disclaimer. 19 * 2. Redistributions in binary form must reproduce the above copyright 20 * notice, this list of conditions and the following disclaimer in the 21 * documentation and/or other materials provided with the distribution. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 26 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 /* 37 * Chelsio Unified Debug Interface header file. 38 * Version 1.1 39 */ 40 #ifndef _CUDBG_IF_H_ 41 #define _CUDBG_IF_H_ 42 43 #ifndef _KERNEL 44 #include <stdlib.h> 45 #endif 46 47 #include "cudbg_lib_common.h" 48 49 #ifdef __GNUC__ 50 #define ATTRIBUTE_UNUSED __attribute__ ((unused)) 51 #else 52 #define ATTRIBUTE_UNUSED 53 #endif 54 55 #if defined(CONFIG_CUDBG_DEBUG) 56 #define cudbg_debug(pdbg_init, format, ...) do {\ 57 pdbg_init->print(format, ##__VA_ARGS__); \ 58 } while (0) 59 #else 60 #define cudbg_debug(pdbg_init, format, ...) do { } while (0) 61 #endif 62 63 #define OUT 64 #define IN 65 #define INOUT 66 67 /* Error codes */ 68 69 #define CUDBG_STATUS_SUCCESS 0 70 #define CUDBG_STATUS_NOSPACE -2 71 #define CUDBG_STATUS_FLASH_WRITE_FAIL -3 72 #define CUDBG_STATUS_FLASH_READ_FAIL -4 73 #define CUDBG_STATUS_UNDEFINED_OUT_BUF -5 74 #define CUDBG_STATUS_UNDEFINED_CBFN -6 75 #define CUDBG_STATUS_UNDEFINED_PRINTF_CBFN -7 76 #define CUDBG_STATUS_ADAP_INVALID -8 77 #define CUDBG_STATUS_FLASH_EMPTY -9 78 #define CUDBG_STATUS_NO_ADAPTER -10 79 #define CUDBG_STATUS_NO_SIGNATURE -11 80 #define CUDBG_STATUS_MULTIPLE_REG -12 81 #define CUDBG_STATUS_UNREGISTERED -13 82 #define CUDBG_STATUS_UNDEFINED_ENTITY -14 83 #define CUDBG_STATUS_REG_FAIlED -15 84 #define CUDBG_STATUS_DEVLOG_FAILED -16 85 #define CUDBG_STATUS_SMALL_BUFF -17 86 #define CUDBG_STATUS_CHKSUM_MISSMATCH -18 87 #define CUDBG_STATUS_NO_SCRATCH_MEM -19 88 #define CUDBG_STATUS_OUTBUFF_OVERFLOW -20 89 #define CUDBG_STATUS_INVALID_BUFF -21 /* Invalid magic */ 90 #define CUDBG_STATUS_FILE_OPEN_FAIL -22 91 #define CUDBG_STATUS_DEVLOG_INT_FAIL -23 92 #define CUDBG_STATUS_ENTITY_NOT_FOUND -24 93 #define CUDBG_STATUS_DECOMPRESS_FAIL -25 94 #define CUDBG_STATUS_BUFFER_SHORT -26 95 #define CUDBG_METADATA_VERSION_MISMATCH -27 96 #define CUDBG_STATUS_NOT_IMPLEMENTED -28 97 #define CUDBG_SYSTEM_ERROR -29 98 #define CUDBG_STATUS_MMAP_FAILED -30 99 #define CUDBG_STATUS_FILE_WRITE_FAILED -31 100 #define CUDBG_STATUS_CCLK_NOT_DEFINED -32 101 #define CUDBG_STATUS_FLASH_FULL -33 102 #define CUDBG_STATUS_SECTOR_EMPTY -34 103 #define CUDBG_STATUS_ENTITY_NOT_REQUESTED -35 104 #define CUDBG_STATUS_NOT_SUPPORTED -36 105 #define CUDBG_STATUS_FILE_READ_FAILED -37 106 #define CUDBG_STATUS_CORRUPTED -38 107 #define CUDBG_STATUS_INVALID_INDEX -39 108 109 #define CUDBG_MAJOR_VERSION 1 110 #define CUDBG_MINOR_VERSION 14 111 #define CUDBG_BUILD_VERSION 0 112 113 #define CUDBG_FILE_NAME_LEN 256 114 #define CUDBG_DIR_NAME_LEN 256 115 #define CUDBG_MAX_BITMAP_LEN 16 116 117 static char ATTRIBUTE_UNUSED * err_msg[] = { 118 "Success", 119 "Unknown", 120 "No space", 121 "Flash write fail", 122 "Flash read fail", 123 "Undefined out buf", 124 "Callback function undefined", 125 "Print callback function undefined", 126 "ADAP invalid", 127 "Flash empty", 128 "No adapter", 129 "No signature", 130 "Multiple registration", 131 "Unregistered", 132 "Undefined entity", 133 "Reg failed", 134 "Devlog failed", 135 "Small buff", 136 "Checksum mismatch", 137 "No scratch memory", 138 "Outbuff overflow", 139 "Invalid buffer", 140 "File open fail", 141 "Devlog int fail", 142 "Entity not found", 143 "Decompress fail", 144 "Buffer short", 145 "Version mismatch", 146 "Not implemented", 147 "System error", 148 "Mmap failed", 149 "File write failed", 150 "cclk not defined", 151 "Flash full", 152 "Sector empty", 153 "Entity not requested", 154 "Not supported", 155 "File read fail", 156 "Corrupted", 157 "Invalid Index" 158 }; 159 160 enum CUDBG_DBG_ENTITY_TYPE { 161 CUDBG_ALL = 0, 162 CUDBG_REG_DUMP = 1, 163 CUDBG_DEV_LOG = 2, 164 CUDBG_CIM_LA = 3, 165 CUDBG_CIM_MA_LA = 4, 166 CUDBG_CIM_QCFG = 5, 167 CUDBG_CIM_IBQ_TP0 = 6, 168 CUDBG_CIM_IBQ_TP1 = 7, 169 CUDBG_CIM_IBQ_ULP = 8, 170 CUDBG_CIM_IBQ_SGE0 = 9, 171 CUDBG_CIM_IBQ_SGE1 = 10, 172 CUDBG_CIM_IBQ_NCSI = 11, 173 CUDBG_CIM_OBQ_ULP0 = 12, 174 CUDBG_CIM_OBQ_ULP1 = 13, 175 CUDBG_CIM_OBQ_ULP2 = 14, 176 CUDBG_CIM_OBQ_ULP3 = 15, 177 CUDBG_CIM_OBQ_SGE = 16, 178 CUDBG_CIM_OBQ_NCSI = 17, 179 CUDBG_EDC0 = 18, 180 CUDBG_EDC1 = 19, 181 CUDBG_MC0 = 20, 182 CUDBG_MC1 = 21, 183 CUDBG_RSS = 22, 184 CUDBG_RSS_PF_CONF = 23, 185 CUDBG_RSS_KEY = 24, 186 CUDBG_RSS_VF_CONF = 25, 187 CUDBG_RSS_CONF = 26, 188 CUDBG_PATH_MTU = 27, 189 CUDBG_SW_STATE = 28, 190 CUDBG_WTP = 29, 191 CUDBG_PM_STATS = 30, 192 CUDBG_HW_SCHED = 31, 193 CUDBG_TCP_STATS = 32, 194 CUDBG_TP_ERR_STATS = 33, 195 CUDBG_FCOE_STATS = 34, 196 CUDBG_RDMA_STATS = 35, 197 CUDBG_TP_INDIRECT = 36, 198 CUDBG_SGE_INDIRECT = 37, 199 CUDBG_CPL_STATS = 38, 200 CUDBG_DDP_STATS = 39, 201 CUDBG_WC_STATS = 40, 202 CUDBG_ULPRX_LA = 41, 203 CUDBG_LB_STATS = 42, 204 CUDBG_TP_LA = 43, 205 CUDBG_MEMINFO = 44, 206 CUDBG_CIM_PIF_LA = 45, 207 CUDBG_CLK = 46, 208 CUDBG_CIM_OBQ_RXQ0 = 47, 209 CUDBG_CIM_OBQ_RXQ1 = 48, 210 CUDBG_MAC_STATS = 49, 211 CUDBG_PCIE_INDIRECT = 50, 212 CUDBG_PM_INDIRECT = 51, 213 CUDBG_FULL = 52, 214 CUDBG_TX_RATE = 53, 215 CUDBG_TID_INFO = 54, 216 CUDBG_PCIE_CONFIG = 55, 217 CUDBG_DUMP_CONTEXT = 56, 218 CUDBG_MPS_TCAM = 57, 219 CUDBG_VPD_DATA = 58, 220 CUDBG_LE_TCAM = 59, 221 CUDBG_CCTRL = 60, 222 CUDBG_MA_INDIRECT = 61, 223 CUDBG_ULPTX_LA = 62, 224 CUDBG_EXT_ENTITY = 63, 225 CUDBG_UP_CIM_INDIRECT = 64, 226 CUDBG_PBT_TABLE = 65, 227 CUDBG_MBOX_LOG = 66, 228 CUDBG_HMA_INDIRECT = 67, 229 CUDBG_MAX_ENTITY = 68, 230 }; 231 232 #define ENTITY_FLAG_NULL 0 233 #define ENTITY_FLAG_REGISTER 1 234 #define ENTITY_FLAG_BINARY 2 235 #define ENTITY_FLAG_FW_NO_ATTACH 3 236 237 /* file_name matches Linux cxgb4 debugfs entry names. */ 238 struct el {char *name; char *file_name; int bit; u32 flag; }; 239 static struct el ATTRIBUTE_UNUSED entity_list[] = { 240 {"all", "all", CUDBG_ALL, ENTITY_FLAG_NULL}, 241 {"regdump", "regdump", CUDBG_REG_DUMP, 1 << ENTITY_FLAG_REGISTER}, 242 {"devlog", "devlog", CUDBG_DEV_LOG, ENTITY_FLAG_NULL}, 243 {"cimla", "cim_la", CUDBG_CIM_LA, ENTITY_FLAG_NULL}, 244 {"cimmala", "cim_ma_la", CUDBG_CIM_MA_LA, ENTITY_FLAG_NULL}, 245 {"cimqcfg", "cim_qcfg", CUDBG_CIM_QCFG, ENTITY_FLAG_NULL}, 246 {"ibqtp0", "ibq_tp0", CUDBG_CIM_IBQ_TP0, ENTITY_FLAG_NULL}, 247 {"ibqtp1", "ibq_tp1", CUDBG_CIM_IBQ_TP1, ENTITY_FLAG_NULL}, 248 {"ibqulp", "ibq_ulp", CUDBG_CIM_IBQ_ULP, ENTITY_FLAG_NULL}, 249 {"ibqsge0", "ibq_sge0", CUDBG_CIM_IBQ_SGE0, ENTITY_FLAG_NULL}, 250 {"ibqsge1", "ibq_sge1", CUDBG_CIM_IBQ_SGE1, ENTITY_FLAG_NULL}, 251 {"ibqncsi", "ibq_ncsi", CUDBG_CIM_IBQ_NCSI, ENTITY_FLAG_NULL}, 252 {"obqulp0", "obq_ulp0", CUDBG_CIM_OBQ_ULP0, ENTITY_FLAG_NULL}, 253 {"obqulp1", "obq_ulp1", CUDBG_CIM_OBQ_ULP1, ENTITY_FLAG_NULL}, 254 {"obqulp2", "obq_ulp2", CUDBG_CIM_OBQ_ULP2, ENTITY_FLAG_NULL}, 255 {"obqulp3", "obq_ulp3", CUDBG_CIM_OBQ_ULP3, ENTITY_FLAG_NULL}, 256 {"obqsge", "obq_sge", CUDBG_CIM_OBQ_SGE, ENTITY_FLAG_NULL}, 257 {"obqncsi", "obq_ncsi", CUDBG_CIM_OBQ_NCSI, ENTITY_FLAG_NULL}, 258 {"edc0", "edc0", CUDBG_EDC0, (1 << ENTITY_FLAG_BINARY)}, 259 {"edc1", "edc1", CUDBG_EDC1, (1 << ENTITY_FLAG_BINARY)}, 260 {"mc0", "mc0", CUDBG_MC0, (1 << ENTITY_FLAG_BINARY)}, 261 {"mc1", "mc1", CUDBG_MC1, (1 << ENTITY_FLAG_BINARY)}, 262 {"rss", "rss", CUDBG_RSS, ENTITY_FLAG_NULL}, 263 {"rss_pf_config", "rss_pf_config", CUDBG_RSS_PF_CONF, ENTITY_FLAG_NULL}, 264 {"rss_key", "rss_key", CUDBG_RSS_KEY, ENTITY_FLAG_NULL}, 265 {"rss_vf_config", "rss_vf_config", CUDBG_RSS_VF_CONF, ENTITY_FLAG_NULL}, 266 {"rss_config", "rss_config", CUDBG_RSS_CONF, ENTITY_FLAG_NULL}, 267 {"pathmtu", "path_mtus", CUDBG_PATH_MTU, ENTITY_FLAG_NULL}, 268 {"swstate", "sw_state", CUDBG_SW_STATE, ENTITY_FLAG_NULL}, 269 {"wtp", "wtp", CUDBG_WTP, ENTITY_FLAG_NULL}, 270 {"pmstats", "pm_stats", CUDBG_PM_STATS, ENTITY_FLAG_NULL}, 271 {"hwsched", "hw_sched", CUDBG_HW_SCHED, ENTITY_FLAG_NULL}, 272 {"tcpstats", "tcp_stats", CUDBG_TCP_STATS, ENTITY_FLAG_NULL}, 273 {"tperrstats", "tp_err_stats", CUDBG_TP_ERR_STATS, ENTITY_FLAG_NULL}, 274 {"fcoestats", "fcoe_stats", CUDBG_FCOE_STATS, ENTITY_FLAG_NULL}, 275 {"rdmastats", "rdma_stats", CUDBG_RDMA_STATS, ENTITY_FLAG_NULL}, 276 {"tpindirect", "tp_indirect", CUDBG_TP_INDIRECT, 277 1 << ENTITY_FLAG_REGISTER}, 278 {"sgeindirect", "sge_indirect", CUDBG_SGE_INDIRECT, 279 1 << ENTITY_FLAG_REGISTER}, 280 {"cplstats", "cpl_stats", CUDBG_CPL_STATS, ENTITY_FLAG_NULL}, 281 {"ddpstats", "ddp_stats", CUDBG_DDP_STATS, ENTITY_FLAG_NULL}, 282 {"wcstats", "wc_stats", CUDBG_WC_STATS, ENTITY_FLAG_NULL}, 283 {"ulprxla", "ulprx_la", CUDBG_ULPRX_LA, ENTITY_FLAG_NULL}, 284 {"lbstats", "lb_stats", CUDBG_LB_STATS, ENTITY_FLAG_NULL}, 285 {"tpla", "tp_la", CUDBG_TP_LA, ENTITY_FLAG_NULL}, 286 {"meminfo", "meminfo", CUDBG_MEMINFO, ENTITY_FLAG_NULL}, 287 {"cimpifla", "cim_pif_la", CUDBG_CIM_PIF_LA, ENTITY_FLAG_NULL}, 288 {"clk", "clk", CUDBG_CLK, ENTITY_FLAG_NULL}, 289 {"obq_sge_rx_q0", "obq_sge_rx_q0", CUDBG_CIM_OBQ_RXQ0, 290 ENTITY_FLAG_NULL}, 291 {"obq_sge_rx_q1", "obq_sge_rx_q1", CUDBG_CIM_OBQ_RXQ1, 292 ENTITY_FLAG_NULL}, 293 {"macstats", "mac_stats", CUDBG_MAC_STATS, ENTITY_FLAG_NULL}, 294 {"pcieindirect", "pcie_indirect", CUDBG_PCIE_INDIRECT, 295 1 << ENTITY_FLAG_REGISTER}, 296 {"pmindirect", "pm_indirect", CUDBG_PM_INDIRECT, 297 1 << ENTITY_FLAG_REGISTER}, 298 {"full", "full", CUDBG_FULL, ENTITY_FLAG_NULL}, 299 {"txrate", "tx_rate", CUDBG_TX_RATE, ENTITY_FLAG_NULL}, 300 {"tidinfo", "tids", CUDBG_TID_INFO, ENTITY_FLAG_NULL | 301 (1 << ENTITY_FLAG_FW_NO_ATTACH)}, 302 {"pcieconfig", "pcie_config", CUDBG_PCIE_CONFIG, ENTITY_FLAG_NULL}, 303 {"dumpcontext", "dump_context", CUDBG_DUMP_CONTEXT, ENTITY_FLAG_NULL}, 304 {"mpstcam", "mps_tcam", CUDBG_MPS_TCAM, ENTITY_FLAG_NULL}, 305 {"vpddata", "vpd_data", CUDBG_VPD_DATA, ENTITY_FLAG_NULL}, 306 {"letcam", "le_tcam", CUDBG_LE_TCAM, ENTITY_FLAG_NULL}, 307 {"cctrl", "cctrl", CUDBG_CCTRL, ENTITY_FLAG_NULL}, 308 {"maindirect", "ma_indirect", CUDBG_MA_INDIRECT, 309 1 << ENTITY_FLAG_REGISTER}, 310 {"ulptxla", "ulptx_la", CUDBG_ULPTX_LA, ENTITY_FLAG_NULL}, 311 {"extentity", "ext_entity", CUDBG_EXT_ENTITY, ENTITY_FLAG_NULL}, 312 {"upcimindirect", "up_cim_indirect", CUDBG_UP_CIM_INDIRECT, 313 1 << ENTITY_FLAG_REGISTER}, 314 {"pbttables", "pbt_tables", CUDBG_PBT_TABLE, ENTITY_FLAG_NULL}, 315 {"mboxlog", "mboxlog", CUDBG_MBOX_LOG, ENTITY_FLAG_NULL}, 316 {"hmaindirect", "hma_indirect", CUDBG_HMA_INDIRECT, 317 1 << ENTITY_FLAG_REGISTER}, 318 }; 319 320 #ifdef _KERNEL 321 typedef int (*cudbg_print_cb) (dev_info_t *dip, ...); 322 #else 323 typedef int (*cudbg_print_cb) (char *, ...); 324 #endif 325 326 struct cudbg_init_hdr { 327 u8 major_ver; 328 u8 minor_ver; 329 u8 build_ver; 330 u8 res; 331 u16 init_struct_size; 332 }; 333 334 struct cudbg_flash_hdr { 335 u32 signature; 336 u8 major_ver; 337 u8 minor_ver; 338 u8 build_ver; 339 u8 res; 340 u64 timestamp; 341 u64 time_res; 342 u32 hdr_len; 343 u32 data_len; 344 u32 hdr_flags; 345 u32 sec_seq_no; 346 u32 reserved[22]; 347 }; 348 349 struct cudbg_param { 350 u16 param_type; 351 u16 reserved; 352 union { 353 struct { 354 u32 memtype; /* which memory (EDC0, EDC1, MC) */ 355 u32 start; /* start of log in firmware memory */ 356 u32 size; /* size of log */ 357 } devlog_param; 358 struct { 359 struct mbox_cmd_log *log; 360 u16 mbox_cmds; 361 } mboxlog_param; 362 struct { 363 u8 caller_string[100]; 364 u8 os_type; 365 } sw_state_param; 366 u64 time; 367 u8 tcb_bit_param; 368 void *adap; 369 void *access_lock; 370 } u; 371 }; 372 373 /* params for tcb_bit_param */ 374 #define CUDBG_TCB_BRIEF_PARAM 0x1 375 #define CUDBG_TCB_FROM_CARD_PARAM 0x2 376 #define CUDBG_TCB_AS_SCB_PARAM 0x4 377 378 enum { 379 /* params for os_type */ 380 CUDBG_OS_TYPE_WINDOWS = 1, 381 CUDBG_OS_TYPE_LINUX = 2, 382 CUDBG_OS_TYPE_ESX = 3, 383 CUDBG_OS_TYPE_UNKNOWN = 4, 384 }; 385 386 /* 387 * * What is OFFLINE_VIEW_ONLY mode? 388 * 389 * cudbg frame work will be used only to interpret previously collected 390 * data store in a file (i.e NOT hw flash) 391 */ 392 393 struct cudbg_init { 394 struct cudbg_init_hdr header; 395 struct adapter *adap; /* Pointer to adapter structure 396 with filled fields */ 397 cudbg_print_cb print; /* Platform dependent print 398 function */ 399 u32 verbose:1; /* Turn on verbose print */ 400 u32 use_flash:1; /* Use flash to collect or view 401 debug */ 402 u32 full_mode:1; /* If set, cudbg will pull in 403 common code */ 404 u32 no_compress:1; /* Dont compress will storing 405 the collected debug */ 406 u32 info:1; /* Show just the info, Dont 407 interpret */ 408 u32 reserved:27; 409 u8 dbg_bitmap[CUDBG_MAX_BITMAP_LEN]; 410 /* Bit map to select the dbg 411 data type to be collected 412 or viewed */ 413 }; 414 415 struct cudbg_private { 416 struct cudbg_init dbg_init; 417 #ifdef _KERNEL 418 struct cudbg_flash_sec_info sec_info; 419 #endif 420 }; 421 422 /********************************* Helper functions *************************/ 423 void set_dbg_bitmap(u8 *bitmap, enum CUDBG_DBG_ENTITY_TYPE type); 424 void reset_dbg_bitmap(u8 *bitmap, enum CUDBG_DBG_ENTITY_TYPE type); 425 struct cudbg_init * cudbg_get_init(void *handle); 426 427 /** 428 * cudbg_collect - Collect and store debug information. 429 * ## Parameters ## 430 * @handle : A pointer returned by cudbg_alloc_handle. 431 * @outbuf : pointer to output buffer, to store the collected information 432 * or to use it as a scratch buffer in case HW flash is used to 433 * store the debug information. 434 * @outbuf_size : Size of output buffer. 435 * ## Return ## 436 * If the function succeeds, the return value will be size of debug information 437 * collected and stored. 438 * -ve value represent error. 439 */ 440 int cudbg_collect(void *handle, void *outbuf, u32 *outbuf_size); 441 442 int cudbg_view(void *handle, void *pinbuf, u32 inbuf_size, 443 void *poutbuf, s64 *poutbuf_size); 444 void init_cudbg_hdr(struct cudbg_init_hdr *hdr); 445 void * cudbg_alloc_handle(void); 446 void cudbg_free_handle(void *handle); 447 #endif /* _CUDBG_IF_H_ */ 448