xref: /illumos-gate/usr/src/uts/common/io/xge/hal/include/xgehal-ring.h (revision 7eced415)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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://www.opensolaris.org/os/licensing.
 * 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 (c) 2002-2006 Neterion, Inc.
 */

#ifndef XGE_HAL_RING_H
#define XGE_HAL_RING_H

#include "xgehal-channel.h"
#include "xgehal-config.h"
#include "xgehal-mm.h"

__EXTERN_BEGIN_DECLS

/* HW ring configuration */
#define XGE_HAL_RING_RXDBLOCK_SIZE	0x1000

#define XGE_HAL_RXD_T_CODE_OK		0x0
#define XGE_HAL_RXD_T_CODE_PARITY	0x1
#define XGE_HAL_RXD_T_CODE_ABORT	0x2
#define XGE_HAL_RXD_T_CODE_PARITY_ABORT	0x3
#define XGE_HAL_RXD_T_CODE_RDA_FAILURE	0x4
#define XGE_HAL_RXD_T_CODE_UNKNOWN_PROTO 0x5
#define XGE_HAL_RXD_T_CODE_BAD_FCS	0x6
#define XGE_HAL_RXD_T_CODE_BUFF_SIZE	0x7
#define XGE_HAL_RXD_T_CODE_BAD_ECC	0x8
#define XGE_HAL_RXD_T_CODE_UNUSED_C	0xC
#define XGE_HAL_RXD_T_CODE_UNKNOWN	0xF

#define XGE_HAL_RING_USE_MTU		-1

/* control_1 and control_2 formatting - same for all buffer modes */
#define XGE_HAL_RXD_GET_L3_CKSUM(control_1) ((u16)(control_1>>16) & 0xFFFF)
#define XGE_HAL_RXD_GET_L4_CKSUM(control_1) ((u16)(control_1 & 0xFFFF))

#define XGE_HAL_RXD_MASK_VLAN_TAG		vBIT(0xFFFF,48,16)
#define XGE_HAL_RXD_SET_VLAN_TAG(control_2, val) control_2 |= (u16)val
#define XGE_HAL_RXD_GET_VLAN_TAG(control_2)	((u16)(control_2 & 0xFFFF))

#define XGE_HAL_RXD_POSTED_4_XFRAME		BIT(7)  /* control_1 */
#define XGE_HAL_RXD_NOT_COMPLETED               BIT(0)  /* control_2 */
#define XGE_HAL_RXD_T_CODE		(BIT(12)|BIT(13)|BIT(14)|BIT(15))
#define XGE_HAL_RXD_GET_T_CODE(control_1)	\
				((control_1 & XGE_HAL_RXD_T_CODE)>>48)
#define XGE_HAL_RXD_SET_T_CODE(control_1, val) \
				(control_1 |= (((u64)val & 0xF) << 48))

#define XGE_HAL_RXD_MASK_FRAME_TYPE		vBIT(0x3,25,2)
#define XGE_HAL_RXD_MASK_FRAME_PROTO		vBIT(0xFFFF,24,8)
#define XGE_HAL_RXD_GET_FRAME_TYPE(control_1)	\
		(u8)(0x3 & ((control_1 & XGE_HAL_RXD_MASK_FRAME_TYPE) >> 37))
#define XGE_HAL_RXD_GET_FRAME_PROTO(control_1)	\
			(u8)((control_1 & XGE_HAL_RXD_MASK_FRAME_PROTO) >> 32)
#define XGE_HAL_RXD_FRAME_PROTO_VLAN_TAGGED	BIT(24)
#define XGE_HAL_RXD_FRAME_PROTO_IPV4		BIT(27)
#define XGE_HAL_RXD_FRAME_PROTO_IPV6		BIT(28)
#define XGE_HAL_RXD_FRAME_PROTO_IP_FRAGMENTED	BIT(29)
#define XGE_HAL_RXD_FRAME_PROTO_TCP		BIT(30)
#define XGE_HAL_RXD_FRAME_PROTO_UDP		BIT(31)
#define XGE_HAL_RXD_FRAME_TCP_OR_UDP (XGE_HAL_RXD_FRAME_PROTO_TCP | \
				XGE_HAL_RXD_FRAME_PROTO_UDP)

