xref: /illumos-gate/usr/src/uts/common/io/cxgbe/t4nex/cudbg.h (revision 41378e79)

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source. A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*-
 * Copyright (c) 2019 Chelsio Communications, Inc.
 * All rights reserved.
 * * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * Chelsio Unified Debug Interface header file.
 * Version 1.1
 */
#ifndef _CUDBG_IF_H_
#define _CUDBG_IF_H_

#ifndef _KERNEL
#include <stdlib.h>
#endif

#include "cudbg_lib_common.h"

#ifdef __GNUC__
#define ATTRIBUTE_UNUSED __attribute__ ((unused))
#else
#define ATTRIBUTE_UNUSED
#endif

#if defined(CONFIG_CUDBG_DEBUG)
#define cudbg_debug(pdbg_init, format,  ...) do {\
	pdbg_init->print(format, ##__VA_ARGS__); \
} while (0)
#else
#define cudbg_debug(pdbg_init, format,  ...) do { } while (0)
#endif

#define OUT
#define IN
#define INOUT

/* Error codes */

#define CUDBG_STATUS_SUCCESS		     0
#define CUDBG_STATUS_NOSPACE		    -2
#define CUDBG_STATUS_FLASH_WRITE_FAIL	    -3
#define CUDBG_STATUS_FLASH_READ_FAIL	    -4
#define CUDBG_STATUS_UNDEFINED_OUT_BUF	    -5
#define CUDBG_STATUS_UNDEFINED_CBFN	    -6
#define CUDBG_STATUS_UNDEFINED_PRINTF_CBFN  -7
#define CUDBG_STATUS_ADAP_INVALID	    -8
#define CUDBG_STATUS_FLASH_EMPTY	    -9
#define CUDBG_STATUS_NO_ADAPTER		    -10
#define CUDBG_STATUS_NO_SIGNATURE	    -11
#define CUDBG_STATUS_MULTIPLE_REG	    -12
#define CUDBG_STATUS_UNREGISTERED	    -13
#define CUDBG_STATUS_UNDEFINED_ENTITY	    -14
#define CUDBG_STATUS_REG_FAIlED		    -15
#define CUDBG_STATUS_DEVLOG_FAILED	    -16
#define CUDBG_STATUS_SMALL_BUFF		    -17
#define CUDBG_STATUS_CHKSUM_MISSMATCH	    -18
#define CUDBG_STATUS_NO_SCRATCH_MEM	    -19
#define CUDBG_STATUS_OUTBUFF_OVERFLOW	    -20
#define CUDBG_STATUS_INVALID_BUFF	    -21  /* Invalid magic */
#define CUDBG_STATUS_FILE_OPEN_FAIL	    -22
#define CUDBG_STATUS_DEVLOG_INT_FAIL	    -23
#define CUDBG_STATUS_ENTITY_NOT_FOUND	    -24
#define CUDBG_STATUS_DECOMPRESS_FAIL	    -25
#define CUDBG_STATUS_BUFFER_SHORT	    -26
#define CUDBG_METADATA_VERSION_MISMATCH     -27
#define CUDBG_STATUS_NOT_IMPLEMENTED	    -28
#define CUDBG_SYSTEM_ERROR		    -29
#define CUDBG_STATUS_MMAP_FAILED	    -30
#define CUDBG_STATUS_FILE_WRITE_FAILED	    -31
#define CUDBG_STATUS_CCLK_NOT_DEFINED	    -32
#define CUDBG_STATUS_FLASH_FULL            -33
#define CUDBG_STATUS_SECTOR_EMPTY          -34
#define CUDBG_STATUS_ENTITY_NOT_REQUESTED  -35
#define CUDBG_STATUS_NOT_SUPPORTED         -36
#define CUDBG_STATUS_FILE_READ_FAILED      -37
#define CUDBG_STATUS_CORRUPTED             -38
#define CUDBG_STATUS_INVALID_INDEX         -39

#define CUDBG_MAJOR_VERSION		    1
#define CUDBG_MINOR_VERSION		    14
#define CUDBG_BUILD_VERSION		    0

#define CUDBG_FILE_NAME_LEN 256
#define CUDBG_DIR_NAME_LEN  256
#define CUDBG_MAX_BITMAP_LEN 16

