/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (C) 2020 Marvell International Ltd.
 *
 * Interface to the hardware Packet Input Processing unit.
 */

#ifndef __CVMX_PIP_H__
#define __CVMX_PIP_H__

#include "cvmx-wqe.h"
#include "cvmx-pki.h"
#include "cvmx-helper-pki.h"

#include "cvmx-helper.h"
#include "cvmx-helper-util.h"
#include "cvmx-pki-resources.h"

#define CVMX_PIP_NUM_INPUT_PORTS 46
#define CVMX_PIP_NUM_WATCHERS	 8

/*
 * Encodes the different error and exception codes
 */
typedef enum {
	CVMX_PIP_L4_NO_ERR = 0ull,
	/*        1  = TCP (UDP) packet not long enough to cover TCP (UDP) header */
	CVMX_PIP_L4_MAL_ERR = 1ull,
	/*        2  = TCP/UDP checksum failure */
	CVMX_PIP_CHK_ERR = 2ull,
	/*        3  = TCP/UDP length check (TCP/UDP length does not match IP length) */
	CVMX_PIP_L4_LENGTH_ERR = 3ull,
	/*        4  = illegal TCP/UDP port (either source or dest port is zero) */
	CVMX_PIP_BAD_PRT_ERR = 4ull,
	/*        8  = TCP flags = FIN only */
	CVMX_PIP_TCP_FLG8_ERR = 8ull,
	/*        9  = TCP flags = 0 */
	CVMX_PIP_TCP_FLG9_ERR = 9ull,
	/*        10 = TCP flags = FIN+RST+* */
	CVMX_PIP_TCP_FLG10_ERR = 10ull,
	/*        11 = TCP flags = SYN+URG+* */
	CVMX_PIP_TCP_FLG11_ERR = 11ull,
	/*        12 = TCP flags = SYN+RST+* */
	CVMX_PIP_TCP_FLG12_ERR = 12ull,
	/*        13 = TCP flags = SYN+FIN+* */
	CVMX_PIP_TCP_FLG13_ERR = 13ull
} cvmx_pip_l4_err_t;

typedef enum {
	CVMX_PIP_IP_NO_ERR = 0ull,
	/*        1 = not IPv4 or IPv6 */
	CVMX_PIP_NOT_IP = 1ull,
	/*        2 = IPv4 header checksum violation */
	CVMX_PIP_IPV4_HDR_CHK = 2ull,
	/*        3 = malformed (packet not long enough to cover IP hdr) */
	CVMX_PIP_IP_MAL_HDR = 3ull,
	/*        4 = malformed (packet not long enough to cover len in IP hdr) */
	CVMX_PIP_IP_MAL_PKT = 4ull,
	/*        5 = TTL / hop count equal zero */
	CVMX_PIP_TTL_HOP = 5ull,
	/*        6 = IPv4 options / IPv6 early extension headers */
	CVMX_PIP_OPTS = 6ull
} cvmx_pip_ip_exc_t;

/**
 * NOTES
 *       late collision (data received before collision)
 *            late collisions cannot be detected by the receiver
 *            they would appear as JAM bits which would appear as bad FCS
 *            or carrier extend error which is CVMX_PIP_EXTEND_ERR
 */
typedef enum {
	/**
	 * No error
	 */
	CVMX_PIP_RX_NO_ERR = 0ull,

	CVMX_PIP_PARTIAL_ERR =
		1ull, /* RGM+SPI            1 = partially received packet (buffering/bandwidth not adequate) */
	CVMX_PIP_JABBER_ERR =
		2ull, /* RGM+SPI            2 = receive packet too large and truncated */
	CVMX_PIP_OVER_FCS_ERR =
		3ull, /* RGM                3 = max frame error (pkt len > max frame len) (with FCS error) */
	CVMX_PIP_OVER_ERR =
		4ull, /* RGM+SPI            4 = max frame error (pkt len > max frame len) */
	CVMX_PIP_ALIGN_ERR =
		5ull, /* RGM                5 = nibble error (data not byte multiple - 100M and 10M only) */
	CVMX_PIP_UNDER_FCS_ERR =
		6ull, /* RGM                6 = min frame error (pkt len < min frame len) (with FCS error) */
	CVMX_PIP_GMX_FCS_ERR = 7ull, /* RGM                7 = FCS error */
	CVMX_PIP_UNDER_ERR =
		8ull, /* RGM+SPI            8 = min frame error (pkt len < min frame len) */
	CVMX_PIP_EXTEND_ERR = 9ull, /* RGM                9 = Frame carrier extend error */
	CVMX_PIP_TERMINATE_ERR =
		9ull, /* XAUI               9 = Packet was terminated with an idle cycle */
	CVMX_PIP_LENGTH_ERR =
		10ull, /* RGM               10 = length mismatch (len did not match len in L2 length/type) */
	CVMX_PIP_DAT_ERR =
		11ull, /* RGM               11 = Frame error (some or all data bits marked err) */
	CVMX_PIP_DIP_ERR = 11ull, /*     SPI           11 = DIP4 error */
	CVMX_PIP_SKIP_ERR =
		12ull, /* RGM               12 = packet was not large enough to pass the skipper - no inspection could occur */
	CVMX_PIP_NIBBLE_ERR =
		13ull, /* RGM               13 = studder error (data not repeated - 100M and 10M only) */
	CVMX_PIP_PIP_FCS = 16L, /* RGM+SPI           16 = FCS error */
	CVMX_PIP_PIP_SKIP_ERR =
		17L, /* RGM+SPI+PCI       17 = packet was not large enough to pass the skipper - no inspection could occur */
	CVMX_PIP_PIP_L2_MAL_HDR =
		18L, /* RGM+SPI+PCI       18 = malformed l2 (packet not long enough to cover L2 hdr) */
	CVMX_PIP_PUNY_ERR =
		47L /* SGMII             47 = PUNY error (packet was 4B or less when FCS stripping is enabled) */
	/* NOTES
	 *       xx = late collision (data received before collision)
	 *            late collisions cannot be detected by the receiver
	 *            they would appear as JAM bits which would appear as bad FCS
	 *            or carrier extend error which is CVMX_PIP_EXTEND_ERR
	 */
} cvmx_pip_rcv_err_t;

/**
 * This defines the err_code field errors in the work Q entry
 */
typedef union {
	cvmx_pip_l4_err_t l4_err;
	cvmx_pip_ip_exc_t ip_exc;
	cvmx_pip_rcv_err_t rcv_err;
} cvmx_pip_err_t;

/**
 * Status statistics for a port
 */