/**
 * enum xge_hal_frame_type_e - Ethernet frame format.
 * @XGE_HAL_FRAME_TYPE_DIX: DIX (Ethernet II) format.
 * @XGE_HAL_FRAME_TYPE_LLC: LLC format.
 * @XGE_HAL_FRAME_TYPE_SNAP: SNAP format.
 * @XGE_HAL_FRAME_TYPE_IPX: IPX format.
 *
 * Ethernet frame format.
 */
typedef enum xge_hal_frame_type_e {
	XGE_HAL_FRAME_TYPE_DIX			= 0x0,
	XGE_HAL_FRAME_TYPE_LLC			= 0x1,
	XGE_HAL_FRAME_TYPE_SNAP			= 0x2,
	XGE_HAL_FRAME_TYPE_IPX			= 0x3,
} xge_hal_frame_type_e;

/**
 * enum xge_hal_frame_proto_e - Higher-layer ethernet protocols.
 * @XGE_HAL_FRAME_PROTO_VLAN_TAGGED: VLAN.
 * @XGE_HAL_FRAME_PROTO_IPV4: IPv4.
 * @XGE_HAL_FRAME_PROTO_IPV6: IPv6.
 * @XGE_HAL_FRAME_PROTO_IP_FRAGMENTED: IP fragmented.
 * @XGE_HAL_FRAME_PROTO_TCP: TCP.
 * @XGE_HAL_FRAME_PROTO_UDP: UDP.
 * @XGE_HAL_FRAME_PROTO_TCP_OR_UDP: TCP or UDP.
 *
 * Higher layer ethernet protocols and options.
 */
typedef enum xge_hal_frame_proto_e {
	XGE_HAL_FRAME_PROTO_VLAN_TAGGED		= 0x80,
	XGE_HAL_FRAME_PROTO_IPV4		= 0x10,
	XGE_HAL_FRAME_PROTO_IPV6		= 0x08,
	XGE_HAL_FRAME_PROTO_IP_FRAGMENTED	= 0x04,
	XGE_HAL_FRAME_PROTO_TCP			= 0x02,
	XGE_HAL_FRAME_PROTO_UDP			= 0x01,
	XGE_HAL_FRAME_PROTO_TCP_OR_UDP		= (XGE_HAL_FRAME_PROTO_TCP | \
						   XGE_HAL_FRAME_PROTO_UDP)
} xge_hal_frame_proto_e;

/*
 * xge_hal_ring_rxd_1_t
 */
typedef struct {
	u64 host_control;
	u64 control_1;
	u64 control_2;
#define XGE_HAL_RXD_1_MASK_BUFFER0_SIZE		vBIT(0xFFFF,0,16)
#define XGE_HAL_RXD_1_SET_BUFFER0_SIZE(val)	vBIT(val,0,16)
#define XGE_HAL_RXD_1_GET_BUFFER0_SIZE(Control_2) \
			(int)((Control_2 & vBIT(0xFFFF,0,16))>>48)
#define XGE_HAL_RXD_1_GET_RTH_VALUE(Control_2) \
			(u32)((Control_2 & vBIT(0xFFFFFFFF,16,32))>>16)
	u64 buffer0_ptr;
} xge_hal_ring_rxd_1_t;

/*
 * xge_hal_ring_rxd_3_t
 */
