xref: /illumos-gate/usr/src/uts/common/io/qede/579xx/drivers/ecore/ecore_dbg_fw_funcs.h (revision 14b24e2b)

/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, v.1,  (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://opensource.org/licenses/CDDL-1.0.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/

/*
* Copyright 2014-2017 Cavium, Inc.
* The contents of this file are subject to the terms of the Common Development
* and Distribution License, v.1,  (the "License").

* You may not use this file except in compliance with the License.

* You can obtain a copy of the License at available
* at http://opensource.org/licenses/CDDL-1.0

* See the License for the specific language governing permissions and
* limitations under the License.
*/

#ifndef _DBG_FW_FUNCS_H
#define _DBG_FW_FUNCS_H
/**************************** Public Functions *******************************/

/**
 * @brief ecore_dbg_set_bin_ptr - Sets a pointer to the binary data with debug
 * arrays.
 *
 * @param bin_ptr - a pointer to the binary data with debug arrays.
 */
enum dbg_status ecore_dbg_set_bin_ptr(const u8 * const bin_ptr);

/**
 * @brief ecore_dbg_set_app_ver - Sets the version of the calling app.
 *
 * The application should call this function with the TOOLS_VERSION
 * it compiles with. Must be called before all other debug functions.
 *
 * @return error if one of the following holds:
 *	- the specified app version is not supported
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_set_app_ver(u32 ver);

/**
 * @brief ecore_dbg_get_fw_func_ver - Returns the FW func version.
 *
 * @return the FW func version.
 */
u32 ecore_dbg_get_fw_func_ver(void);

/**
* @brief ecore_dbg_get_chip_id - Returns the FW func version.
*
* @param p_hwfn - HW device data
*
* @return the chip ID.
*/
enum chip_ids ecore_dbg_get_chip_id(struct ecore_hwfn *p_hwfn);

/**
 * @brief ecore_dbg_bus_reset - Resets the Debug block.
 *
 * After reset:
 * - The last recording is erased.
 * - Recording is directed to the internal buffer.
 * - Wrap-around recording is selected.
 * - All HW blocks are disabled.
 * - All Storms are disabled and all SEM filters are cleared.
 *
 * @param p_hwfn -		    HW device data
 * @param p_ptt -		    Ptt window used for writing the registers.
 * @param one_shot_en -     Enable/Disable one-shot recording. If disabled,
 *			    wrap-around recording is used instead.
 * @param force_hw_dwords - If set to 0, no. of HW/Storm dwords per cycle is
 *			    chosen automatically based on the enabled inputs.
 *			    Otherwise, no. of HW dwords per cycle is forced to
 *			    the specified value. Valid values: 0/2/4/8.
 * @param unify_inputs -    If true, all recorded data is associated with a
 *			    single input, as if all data was received from the
 *			    same block. Otherwise, each data unit is associated
 *			    with its original input.
 * @param grc_input_en -    Enable/Disable recording GRC input. If enabled, the
 *			    GRC input is recorded to the lsb dword of a cycle.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 *	- force_hw_dwords is invalid.
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_reset(struct ecore_hwfn *p_hwfn,
									struct ecore_ptt *p_ptt,
									bool one_shot_en,
									u8 force_hw_dwords,
									bool unify_inputs,
									bool grc_input_en);

/**
 * @brief ecore_dbg_bus_set_pci_output - Directs debug output to a PCI buffer.
 *
 * @param p_hwfn -		HW device data
 * @param p_ptt -		Ptt window used for writing the registers.
 * @param buf_size_kb - Size of PCI buffer to allocate (in KB). Must be aligned
 *			to PCI request size.
 *
 * @return error if one of the following holds:
 *	- the Debug block wasn't reset since last recording
 *	- the version wasn't set
 *	- the output was already set
 *	- the PCI buffer size is not aligned to PCI packet size
 *	- the PCI buffer allocation failed
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_set_pci_output(struct ecore_hwfn *p_hwfn,
											 struct ecore_ptt *p_ptt,
											 u16 buf_size_kb);

/**
 * @brief ecore_dbg_bus_set_nw_output - Directs debug output to the network.
 *
 * @param p_hwfn -			HW device data
 * @param p_ptt -			Ptt window used for writing the registers.
 * @param port_id -		Port ID to transmit the debug data on
 * @param dest_addr_lo32 -	Destination MAC address (for Eth header)
 * @param dest_addr_hi16
 * @param data_limit_size_kb -  Data limit size in KB (valid only for one-shot)
 *				If set to 0, data limit won't be configured.
 * @param send_to_other_engine -If true:
 *				1) The NW output will be sent to the DBG block
 *				   of the other engine.
 *				2) port_id argument is ignored.
 *				3) rcv_from_other_engine should be set to false
 *				   The other engine DBG block should call this
 *				   function with rcv_from_other_engine set to
 *				   true.
 * @param rcv_from_other_engine-If true:
 *				1) the DBG block receives the NW output sent
 *				   from the other engine DBG block, and sends
 *				   it to a NW port in the current engine
 *				   (according to port_id).
 *				2) The src/dest addresses and eth_type
 *				   arguments are ignored.
 *				3) send_to_other_engine should be set to false.
 *				   The other engine DBG block should call this
 *				   function with send_to_other_engine set to
 *				   true.
 *
 * @return error if one of the following holds:
 *	- the Debug block wasn't reset since last recording
 *	- the version wasn't set
 *	- the output was already set
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_set_nw_output(struct ecore_hwfn *p_hwfn,
											struct ecore_ptt *p_ptt,
											u8 port_id,
											u32 dest_addr_lo32,
											u16 dest_addr_hi16,
											u16 data_limit_size_kb,
											bool send_to_other_engine,
											bool rcv_from_other_engine);

/**
 * @brief ecore_dbg_bus_enable_block - Enables recording of the specified block
 *
 * Each recording cycle contains 4 "units". If the recorded HW data requires up
 * to 4 dwords per cycle, each unit is one dword (32 bits). Otherwise, each
 * unit is 2 dwords (64 bits).
 *
 * @param p_hwfn -		HW device data
 * @param p_ptt -		Ptt window used for writing the registers.
 * @param block -	block to be enabled.
 * @param line_num -	debug line number to select.
 * @param cycle_en -	4-bit value. If bit i is set, unit i is enabled.
 * @param right_shift -	number of units to  right the debug data (0-3).
 * @param force_valid - 4-bit value. If bit i is set, unit i is forced valid.
 * @param force_frame - 4-bit value. If bit i is set, the frame bit of unit i
 *			is forced.
 *
 * @return error if one of the following holds:
 *	- the Debug block wasn't reset since last recording
 *	- the version wasn't set
 *	- block is not valid
 *	- block was already enabled
 *	- cycle_en, force_valid or force_frame are wider than 4 bits
 *	- right_shift is larger than 3
 *	- cycle unit 0 is enabled, but GRC or timestamp were also enabled.
 *	- Too many inputs were enabled.
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_enable_block(struct ecore_hwfn *p_hwfn,
										   struct ecore_ptt *p_ptt,
										   enum block_id block,
										   u8 line_num,
										   u8 cycle_en,
										   u8 right_shift,
										   u8 force_valid,
										   u8 force_frame);

/**
 * @brief ecore_dbg_bus_enable_storm - Enables recording of the specified Storm
 *
 * @param p_hwfn -		HW device data
 * @param storm -	Storm to be enabled.
 * @param storm_mode-	Storm mode
 *
 * @return error if one of the following holds:
 *	- the Debug block wasn't reset since last recording
 *	- the version wasn't set
 *	- the specified storm or mode is invalid
 *	- Storm was already enabled
 *	- only HW data can be recorded
 *	- Too many inputs were enabled.
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_enable_storm(struct ecore_hwfn *p_hwfn,
										   enum dbg_storms storm,
										   enum dbg_bus_storm_modes storm_mode);

/**
 * @brief ecore_dbg_bus_enable_timestamp - Enables timestamp recording.
 *
 * When enabled, the timestamp input is always recorded to the lsb dword of
 * a cycle, with HW ID 0.
 *
 * @param p_hwfn -	     HW device data
 * @param p_ptt -	     Ptt window used for writing the registers.
 * @param valid_en - 3-bit value. The Timestamp will be recorded in a cycle if
 *		     bit i is set and unit i+1 is valid.
 * @param frame_en - 3-bit value. The Timestamp will be recorded in a cycle if
 *		     bit i is set and unit i+1 has frame bit set.
 * @param tick_len - timestamp tick length in cycles, minus 1. A value of 0
 *		     means one cycle.
 *
 * @return error if one of the following holds:
 *	- the Debug block wasn't reset since last recording
 *	- the version wasn't set
 *	- valid_en or frame_en are wider than 4 bits
 *	- Both timestamp and GRC are enabled.
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_enable_timestamp(struct ecore_hwfn *p_hwfn,
											   struct ecore_ptt *p_ptt,
											   u8 valid_en,
											   u8 frame_en,
											   u32 tick_len);

/**
 * @brief ecore_dbg_bus_add_eid_range_sem_filter- Add Event ID range SEM filter
 *
 * @param p_hwfn -     HW device data
 * @param storm -   Storm to be filtered.
 * @param min_eid - minimal Event ID to filter on.
 * @param max_eid - maximal Event ID to filter on.
 *
 * @return error if one of the following holds:
 *	- the specified Storm is invalid
 *	- the specified Storm wasn't enabled
 *	- the EID range is not valid
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_add_eid_range_sem_filter(struct ecore_hwfn *p_hwfn,
													   enum dbg_storms storm,
													   u8 min_eid,
													   u8 max_eid);

/**
 * @brief ecore_dbg_bus_add_eid_mask_sem_filter - Add Event ID mask SEM filter
 *
 * @param p_hwfn -      HW device data
 * @param storm -    Storm to be filtered.
 * @param eid_val -  Event ID value.
 * @param eid_mask - Event ID mask. 0's in the mask = don't care bits.
 *
 * @return error if one of the following holds:
 *	- the specified Storm is invalid
 *	- the specified Storm wasn't enabled
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_add_eid_mask_sem_filter(struct ecore_hwfn *p_hwfn,
													  enum dbg_storms storm,
													  u8 eid_val,
													  u8 eid_mask);

/**
 * @brief ecore_dbg_bus_add_cid_sem_filter - Adds a CID SEM filter.
 *
 * @param p_hwfn -   HW device data
 * @param storm	- Storm to be filtered.
 * @param cid -   CID to filter on.
 *
 * @return error if one of the following holds:
 *	- the specified Storm is invalid
 *	- the specified Storm wasn't enabled
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_add_cid_sem_filter(struct ecore_hwfn *p_hwfn,
												 enum dbg_storms storm,
												 u32 cid);

/**
 * @brief ecore_dbg_bus_enable_filter - Enables the recording filter.
 *
 * A filter contains up to 4 constraints. The data is "filtered in" when the
 * added constraints hold.
 *
 * @param p_hwfn -		  HW device data
 * @param p_ptt -		  Ptt window used for writing the registers.
 * @param block -	  block to filter on.
 * @param const_msg_len	- Constant message length (in cycles) to be used for
 *			  message-based filter constraints. If set to 0,
 *			  message length is based only on frame bit received
 *			  from HW (no constant message length).
 *
 * @return error if one of the following holds:
 *	- the Debug block wasn't reset since last recording
 *	- the version wasn't set
 *	- the filter was already enabled
 *	- block is not valid or not enabled
 *	- more than 4 dwords are recorded per-cycle (forbids filters)
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_enable_filter(struct ecore_hwfn *p_hwfn,
											struct ecore_ptt *p_ptt,
											enum block_id block,
											u8 const_msg_len);

/**
 * @brief ecore_dbg_bus_enable_trigger - Enables the recording trigger.
 *
 * A trigger contains up to 3 states, where each state contains up to
 * 4 constraints. After the constraints of a state hold for a specified number
 * of times, the DBG block moves to the next state. If there's no next state,
 * the DBG block triggers.
 *
 * @param p_hwfn -			HW device data
 * @param p_ptt -			Ptt window used for writing the registers.
 * @param rec_pre_trigger -	if true, recording starts before the trigger.
 *				if false, recording starts at the trigger.
 * @param pre_chunks -		max number of chunks to record before the
 *				trigger (1-47). If set to 0, recording starts
 *				from time 0. Ignored if rec_pre_trigger is
 *				false.
 * @param rec_post_trigger -	if true, recording ends after the trigger.
 *				if false, recording ends at the trigger.
 * @param post_cycles -		max number of cycles to record after the
 *				trigger (0x1-0xffffffff). If set to 0,
 *				recording ends only when stopped by the user.
 *				Ignored if rec_post_trigger is false.
 * @param filter_pre_trigger -	if true, data is filtered before the trigger.
 *				Ignored if the filter wasn't enabled.
 * @param filter_post_trigger -	if true, data is filtered after the trigger.
 *				Ignored if the filter wasn't enabled.
 *
 * @return error if one of the following holds:
 *	- the Debug block wasn't reset since last recording
 *	- the version wasn't set
 *	- the trigger was already enabled
 *	- more than 4 dwords are recorded per-cycle (forbids triggers)
 *	- pre_chunks is not in the range 0-47.
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_enable_trigger(struct ecore_hwfn *p_hwfn,
											 struct ecore_ptt *p_ptt,
											 bool rec_pre_trigger,
											 u8 pre_chunks,
											 bool rec_post_trigger,
											 u32 post_cycles,
											 bool filter_pre_trigger,
											 bool filter_post_trigger);

/**
 * @brief ecore_dbg_bus_add_trigger_state - Adds a trigger state.
 *
 * Up to 3 trigger states can be added, where each state contains up to
 * 4 constraints. After the constraints of a state hold for the specified
 * number of times, the DBG block moves to the next state. If there's no next
 * state, the DBG block triggers.
 *
 * @param p_hwfn -		  HW device data
 * @param p_ptt -		  Ptt window used for writing the registers.
 * @param block	-	  block to trigger on.
 * @param const_msg_len	- Constant message length (in cycles) to be used for
 *			  message-based filter constraints. If set to 0,
 *			  message length is based only on frame bit received
 *			  from HW (no constant message length).
 * @param count_to_next	- The number of times the constraints of the state
 *			  should hold before moving to the next state. Must be
 *			  non-zero.
 *
 * @return error if one of the following holds:
 *	- The trigger wasn't enabled.
 *	- more than 3 trigger states were added
 *	- block is not valid or not enabled
 *	- count_to_next is 0
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_add_trigger_state(struct ecore_hwfn *p_hwfn,
												struct ecore_ptt *p_ptt,
												enum block_id block,
												u8 const_msg_len,
												u16 count_to_next);

/**
 * @brief ecore_dbg_bus_add_constraint - Adds a filter/trigger constraint.
 *
 * The constraint is added to a filter or trigger state, which ever was added
 * last. The filter/trigger happens if both of the following hold:
 * 1. All mandatory constraints are true.
 * 2. At least one optional (non-mandatory) constraints is true.
 *
 * @param p_hwfn -			  HW device data
 * @param p_ptt -			  Ptt window used for writing the registers.
 * @param op -			  constraint operation
 * @param data -		  32-bit data to compare with the recorded
 *				  data.
 * @param data_mask -		  32-bit mask for data comparison. If mask bit
 *				  i is 1, data bit i is compared, otherwise
 *				  it's ignored.
 *				  For eq/ne operations: any mask can be used.
 *				  For other operations: the mask must be
 *				  non-zero, and the 1's in the mask must be
 *				  continuous.
 * @param compare_frame -	  indicates if the frame bit should be
 *				  compared. Must be false for all operations
 *				  other than eq/ne.
 * @param frame_bit -		  frame bit to compare with the recorded data
 *				  (0/1). ignored if compare_frame is false.
 * @param cycle_offset -	  offset in cycles from the beginning of the
 *				  message, where cycle = 4 dwords.
 * @param dword_offset_in_cycle	- offset in dwords from the beginning of the
 *				  cycle (0-3).
 * @param is_mandatory -	  indicates if this constraint is mandatory
 *				  (true) or optional (false). The data is
 *				  filtered-in if all mandatory constraints hold
 *				  AND at least one optional constraint (if
 *				  added) holds.
 *
 * @return error if one of the following holds:
 *	- a filter or trigger state weren't enabled
 *	- all 4 filter constraints were added already
 *	- the op string is invalid
 *	- the data mask is invalid.
 *	- frame bit is not 0/1.
 *	- cycle_offset and dword_offset are not in the range 0-3.
 *	- compare_frame is true and operation is not eq/ne.
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_add_constraint(struct ecore_hwfn *p_hwfn,
											 struct ecore_ptt *p_ptt,
											 enum dbg_bus_constraint_ops constraint_op,
											 u32 data,
											 u32 data_mask,
											 bool compare_frame,
											 u8 frame_bit,
											 u8 cycle_offset,
											 u8 dword_offset_in_cycle,
											 bool is_mandatory);

/**
 * @brief ecore_dbg_bus_start - Starts the recording.
 *
 * @param p_hwfn - HW device data
 * @param p_ptt - Ptt window used for writing the registers.
 *
 * @return error if one of the following holds:
 *	- the Debug block wasn't reset since last recording
 *	- the version wasn't set
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_start(struct ecore_hwfn *p_hwfn,
									struct ecore_ptt *p_ptt);

/**
 * @brief ecore_dbg_bus_stop - Stops the recording and flushes the internal
 * buffer.
 *
 * @param p_hwfn - HW device data
 * @param p_ptt - Ptt window used for writing the registers.
 *
 * @return error if a recording is not in progress, ok otherwise.
 */
enum dbg_status ecore_dbg_bus_stop(struct ecore_hwfn *p_hwfn,
								   struct ecore_ptt *p_ptt);

/**
 * @brief ecore_dbg_bus_get_dump_buf_size - Returns the required buffer size
 * for Debug Bus recording.
 *
 * @param p_hwfn -      HW device data
 * @param p_ptt -	     Ptt window used for writing the registers.
 * @param buf_size - OUT: the required size (in dwords) of the buffer for
 *		     dumping the recorded Debug Bus data. If recording to the
 *		     internal buffer, the size of the internal buffer is
 *		     returned. If recording to PCI, the size of the PCI buffer
 *		     is returned. Otherwise, 0 is returned.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_get_dump_buf_size(struct ecore_hwfn *p_hwfn,
												struct ecore_ptt *p_ptt,
												u32 *buf_size);

/**
 * @brief ecore_dbg_bus_dump - Dumps the recorded Debug Bus data into the
 * specified buffer.
 *
 * The dumped data starts with a header. If recording to NW, only a header is
 * dumped. The dumped size is assigned to num_dumped_dwords.
 *
 * @param p_hwfn -			HW device data
 * @param p_ptt -			Ptt window used for writing the registers.
 * @param dump_buf -		Pointer to copy the recorded data into.
 * @param buf_size_in_dwords -	Size of the specified buffer in dwords.
 * @param num_dumped_dwords -	OUT: number of dumped dwords.
 *
 * @return error if one of the following holds:
 *	- a recording wasn't started/stopped
 *	- the specified dump buffer is too small
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_bus_dump(struct ecore_hwfn *p_hwfn,
								   struct ecore_ptt *p_ptt,
								   u32 *dump_buf,
								   u32 buf_size_in_dwords,
								   u32 *num_dumped_dwords);

/**
 * @brief ecore_dbg_grc_config - Sets the value of a GRC parameter.
 *
 * @param p_hwfn -		HW device data
 * @param grc_param -	GRC parameter
 * @param val -		Value to set.

 * @return error if one of the following holds:
 *	- the version wasn't set
 *	- grc_param is invalid
 *	- val is outside the allowed boundaries
 */
enum dbg_status ecore_dbg_grc_config(struct ecore_hwfn *p_hwfn,
									 enum dbg_grc_params grc_param,
									 u32 val);

/**
* @brief ecore_dbg_grc_set_params_default - Reverts all GRC parameters to their
* default value.
*
* @param p_hwfn - HW device data
*/
void ecore_dbg_grc_set_params_default(struct ecore_hwfn *p_hwfn);

/**
 * @brief ecore_dbg_grc_get_dump_buf_size - Returns the required buffer size
 * for GRC Dump.
 *
 * @param p_hwfn -      HW device data
 * @param p_ptt -	     Ptt window used for writing the registers.
 * @param buf_size - OUT: required buffer size (in dwords) for GRC Dump data.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_grc_get_dump_buf_size(struct ecore_hwfn *p_hwfn,
												struct ecore_ptt *p_ptt,
												u32 *buf_size);

/**
 * @brief ecore_dbg_grc_dump - Dumps GRC data into the specified buffer.
 *
 * @param p_hwfn -			HW device data
 * @param p_ptt -			Ptt window used for writing the registers.
 * @param dump_buf -		Pointer to write the collected GRC data into.
 * @param buf_size_in_dwords -	Size of the specified buffer in dwords.
 * @param num_dumped_dwords -	OUT: number of dumped dwords.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 *	- the specified dump buffer is too small
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_grc_dump(struct ecore_hwfn *p_hwfn,
								   struct ecore_ptt *p_ptt,
								   u32 *dump_buf,
								   u32 buf_size_in_dwords,
								   u32 *num_dumped_dwords);

/**
 * @brief ecore_dbg_idle_chk_get_dump_buf_size - Returns the required buffer
 * size for idle check results.
 *
 * @param p_hwfn -      HW device data
 * @param p_ptt -      Ptt window used for writing the registers.
 * @param buf_size - OUT: required buffer size (in dwords) for idle check data.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_idle_chk_get_dump_buf_size(struct ecore_hwfn *p_hwfn,
													 struct ecore_ptt *p_ptt,
													 u32 *buf_size);

/**
 * @brief ecore_dbg_idle_chk_dump - Performs idle check and writes the results
 * into the specified buffer.
 *
 * @param p_hwfn -			HW device data
 * @param p_ptt -			Ptt window used for writing the registers.
 * @param dump_buf -		Pointer to write the idle check data into.
 * @param buf_size_in_dwords -	Size of the specified buffer in dwords.
 * @param num_dumped_dwords -	OUT: number of dumped dwords.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 *	- the specified buffer is too small
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_idle_chk_dump(struct ecore_hwfn *p_hwfn,
										struct ecore_ptt *p_ptt,
										u32 *dump_buf,
										u32 buf_size_in_dwords,
										u32 *num_dumped_dwords);

/**
 * @brief ecore_dbg_mcp_trace_get_dump_buf_size - Returns the required buffer
 * size for mcp trace results.
 *
 * @param p_hwfn -	     HW device data
 * @param p_ptt -	     Ptt window used for writing the registers.
 * @param buf_size - OUT: required buffer size (in dwords) for mcp trace data.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 *	- the trace data in MCP scratchpad contain an invalid signature
 *	- the bundle ID in NVRAM is invalid
 *	- the trace meta data cannot be found (in NVRAM or image file)
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_mcp_trace_get_dump_buf_size(struct ecore_hwfn *p_hwfn,
													  struct ecore_ptt *p_ptt,
													  u32 *buf_size);

/**
 * @brief ecore_dbg_mcp_trace_dump - Performs mcp trace and writes the results
 * into the specified buffer.
 *
 * @param p_hwfn -			HW device data
 * @param p_ptt -			Ptt window used for writing the registers.
 * @param dump_buf -		Pointer to write the mcp trace data into.
 * @param buf_size_in_dwords -	Size of the specified buffer in dwords.
 * @param num_dumped_dwords -	OUT: number of dumped dwords.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 *	- the specified buffer is too small
 *	- the trace data in MCP scratchpad contain an invalid signature
 *	- the bundle ID in NVRAM is invalid
 *	- the trace meta data cannot be found (in NVRAM or image file)
 *	- the trace meta data cannot be read (from NVRAM or image file)
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_mcp_trace_dump(struct ecore_hwfn *p_hwfn,
										 struct ecore_ptt *p_ptt,
										 u32 *dump_buf,
										 u32 buf_size_in_dwords,
										 u32 *num_dumped_dwords);

/**
 * @brief ecore_dbg_reg_fifo_get_dump_buf_size - Returns the required buffer
 * size for grc trace fifo results.
 *
 * @param p_hwfn -      HW device data
 * @param p_ptt -      Ptt window used for writing the registers.
 * @param buf_size - OUT: required buffer size (in dwords) for reg fifo data.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_reg_fifo_get_dump_buf_size(struct ecore_hwfn *p_hwfn,
													 struct ecore_ptt *p_ptt,
													 u32 *buf_size);

/**
 * @brief ecore_dbg_reg_fifo_dump - Reads the reg fifo and writes the results
 * into the specified buffer.
 *
 * @param p_hwfn -			HW device data
 * @param p_ptt -			Ptt window used for writing the registers.
 * @param dump_buf -		Pointer to write the reg fifo data into.
 * @param buf_size_in_dwords -	Size of the specified buffer in dwords.
 * @param num_dumped_dwords -	OUT: number of dumped dwords.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 *	- the specified buffer is too small
 *	- DMAE transaction failed
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_reg_fifo_dump(struct ecore_hwfn *p_hwfn,
										struct ecore_ptt *p_ptt,
										u32 *dump_buf,
										u32 buf_size_in_dwords,
										u32 *num_dumped_dwords);

/**
* @brief ecore_dbg_igu_fifo_get_dump_buf_size - Returns the required buffer
* size for the IGU fifo results.
*
* @param p_hwfn -      HW device data
* @param p_ptt -      Ptt window used for writing the registers.
* @param buf_size - OUT: required buffer size (in dwords) for IGU fifo data.
*
* @return error if one of the following holds:
*	- the version wasn't set
* Otherwise, returns ok.
*/
enum dbg_status ecore_dbg_igu_fifo_get_dump_buf_size(struct ecore_hwfn *p_hwfn,
													 struct ecore_ptt *p_ptt,
													 u32 *buf_size);

/**
* @brief ecore_dbg_igu_fifo_dump - Reads the IGU fifo and writes the results
* into the specified buffer.
*
* @param p_hwfn -			HW device data
* @param p_ptt -			Ptt window used for writing the registers.
* @param dump_buf -		Pointer to write the IGU fifo data into.
* @param buf_size_in_dwords -	Size of the specified buffer in dwords.
* @param num_dumped_dwords -	OUT: number of dumped dwords.
*
* @return error if one of the following holds:
*	- the version wasn't set
*	- the specified buffer is too small
*	- DMAE transaction failed
* Otherwise, returns ok.
*/
enum dbg_status ecore_dbg_igu_fifo_dump(struct ecore_hwfn *p_hwfn,
										struct ecore_ptt *p_ptt,
										u32 *dump_buf,
										u32 buf_size_in_dwords,
										u32 *num_dumped_dwords);

/**
 * @brief ecore_dbg_protection_override_get_dump_buf_size - Return the required
 * buffer size for protection override window results.
 *
 * @param p_hwfn -      HW device data
 * @param p_ptt -      Ptt window used for writing the registers.
 * @param buf_size - OUT: required buffer size (in dwords) for protection
 *		     override data.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_protection_override_get_dump_buf_size(struct ecore_hwfn *p_hwfn,
																struct ecore_ptt *p_ptt,
																u32 *buf_size);
/**
 * @brief ecore_dbg_protection_override_dump - Reads protection override window
 * entries and writes the results into the specified buffer.
 *
 * @param p_hwfn -			HW device data
 * @param p_ptt -			Ptt window used for writing the registers.
 * @param dump_buf -		Pointer to write the protection override data
 *				into.
 * @param buf_size_in_dwords -	Size of the specified buffer in dwords.
 * @param num_dumped_dwords -	OUT: number of dumped dwords.
 *
 * @return error if one of the following holds:
 *	- the version wasn't set
 *	- the specified buffer is too small
 *	- DMAE transaction failed
 * Otherwise, returns ok.
 */
enum dbg_status ecore_dbg_protection_override_dump(struct ecore_hwfn *p_hwfn,
												   struct ecore_ptt *p_ptt,
												   u32 *dump_buf,
												   u32 buf_size_in_dwords,
												   u32 *num_dumped_dwords);

/**
* @brief ecore_dbg_fw_asserts_get_dump_buf_size - Returns the required buffer
* size for FW Asserts results.
*
* @param p_hwfn -	    HW device data
* @param p_ptt -	    Ptt window used for writing the registers.
* @param buf_size - OUT: required buffer size (in dwords) for FW Asserts data.
*
* @return error if one of the following holds:
*	- the version wasn't set
* Otherwise, returns ok.
*/
enum dbg_status ecore_dbg_fw_asserts_get_dump_buf_size(struct ecore_hwfn *p_hwfn,
													   struct ecore_ptt *p_ptt,
													   u32 *buf_size);

/**
* @brief ecore_dbg_fw_asserts_dump - Reads the FW Asserts and writes the
* results into the specified buffer.
*
* @param p_hwfn -			HW device data
* @param p_ptt -			Ptt window used for writing the registers.
* @param dump_buf -		Pointer to write the FW Asserts data into.
* @param buf_size_in_dwords -	Size of the specified buffer in dwords.
* @param num_dumped_dwords -	OUT: number of dumped dwords.
*
* @return error if one of the following holds:
*	- the version wasn't set
*	- the specified buffer is too small
* Otherwise, returns ok.
*/
enum dbg_status ecore_dbg_fw_asserts_dump(struct ecore_hwfn *p_hwfn,
										  struct ecore_ptt *p_ptt,
										  u32 *dump_buf,
										  u32 buf_size_in_dwords,
										  u32 *num_dumped_dwords);

/**
* @brief ecore_dbg_read_attn - Reads the attention registers of the specified
* block and type, and writes the results into the specified buffer.
*
* @param p_hwfn -		HW device data
* @param p_ptt -		Ptt window used for writing the registers.
* @param block -	Block ID.
* @param attn_type -	Attention type.
* @param clear_status -	Indicates if the attention status should be cleared.
* @param results -	OUT: Pointer to write the read results into
*
* @return error if one of the following holds:
*	- the version wasn't set
* Otherwise, returns ok.
*/
enum dbg_status ecore_dbg_read_attn(struct ecore_hwfn *p_hwfn,
									struct ecore_ptt *p_ptt,
									enum block_id block,
									enum dbg_attn_type attn_type,
									bool clear_status,
									struct dbg_attn_block_result *results);

/**
* @brief ecore_dbg_print_attn - Prints attention registers values in the
* specified results struct.
*
* @param p_hwfn -     HW device data
* @param results - Pointer to the attention read results
*
* @return error if one of the following holds:
*	- the version wasn't set
* Otherwise, returns ok.
*/
enum dbg_status ecore_dbg_print_attn(struct ecore_hwfn *p_hwfn,
									 struct dbg_attn_block_result *results);

/**
* @brief ecore_is_block_in_reset - Returns true if the specified block is in
* reset, false otherwise.
*
* @param p_hwfn   - HW device data
* @param p_ptt   - Ptt window used for writing the registers.
* @param block - Block ID.
*
* @return true if the specified block is in reset, false otherwise.
*/
bool ecore_is_block_in_reset(struct ecore_hwfn *p_hwfn,
							 struct ecore_ptt *p_ptt,
							 enum block_id block);


#endif