static char ATTRIBUTE_UNUSED * err_msg[] = {
	"Success",
	"Unknown",
	"No space",
	"Flash write fail",
	"Flash read fail",
	"Undefined out buf",
	"Callback function undefined",
	"Print callback function undefined",
	"ADAP invalid",
	"Flash empty",
	"No adapter",
	"No signature",
	"Multiple registration",
	"Unregistered",
	"Undefined entity",
	"Reg failed",
	"Devlog failed",
	"Small buff",
	"Checksum mismatch",
	"No scratch memory",
	"Outbuff overflow",
	"Invalid buffer",
	"File open fail",
	"Devlog int fail",
	"Entity not found",
	"Decompress fail",
	"Buffer short",
	"Version mismatch",
	"Not implemented",
	"System error",
	"Mmap failed",
	"File write failed",
	"cclk not defined",
	"Flash full",
	"Sector empty",
	"Entity not requested",
	"Not supported",
	"File read fail",
	"Corrupted",
	"Invalid Index"
};

enum CUDBG_DBG_ENTITY_TYPE {
	CUDBG_ALL	   = 0,
	CUDBG_REG_DUMP	   = 1,
	CUDBG_DEV_LOG	   = 2,
	CUDBG_CIM_LA	   = 3,
	CUDBG_CIM_MA_LA    = 4,
	CUDBG_CIM_QCFG	   = 5,
	CUDBG_CIM_IBQ_TP0  = 6,
	CUDBG_CIM_IBQ_TP1  = 7,
	CUDBG_CIM_IBQ_ULP  = 8,
	CUDBG_CIM_IBQ_SGE0 = 9,
	CUDBG_CIM_IBQ_SGE1 = 10,
	CUDBG_CIM_IBQ_NCSI = 11,
	CUDBG_CIM_OBQ_ULP0 = 12,
	CUDBG_CIM_OBQ_ULP1 = 13,
	CUDBG_CIM_OBQ_ULP2 = 14,
	CUDBG_CIM_OBQ_ULP3 = 15,
	CUDBG_CIM_OBQ_SGE  = 16,
	CUDBG_CIM_OBQ_NCSI = 17,
	CUDBG_EDC0	   = 18,
	CUDBG_EDC1	   = 19,
	CUDBG_MC0	   = 20,
	CUDBG_MC1	   = 21,
	CUDBG_RSS	   = 22,
	CUDBG_RSS_PF_CONF  = 23,
	CUDBG_RSS_KEY	   = 24,
	CUDBG_RSS_VF_CONF  = 25,
	CUDBG_RSS_CONF	   = 26,
	CUDBG_PATH_MTU	   = 27,
	CUDBG_SW_STATE	   = 28,
	CUDBG_WTP	   = 29,
	CUDBG_PM_STATS	   = 30,
	CUDBG_HW_SCHED	   = 31,
	CUDBG_TCP_STATS    = 32,
	CUDBG_TP_ERR_STATS = 33,
	CUDBG_FCOE_STATS   = 34,
	CUDBG_RDMA_STATS   = 35,
	CUDBG_TP_INDIRECT  = 36,
	CUDBG_SGE_INDIRECT = 37,
	CUDBG_CPL_STATS    = 38,
	CUDBG_DDP_STATS    = 39,
	CUDBG_WC_STATS	   = 40,
	CUDBG_ULPRX_LA	   = 41,
	CUDBG_LB_STATS	   = 42,
	CUDBG_TP_LA	   = 43,
	CUDBG_MEMINFO	   = 44,
	CUDBG_CIM_PIF_LA   = 45,
	CUDBG_CLK	   = 46,
	CUDBG_CIM_OBQ_RXQ0 = 47,
	CUDBG_CIM_OBQ_RXQ1 = 48,
	CUDBG_MAC_STATS    = 49,
	CUDBG_PCIE_INDIRECT = 50,
	CUDBG_PM_INDIRECT  = 51,
	CUDBG_FULL	   = 52,
	CUDBG_TX_RATE	   = 53,
	CUDBG_TID_INFO	   = 54,
	CUDBG_PCIE_CONFIG  = 55,
	CUDBG_DUMP_CONTEXT = 56,
	CUDBG_MPS_TCAM	   = 57,
	CUDBG_VPD_DATA	   = 58,
	CUDBG_LE_TCAM	   = 59,
	CUDBG_CCTRL	   = 60,
	CUDBG_MA_INDIRECT  = 61,
	CUDBG_ULPTX_LA	   = 62,
	CUDBG_EXT_ENTITY   = 63,
	CUDBG_UP_CIM_INDIRECT = 64,
	CUDBG_PBT_TABLE    = 65,
	CUDBG_MBOX_LOG     = 66,
	CUDBG_HMA_INDIRECT = 67,
	CUDBG_MAX_ENTITY   = 68,
};