typedef struct {
	u64 host_control;
	u64 control_1;

	u64 control_2;
#define XGE_HAL_RXD_3_MASK_BUFFER0_SIZE		vBIT(0xFF,8,8)
#define XGE_HAL_RXD_3_SET_BUFFER0_SIZE(val)	vBIT(val,8,8)
#define XGE_HAL_RXD_3_MASK_BUFFER1_SIZE		vBIT(0xFFFF,16,16)
#define XGE_HAL_RXD_3_SET_BUFFER1_SIZE(val)	vBIT(val,16,16)
#define XGE_HAL_RXD_3_MASK_BUFFER2_SIZE		vBIT(0xFFFF,32,16)
#define XGE_HAL_RXD_3_SET_BUFFER2_SIZE(val)	vBIT(val,32,16)


#define XGE_HAL_RXD_3_GET_BUFFER0_SIZE(Control_2) \
				(int)((Control_2 & vBIT(0xFF,8,8))>>48)
#define XGE_HAL_RXD_3_GET_BUFFER1_SIZE(Control_2) \
				(int)((Control_2 & vBIT(0xFFFF,16,16))>>32)
#define XGE_HAL_RXD_3_GET_BUFFER2_SIZE(Control_2) \
				(int)((Control_2 & vBIT(0xFFFF,32,16))>>16)

	u64 buffer0_ptr;
	u64 buffer1_ptr;
	u64 buffer2_ptr;
} xge_hal_ring_rxd_3_t;

/*
 * xge_hal_ring_rxd_5_t
 */
typedef struct {
#ifdef XGE_OS_HOST_BIG_ENDIAN
	u32 host_control;
	u32 control_3;
#else
	u32 control_3;
	u32 host_control;
#endif


#define XGE_HAL_RXD_5_MASK_BUFFER3_SIZE		vBIT(0xFFFF,32,16)
#define XGE_HAL_RXD_5_SET_BUFFER3_SIZE(val)	vBIT(val,32,16)
#define XGE_HAL_RXD_5_MASK_BUFFER4_SIZE		vBIT(0xFFFF,48,16)
#define XGE_HAL_RXD_5_SET_BUFFER4_SIZE(val)	vBIT(val,48,16)

#define XGE_HAL_RXD_5_GET_BUFFER3_SIZE(Control_3) \
				(int)((Control_3 & vBIT(0xFFFF,32,16))>>16)
#define XGE_HAL_RXD_5_GET_BUFFER4_SIZE(Control_3) \
				(int)((Control_3 & vBIT(0xFFFF,48,16)))

	u64 control_1;
	u64 control_2;

#define XGE_HAL_RXD_5_MASK_BUFFER0_SIZE		vBIT(0xFFFF,0,16)
#define XGE_HAL_RXD_5_SET_BUFFER0_SIZE(val)	vBIT(val,0,16)
#define XGE_HAL_RXD_5_MASK_BUFFER1_SIZE		vBIT(0xFFFF,16,16)
#define XGE_HAL_RXD_5_SET_BUFFER1_SIZE(val)	vBIT(val,16,16)
#define XGE_HAL_RXD_5_MASK_BUFFER2_SIZE		vBIT(0xFFFF,32,16)
#define XGE_HAL_RXD_5_SET_BUFFER2_SIZE(val)	vBIT(val,32,16)


#define XGE_HAL_RXD_5_GET_BUFFER0_SIZE(Control_2) \
			(int)((Control_2 & vBIT(0xFFFF,0,16))>>48)
#define XGE_HAL_RXD_5_GET_BUFFER1_SIZE(Control_2) \
			(int)((Control_2 & vBIT(0xFFFF,16,16))>>32)
#define XGE_HAL_RXD_5_GET_BUFFER2_SIZE(Control_2) \
			(int)((Control_2 & vBIT(0xFFFF,32,16))>>16)
	u64 buffer0_ptr;
	u64 buffer1_ptr;
	u64 buffer2_ptr;
	u64 buffer3_ptr;
	u64 buffer4_ptr;
} xge_hal_ring_rxd_5_t;

