path: root/usr/src/uts/common/io/qede/qede_dbg.c

/*
* 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.
*/


#include "qede.h"

/*
 * Compliments of Larry W. and qlc team.
 */
void
qede_stacktrace(qede_t *qede)
{
	int depth, i;
	pc_t pcstack[16];
	char *sym;
	ulong_t	off;

	depth = getpcstack(&pcstack[0], 16);

	cmn_err(CE_CONT, "qede(%d): ---------- \n", qede->instance);
	for (i = 0; i < OSAL_MIN_T(int, depth, 16); i++) {
		sym = kobj_getsymname((uintptr_t)pcstack[i], &off);

		if (sym == NULL) {
			cmn_err(CE_CONT, "qede(%d): sym is NULL\n",
			    qede->instance);
		} else {
			cmn_err(CE_CONT, "%s(%d): %s+%lx\n", __func__,
			    qede->instance, sym ? sym : "?", off);
		}
	}
	cmn_err(CE_CONT, "qede(%d): ---------- \n", qede->instance);
}

void
qede_dbg_ipv6_ext_hdr(qede_tx_pktinfo_t *pktinfo, mblk_t *mp)
{
	struct ether_header *eth_hdr = 
	    (struct ether_header *)(void *)mp->b_rptr;
	ipha_t *ip_hdr;
	struct ip6_hdr *ipv6hdr = NULL;

	/* mac header type and len */
	if (ntohs(eth_hdr->ether_type) == ETHERTYPE_IP) {
		pktinfo->ether_type = ntohs(eth_hdr->ether_type);
		pktinfo->mac_hlen = sizeof (struct ether_header);
	} else if (ntohs(eth_hdr->ether_type) == ETHERTYPE_VLAN) {
		struct ether_vlan_header *vlan_hdr =
		    (struct ether_vlan_header *)(void *)mp->b_rptr;
		pktinfo->ether_type = ntohs(vlan_hdr->ether_type);
		pktinfo->mac_hlen = sizeof (struct ether_vlan_header);
	}

	ip_hdr = (ipha_t *)(void *)((u8 *)mp->b_rptr + pktinfo->mac_hlen);

	if (IPH_HDR_VERSION(ip_hdr) == IPV6_VERSION) {
		ipv6hdr = (struct ip6_hdr *)(void *)ip_hdr;
		
		if (ipv6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt == IPPROTO_IPV6) {
			cmn_err(CE_NOTE, "%s: ipv6 extenstion header found !",
			    __func__);
		}
	}
}

char *
qede_get_L4_type(uint16_t parse_flags)
{
	parse_flags = (parse_flags >> PARSING_AND_ERR_FLAGS_L4PROTOCOL_SHIFT)
	    & PARSING_AND_ERR_FLAGS_L4PROTOCOL_MASK;
	if (parse_flags == 1)  {
		return ("TCP");
	} else if (parse_flags == 2) {
		return ("UDP");
	} else {
		return ("UNKNOWN");
	}
}

char *
qede_get_L3_type(uint16_t parse_flags)
{
	parse_flags = (parse_flags >> PARSING_AND_ERR_FLAGS_L3TYPE_SHIFT)
	    & PARSING_AND_ERR_FLAGS_L3TYPE_MASK;
	if (parse_flags == 1) {
		return ("IPv4");
	} else if (parse_flags == 2) {
		return ("IPv6");
	} else {
		return ("UNKNOWN");
	}
}


void
qede_print_vport_params(qede_t *qede,
    struct ecore_sp_vport_update_params *vport_params)
{
	struct ecore_filter_accept_flags *accept_flags;

	accept_flags = &vport_params->accept_flags;