typedef struct {
	u64 dropped_octets;
	u64 dropped_packets;
	u64 pci_raw_packets;
	u64 octets;
	u64 packets;
	u64 multicast_packets;
	u64 broadcast_packets;
	u64 len_64_packets;
	u64 len_65_127_packets;
	u64 len_128_255_packets;
	u64 len_256_511_packets;
	u64 len_512_1023_packets;
	u64 len_1024_1518_packets;
	u64 len_1519_max_packets;
	u64 fcs_align_err_packets;
	u64 runt_packets;
	u64 runt_crc_packets;
	u64 oversize_packets;
	u64 oversize_crc_packets;
	u64 inb_packets;
	u64 inb_octets;
	u64 inb_errors;
	u64 mcast_l2_red_packets;
	u64 bcast_l2_red_packets;
	u64 mcast_l3_red_packets;
	u64 bcast_l3_red_packets;
} cvmx_pip_port_status_t;

/**
 * Definition of the PIP custom header that can be prepended
 * to a packet by external hardware.
 */
typedef union {
	u64 u64;
	struct {
		u64 rawfull : 1;
		u64 reserved0 : 5;
		cvmx_pip_port_parse_mode_t parse_mode : 2;
		u64 reserved1 : 1;
		u64 skip_len : 7;
		u64 grpext : 2;
		u64 nqos : 1;
		u64 ngrp : 1;
		u64 ntt : 1;
		u64 ntag : 1;
		u64 qos : 3;
		u64 grp : 4;
		u64 rs : 1;
		cvmx_pow_tag_type_t tag_type : 2;
		u64 tag : 32;
	} s;
} cvmx_pip_pkt_inst_hdr_t;

enum cvmx_pki_pcam_match {
	CVMX_PKI_PCAM_MATCH_IP,
	CVMX_PKI_PCAM_MATCH_IPV4,
	CVMX_PKI_PCAM_MATCH_IPV6,
	CVMX_PKI_PCAM_MATCH_TCP
};

/* CSR typedefs have been moved to cvmx-pip-defs.h */
static inline int cvmx_pip_config_watcher(int index, int type, u16 match, u16 mask, int grp,
					  int qos)
{
	if (index >= CVMX_PIP_NUM_WATCHERS) {
		debug("ERROR: pip watcher %d is > than supported\n", index);
		return -1;
	}
	if (octeon_has_feature(OCTEON_FEATURE_PKI)) {
		/* store in software for now, only when the watcher is enabled program the entry*/
		if (type == CVMX_PIP_QOS_WATCH_PROTNH) {
			qos_watcher[index].field = CVMX_PKI_PCAM_TERM_L3_FLAGS;
			qos_watcher[index].data = (u32)(match << 16);
			qos_watcher[index].data_mask = (u32)(mask << 16);
			qos_watcher[index].advance = 0;
		} else if (type == CVMX_PIP_QOS_WATCH_TCP) {
			qos_watcher[index].field = CVMX_PKI_PCAM_TERM_L4_PORT;
			qos_watcher[index].data = 0x060000;
			qos_watcher[index].data |= (u32)match;
			qos_watcher[index].data_mask = (u32)(mask);
			qos_watcher[index].advance = 0;
		} else if (type == CVMX_PIP_QOS_WATCH_UDP) {
			qos_watcher[index].field = CVMX_PKI_PCAM_TERM_L4_PORT;
			qos_watcher[index].data = 0x110000;
			qos_watcher[index].data |= (u32)match;
			qos_watcher[index].data_mask = (u32)(mask);
			qos_watcher[index].advance = 0;
		} else if (type == 0x4 /*CVMX_PIP_QOS_WATCH_ETHERTYPE*/) {
			qos_watcher[index].field = CVMX_PKI_PCAM_TERM_ETHTYPE0;
			if (match == 0x8100) {
				debug("ERROR: default vlan entry already exist, cant set watcher\n");
				return -1;
			}
			qos_watcher[index].data = (u32)(match << 16);
			qos_watcher[index].data_mask = (u32)(mask << 16);
			qos_watcher[index].advance = 4;
		} else {
			debug("ERROR: Unsupported watcher type %d\n", type);
			return -1;
		}
		if (grp >= 32) {
			debug("ERROR: grp %d out of range for backward compat 78xx\n", grp);
			return -1;
		}
		qos_watcher[index].sso_grp = (u8)(grp << 3 | qos);
		qos_watcher[index].configured = 1;
	} else {
		/* Implement it later */
	}
	return 0;
}

static inline int __cvmx_pip_set_tag_type(int node, int style, int tag_type, int field)
{
	struct cvmx_pki_style_config style_cfg;
	int style_num;
	int pcam_offset;
	int bank;
	struct cvmx_pki_pcam_input pcam_input;
	struct cvmx_pki_pcam_action pcam_action;

	/* All other style parameters remain same except tag type */
	cvmx_pki_read_style_config(node, style, CVMX_PKI_CLUSTER_ALL, &style_cfg);
	style_cfg.parm_cfg.tag_type = (enum cvmx_sso_tag_type)tag_type;
	style_num = cvmx_pki_style_alloc(node, -1);
	if (style_num < 0) {
		debug("ERROR: style not available to set tag type\n");
		return -1;
	}
	cvmx_pki_write_style_config(node, style_num, CVMX_PKI_CLUSTER_ALL, &style_cfg);
	memset(&pcam_input, 0, sizeof(pcam_input));
	memset(&pcam_action, 0, sizeof(pcam_action));
	pcam_input.style = style;
	pcam_input.style_mask = 0xff;
	if (field == CVMX_PKI_PCAM_MATCH_IP) {
		pcam_input.field = CVMX_PKI_PCAM_TERM_ETHTYPE0;
		pcam_input.field_mask = 0xff;
		pcam_input.data = 0x08000000;
		pcam_input.data_mask = 0xffff0000;
		pcam_action.pointer_advance = 4;
		/* legacy will write to all clusters*/
		bank = 0;
		pcam_offset = cvmx_pki_pcam_entry_alloc(node, CVMX_PKI_FIND_AVAL_ENTRY, bank,
							CVMX_PKI_CLUSTER_ALL);
		if (pcam_offset < 0) {
			debug("ERROR: pcam entry not available to enable qos watcher\n");
			cvmx_pki_style_free(node, style_num);
			return -1;
		}
		pcam_action.parse_mode_chg = CVMX_PKI_PARSE_NO_CHG;
		pcam_action.layer_type_set = CVMX_PKI_LTYPE_E_NONE;
		pcam_action.style_add = (u8)(style_num - style);
		cvmx_pki_pcam_write_entry(node, pcam_offset, CVMX_PKI_CLUSTER_ALL, pcam_input,
					  pcam_action);
		field = CVMX_PKI_PCAM_MATCH_IPV6;
	}
	if (field == CVMX_PKI_PCAM_MATCH_IPV4) {
		pcam_input.field = CVMX_PKI_PCAM_TERM_ETHTYPE0;
		pcam_input.field_mask = 0xff;
		pcam_input.data = 0x08000000;
		pcam_input.data_mask = 0xffff0000;
		pcam_action.pointer_advance = 4;
	} else if (field == CVMX_PKI_PCAM_MATCH_IPV6) {
		pcam_input.field = CVMX_PKI_PCAM_TERM_ETHTYPE0;
		pcam_input.field_mask = 0xff;
		pcam_input.data = 0x86dd00000;
		pcam_input.data_mask = 0xffff0000;
		pcam_action.pointer_advance = 4;
	} else if (field == CVMX_PKI_PCAM_MATCH_TCP) {
		pcam_input.field = CVMX_PKI_PCAM_TERM_L4_PORT;
		pcam_input.field_mask = 0xff;
		pcam_input.data = 0x60000;
		pcam_input.data_mask = 0xff0000;
		pcam_action.pointer_advance = 0;
	}
	pcam_action.parse_mode_chg = CVMX_PKI_PARSE_NO_CHG;
	pcam_action.layer_type_set = CVMX_PKI_LTYPE_E_NONE;
	pcam_action.style_add = (u8)(style_num - style);
	bank = pcam_input.field & 0x01;
	pcam_offset = cvmx_pki_pcam_entry_alloc(node, CVMX_PKI_FIND_AVAL_ENTRY, bank,
						CVMX_PKI_CLUSTER_ALL);
	if (pcam_offset < 0) {
		debug("ERROR: pcam entry not available to enable qos watcher\n");
		cvmx_pki_style_free(node, style_num);
		return -1;
	}
	cvmx_pki_pcam_write_entry(node, pcam_offset, CVMX_PKI_CLUSTER_ALL, pcam_input, pcam_action);
	return style_num;
}