#define ENTITY_FLAG_NULL 0
#define ENTITY_FLAG_REGISTER 1
#define ENTITY_FLAG_BINARY 2
#define ENTITY_FLAG_FW_NO_ATTACH    3

/* file_name matches Linux cxgb4 debugfs entry names. */
struct el {char *name; char *file_name; int bit; u32 flag; };
static struct el ATTRIBUTE_UNUSED entity_list[] = {
	{"all", "all", CUDBG_ALL, ENTITY_FLAG_NULL},
	{"regdump", "regdump", CUDBG_REG_DUMP, 1 << ENTITY_FLAG_REGISTER},
	{"devlog", "devlog", CUDBG_DEV_LOG, ENTITY_FLAG_NULL},
	{"cimla", "cim_la", CUDBG_CIM_LA, ENTITY_FLAG_NULL},
	{"cimmala", "cim_ma_la", CUDBG_CIM_MA_LA, ENTITY_FLAG_NULL},
	{"cimqcfg", "cim_qcfg", CUDBG_CIM_QCFG, ENTITY_FLAG_NULL},
	{"ibqtp0", "ibq_tp0", CUDBG_CIM_IBQ_TP0, ENTITY_FLAG_NULL},
	{"ibqtp1", "ibq_tp1", CUDBG_CIM_IBQ_TP1, ENTITY_FLAG_NULL},
	{"ibqulp", "ibq_ulp", CUDBG_CIM_IBQ_ULP, ENTITY_FLAG_NULL},
	{"ibqsge0", "ibq_sge0", CUDBG_CIM_IBQ_SGE0, ENTITY_FLAG_NULL},
	{"ibqsge1", "ibq_sge1", CUDBG_CIM_IBQ_SGE1, ENTITY_FLAG_NULL},
	{"ibqncsi", "ibq_ncsi", CUDBG_CIM_IBQ_NCSI, ENTITY_FLAG_NULL},
	{"obqulp0", "obq_ulp0", CUDBG_CIM_OBQ_ULP0, ENTITY_FLAG_NULL},
	{"obqulp1", "obq_ulp1", CUDBG_CIM_OBQ_ULP1, ENTITY_FLAG_NULL},
	{"obqulp2", "obq_ulp2", CUDBG_CIM_OBQ_ULP2, ENTITY_FLAG_NULL},
	{"obqulp3", "obq_ulp3", CUDBG_CIM_OBQ_ULP3, ENTITY_FLAG_NULL},
	{"obqsge", "obq_sge", CUDBG_CIM_OBQ_SGE, ENTITY_FLAG_NULL},
	{"obqncsi", "obq_ncsi", CUDBG_CIM_OBQ_NCSI, ENTITY_FLAG_NULL},
	{"edc0", "edc0", CUDBG_EDC0, (1 << ENTITY_FLAG_BINARY)},
	{"edc1", "edc1", CUDBG_EDC1, (1 << ENTITY_FLAG_BINARY)},
	{"mc0", "mc0", CUDBG_MC0, (1 << ENTITY_FLAG_BINARY)},
	{"mc1", "mc1", CUDBG_MC1, (1 << ENTITY_FLAG_BINARY)},
	{"rss", "rss", CUDBG_RSS, ENTITY_FLAG_NULL},
	{"rss_pf_config", "rss_pf_config", CUDBG_RSS_PF_CONF, ENTITY_FLAG_NULL},
	{"rss_key", "rss_key", CUDBG_RSS_KEY, ENTITY_FLAG_NULL},
	{"rss_vf_config", "rss_vf_config", CUDBG_RSS_VF_CONF, ENTITY_FLAG_NULL},
	{"rss_config", "rss_config", CUDBG_RSS_CONF, ENTITY_FLAG_NULL},
	{"pathmtu", "path_mtus", CUDBG_PATH_MTU, ENTITY_FLAG_NULL},
	{"swstate", "sw_state", CUDBG_SW_STATE, ENTITY_FLAG_NULL},
	{"wtp", "wtp", CUDBG_WTP, ENTITY_FLAG_NULL},
	{"pmstats", "pm_stats", CUDBG_PM_STATS, ENTITY_FLAG_NULL},
	{"hwsched", "hw_sched", CUDBG_HW_SCHED, ENTITY_FLAG_NULL},
	{"tcpstats", "tcp_stats", CUDBG_TCP_STATS, ENTITY_FLAG_NULL},
	{"tperrstats", "tp_err_stats", CUDBG_TP_ERR_STATS, ENTITY_FLAG_NULL},
	{"fcoestats", "fcoe_stats", CUDBG_FCOE_STATS, ENTITY_FLAG_NULL},
	{"rdmastats", "rdma_stats", CUDBG_RDMA_STATS, ENTITY_FLAG_NULL},
	{"tpindirect", "tp_indirect", CUDBG_TP_INDIRECT,
					1 << ENTITY_FLAG_REGISTER},
	{"sgeindirect", "sge_indirect", CUDBG_SGE_INDIRECT,
					1 << ENTITY_FLAG_REGISTER},
	{"cplstats", "cpl_stats", CUDBG_CPL_STATS, ENTITY_FLAG_NULL},
	{"ddpstats", "ddp_stats", CUDBG_DDP_STATS, ENTITY_FLAG_NULL},
	{"wcstats", "wc_stats", CUDBG_WC_STATS, ENTITY_FLAG_NULL},
	{"ulprxla", "ulprx_la", CUDBG_ULPRX_LA, ENTITY_FLAG_NULL},
	{"lbstats", "lb_stats", CUDBG_LB_STATS, ENTITY_FLAG_NULL},
	{"tpla", "tp_la", CUDBG_TP_LA, ENTITY_FLAG_NULL},
	{"meminfo", "meminfo", CUDBG_MEMINFO, ENTITY_FLAG_NULL},
	{"cimpifla", "cim_pif_la", CUDBG_CIM_PIF_LA, ENTITY_FLAG_NULL},
	{"clk", "clk", CUDBG_CLK, ENTITY_FLAG_NULL},
	{"obq_sge_rx_q0", "obq_sge_rx_q0", CUDBG_CIM_OBQ_RXQ0,
					ENTITY_FLAG_NULL},
	{"obq_sge_rx_q1", "obq_sge_rx_q1", CUDBG_CIM_OBQ_RXQ1,
					ENTITY_FLAG_NULL},
	{"macstats", "mac_stats", CUDBG_MAC_STATS, ENTITY_FLAG_NULL},
	{"pcieindirect", "pcie_indirect", CUDBG_PCIE_INDIRECT,
					1 << ENTITY_FLAG_REGISTER},
	{"pmindirect", "pm_indirect", CUDBG_PM_INDIRECT,
				1 << ENTITY_FLAG_REGISTER},
	{"full", "full", CUDBG_FULL, ENTITY_FLAG_NULL},
	{"txrate", "tx_rate", CUDBG_TX_RATE, ENTITY_FLAG_NULL},
	{"tidinfo", "tids", CUDBG_TID_INFO, ENTITY_FLAG_NULL |
				(1 << ENTITY_FLAG_FW_NO_ATTACH)},
	{"pcieconfig", "pcie_config", CUDBG_PCIE_CONFIG, ENTITY_FLAG_NULL},
	{"dumpcontext", "dump_context", CUDBG_DUMP_CONTEXT, ENTITY_FLAG_NULL},
	{"mpstcam", "mps_tcam", CUDBG_MPS_TCAM, ENTITY_FLAG_NULL},
	{"vpddata", "vpd_data", CUDBG_VPD_DATA, ENTITY_FLAG_NULL},
	{"letcam", "le_tcam", CUDBG_LE_TCAM, ENTITY_FLAG_NULL},
	{"cctrl", "cctrl", CUDBG_CCTRL, ENTITY_FLAG_NULL},
	{"maindirect", "ma_indirect", CUDBG_MA_INDIRECT,
				1 << ENTITY_FLAG_REGISTER},
	{"ulptxla", "ulptx_la", CUDBG_ULPTX_LA, ENTITY_FLAG_NULL},
	{"extentity", "ext_entity", CUDBG_EXT_ENTITY, ENTITY_FLAG_NULL},
	{"upcimindirect", "up_cim_indirect", CUDBG_UP_CIM_INDIRECT,
					1 << ENTITY_FLAG_REGISTER},
	{"pbttables", "pbt_tables", CUDBG_PBT_TABLE, ENTITY_FLAG_NULL},
	{"mboxlog", "mboxlog", CUDBG_MBOX_LOG, ENTITY_FLAG_NULL},
	{"hmaindirect", "hma_indirect", CUDBG_HMA_INDIRECT,
				1 << ENTITY_FLAG_REGISTER},
};