	cmn_err(CE_WARN, "opaque_fid = %d",
		vport_params->opaque_fid);
	cmn_err(CE_WARN, "vport_id = %d",
		vport_params->vport_id);
	cmn_err(CE_WARN, "update_vport_active_rx_flg = %d",
		vport_params->update_vport_active_rx_flg);
	cmn_err(CE_WARN, "vport_active_rx_flg = %d",
		vport_params->vport_active_rx_flg);
	cmn_err(CE_WARN, "update_vport_active_tx_flg = %d",
		vport_params->update_vport_active_tx_flg);
	cmn_err(CE_WARN, "vport_active_tx_flg = %d",
		vport_params->vport_active_tx_flg);
	cmn_err(CE_WARN, "update_inner_vlan_removal_flg = %d",
		vport_params->update_inner_vlan_removal_flg);
	cmn_err(CE_WARN, "inner_vlan_removal_flg = %d",
		vport_params->inner_vlan_removal_flg);
	cmn_err(CE_WARN, "update_default_vlan_enable_flg = %d",
		vport_params->update_default_vlan_enable_flg);
	cmn_err(CE_WARN, "default_vlan_enable_flg = %d",
		vport_params->default_vlan_enable_flg);
	cmn_err(CE_WARN, "update_default_vlan_flg = %d",
		vport_params->update_default_vlan_flg);
	cmn_err(CE_WARN, "default_vlan = %d",
		vport_params->default_vlan);
	cmn_err(CE_WARN, "update_tx_switching_flg = %d",
		vport_params->update_tx_switching_flg);
	cmn_err(CE_WARN, "tx_switching_flg = %d",
		vport_params->tx_switching_flg);
	cmn_err(CE_WARN, "update_approx_mcast_flg = %d",
		vport_params->update_approx_mcast_flg);
	cmn_err(CE_WARN, "update_anti_spoofing_en_flg = %d",
		vport_params->update_anti_spoofing_en_flg);
	cmn_err(CE_WARN, "anti_spoofing_en = %d",
		vport_params->anti_spoofing_en);
	cmn_err(CE_WARN, "update_accept_any_vlan_flg = %d",
		vport_params->update_accept_any_vlan_flg);
	cmn_err(CE_WARN, "accept_any_vlan = %d",
		vport_params->accept_any_vlan);

	cmn_err(CE_WARN, "update_rx_mode_config; = %d",
		accept_flags->update_rx_mode_config);
	cmn_err(CE_WARN, "update_tx_mode_config; = %d",
		accept_flags->update_tx_mode_config);
}

void
qede_dump_bytes(char *buf, int len)
{
	int i;
	for (i = 0; i < len; i += 8, buf+=8) {
		cmn_err(CE_NOTE, 
		    "!%.02x %.02x %.02x %.02x %.02x %.02x %.02x %.02x",
		    buf[i + 0] & 0xff, buf[i + 1] & 0xff,
		    buf[i + 2] & 0xff, buf[i + 3] & 0xff,
		    buf[i + 4] & 0xff, buf[i + 5] & 0xff,
		    buf[i + 6] & 0xff, buf[i + 7] & 0xff);
	}
}

void
qede_dump_single_mblk(qede_t *qede, mblk_t *mp)
{
	int len = MBLKL(mp);
	u8 *buf = mp->b_rptr;
	int i;

	for (i = 0; i < len; i += 8) {
		cmn_err(CE_NOTE, "!%p: %2x %2x %2x %2x %2x %2x %2x %2x",
		    buf, buf[i], buf[i + 1],
		    buf[i + 2], buf[i + 3],
		    buf[i + 4], buf[i + 5],
		    buf[i + 6], buf[i + 7]);
	}
}

void
qede_dump_mblk_chain_bcont_ptr(qede_t *qede, mblk_t *mp)
{
	mblk_t *bp;
	int len, num_mblk = 0;
	int total_len = 0;

	for (bp = mp; bp != NULL; bp = bp->b_cont) {
		len = MBLKL(bp);
		total_len += len;
		num_mblk++;
		
		qede_info(qede, "b_cont bp len %d", len);	
		qede_dump_single_mblk(qede, bp);
	}

	qede_info(qede, "Total b_cont mblks %d, total_len %d",
	    num_mblk, total_len);
}
/*
 * Loop through all data elements in mp
 * and print them
 */
void
qede_dump_mblk_chain_bnext_ptr(qede_t *qede, mblk_t *mp)
{
	mblk_t *bp;
	int len, num_mblk = 0;
	int total_len = 0;

	for (bp = mp; bp != NULL; bp = bp->b_next) {
		len = MBLKL(bp);
		total_len += len;
		num_mblk++;
		
		qede_info(qede, "b_next bp len %d", len);	
	}

	qede_info(qede, "Total b_next mblks %d, total_len %d",
	    num_mblk, total_len);
}

void
qede_print_intr_ctx(qede_intr_context_t *intr_ctx)
{
}

void
qede_print_tx_ring(qede_tx_ring_t *tx_ring)
{
}

void
qede_print_rx_ring(qede_rx_ring_t *rx_ring)
{
}

void
qede_print_fastpath(qede_fastpath_t *fp)
{
}

void
qede_print_qede(qede_t *qede)
{
}

/*
 * This function is called from ecore in the init path
 * just before starting the function
 */