/* Only for legacy internal use */
static inline int __cvmx_pip_enable_watcher_78xx(int node, int index, int style)
{
	struct cvmx_pki_style_config style_cfg;
	struct cvmx_pki_qpg_config qpg_cfg;
	struct cvmx_pki_pcam_input pcam_input;
	struct cvmx_pki_pcam_action pcam_action;
	int style_num;
	int qpg_offset;
	int pcam_offset;
	int bank;

	if (!qos_watcher[index].configured) {
		debug("ERROR: qos watcher %d should be configured before enable\n", index);
		return -1;
	}
	/* All other style parameters remain same except grp and qos and qps base */
	cvmx_pki_read_style_config(node, style, CVMX_PKI_CLUSTER_ALL, &style_cfg);
	cvmx_pki_read_qpg_entry(node, style_cfg.parm_cfg.qpg_base, &qpg_cfg);
	qpg_cfg.qpg_base = CVMX_PKI_FIND_AVAL_ENTRY;
	qpg_cfg.grp_ok = qos_watcher[index].sso_grp;
	qpg_cfg.grp_bad = qos_watcher[index].sso_grp;
	qpg_offset = cvmx_helper_pki_set_qpg_entry(node, &qpg_cfg);
	if (qpg_offset == -1) {
		debug("Warning: no new qpg entry available to enable watcher\n");
		return -1;
	}
	/* try to reserve the style, if it is not configured already, reserve
	   and configure it */
	style_cfg.parm_cfg.qpg_base = qpg_offset;
	style_num = cvmx_pki_style_alloc(node, -1);
	if (style_num < 0) {
		debug("ERROR: style not available to enable qos watcher\n");
		cvmx_pki_qpg_entry_free(node, qpg_offset, 1);
		return -1;
	}
	cvmx_pki_write_style_config(node, style_num, CVMX_PKI_CLUSTER_ALL, &style_cfg);
	/* legacy will write to all clusters*/
	bank = qos_watcher[index].field & 0x01;
	pcam_offset = cvmx_pki_pcam_entry_alloc(node, CVMX_PKI_FIND_AVAL_ENTRY, bank,
						CVMX_PKI_CLUSTER_ALL);
	if (pcam_offset < 0) {
		debug("ERROR: pcam entry not available to enable qos watcher\n");
		cvmx_pki_style_free(node, style_num);
		cvmx_pki_qpg_entry_free(node, qpg_offset, 1);
		return -1;
	}
	memset(&pcam_input, 0, sizeof(pcam_input));
	memset(&pcam_action, 0, sizeof(pcam_action));
	pcam_input.style = style;
	pcam_input.style_mask = 0xff;
	pcam_input.field = qos_watcher[index].field;
	pcam_input.field_mask = 0xff;
	pcam_input.data = qos_watcher[index].data;
	pcam_input.data_mask = qos_watcher[index].data_mask;
	pcam_action.parse_mode_chg = CVMX_PKI_PARSE_NO_CHG;
	pcam_action.layer_type_set = CVMX_PKI_LTYPE_E_NONE;
	pcam_action.style_add = (u8)(style_num - style);
	pcam_action.pointer_advance = qos_watcher[index].advance;
	cvmx_pki_pcam_write_entry(node, pcam_offset, CVMX_PKI_CLUSTER_ALL, pcam_input, pcam_action);
	return 0;
}

/**
 * Configure an ethernet input port
 *
 * @param ipd_port Port number to configure
 * @param port_cfg Port hardware configuration
 * @param port_tag_cfg Port POW tagging configuration
 */