#define XGE_HAL_RXD_GET_RTH_SPDM_HIT(Control_1) \
		(u8)((Control_1 & BIT(18))>>45)
#define XGE_HAL_RXD_GET_RTH_IT_HIT(Control_1) \
		(u8)((Control_1 & BIT(19))>>44)
#define XGE_HAL_RXD_GET_RTH_HASH_TYPE(Control_1) \
		(u8)((Control_1 & vBIT(0xF,20,4))>>40)

#define XGE_HAL_RXD_HASH_TYPE_NONE				0x0
#define XGE_HAL_RXD_HASH_TYPE_TCP_IPV4			0x1
#define XGE_HAL_RXD_HASH_TYPE_UDP_IPV4			0x2
#define XGE_HAL_RXD_HASH_TYPE_IPV4				0x3
#define XGE_HAL_RXD_HASH_TYPE_TCP_IPV6			0x4
#define XGE_HAL_RXD_HASH_TYPE_UDP_IPV6			0x5
#define XGE_HAL_RXD_HASH_TYPE_IPV6				0x6
#define XGE_HAL_RXD_HASH_TYPE_TCP_IPV6_EX		0x7
#define XGE_HAL_RXD_HASH_TYPE_UDP_IPV6_EX		0x8
#define XGE_HAL_RXD_HASH_TYPE_IPV6_EX			0x9

typedef u8 xge_hal_ring_block_t[XGE_HAL_RING_RXDBLOCK_SIZE];

#define XGE_HAL_RING_NEXT_BLOCK_POINTER_OFFSET	0xFF8
#define XGE_HAL_RING_MEMBLOCK_IDX_OFFSET	0xFF0

#define XGE_HAL_RING_RXD_SIZEOF(n) \
	(n==1 ? sizeof(xge_hal_ring_rxd_1_t) : \
		(n==3 ? sizeof(xge_hal_ring_rxd_3_t) : \
			sizeof(xge_hal_ring_rxd_5_t)))

#define XGE_HAL_RING_RXDS_PER_BLOCK(n) \
	(n==1 ? 127 : (n==3 ? 85 : 63))

/**
 * struct xge_hal_ring_rxd_priv_t - Receive descriptor HAL-private data.
 * @dma_addr: DMA (mapped) address of _this_ descriptor.
 * @dma_handle: DMA handle used to map the descriptor onto device.
 * @dma_offset: Descriptor's offset in the memory block. HAL allocates
 *              descriptors in memory blocks of
 *              %XGE_HAL_RING_RXDBLOCK_SIZE
 *              bytes. Each memblock is contiguous DMA-able memory. Each
 *              memblock contains 1 or more 4KB RxD blocks visible to the
 *              Xframe hardware.
 * @dma_object: DMA address and handle of the memory block that contains
 *              the descriptor. This member is used only in the "checked"
 *              version of the HAL (to enforce certain assertions);
 *              otherwise it gets compiled out.
 * @allocated: True if the descriptor is reserved, 0 otherwise. Internal usage.
 *
 * Per-receive decsriptor HAL-private data. HAL uses the space to keep DMA
 * information associated with the descriptor. Note that ULD can ask HAL
 * to allocate additional per-descriptor space for its own (ULD-specific)
 * purposes.
 */
typedef struct xge_hal_ring_rxd_priv_t {
	dma_addr_t		dma_addr;
	pci_dma_h		dma_handle;
	ptrdiff_t		dma_offset;
#ifdef XGE_DEBUG_ASSERT
	xge_hal_mempool_dma_t	*dma_object;
#endif
#ifdef XGE_OS_MEMORY_CHECK
	int			allocated;
#endif
} xge_hal_ring_rxd_priv_t;