#ifdef _KERNEL
typedef int (*cudbg_print_cb) (dev_info_t *dip, int, char *, ...);
#else
typedef int (*cudbg_print_cb) (char *, ...);
#endif

struct cudbg_init_hdr {
	u8   major_ver;
	u8   minor_ver;
	u8   build_ver;
	u8   res;
	u16  init_struct_size;
};

struct cudbg_flash_hdr {
	u32 signature;
	u8 major_ver;
	u8 minor_ver;
	u8 build_ver;
	u8 res;
	u64 timestamp;
	u64 time_res;
	u32 hdr_len;
	u32 data_len;
	u32 hdr_flags;
	u32 sec_seq_no;
	u32 reserved[22];
};

struct cudbg_param {
	u16			 param_type;
	u16			 reserved;
	union {
		struct {
			u32 memtype;	/* which memory (EDC0, EDC1, MC) */
			u32 start;	/* start of log in firmware memory */
			u32 size;	/* size of log */
		} devlog_param;
		struct {
			struct mbox_cmd_log *log;
			u16 mbox_cmds;
		} mboxlog_param;
		struct {
			u8 caller_string[100];
			u8 os_type;
		} sw_state_param;
		u64 time;
		u8 tcb_bit_param;
		void *adap;
		void *access_lock;
	} u;
};