static inline void cvmx_pip_config_port(u64 ipd_port, cvmx_pip_prt_cfgx_t port_cfg,
					cvmx_pip_prt_tagx_t port_tag_cfg)
{
	struct cvmx_pki_qpg_config qpg_cfg;
	int qpg_offset;
	u8 tcp_tag = 0xff;
	u8 ip_tag = 0xaa;
	int style, nstyle, n4style, n6style;

	if (octeon_has_feature(OCTEON_FEATURE_PKI)) {
		struct cvmx_pki_port_config pki_prt_cfg;
		struct cvmx_xport xp = cvmx_helper_ipd_port_to_xport(ipd_port);

		cvmx_pki_get_port_config(ipd_port, &pki_prt_cfg);
		style = pki_prt_cfg.pkind_cfg.initial_style;
		if (port_cfg.s.ih_pri || port_cfg.s.vlan_len || port_cfg.s.pad_len)
			debug("Warning: 78xx: use different config for this option\n");
		pki_prt_cfg.style_cfg.parm_cfg.minmax_sel = port_cfg.s.len_chk_sel;
		pki_prt_cfg.style_cfg.parm_cfg.lenerr_en = port_cfg.s.lenerr_en;
		pki_prt_cfg.style_cfg.parm_cfg.maxerr_en = port_cfg.s.maxerr_en;
		pki_prt_cfg.style_cfg.parm_cfg.minerr_en = port_cfg.s.minerr_en;
		pki_prt_cfg.style_cfg.parm_cfg.fcs_chk = port_cfg.s.crc_en;
		if (port_cfg.s.grp_wat || port_cfg.s.qos_wat || port_cfg.s.grp_wat_47 ||
		    port_cfg.s.qos_wat_47) {
			u8 group_mask = (u8)(port_cfg.s.grp_wat | (u8)(port_cfg.s.grp_wat_47 << 4));
			u8 qos_mask = (u8)(port_cfg.s.qos_wat | (u8)(port_cfg.s.qos_wat_47 << 4));
			int i;

			for (i = 0; i < CVMX_PIP_NUM_WATCHERS; i++) {
				if ((group_mask & (1 << i)) || (qos_mask & (1 << i)))
					__cvmx_pip_enable_watcher_78xx(xp.node, i, style);
			}
		}
		if (port_tag_cfg.s.tag_mode) {
			if (OCTEON_IS_MODEL(OCTEON_CN78XX_PASS1_X))
				cvmx_printf("Warning: mask tag is not supported in 78xx pass1\n");
			else {
			}
			/* need to implement for 78xx*/
		}
		if (port_cfg.s.tag_inc)
			debug("Warning: 78xx uses differnet method for tag generation\n");
		pki_prt_cfg.style_cfg.parm_cfg.rawdrp = port_cfg.s.rawdrp;
		pki_prt_cfg.pkind_cfg.parse_en.inst_hdr = port_cfg.s.inst_hdr;
		if (port_cfg.s.hg_qos)
			pki_prt_cfg.style_cfg.parm_cfg.qpg_qos = CVMX_PKI_QPG_QOS_HIGIG;
		else if (port_cfg.s.qos_vlan)
			pki_prt_cfg.style_cfg.parm_cfg.qpg_qos = CVMX_PKI_QPG_QOS_VLAN;
		else if (port_cfg.s.qos_diff)
			pki_prt_cfg.style_cfg.parm_cfg.qpg_qos = CVMX_PKI_QPG_QOS_DIFFSERV;
		if (port_cfg.s.qos_vod)
			debug("Warning: 78xx needs pcam entries installed to achieve qos_vod\n");
		if (port_cfg.s.qos) {
			cvmx_pki_read_qpg_entry(xp.node, pki_prt_cfg.style_cfg.parm_cfg.qpg_base,
						&qpg_cfg);
			qpg_cfg.qpg_base = CVMX_PKI_FIND_AVAL_ENTRY;
			qpg_cfg.grp_ok |= port_cfg.s.qos;
			qpg_cfg.grp_bad |= port_cfg.s.qos;
			qpg_offset = cvmx_helper_pki_set_qpg_entry(xp.node, &qpg_cfg);
			if (qpg_offset == -1)
				debug("Warning: no new qpg entry available, will not modify qos\n");
			else
				pki_prt_cfg.style_cfg.parm_cfg.qpg_base = qpg_offset;
		}
		if (port_tag_cfg.s.grp != pki_dflt_sso_grp[xp.node].group) {
			cvmx_pki_read_qpg_entry(xp.node, pki_prt_cfg.style_cfg.parm_cfg.qpg_base,
						&qpg_cfg);
			qpg_cfg.qpg_base = CVMX_PKI_FIND_AVAL_ENTRY;
			qpg_cfg.grp_ok |= (u8)(port_tag_cfg.s.grp << 3);
			qpg_cfg.grp_bad |= (u8)(port_tag_cfg.s.grp << 3);
			qpg_offset = cvmx_helper_pki_set_qpg_entry(xp.node, &qpg_cfg);
			if (qpg_offset == -1)
				debug("Warning: no new qpg entry available, will not modify group\n");
			else
				pki_prt_cfg.style_cfg.parm_cfg.qpg_base = qpg_offset;
		}
		pki_prt_cfg.pkind_cfg.parse_en.dsa_en = port_cfg.s.dsa_en;
		pki_prt_cfg.pkind_cfg.parse_en.hg_en = port_cfg.s.higig_en;
		pki_prt_cfg.style_cfg.tag_cfg.tag_fields.layer_c_src =
			port_tag_cfg.s.ip6_src_flag | port_tag_cfg.s.ip4_src_flag;
		pki_prt_cfg.style_cfg.tag_cfg.tag_fields.layer_c_dst =
			port_tag_cfg.s.ip6_dst_flag | port_tag_cfg.s.ip4_dst_flag;
		pki_prt_cfg.style_cfg.tag_cfg.tag_fields.ip_prot_nexthdr =
			port_tag_cfg.s.ip6_nxth_flag | port_tag_cfg.s.ip4_pctl_flag;
		pki_prt_cfg.style_cfg.tag_cfg.tag_fields.layer_d_src =
			port_tag_cfg.s.ip6_sprt_flag | port_tag_cfg.s.ip4_sprt_flag;
		pki_prt_cfg.style_cfg.tag_cfg.tag_fields.layer_d_dst =
			port_tag_cfg.s.ip6_dprt_flag | port_tag_cfg.s.ip4_dprt_flag;
		pki_prt_cfg.style_cfg.tag_cfg.tag_fields.input_port = port_tag_cfg.s.inc_prt_flag;
		pki_prt_cfg.style_cfg.tag_cfg.tag_fields.first_vlan = port_tag_cfg.s.inc_vlan;
		pki_prt_cfg.style_cfg.tag_cfg.tag_fields.second_vlan = port_tag_cfg.s.inc_vs;

		if (port_tag_cfg.s.tcp6_tag_type == port_tag_cfg.s.tcp4_tag_type)
			tcp_tag = port_tag_cfg.s.tcp6_tag_type;
		if (port_tag_cfg.s.ip6_tag_type == port_tag_cfg.s.ip4_tag_type)
			ip_tag = port_tag_cfg.s.ip6_tag_type;
		pki_prt_cfg.style_cfg.parm_cfg.tag_type =
			(enum cvmx_sso_tag_type)port_tag_cfg.s.non_tag_type;
		if (tcp_tag == ip_tag && tcp_tag == port_tag_cfg.s.non_tag_type)
			pki_prt_cfg.style_cfg.parm_cfg.tag_type = (enum cvmx_sso_tag_type)tcp_tag;
		else if (tcp_tag == ip_tag) {
			/* allocate and copy style */
			/* modify tag type */
			/*pcam entry for ip6 && ip4 match*/
			/* default is non tag type */
			__cvmx_pip_set_tag_type(xp.node, style, ip_tag, CVMX_PKI_PCAM_MATCH_IP);
		} else if (ip_tag == port_tag_cfg.s.non_tag_type) {
			/* allocate and copy style */
			/* modify tag type */
			/*pcam entry for tcp6 & tcp4 match*/
			/* default is non tag type */
			__cvmx_pip_set_tag_type(xp.node, style, tcp_tag, CVMX_PKI_PCAM_MATCH_TCP);
		} else {
			if (ip_tag != 0xaa) {
				nstyle = __cvmx_pip_set_tag_type(xp.node, style, ip_tag,
								 CVMX_PKI_PCAM_MATCH_IP);
				if (tcp_tag != 0xff)
					__cvmx_pip_set_tag_type(xp.node, nstyle, tcp_tag,
								CVMX_PKI_PCAM_MATCH_TCP);
				else {
					n4style = __cvmx_pip_set_tag_type(xp.node, nstyle, ip_tag,
									  CVMX_PKI_PCAM_MATCH_IPV4);
					__cvmx_pip_set_tag_type(xp.node, n4style,
								port_tag_cfg.s.tcp4_tag_type,
								CVMX_PKI_PCAM_MATCH_TCP);
					n6style = __cvmx_pip_set_tag_type(xp.node, nstyle, ip_tag,
									  CVMX_PKI_PCAM_MATCH_IPV6);
					__cvmx_pip_set_tag_type(xp.node, n6style,
								port_tag_cfg.s.tcp6_tag_type,
								CVMX_PKI_PCAM_MATCH_TCP);
				}
			} else {
				n4style = __cvmx_pip_set_tag_type(xp.node, style,
								  port_tag_cfg.s.ip4_tag_type,
								  CVMX_PKI_PCAM_MATCH_IPV4);
				n6style = __cvmx_pip_set_tag_type(xp.node, style,
								  port_tag_cfg.s.ip6_tag_type,
								  CVMX_PKI_PCAM_MATCH_IPV6);
				if (tcp_tag != 0xff) {
					__cvmx_pip_set_tag_type(xp.node, n4style, tcp_tag,
								CVMX_PKI_PCAM_MATCH_TCP);
					__cvmx_pip_set_tag_type(xp.node, n6style, tcp_tag,
								CVMX_PKI_PCAM_MATCH_TCP);
				} else {
					__cvmx_pip_set_tag_type(xp.node, n4style,
								port_tag_cfg.s.tcp4_tag_type,
								CVMX_PKI_PCAM_MATCH_TCP);
					__cvmx_pip_set_tag_type(xp.node, n6style,
								port_tag_cfg.s.tcp6_tag_type,
								CVMX_PKI_PCAM_MATCH_TCP);
				}
			}
		}
		pki_prt_cfg.style_cfg.parm_cfg.qpg_dis_padd = !port_tag_cfg.s.portadd_en;

		if (port_cfg.s.mode == 0x1)
			pki_prt_cfg.pkind_cfg.initial_parse_mode = CVMX_PKI_PARSE_LA_TO_LG;
		else if (port_cfg.s.mode == 0x2)
			pki_prt_cfg.pkind_cfg.initial_parse_mode = CVMX_PKI_PARSE_LC_TO_LG;
		else
			pki_prt_cfg.pkind_cfg.initial_parse_mode = CVMX_PKI_PARSE_NOTHING;
		/* This is only for backward compatibility, not all the parameters are supported in 78xx */
		cvmx_pki_set_port_config(ipd_port, &pki_prt_cfg);
	} else {
		if (octeon_has_feature(OCTEON_FEATURE_PKND)) {
			int interface, index, pknd;

			interface = cvmx_helper_get_interface_num(ipd_port);
			index = cvmx_helper_get_interface_index_num(ipd_port);
			pknd = cvmx_helper_get_pknd(interface, index);

			ipd_port = pknd; /* overload port_num with pknd */
		}
		csr_wr(CVMX_PIP_PRT_CFGX(ipd_port), port_cfg.u64);
		csr_wr(CVMX_PIP_PRT_TAGX(ipd_port), port_tag_cfg.u64);
	}
}