/**
 * struct xge_hal_ring_t - Ring channel.
 * @channel: Channel "base" of this ring, the common part of all HAL
 *           channels.
 * @buffer_mode: 1, 3, or 5. The value specifies a receive buffer mode,
 *          as per Xframe User Guide.
 * @indicate_max_pkts: Maximum number of packets processed within a single
 *          interrupt. Can be used to limit the time spent inside hw
 *          interrupt.
 * @config: Ring configuration, part of device configuration
 *          (see xge_hal_device_config_t{}).
 * @rxd_size: RxD sizes for 1-, 3- or 5- buffer modes. As per Xframe spec,
 *            1-buffer mode descriptor is 32 byte long, etc.
 * @rxd_priv_size: Per RxD size reserved (by HAL) for ULD to keep per-descriptor
 *                 data (e.g., DMA handle for Solaris)
 * @rxds_per_block: Number of descriptors per hardware-defined RxD
 *                  block. Depends on the (1-,3-,5-) buffer mode.
 * @mempool: Memory pool, the pool from which descriptors get allocated.
 *           (See xge_hal_mm.h).
 * @rxdblock_priv_size: Reserved at the end of each RxD block. HAL internal
 *                      usage. Not to confuse with @rxd_priv_size.
 * @reserved_rxds_arr: Array of RxD pointers. At any point in time each
 *                     entry in this array is available for allocation
 *                     (via xge_hal_ring_dtr_reserve()) and posting.
 * @cmpl_cnt: Completion counter. Is reset to zero upon entering the ISR.
 *            Used in conjunction with @indicate_max_pkts.
 * Ring channel.
 *
 * Note: The structure is cache line aligned to better utilize
 *       CPU cache performance.
 */
typedef struct xge_hal_ring_t {
	xge_hal_channel_t		channel;
	int				buffer_mode;
	int				indicate_max_pkts;
	xge_hal_ring_config_t		*config;
	int				rxd_size;
	int				rxd_priv_size;
	int				rxds_per_block;
	xge_hal_mempool_t		*mempool;
	int				rxdblock_priv_size;
	void				**reserved_rxds_arr;
	int				cmpl_cnt;
} __xge_os_attr_cacheline_aligned xge_hal_ring_t;

/**
 * struct xge_hal_dtr_info_t - Extended information associated with a
 * completed ring descriptor.
 * @l3_cksum: Result of IP checksum check (by Xframe hardware).
 *            This field containing XGE_HAL_L3_CKSUM_OK would mean that
 *            the checksum is correct, otherwise - the datagram is
 *            corrupted.
 * @l4_cksum: Result of TCP/UDP checksum check (by Xframe hardware).
 *            This field containing XGE_HAL_L4_CKSUM_OK would mean that
 *            the checksum is correct. Otherwise - the packet is
 *            corrupted.
 * @frame: See xge_hal_frame_type_e{}.
 * @proto:    Reporting bits for various higher-layer protocols, including (but
 *	      note restricted to) TCP and UDP. See xge_hal_frame_proto_e{}.
 * @vlan:     VLAN tag extracted from the received frame.
 * @rth_value: Receive Traffic Hashing(RTH) hash value. Produced by Xframe II
 *             hardware if RTH is enabled.
 * @rth_it_hit: Set, If RTH hash value calculated by the Xframe II hardware
 *             has a matching entry in the Indirection table.
 * @rth_spdm_hit: Set, If RTH hash value calculated by the Xframe II hardware
 *             has a matching entry in the Socket Pair Direct Match table.
 * @rth_hash_type: RTH hash code of the function used to calculate the hash.
 * @reserved_pad: Unused byte.
 */
typedef struct xge_hal_dtr_info_t {
	int	l3_cksum;
	int	l4_cksum;
	int	frame; /* zero or more of xge_hal_frame_type_e flags */
	int	proto; /* zero or more of xge_hal_frame_proto_e flags */
	int	vlan;
	u32	rth_value;
	u8	rth_it_hit;
	u8	rth_spdm_hit;
	u8	rth_hash_type;
	u8	reserved_pad;
} xge_hal_dtr_info_t;