/* params for tcb_bit_param */
#define CUDBG_TCB_BRIEF_PARAM      0x1
#define CUDBG_TCB_FROM_CARD_PARAM  0x2
#define CUDBG_TCB_AS_SCB_PARAM     0x4

enum {
        /* params for os_type */
        CUDBG_OS_TYPE_WINDOWS = 1,
        CUDBG_OS_TYPE_LINUX = 2,
        CUDBG_OS_TYPE_ESX = 3,
        CUDBG_OS_TYPE_UNKNOWN = 4,
};

/*
 * * What is OFFLINE_VIEW_ONLY mode?
 *
 * cudbg frame work will be used only to interpret previously collected
 * data store in a file (i.e NOT hw flash)
 */

struct cudbg_init {
	struct cudbg_init_hdr	 header;
	struct adapter		 *adap;		 /* Pointer to adapter structure
						    with filled fields */
	cudbg_print_cb		 print;		 /* Platform dependent print
						    function */
	u32			 verbose:1;	 /* Turn on verbose print */
	u32			 use_flash:1;	 /* Use flash to collect or view
						    debug */
	u32			 full_mode:1;	 /* If set, cudbg will pull in
						    common code */
	u32			 no_compress:1;  /* Dont compress will storing
						    the collected debug */
	u32			 info:1;	 /* Show just the info, Dont
						    interpret */
	u32			 reserved:27;
	u8			 dbg_bitmap[CUDBG_MAX_BITMAP_LEN];
						/* Bit map to select the dbg
						    data type to be collected
						    or viewed */
};

struct cudbg_private {
	struct cudbg_init  dbg_init;
#ifdef _KERNEL
	struct cudbg_flash_sec_info  sec_info;
#endif
};

/********************************* Helper functions *************************/
void set_dbg_bitmap(u8 *bitmap, enum CUDBG_DBG_ENTITY_TYPE type);
void reset_dbg_bitmap(u8 *bitmap, enum CUDBG_DBG_ENTITY_TYPE type);
struct cudbg_init * cudbg_get_init(void *handle);

/**
 *  cudbg_collect - Collect and store debug information.
 *  ## Parameters ##
 *  @handle : A pointer returned by cudbg_alloc_handle.
 *  @outbuf : pointer to output buffer, to store the collected information
 *	      or to use it as a scratch buffer in case HW flash is used to
 *	      store the debug information.
 *  @outbuf_size : Size of output buffer.
 *  ##	Return ##
 *  If the function succeeds, the return value will be size of debug information
 *  collected and stored.
 *  -ve value represent error.
 */
int cudbg_collect(void *handle, void *outbuf, u32 *outbuf_size);

int cudbg_view(void *handle, void *pinbuf, u32 inbuf_size,
               void *poutbuf, s64 *poutbuf_size);
void init_cudbg_hdr(struct cudbg_init_hdr *hdr);
void * cudbg_alloc_handle(void);
void cudbg_free_handle(void *handle);
#endif /* _CUDBG_IF_H_ */