/**
 * Configure the VLAN priority to QoS queue mapping.
 *
 * @param vlan_priority
 *               VLAN priority (0-7)
 * @param qos    QoS queue for packets matching this watcher
 */
static inline void cvmx_pip_config_vlan_qos(u64 vlan_priority, u64 qos)
{
	if (!octeon_has_feature(OCTEON_FEATURE_PKND)) {
		cvmx_pip_qos_vlanx_t pip_qos_vlanx;

		pip_qos_vlanx.u64 = 0;
		pip_qos_vlanx.s.qos = qos;
		csr_wr(CVMX_PIP_QOS_VLANX(vlan_priority), pip_qos_vlanx.u64);
	}
}

/**
 * Configure the Diffserv to QoS queue mapping.
 *
 * @param diffserv Diffserv field value (0-63)
 * @param qos      QoS queue for packets matching this watcher
 */
static inline void cvmx_pip_config_diffserv_qos(u64 diffserv, u64 qos)
{
	if (!octeon_has_feature(OCTEON_FEATURE_PKND)) {
		cvmx_pip_qos_diffx_t pip_qos_diffx;

		pip_qos_diffx.u64 = 0;
		pip_qos_diffx.s.qos = qos;
		csr_wr(CVMX_PIP_QOS_DIFFX(diffserv), pip_qos_diffx.u64);
	}
}

/**
 * Get the status counters for a port for older non PKI chips.
 *
 * @param port_num Port number (ipd_port) to get statistics for.
 * @param clear    Set to 1 to clear the counters after they are read
 * @param status   Where to put the results.
 */