void 
qede_debug_before_pf_start(struct ecore_dev *edev, u8 id)
{
}

void 
qede_debug_after_pf_stop(void *cdev, u8 my_id)
{
}


void 
qede_dump_reg_cqe(struct eth_fast_path_rx_reg_cqe *cqe)
{
	cmn_err(CE_WARN, "qede_dump_reg_cqe");
	cmn_err(CE_WARN, "    pkt_len = %d", LE_16(cqe->pkt_len));
	cmn_err(CE_WARN, "    bd_num = %d", cqe->bd_num);
	cmn_err(CE_WARN, "    len_on_first_bd = %d", 
	    LE_16(cqe->len_on_first_bd));
	cmn_err(CE_WARN, "    placement_offset = %d", cqe->placement_offset);
	cmn_err(CE_WARN, "    vlan_tag = %d", LE_16(cqe->vlan_tag));
	cmn_err(CE_WARN, "    rss_hash = %d", LE_32(cqe->rss_hash));
	cmn_err(CE_WARN, "    pars_flags = %x", 
	    LE_16((uint16_t)cqe->pars_flags.flags));
	cmn_err(CE_WARN, "    tunnel_pars_flags = %x", 
	    cqe->tunnel_pars_flags.flags);
	cmn_err(CE_WARN, "    bitfields = %x", cqe->bitfields);
}

void 
qede_dump_start_lro_cqe(struct eth_fast_path_rx_tpa_start_cqe *cqe)
{
	int i;
	cmn_err(CE_WARN, "qede_dump_start_lro_cqe");
	cmn_err(CE_WARN, "    tpa_agg_index = %d", cqe->tpa_agg_index);
	cmn_err(CE_WARN, "    seg_len = %d", LE_16(cqe->seg_len));
	cmn_err(CE_WARN, "    vlan_tag = %d", LE_16(cqe->vlan_tag));
	cmn_err(CE_WARN, "    rss_hash = %d", LE_32(cqe->rss_hash));
	cmn_err(CE_WARN, "    len_on_first_bd = %d", 
	    LE_16(cqe->len_on_first_bd));
	cmn_err(CE_WARN, "    placement_offset = %d", cqe->placement_offset);
	cmn_err(CE_WARN, "    header_len = %d", cqe->header_len);
	for (i = 0; i < ETH_TPA_CQE_START_LEN_LIST_SIZE; i++)
		cmn_err(CE_WARN, "    ext_bd_len_list[%d] = %d", i, 
		    LE_16(cqe->ext_bd_len_list[i]));
	cmn_err(CE_WARN, "    pars_flags = 0x%x", 
	    LE_16((uint16_t)cqe->pars_flags.flags));
	cmn_err(CE_WARN, "    tunnel_pars_flags = 0x%x", 
	    cqe->tunnel_pars_flags.flags);
	cmn_err(CE_WARN, "    bitfields = 0x%x", cqe->bitfields );
}

void 
qede_dump_cont_lro_cqe(struct eth_fast_path_rx_tpa_cont_cqe *cqe)
{
	int i;
	cmn_err(CE_WARN, "qede_dump_cont_lro_cqe");
	cmn_err(CE_WARN, "    tpa_agg_index = %d", cqe->tpa_agg_index);
	for (i = 0; i < ETH_TPA_CQE_CONT_LEN_LIST_SIZE; i++) {
		cmn_err(CE_WARN, "    len_list[%d] = %d", i, 
		    LE_16(cqe->len_list[i]));
	}
}

void 
qede_dump_end_lro_cqe(struct eth_fast_path_rx_tpa_end_cqe *cqe)
{
	int i;
	cmn_err(CE_WARN, "qede_dump_end_lro_cqe");
	cmn_err(CE_WARN, "    tpa_agg_index = %d", cqe->tpa_agg_index );
	cmn_err(CE_WARN, "    total_packet_len = %d", 
	    LE_16(cqe->total_packet_len));
	cmn_err(CE_WARN, "    num_of_bds = %d", cqe->num_of_bds);
	cmn_err(CE_WARN, "    num_of_coalesced_segs = %d", 
	    LE_16(cqe->num_of_coalesced_segs));
	for (i = 0; i < ETH_TPA_CQE_END_LEN_LIST_SIZE; i++) {
		cmn_err(CE_WARN, "    len_list[%d] = %d", i, 
		    LE_16(cqe->len_list[i]));
	}
	cmn_err(CE_WARN, "    ts_delta = %d", LE_32(cqe->ts_delta));
}