/* ========================== RING PRIVATE API ============================ */

xge_hal_status_e __hal_ring_open(xge_hal_channel_h channelh,
			xge_hal_channel_attr_t	*attr);

void __hal_ring_close(xge_hal_channel_h channelh);

void __hal_ring_hw_initialize(xge_hal_device_h devh);

void __hal_ring_mtu_set(xge_hal_device_h devh, int new_mtu);

void __hal_ring_prc_enable(xge_hal_channel_h channelh);

void __hal_ring_prc_disable(xge_hal_channel_h channelh);

xge_hal_status_e __hal_ring_initial_replenish(xge_hal_channel_t *channel,
					      xge_hal_channel_reopen_e reopen);

#if defined(XGE_DEBUG_FP) && (XGE_DEBUG_FP & XGE_DEBUG_FP_RING)
#define __HAL_STATIC_RING
#define __HAL_INLINE_RING

__HAL_STATIC_RING __HAL_INLINE_RING int
__hal_ring_block_memblock_idx(xge_hal_ring_block_t *block);

__HAL_STATIC_RING __HAL_INLINE_RING void
__hal_ring_block_memblock_idx_set(xge_hal_ring_block_t*block, int memblock_idx);

__HAL_STATIC_RING __HAL_INLINE_RING dma_addr_t
__hal_ring_block_next_pointer(xge_hal_ring_block_t *block);

__HAL_STATIC_RING __HAL_INLINE_RING void
__hal_ring_block_next_pointer_set(xge_hal_ring_block_t*block,
			dma_addr_t dma_next);

__HAL_STATIC_RING __HAL_INLINE_RING xge_hal_ring_rxd_priv_t*
__hal_ring_rxd_priv(xge_hal_ring_t *ring, xge_hal_dtr_h dtrh);

/* =========================== RING PUBLIC API ============================ */

__HAL_STATIC_RING __HAL_INLINE_RING xge_hal_status_e
xge_hal_ring_dtr_reserve(xge_hal_channel_h channelh, xge_hal_dtr_h *dtrh);

__HAL_STATIC_RING __HAL_INLINE_RING void*
xge_hal_ring_dtr_private(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_1b_set(xge_hal_dtr_h dtrh, dma_addr_t dma_pointer, int	size);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_info_get(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh,
			xge_hal_dtr_info_t *ext_info);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_1b_get(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh,
			dma_addr_t *dma_pointer, int *pkt_length);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_3b_set(xge_hal_dtr_h dtrh, dma_addr_t dma_pointers[],
			int sizes[]);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_3b_get(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh,
			dma_addr_t dma_pointers[], int sizes[]);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_5b_set(xge_hal_dtr_h dtrh, dma_addr_t dma_pointers[],
			int sizes[]);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_5b_get(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh,
			dma_addr_t dma_pointer[], int sizes[]);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_post(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_pre_post(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_post_post(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_post_post_wmb(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh);

__HAL_STATIC_RING __HAL_INLINE_RING xge_hal_status_e
xge_hal_ring_dtr_next_completed(xge_hal_channel_h channelh, xge_hal_dtr_h *dtrh,
			u8 *t_code);

__HAL_STATIC_RING __HAL_INLINE_RING void
xge_hal_ring_dtr_free(xge_hal_channel_h channelh, xge_hal_dtr_h dtrh);

__HAL_STATIC_RING __HAL_INLINE_RING	xge_hal_status_e
xge_hal_ring_is_next_dtr_completed(xge_hal_channel_h channelh);

#else /* XGE_FASTPATH_EXTERN */
#define __HAL_STATIC_RING static
#define __HAL_INLINE_RING inline
#include "xgehal-ring-fp.c"
#endif /* XGE_FASTPATH_INLINE */

__EXTERN_END_DECLS

#endif /* XGE_HAL_RING_H */