static inline void cvmx_pip_get_port_stats(u64 port_num, u64 clear, cvmx_pip_port_status_t *status)
{
	cvmx_pip_stat_ctl_t pip_stat_ctl;
	cvmx_pip_stat0_prtx_t stat0;
	cvmx_pip_stat1_prtx_t stat1;
	cvmx_pip_stat2_prtx_t stat2;
	cvmx_pip_stat3_prtx_t stat3;
	cvmx_pip_stat4_prtx_t stat4;
	cvmx_pip_stat5_prtx_t stat5;
	cvmx_pip_stat6_prtx_t stat6;
	cvmx_pip_stat7_prtx_t stat7;
	cvmx_pip_stat8_prtx_t stat8;
	cvmx_pip_stat9_prtx_t stat9;
	cvmx_pip_stat10_x_t stat10;
	cvmx_pip_stat11_x_t stat11;
	cvmx_pip_stat_inb_pktsx_t pip_stat_inb_pktsx;
	cvmx_pip_stat_inb_octsx_t pip_stat_inb_octsx;
	cvmx_pip_stat_inb_errsx_t pip_stat_inb_errsx;
	int interface = cvmx_helper_get_interface_num(port_num);
	int index = cvmx_helper_get_interface_index_num(port_num);

	pip_stat_ctl.u64 = 0;
	pip_stat_ctl.s.rdclr = clear;
	csr_wr(CVMX_PIP_STAT_CTL, pip_stat_ctl.u64);

	if (octeon_has_feature(OCTEON_FEATURE_PKND)) {
		int pknd = cvmx_helper_get_pknd(interface, index);
		/*
		 * PIP_STAT_CTL[MODE] 0 means pkind.
		 */
		stat0.u64 = csr_rd(CVMX_PIP_STAT0_X(pknd));
		stat1.u64 = csr_rd(CVMX_PIP_STAT1_X(pknd));
		stat2.u64 = csr_rd(CVMX_PIP_STAT2_X(pknd));
		stat3.u64 = csr_rd(CVMX_PIP_STAT3_X(pknd));
		stat4.u64 = csr_rd(CVMX_PIP_STAT4_X(pknd));
		stat5.u64 = csr_rd(CVMX_PIP_STAT5_X(pknd));
		stat6.u64 = csr_rd(CVMX_PIP_STAT6_X(pknd));
		stat7.u64 = csr_rd(CVMX_PIP_STAT7_X(pknd));
		stat8.u64 = csr_rd(CVMX_PIP_STAT8_X(pknd));
		stat9.u64 = csr_rd(CVMX_PIP_STAT9_X(pknd));
		stat10.u64 = csr_rd(CVMX_PIP_STAT10_X(pknd));
		stat11.u64 = csr_rd(CVMX_PIP_STAT11_X(pknd));
	} else {
		if (port_num >= 40) {
			stat0.u64 = csr_rd(CVMX_PIP_XSTAT0_PRTX(port_num));
			stat1.u64 = csr_rd(CVMX_PIP_XSTAT1_PRTX(port_num));
			stat2.u64 = csr_rd(CVMX_PIP_XSTAT2_PRTX(port_num));
			stat3.u64 = csr_rd(CVMX_PIP_XSTAT3_PRTX(port_num));
			stat4.u64 = csr_rd(CVMX_PIP_XSTAT4_PRTX(port_num));
			stat5.u64 = csr_rd(CVMX_PIP_XSTAT5_PRTX(port_num));
			stat6.u64 = csr_rd(CVMX_PIP_XSTAT6_PRTX(port_num));
			stat7.u64 = csr_rd(CVMX_PIP_XSTAT7_PRTX(port_num));
			stat8.u64 = csr_rd(CVMX_PIP_XSTAT8_PRTX(port_num));
			stat9.u64 = csr_rd(CVMX_PIP_XSTAT9_PRTX(port_num));
			if (OCTEON_IS_MODEL(OCTEON_CN6XXX)) {
				stat10.u64 = csr_rd(CVMX_PIP_XSTAT10_PRTX(port_num));
				stat11.u64 = csr_rd(CVMX_PIP_XSTAT11_PRTX(port_num));
			}
		} else {
			stat0.u64 = csr_rd(CVMX_PIP_STAT0_PRTX(port_num));
			stat1.u64 = csr_rd(CVMX_PIP_STAT1_PRTX(port_num));
			stat2.u64 = csr_rd(CVMX_PIP_STAT2_PRTX(port_num));
			stat3.u64 = csr_rd(CVMX_PIP_STAT3_PRTX(port_num));
			stat4.u64 = csr_rd(CVMX_PIP_STAT4_PRTX(port_num));
			stat5.u64 = csr_rd(CVMX_PIP_STAT5_PRTX(port_num));
			stat6.u64 = csr_rd(CVMX_PIP_STAT6_PRTX(port_num));
			stat7.u64 = csr_rd(CVMX_PIP_STAT7_PRTX(port_num));
			stat8.u64 = csr_rd(CVMX_PIP_STAT8_PRTX(port_num));
			stat9.u64 = csr_rd(CVMX_PIP_STAT9_PRTX(port_num));
			if (OCTEON_IS_OCTEON2() || OCTEON_IS_MODEL(OCTEON_CN70XX)) {
				stat10.u64 = csr_rd(CVMX_PIP_STAT10_PRTX(port_num));
				stat11.u64 = csr_rd(CVMX_PIP_STAT11_PRTX(port_num));
			}
		}
	}
	if (octeon_has_feature(OCTEON_FEATURE_PKND)) {
		int pknd = cvmx_helper_get_pknd(interface, index);

		pip_stat_inb_pktsx.u64 = csr_rd(CVMX_PIP_STAT_INB_PKTS_PKNDX(pknd));
		pip_stat_inb_octsx.u64 = csr_rd(CVMX_PIP_STAT_INB_OCTS_PKNDX(pknd));
		pip_stat_inb_errsx.u64 = csr_rd(CVMX_PIP_STAT_INB_ERRS_PKNDX(pknd));
	} else {
		pip_stat_inb_pktsx.u64 = csr_rd(CVMX_PIP_STAT_INB_PKTSX(port_num));
		pip_stat_inb_octsx.u64 = csr_rd(CVMX_PIP_STAT_INB_OCTSX(port_num));
		pip_stat_inb_errsx.u64 = csr_rd(CVMX_PIP_STAT_INB_ERRSX(port_num));
	}

	status->dropped_octets = stat0.s.drp_octs;
	status->dropped_packets = stat0.s.drp_pkts;
	status->octets = stat1.s.octs;
	status->pci_raw_packets = stat2.s.raw;
	status->packets = stat2.s.pkts;
	status->multicast_packets = stat3.s.mcst;
	status->broadcast_packets = stat3.s.bcst;
	status->len_64_packets = stat4.s.h64;
	status->len_65_127_packets = stat4.s.h65to127;
	status->len_128_255_packets = stat5.s.h128to255;
	status->len_256_511_packets = stat5.s.h256to511;
	status->len_512_1023_packets = stat6.s.h512to1023;
	status->len_1024_1518_packets = stat6.s.h1024to1518;
	status->len_1519_max_packets = stat7.s.h1519;
	status->fcs_align_err_packets = stat7.s.fcs;
	status->runt_packets = stat8.s.undersz;
	status->runt_crc_packets = stat8.s.frag;
	status->oversize_packets = stat9.s.oversz;
	status->oversize_crc_packets = stat9.s.jabber;
	if (OCTEON_IS_OCTEON2() || OCTEON_IS_MODEL(OCTEON_CN70XX)) {
		status->mcast_l2_red_packets = stat10.s.mcast;
		status->bcast_l2_red_packets = stat10.s.bcast;
		status->mcast_l3_red_packets = stat11.s.mcast;
		status->bcast_l3_red_packets = stat11.s.bcast;
	}
	status->inb_packets = pip_stat_inb_pktsx.s.pkts;
	status->inb_octets = pip_stat_inb_octsx.s.octs;
	status->inb_errors = pip_stat_inb_errsx.s.errs;
}

/**
 * Get the status counters for a port.
 *
 * @param port_num Port number (ipd_port) to get statistics for.
 * @param clear    Set to 1 to clear the counters after they are read
 * @param status   Where to put the results.
 */
static inline void cvmx_pip_get_port_status(u64 port_num, u64 clear, cvmx_pip_port_status_t *status)
{
	if (octeon_has_feature(OCTEON_FEATURE_PKI)) {
		unsigned int node = cvmx_get_node_num();

		cvmx_pki_get_port_stats(node, port_num, (struct cvmx_pki_port_stats *)status);
	} else {
		cvmx_pip_get_port_stats(port_num, clear, status);
	}
}

/**
 * Configure the hardware CRC engine
 *
 * @param interface Interface to configure (0 or 1)
 * @param invert_result
 *                 Invert the result of the CRC
 * @param reflect  Reflect
 * @param initialization_vector
 *                 CRC initialization vector
 */
static inline void cvmx_pip_config_crc(u64 interface, u64 invert_result, u64 reflect,
				       u32 initialization_vector)
{
	/* Only CN38XX & CN58XX */
}

/**
 * Clear all bits in a tag mask. This should be called on
 * startup before any calls to cvmx_pip_tag_mask_set. Each bit
 * set in the final mask represent a byte used in the packet for
 * tag generation.
 *
 * @param mask_index Which tag mask to clear (0..3)
 */
static inline void cvmx_pip_tag_mask_clear(u64 mask_index)
{
	u64 index;
	cvmx_pip_tag_incx_t pip_tag_incx;

	pip_tag_incx.u64 = 0;
	pip_tag_incx.s.en = 0;
	for (index = mask_index * 16; index < (mask_index + 1) * 16; index++)
		csr_wr(CVMX_PIP_TAG_INCX(index), pip_tag_incx.u64);
}

/**
 * Sets a range of bits in the tag mask. The tag mask is used
 * when the cvmx_pip_port_tag_cfg_t tag_mode is non zero.
 * There are four separate masks that can be configured.
 *
 * @param mask_index Which tag mask to modify (0..3)
 * @param offset     Offset into the bitmask to set bits at. Use the GCC macro
 *                   offsetof() to determine the offsets into packet headers.
 *                   For example, offsetof(ethhdr, protocol) returns the offset
 *                   of the ethernet protocol field.  The bitmask selects which bytes
 *                   to include the the tag, with bit offset X selecting byte at offset X
 *                   from the beginning of the packet data.
 * @param len        Number of bytes to include. Usually this is the sizeof()
 *                   the field.
 */
static inline void cvmx_pip_tag_mask_set(u64 mask_index, u64 offset, u64 len)
{
	while (len--) {
		cvmx_pip_tag_incx_t pip_tag_incx;
		u64 index = mask_index * 16 + offset / 8;

		pip_tag_incx.u64 = csr_rd(CVMX_PIP_TAG_INCX(index));
		pip_tag_incx.s.en |= 0x80 >> (offset & 0x7);
		csr_wr(CVMX_PIP_TAG_INCX(index), pip_tag_incx.u64);
		offset++;
	}
}

/**
 * Set byte count for Max-Sized and Min Sized frame check.
 *
 * @param interface   Which interface to set the limit
 * @param max_size    Byte count for Max-Size frame check
 */
static inline void cvmx_pip_set_frame_check(int interface, u32 max_size)
{
	cvmx_pip_frm_len_chkx_t frm_len;

	/* max_size and min_size are passed as 0, reset to default values. */
	if (max_size < 1536)
		max_size = 1536;

	/* On CN68XX frame check is enabled for a pkind n and
	   PIP_PRT_CFG[len_chk_sel] selects which set of
	   MAXLEN/MINLEN to use. */
	if (octeon_has_feature(OCTEON_FEATURE_PKND)) {
		int port;
		int num_ports = cvmx_helper_ports_on_interface(interface);

		for (port = 0; port < num_ports; port++) {
			if (octeon_has_feature(OCTEON_FEATURE_PKI)) {
				int ipd_port;

				ipd_port = cvmx_helper_get_ipd_port(interface, port);
				cvmx_pki_set_max_frm_len(ipd_port, max_size);
			} else {
				int pknd;
				int sel;
				cvmx_pip_prt_cfgx_t config;

				pknd = cvmx_helper_get_pknd(interface, port);
				config.u64 = csr_rd(CVMX_PIP_PRT_CFGX(pknd));
				sel = config.s.len_chk_sel;
				frm_len.u64 = csr_rd(CVMX_PIP_FRM_LEN_CHKX(sel));
				frm_len.s.maxlen = max_size;
				csr_wr(CVMX_PIP_FRM_LEN_CHKX(sel), frm_len.u64);
			}
		}
	}
	/* on cn6xxx and cn7xxx models, PIP_FRM_LEN_CHK0 applies to
	 *     all incoming traffic */
	else if (OCTEON_IS_OCTEON2() || OCTEON_IS_MODEL(OCTEON_CN70XX)) {
		frm_len.u64 = csr_rd(CVMX_PIP_FRM_LEN_CHKX(0));
		frm_len.s.maxlen = max_size;
		csr_wr(CVMX_PIP_FRM_LEN_CHKX(0), frm_len.u64);
	}
}

/**
 * Initialize Bit Select Extractor config. Their are 8 bit positions and valids
 * to be used when using the corresponding extractor.
 *
 * @param bit     Bit Select Extractor to use
 * @param pos     Which position to update
 * @param val     The value to update the position with
 */
static inline void cvmx_pip_set_bsel_pos(int bit, int pos, int val)
{
	cvmx_pip_bsel_ext_posx_t bsel_pos;

	/* The bit select extractor is available in CN61XX and CN68XX pass2.0 onwards. */
	if (!octeon_has_feature(OCTEON_FEATURE_BIT_EXTRACTOR))
		return;

	if (bit < 0 || bit > 3) {
		debug("ERROR: cvmx_pip_set_bsel_pos: Invalid Bit-Select Extractor (%d) passed\n",
		      bit);
		return;
	}

	bsel_pos.u64 = csr_rd(CVMX_PIP_BSEL_EXT_POSX(bit));
	switch (pos) {
	case 0:
		bsel_pos.s.pos0_val = 1;
		bsel_pos.s.pos0 = val & 0x7f;
		break;
	case 1:
		bsel_pos.s.pos1_val = 1;
		bsel_pos.s.pos1 = val & 0x7f;
		break;
	case 2:
		bsel_pos.s.pos2_val = 1;
		bsel_pos.s.pos2 = val & 0x7f;
		break;
	case 3:
		bsel_pos.s.pos3_val = 1;
		bsel_pos.s.pos3 = val & 0x7f;
		break;
	case 4:
		bsel_pos.s.pos4_val = 1;
		bsel_pos.s.pos4 = val & 0x7f;
		break;
	case 5:
		bsel_pos.s.pos5_val = 1;
		bsel_pos.s.pos5 = val & 0x7f;
		break;
	case 6:
		bsel_pos.s.pos6_val = 1;
		bsel_pos.s.pos6 = val & 0x7f;
		break;
	case 7:
		bsel_pos.s.pos7_val = 1;
		bsel_pos.s.pos7 = val & 0x7f;
		break;
	default:
		debug("Warning: cvmx_pip_set_bsel_pos: Invalid pos(%d)\n", pos);
		break;
	}
	csr_wr(CVMX_PIP_BSEL_EXT_POSX(bit), bsel_pos.u64);
}

/**
 * Initialize offset and skip values to use by bit select extractor.

 * @param bit	Bit Select Extractor to use
 * @param offset	Offset to add to extractor mem addr to get final address
 *			to lookup table.
 * @param skip		Number of bytes to skip from start of packet 0-64
 */
static inline void cvmx_pip_bsel_config(int bit, int offset, int skip)
{
	cvmx_pip_bsel_ext_cfgx_t bsel_cfg;

	/* The bit select extractor is available in CN61XX and CN68XX pass2.0 onwards. */
	if (!octeon_has_feature(OCTEON_FEATURE_BIT_EXTRACTOR))
		return;

	bsel_cfg.u64 = csr_rd(CVMX_PIP_BSEL_EXT_CFGX(bit));
	bsel_cfg.s.offset = offset;
	bsel_cfg.s.skip = skip;
	csr_wr(CVMX_PIP_BSEL_EXT_CFGX(bit), bsel_cfg.u64);
}

/**
 * Get the entry for the Bit Select Extractor Table.
 * @param work   pointer to work queue entry
 * @return       Index of the Bit Select Extractor Table
 */
static inline int cvmx_pip_get_bsel_table_index(cvmx_wqe_t *work)
{
	int bit = cvmx_wqe_get_port(work) & 0x3;
	/* Get the Bit select table index. */
	int index;
	int y;
	cvmx_pip_bsel_ext_cfgx_t bsel_cfg;
	cvmx_pip_bsel_ext_posx_t bsel_pos;

	/* The bit select extractor is available in CN61XX and CN68XX pass2.0 onwards. */
	if (!octeon_has_feature(OCTEON_FEATURE_BIT_EXTRACTOR))
		return -1;

	bsel_cfg.u64 = csr_rd(CVMX_PIP_BSEL_EXT_CFGX(bit));
	bsel_pos.u64 = csr_rd(CVMX_PIP_BSEL_EXT_POSX(bit));

	for (y = 0; y < 8; y++) {
		char *ptr = (char *)cvmx_phys_to_ptr(work->packet_ptr.s.addr);
		int bit_loc = 0;
		int bit;

		ptr += bsel_cfg.s.skip;
		switch (y) {
		case 0:
			ptr += (bsel_pos.s.pos0 >> 3);
			bit_loc = 7 - (bsel_pos.s.pos0 & 0x3);
			break;
		case 1:
			ptr += (bsel_pos.s.pos1 >> 3);
			bit_loc = 7 - (bsel_pos.s.pos1 & 0x3);
			break;
		case 2:
			ptr += (bsel_pos.s.pos2 >> 3);
			bit_loc = 7 - (bsel_pos.s.pos2 & 0x3);
			break;
		case 3:
			ptr += (bsel_pos.s.pos3 >> 3);
			bit_loc = 7 - (bsel_pos.s.pos3 & 0x3);
			break;
		case 4:
			ptr += (bsel_pos.s.pos4 >> 3);
			bit_loc = 7 - (bsel_pos.s.pos4 & 0x3);
			break;
		case 5:
			ptr += (bsel_pos.s.pos5 >> 3);
			bit_loc = 7 - (bsel_pos.s.pos5 & 0x3);
			break;
		case 6:
			ptr += (bsel_pos.s.pos6 >> 3);
			bit_loc = 7 - (bsel_pos.s.pos6 & 0x3);
			break;
		case 7:
			ptr += (bsel_pos.s.pos7 >> 3);
			bit_loc = 7 - (bsel_pos.s.pos7 & 0x3);
			break;
		}
		bit = (*ptr >> bit_loc) & 1;
		index |= bit << y;
	}
	index += bsel_cfg.s.offset;
	index &= 0x1ff;
	return index;
}

static inline int cvmx_pip_get_bsel_qos(cvmx_wqe_t *work)
{
	int index = cvmx_pip_get_bsel_table_index(work);
	cvmx_pip_bsel_tbl_entx_t bsel_tbl;

	/* The bit select extractor is available in CN61XX and CN68XX pass2.0 onwards. */
	if (!octeon_has_feature(OCTEON_FEATURE_BIT_EXTRACTOR))
		return -1;

	bsel_tbl.u64 = csr_rd(CVMX_PIP_BSEL_TBL_ENTX(index));

	return bsel_tbl.s.qos;
}

static inline int cvmx_pip_get_bsel_grp(cvmx_wqe_t *work)
{
	int index = cvmx_pip_get_bsel_table_index(work);
	cvmx_pip_bsel_tbl_entx_t bsel_tbl;

	/* The bit select extractor is available in CN61XX and CN68XX pass2.0 onwards. */
	if (!octeon_has_feature(OCTEON_FEATURE_BIT_EXTRACTOR))
		return -1;

	bsel_tbl.u64 = csr_rd(CVMX_PIP_BSEL_TBL_ENTX(index));

	return bsel_tbl.s.grp;
}

static inline int cvmx_pip_get_bsel_tt(cvmx_wqe_t *work)
{
	int index = cvmx_pip_get_bsel_table_index(work);
	cvmx_pip_bsel_tbl_entx_t bsel_tbl;

	/* The bit select extractor is available in CN61XX and CN68XX pass2.0 onwards. */
	if (!octeon_has_feature(OCTEON_FEATURE_BIT_EXTRACTOR))
		return -1;

	bsel_tbl.u64 = csr_rd(CVMX_PIP_BSEL_TBL_ENTX(index));

	return bsel_tbl.s.tt;
}

static inline int cvmx_pip_get_bsel_tag(cvmx_wqe_t *work)
{
	int index = cvmx_pip_get_bsel_table_index(work);
	int port = cvmx_wqe_get_port(work);
	int bit = port & 0x3;
	int upper_tag = 0;
	cvmx_pip_bsel_tbl_entx_t bsel_tbl;
	cvmx_pip_bsel_ext_cfgx_t bsel_cfg;
	cvmx_pip_prt_tagx_t prt_tag;

	/* The bit select extractor is available in CN61XX and CN68XX pass2.0 onwards. */
	if (!octeon_has_feature(OCTEON_FEATURE_BIT_EXTRACTOR))
		return -1;

	bsel_tbl.u64 = csr_rd(CVMX_PIP_BSEL_TBL_ENTX(index));
	bsel_cfg.u64 = csr_rd(CVMX_PIP_BSEL_EXT_CFGX(bit));

	prt_tag.u64 = csr_rd(CVMX_PIP_PRT_TAGX(port));
	if (prt_tag.s.inc_prt_flag == 0)
		upper_tag = bsel_cfg.s.upper_tag;
	return bsel_tbl.s.tag | ((bsel_cfg.s.tag << 8) & 0xff00) | ((upper_tag << 16) & 0xffff0000);
}

#endif /*  __CVMX_PIP_H__ */
