renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-22 12:14:01 +08:00
Code

staging: fsl-dpaa2/eth: Add APIs for DPNI objects

Browse Source 
Add the command build/parse APIs for operating on DPNI objects through
the DPAA2 Management Complex.

Signed-off-by: Ioana Radulescu <ruxandra.radulescu@nxp.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Ioana Radulescu 2017-04-28 04:50:28 -05:00 committed by Greg Kroah-Hartman
parent 9425f00e62
commit 0352d1d852
10 changed files with 3656 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/staging/Kconfig
View File

@ -94,6 +94,8 @@ source "drivers/staging/fbtft/Kconfig"
source "drivers/staging/fsl-mc/Kconfig"
source "drivers/staging/fsl-dpaa2/Kconfig"
source "drivers/staging/wilc1000/Kconfig"
source "drivers/staging/most/Kconfig"

1
drivers/staging/Makefile
View File

@ -36,6 +36,7 @@ obj-$(CONFIG_UNISYSSPAR) += unisys/
obj-$(CONFIG_COMMON_CLK_XLNX_CLKWZRD) += clocking-wizard/
obj-$(CONFIG_FB_TFT) += fbtft/
obj-$(CONFIG_FSL_MC_BUS) += fsl-mc/
obj-$(CONFIG_FSL_DPAA2) += fsl-dpaa2/
obj-$(CONFIG_WILC1000) += wilc1000/
obj-$(CONFIG_MOST) += most/
obj-$(CONFIG_KS7010) += ks7010/

17
drivers/staging/fsl-dpaa2/Kconfig Normal file
View File

@ -0,0 +1,17 @@
#
# Freescale DataPath Acceleration Architecture Gen2 (DPAA2) drivers
#
config FSL_DPAA2
bool "Freescale DPAA2 devices"
depends on FSL_MC_BUS
---help---
Build drivers for Freescale DataPath Acceleration
Architecture (DPAA2) family of SoCs.
config FSL_DPAA2_ETH
tristate "Freescale DPAA2 Ethernet"
depends on FSL_DPAA2 && FSL_MC_DPIO
---help---
Ethernet driver for Freescale DPAA2 SoCs, using the
Freescale MC bus driver

5
drivers/staging/fsl-dpaa2/Makefile Normal file
View File

@ -0,0 +1,5 @@
#
# Freescale DataPath Acceleration Architecture Gen2 (DPAA2) drivers
#
obj-$(CONFIG_FSL_DPAA2_ETH) += ethernet/

7
drivers/staging/fsl-dpaa2/ethernet/Makefile Normal file
View File

@ -0,0 +1,7 @@
#
# Makefile for the Freescale DPAA2 Ethernet controller
#
obj-$(CONFIG_FSL_DPAA2_ETH) += fsl-dpaa2-eth.o
fsl-dpaa2-eth-objs := dpni.o

176
drivers/staging/fsl-dpaa2/ethernet/dpkg.h Normal file
View File

@ -0,0 +1,176 @@
/* Copyright 2013-2015 Freescale Semiconductor Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the above-listed copyright holders nor the
* names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FSL_DPKG_H_
#define __FSL_DPKG_H_
#include <linux/types.h>
#include "net.h"
/* Data Path Key Generator API
* Contains initialization APIs and runtime APIs for the Key Generator
*/
/** Key Generator properties */
/**
* Number of masks per key extraction
*/
#define DPKG_NUM_OF_MASKS 4
/**
* Number of extractions per key profile
*/
#define DPKG_MAX_NUM_OF_EXTRACTS 10
/**
* enum dpkg_extract_from_hdr_type - Selecting extraction by header types
* @DPKG_FROM_HDR: Extract selected bytes from header, by offset
* @DPKG_FROM_FIELD: Extract selected bytes from header, by offset from field
* @DPKG_FULL_FIELD: Extract a full field
*/
enum dpkg_extract_from_hdr_type {
DPKG_FROM_HDR = 0,
DPKG_FROM_FIELD = 1,
DPKG_FULL_FIELD = 2
};
/**
* enum dpkg_extract_type - Enumeration for selecting extraction type
* @DPKG_EXTRACT_FROM_HDR: Extract from the header
* @DPKG_EXTRACT_FROM_DATA: Extract from data not in specific header
* @DPKG_EXTRACT_FROM_PARSE: Extract from parser-result;
* e.g. can be used to extract header existence;
* please refer to 'Parse Result definition' section in the parser BG
*/
enum dpkg_extract_type {
DPKG_EXTRACT_FROM_HDR = 0,
DPKG_EXTRACT_FROM_DATA = 1,
DPKG_EXTRACT_FROM_PARSE = 3
};
/**
* struct dpkg_mask - A structure for defining a single extraction mask
* @mask: Byte mask for the extracted content
* @offset: Offset within the extracted content
*/
struct dpkg_mask {
u8 mask;
u8 offset;
};
/**
* struct dpkg_extract - A structure for defining a single extraction
* @type: Determines how the union below is interpreted:
* DPKG_EXTRACT_FROM_HDR: selects 'from_hdr';
* DPKG_EXTRACT_FROM_DATA: selects 'from_data';
* DPKG_EXTRACT_FROM_PARSE: selects 'from_parse'
* @extract: Selects extraction method
* @num_of_byte_masks: Defines the number of valid entries in the array below;
* This is also the number of bytes to be used as masks
* @masks: Masks parameters
*/
struct dpkg_extract {
enum dpkg_extract_type type;
/**
* union extract - Selects extraction method
* @from_hdr - Used when 'type = DPKG_EXTRACT_FROM_HDR'
* @from_data - Used when 'type = DPKG_EXTRACT_FROM_DATA'
* @from_parse - Used when 'type = DPKG_EXTRACT_FROM_PARSE'
*/
union {
/**
* struct from_hdr - Used when 'type = DPKG_EXTRACT_FROM_HDR'
* @prot: Any of the supported headers
* @type: Defines the type of header extraction:
* DPKG_FROM_HDR: use size & offset below;
* DPKG_FROM_FIELD: use field, size and offset below;
* DPKG_FULL_FIELD: use field below
* @field: One of the supported fields (NH_FLD_)
*
* @size: Size in bytes
* @offset: Byte offset
* @hdr_index: Clear for cases not listed below;
* Used for protocols that may have more than a single
* header, 0 indicates an outer header;
* Supported protocols (possible values):
* NET_PROT_VLAN (0, HDR_INDEX_LAST);
* NET_PROT_MPLS (0, 1, HDR_INDEX_LAST);
* NET_PROT_IP(0, HDR_INDEX_LAST);
* NET_PROT_IPv4(0, HDR_INDEX_LAST);
* NET_PROT_IPv6(0, HDR_INDEX_LAST);
*/
struct {
enum net_prot prot;
enum dpkg_extract_from_hdr_type type;
u32 field;
u8 size;
u8 offset;
u8 hdr_index;
} from_hdr;
/**
* struct from_data - Used when 'type = DPKG_EXTRACT_FROM_DATA'
* @size: Size in bytes
* @offset: Byte offset
*/
struct {
u8 size;
u8 offset;
} from_data;
/**
* struct from_parse - Used when
* 'type = DPKG_EXTRACT_FROM_PARSE'
* @size: Size in bytes
* @offset: Byte offset
*/
struct {
u8 size;
u8 offset;
} from_parse;
} extract;
u8 num_of_byte_masks;
struct dpkg_mask masks[DPKG_NUM_OF_MASKS];
};
/**
* struct dpkg_profile_cfg - A structure for defining a full Key Generation
* profile (rule)
* @num_extracts: Defines the number of valid entries in the array below
* @extracts: Array of required extractions
*/
struct dpkg_profile_cfg {
u8 num_extracts;
struct dpkg_extract extracts[DPKG_MAX_NUM_OF_EXTRACTS];
};
#endif /* __FSL_DPKG_H_ */

541
drivers/staging/fsl-dpaa2/ethernet/dpni-cmd.h Normal file
View File

@ -0,0 +1,541 @@
/* Copyright 2013-2016 Freescale Semiconductor Inc.
* Copyright 2016 NXP
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the above-listed copyright holders nor the
* names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _FSL_DPNI_CMD_H
#define _FSL_DPNI_CMD_H
#include "dpni.h"
/* DPNI Version */
#define DPNI_VER_MAJOR 7
#define DPNI_VER_MINOR 0
#define DPNI_CMD_BASE_VERSION 1
#define DPNI_CMD_ID_OFFSET 4
#define DPNI_CMD(id) (((id) << DPNI_CMD_ID_OFFSET) | DPNI_CMD_BASE_VERSION)
#define DPNI_CMDID_OPEN DPNI_CMD(0x801)
#define DPNI_CMDID_CLOSE DPNI_CMD(0x800)
#define DPNI_CMDID_CREATE DPNI_CMD(0x901)
#define DPNI_CMDID_DESTROY DPNI_CMD(0x900)
#define DPNI_CMDID_GET_API_VERSION DPNI_CMD(0xa01)
#define DPNI_CMDID_ENABLE DPNI_CMD(0x002)
#define DPNI_CMDID_DISABLE DPNI_CMD(0x003)
#define DPNI_CMDID_GET_ATTR DPNI_CMD(0x004)
#define DPNI_CMDID_RESET DPNI_CMD(0x005)
#define DPNI_CMDID_IS_ENABLED DPNI_CMD(0x006)
#define DPNI_CMDID_SET_IRQ DPNI_CMD(0x010)
#define DPNI_CMDID_GET_IRQ DPNI_CMD(0x011)
#define DPNI_CMDID_SET_IRQ_ENABLE DPNI_CMD(0x012)
#define DPNI_CMDID_GET_IRQ_ENABLE DPNI_CMD(0x013)
#define DPNI_CMDID_SET_IRQ_MASK DPNI_CMD(0x014)
#define DPNI_CMDID_GET_IRQ_MASK DPNI_CMD(0x015)
#define DPNI_CMDID_GET_IRQ_STATUS DPNI_CMD(0x016)
#define DPNI_CMDID_CLEAR_IRQ_STATUS DPNI_CMD(0x017)
#define DPNI_CMDID_SET_POOLS DPNI_CMD(0x200)
#define DPNI_CMDID_SET_ERRORS_BEHAVIOR DPNI_CMD(0x20B)
#define DPNI_CMDID_GET_QDID DPNI_CMD(0x210)
#define DPNI_CMDID_GET_TX_DATA_OFFSET DPNI_CMD(0x212)
#define DPNI_CMDID_GET_LINK_STATE DPNI_CMD(0x215)
#define DPNI_CMDID_SET_MAX_FRAME_LENGTH DPNI_CMD(0x216)
#define DPNI_CMDID_GET_MAX_FRAME_LENGTH DPNI_CMD(0x217)
#define DPNI_CMDID_SET_LINK_CFG DPNI_CMD(0x21A)
#define DPNI_CMDID_SET_TX_SHAPING DPNI_CMD(0x21B)
#define DPNI_CMDID_SET_MCAST_PROMISC DPNI_CMD(0x220)
#define DPNI_CMDID_GET_MCAST_PROMISC DPNI_CMD(0x221)
#define DPNI_CMDID_SET_UNICAST_PROMISC DPNI_CMD(0x222)
#define DPNI_CMDID_GET_UNICAST_PROMISC DPNI_CMD(0x223)
#define DPNI_CMDID_SET_PRIM_MAC DPNI_CMD(0x224)
#define DPNI_CMDID_GET_PRIM_MAC DPNI_CMD(0x225)
#define DPNI_CMDID_ADD_MAC_ADDR DPNI_CMD(0x226)
#define DPNI_CMDID_REMOVE_MAC_ADDR DPNI_CMD(0x227)
#define DPNI_CMDID_CLR_MAC_FILTERS DPNI_CMD(0x228)
#define DPNI_CMDID_SET_RX_TC_DIST DPNI_CMD(0x235)
#define DPNI_CMDID_ADD_FS_ENT DPNI_CMD(0x244)
#define DPNI_CMDID_REMOVE_FS_ENT DPNI_CMD(0x245)
#define DPNI_CMDID_CLR_FS_ENT DPNI_CMD(0x246)
#define DPNI_CMDID_GET_STATISTICS DPNI_CMD(0x25D)
#define DPNI_CMDID_GET_QUEUE DPNI_CMD(0x25F)
#define DPNI_CMDID_SET_QUEUE DPNI_CMD(0x260)
#define DPNI_CMDID_GET_TAILDROP DPNI_CMD(0x261)
#define DPNI_CMDID_SET_TAILDROP DPNI_CMD(0x262)
#define DPNI_CMDID_GET_PORT_MAC_ADDR DPNI_CMD(0x263)
#define DPNI_CMDID_GET_BUFFER_LAYOUT DPNI_CMD(0x264)
#define DPNI_CMDID_SET_BUFFER_LAYOUT DPNI_CMD(0x265)
#define DPNI_CMDID_SET_TX_CONFIRMATION_MODE DPNI_CMD(0x266)
#define DPNI_CMDID_SET_CONGESTION_NOTIFICATION DPNI_CMD(0x267)
#define DPNI_CMDID_GET_CONGESTION_NOTIFICATION DPNI_CMD(0x268)
#define DPNI_CMDID_SET_EARLY_DROP DPNI_CMD(0x269)
#define DPNI_CMDID_GET_EARLY_DROP DPNI_CMD(0x26A)
#define DPNI_CMDID_GET_OFFLOAD DPNI_CMD(0x26B)
#define DPNI_CMDID_SET_OFFLOAD DPNI_CMD(0x26C)
/* Macros for accessing command fields smaller than 1byte */
#define DPNI_MASK(field) \
GENMASK(DPNI_##field##_SHIFT + DPNI_##field##_SIZE - 1, \
DPNI_##field##_SHIFT)
#define dpni_set_field(var, field, val) \
((var) |= (((val) << DPNI_##field##_SHIFT) & DPNI_MASK(field)))
#define dpni_get_field(var, field) \
(((var) & DPNI_MASK(field)) >> DPNI_##field##_SHIFT)
struct dpni_cmd_open {
__le32 dpni_id;
};
#define DPNI_BACKUP_POOL(val, order) (((val) & 0x1) << (order))
struct dpni_cmd_set_pools {
/* cmd word 0 */
u8 num_dpbp;
u8 backup_pool_mask;
__le16 pad;
/* cmd word 0..4 */
__le32 dpbp_id[DPNI_MAX_DPBP];
/* cmd word 4..6 */
__le16 buffer_size[DPNI_MAX_DPBP];
};
/* The enable indication is always the least significant bit */
#define DPNI_ENABLE_SHIFT 0
#define DPNI_ENABLE_SIZE 1
struct dpni_rsp_is_enabled {
u8 enabled;
};
struct dpni_rsp_get_irq {
/* response word 0 */
__le32 irq_val;
__le32 pad;
/* response word 1 */
__le64 irq_addr;
/* response word 2 */
__le32 irq_num;
__le32 type;
};
struct dpni_cmd_set_irq_enable {
u8 enable;
u8 pad[3];
u8 irq_index;
};
struct dpni_cmd_get_irq_enable {
__le32 pad;
u8 irq_index;
};
struct dpni_rsp_get_irq_enable {
u8 enabled;
};
struct dpni_cmd_set_irq_mask {
__le32 mask;
u8 irq_index;
};
struct dpni_cmd_get_irq_mask {
__le32 pad;
u8 irq_index;
};
struct dpni_rsp_get_irq_mask {
__le32 mask;
};
struct dpni_cmd_get_irq_status {
__le32 status;
u8 irq_index;
};
struct dpni_rsp_get_irq_status {
__le32 status;
};
struct dpni_cmd_clear_irq_status {
__le32 status;
u8 irq_index;
};
struct dpni_rsp_get_attr {
/* response word 0 */
__le32 options;
u8 num_queues;
u8 num_tcs;
u8 mac_filter_entries;
u8 pad0;
/* response word 1 */
u8 vlan_filter_entries;
u8 pad1;
u8 qos_entries;
u8 pad2;
__le16 fs_entries;
__le16 pad3;
/* response word 2 */
u8 qos_key_size;
u8 fs_key_size;
__le16 wriop_version;
};
#define DPNI_ERROR_ACTION_SHIFT 0
#define DPNI_ERROR_ACTION_SIZE 4
#define DPNI_FRAME_ANN_SHIFT 4
#define DPNI_FRAME_ANN_SIZE 1
struct dpni_cmd_set_errors_behavior {
__le32 errors;
/* from least significant bit: error_action:4, set_frame_annotation:1 */
u8 flags;
};
/* There are 3 separate commands for configuring Rx, Tx and Tx confirmation
* buffer layouts, but they all share the same parameters.
* If one of the functions changes, below structure needs to be split.
*/
#define DPNI_PASS_TS_SHIFT 0
#define DPNI_PASS_TS_SIZE 1
#define DPNI_PASS_PR_SHIFT 1
#define DPNI_PASS_PR_SIZE 1
#define DPNI_PASS_FS_SHIFT 2
#define DPNI_PASS_FS_SIZE 1
struct dpni_cmd_get_buffer_layout {
u8 qtype;
};
struct dpni_rsp_get_buffer_layout {
/* response word 0 */
u8 pad0[6];
/* from LSB: pass_timestamp:1, parser_result:1, frame_status:1 */
u8 flags;
u8 pad1;
/* response word 1 */
__le16 private_data_size;
__le16 data_align;
__le16 head_room;
__le16 tail_room;
};
struct dpni_cmd_set_buffer_layout {
/* cmd word 0 */
u8 qtype;
u8 pad0[3];
__le16 options;
/* from LSB: pass_timestamp:1, parser_result:1, frame_status:1 */
u8 flags;
u8 pad1;
/* cmd word 1 */
__le16 private_data_size;
__le16 data_align;
__le16 head_room;
__le16 tail_room;
};
struct dpni_cmd_set_offload {
u8 pad[3];
u8 dpni_offload;
__le32 config;
};
struct dpni_cmd_get_offload {
u8 pad[3];
u8 dpni_offload;
};
struct dpni_rsp_get_offload {
__le32 pad;
__le32 config;
};
struct dpni_cmd_get_qdid {
u8 qtype;
};
struct dpni_rsp_get_qdid {
__le16 qdid;
};
struct dpni_rsp_get_tx_data_offset {
__le16 data_offset;
};
struct dpni_cmd_get_statistics {
u8 page_number;
};
struct dpni_rsp_get_statistics {
__le64 counter[DPNI_STATISTICS_CNT];
};
struct dpni_cmd_set_link_cfg {
/* cmd word 0 */
__le64 pad0;
/* cmd word 1 */
__le32 rate;
__le32 pad1;
/* cmd word 2 */
__le64 options;
};
#define DPNI_LINK_STATE_SHIFT 0
#define DPNI_LINK_STATE_SIZE 1
struct dpni_rsp_get_link_state {
/* response word 0 */
__le32 pad0;
/* from LSB: up:1 */
u8 flags;
u8 pad1[3];
/* response word 1 */
__le32 rate;
__le32 pad2;
/* response word 2 */
__le64 options;
};
struct dpni_cmd_set_max_frame_length {
__le16 max_frame_length;
};
struct dpni_rsp_get_max_frame_length {
__le16 max_frame_length;
};
struct dpni_cmd_set_multicast_promisc {
u8 enable;
};
struct dpni_rsp_get_multicast_promisc {
u8 enabled;
};
struct dpni_cmd_set_unicast_promisc {
u8 enable;
};
struct dpni_rsp_get_unicast_promisc {
u8 enabled;
};
struct dpni_cmd_set_primary_mac_addr {
__le16 pad;
u8 mac_addr[6];
};
struct dpni_rsp_get_primary_mac_addr {
__le16 pad;
u8 mac_addr[6];
};
struct dpni_rsp_get_port_mac_addr {
__le16 pad;
u8 mac_addr[6];
};
struct dpni_cmd_add_mac_addr {
__le16 pad;
u8 mac_addr[6];
};
struct dpni_cmd_remove_mac_addr {
__le16 pad;
u8 mac_addr[6];
};
#define DPNI_UNICAST_FILTERS_SHIFT 0
#define DPNI_UNICAST_FILTERS_SIZE 1
#define DPNI_MULTICAST_FILTERS_SHIFT 1
#define DPNI_MULTICAST_FILTERS_SIZE 1
struct dpni_cmd_clear_mac_filters {
/* from LSB: unicast:1, multicast:1 */
u8 flags;
};
#define DPNI_DIST_MODE_SHIFT 0
#define DPNI_DIST_MODE_SIZE 4
#define DPNI_MISS_ACTION_SHIFT 4
#define DPNI_MISS_ACTION_SIZE 4
struct dpni_cmd_set_rx_tc_dist {
/* cmd word 0 */
__le16 dist_size;
u8 tc_id;
/* from LSB: dist_mode:4, miss_action:4 */
u8 flags;
__le16 pad0;
__le16 default_flow_id;
/* cmd word 1..5 */
__le64 pad1[5];
/* cmd word 6 */
__le64 key_cfg_iova;
};
/* dpni_set_rx_tc_dist extension (structure of the DMA-able memory at
* key_cfg_iova)
*/
struct dpni_mask_cfg {
u8 mask;
u8 offset;
};
#define DPNI_EFH_TYPE_SHIFT 0
#define DPNI_EFH_TYPE_SIZE 4
#define DPNI_EXTRACT_TYPE_SHIFT 0
#define DPNI_EXTRACT_TYPE_SIZE 4
struct dpni_dist_extract {
/* word 0 */
u8 prot;
/* EFH type stored in the 4 least significant bits */
u8 efh_type;
u8 size;
u8 offset;
__le32 field;
/* word 1 */
u8 hdr_index;
u8 constant;
u8 num_of_repeats;
u8 num_of_byte_masks;
/* Extraction type is stored in the 4 LSBs */
u8 extract_type;
u8 pad[3];
/* word 2 */
struct dpni_mask_cfg masks[4];
};
struct dpni_ext_set_rx_tc_dist {
/* extension word 0 */
u8 num_extracts;
u8 pad[7];
/* words 1..25 */
struct dpni_dist_extract extracts[DPKG_MAX_NUM_OF_EXTRACTS];
};
struct dpni_cmd_get_queue {
u8 qtype;
u8 tc;
u8 index;
};
#define DPNI_DEST_TYPE_SHIFT 0
#define DPNI_DEST_TYPE_SIZE 4
#define DPNI_STASH_CTRL_SHIFT 6
#define DPNI_STASH_CTRL_SIZE 1
#define DPNI_HOLD_ACTIVE_SHIFT 7
#define DPNI_HOLD_ACTIVE_SIZE 1
struct dpni_rsp_get_queue {
/* response word 0 */
__le64 pad0;
/* response word 1 */
__le32 dest_id;
__le16 pad1;
u8 dest_prio;
/* From LSB: dest_type:4, pad:2, flc_stash_ctrl:1, hold_active:1 */
u8 flags;
/* response word 2 */
__le64 flc;
/* response word 3 */
__le64 user_context;
/* response word 4 */
__le32 fqid;
__le16 qdbin;
};
struct dpni_cmd_set_queue {
/* cmd word 0 */
u8 qtype;
u8 tc;
u8 index;
u8 options;
__le32 pad0;
/* cmd word 1 */
__le32 dest_id;
__le16 pad1;
u8 dest_prio;
u8 flags;
/* cmd word 2 */
__le64 flc;
/* cmd word 3 */
__le64 user_context;
};
struct dpni_cmd_set_taildrop {
/* cmd word 0 */
u8 congestion_point;
u8 qtype;
u8 tc;
u8 index;
__le32 pad0;
/* cmd word 1 */
/* Only least significant bit is relevant */
u8 enable;
u8 pad1;
u8 units;
u8 pad2;
__le32 threshold;
};
struct dpni_cmd_get_taildrop {
u8 congestion_point;
u8 qtype;
u8 tc;
u8 index;
};
struct dpni_rsp_get_taildrop {
/* cmd word 0 */
__le64 pad0;
/* cmd word 1 */
/* only least significant bit is relevant */
u8 enable;
u8 pad1;
u8 units;
u8 pad2;
__le32 threshold;
};
#endif /* _FSL_DPNI_CMD_H */

1595
drivers/staging/fsl-dpaa2/ethernet/dpni.c Normal file
View File

File diff suppressed because it is too large Load Diff

832
drivers/staging/fsl-dpaa2/ethernet/dpni.h Normal file
View File

@ -0,0 +1,832 @@
/* Copyright 2013-2016 Freescale Semiconductor Inc.
* Copyright 2016 NXP
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the above-listed copyright holders nor the
* names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FSL_DPNI_H
#define __FSL_DPNI_H
#include "dpkg.h"
struct fsl_mc_io;
/**
* Data Path Network Interface API
* Contains initialization APIs and runtime control APIs for DPNI
*/
/** General DPNI macros */
/**
* Maximum number of traffic classes
*/
#define DPNI_MAX_TC 8
/**
* Maximum number of buffer pools per DPNI
*/
#define DPNI_MAX_DPBP 8
/**
* All traffic classes considered; see dpni_set_queue()
*/
#define DPNI_ALL_TCS (u8)(-1)
/**
* All flows within traffic class considered; see dpni_set_queue()
*/
#define DPNI_ALL_TC_FLOWS (u16)(-1)
/**
* Generate new flow ID; see dpni_set_queue()
*/
#define DPNI_NEW_FLOW_ID (u16)(-1)
/**
* Tx traffic is always released to a buffer pool on transmit, there are no
* resources allocated to have the frames confirmed back to the source after
* transmission.
*/
#define DPNI_OPT_TX_FRM_RELEASE 0x000001
/**
* Disables support for MAC address filtering for addresses other than primary
* MAC address. This affects both unicast and multicast. Promiscuous mode can
* still be enabled/disabled for both unicast and multicast. If promiscuous mode
* is disabled, only traffic matching the primary MAC address will be accepted.
*/
#define DPNI_OPT_NO_MAC_FILTER 0x000002
/**
* Allocate policers for this DPNI. They can be used to rate-limit traffic per
* traffic class (TC) basis.
*/
#define DPNI_OPT_HAS_POLICING 0x000004
/**
* Congestion can be managed in several ways, allowing the buffer pool to
* deplete on ingress, taildrop on each queue or use congestion groups for sets
* of queues. If set, it configures a single congestion groups across all TCs.
* If reset, a congestion group is allocated for each TC. Only relevant if the
* DPNI has multiple traffic classes.
*/
#define DPNI_OPT_SHARED_CONGESTION 0x000008
/**
* Enables TCAM for Flow Steering and QoS look-ups. If not specified, all
* look-ups are exact match. Note that TCAM is not available on LS1088 and its
* variants. Setting this bit on these SoCs will trigger an error.
*/
#define DPNI_OPT_HAS_KEY_MASKING 0x000010
/**
* Disables the flow steering table.
*/
#define DPNI_OPT_NO_FS 0x000020
int dpni_open(struct fsl_mc_io *mc_io,
u32 cmd_flags,
int dpni_id,
u16 *token);
int dpni_close(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token);
/**
* struct dpni_pools_cfg - Structure representing buffer pools configuration
* @num_dpbp: Number of DPBPs
* @pools: Array of buffer pools parameters; The number of valid entries
* must match 'num_dpbp' value
*/
struct dpni_pools_cfg {
u8 num_dpbp;
/**
* struct pools - Buffer pools parameters
* @dpbp_id: DPBP object ID
* @buffer_size: Buffer size
* @backup_pool: Backup pool
*/
struct {
int dpbp_id;
u16 buffer_size;
int backup_pool;
} pools[DPNI_MAX_DPBP];
};
int dpni_set_pools(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
const struct dpni_pools_cfg *cfg);
int dpni_enable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token);
int dpni_disable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token);
int dpni_is_enabled(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
int *en);
int dpni_reset(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token);
/**
* DPNI IRQ Index and Events
*/
/**
* IRQ index
*/
#define DPNI_IRQ_INDEX 0
/**
* IRQ event - indicates a change in link state
*/
#define DPNI_IRQ_EVENT_LINK_CHANGED 0x00000001
int dpni_set_irq_enable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u8 en);
int dpni_get_irq_enable(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u8 *en);
int dpni_set_irq_mask(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u32 mask);
int dpni_get_irq_mask(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u32 *mask);
int dpni_get_irq_status(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u32 *status);
int dpni_clear_irq_status(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 irq_index,
u32 status);
/**
* struct dpni_attr - Structure representing DPNI attributes
* @options: Any combination of the following options:
* DPNI_OPT_TX_FRM_RELEASE
* DPNI_OPT_NO_MAC_FILTER
* DPNI_OPT_HAS_POLICING
* DPNI_OPT_SHARED_CONGESTION
* DPNI_OPT_HAS_KEY_MASKING
* DPNI_OPT_NO_FS
* @num_queues: Number of Tx and Rx queues used for traffic distribution.
* @num_tcs: Number of traffic classes (TCs), reserved for the DPNI.
* @mac_filter_entries: Number of entries in the MAC address filtering table.
* @vlan_filter_entries: Number of entries in the VLAN address filtering table.
* @qos_entries: Number of entries in the QoS classification table.
* @fs_entries: Number of entries in the flow steering table.
* @qos_key_size: Size, in bytes, of the QoS look-up key. Defining a key larger
* than this when adding QoS entries will result in an error.
* @fs_key_size: Size, in bytes, of the flow steering look-up key. Defining a
* key larger than this when composing the hash + FS key will
* result in an error.
* @wriop_version: Version of WRIOP HW block. The 3 version values are stored
* on 6, 5, 5 bits respectively.
*/
struct dpni_attr {
u32 options;
u8 num_queues;
u8 num_tcs;
u8 mac_filter_entries;
u8 vlan_filter_entries;
u8 qos_entries;
u16 fs_entries;
u8 qos_key_size;
u8 fs_key_size;
u16 wriop_version;
};
int dpni_get_attributes(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
struct dpni_attr *attr);
/**
* DPNI errors
*/
/**
* Extract out of frame header error
*/
#define DPNI_ERROR_EOFHE 0x00020000
/**
* Frame length error
*/
#define DPNI_ERROR_FLE 0x00002000
/**
* Frame physical error
*/
#define DPNI_ERROR_FPE 0x00001000
/**
* Parsing header error
*/
#define DPNI_ERROR_PHE 0x00000020
/**
* Parser L3 checksum error
*/
#define DPNI_ERROR_L3CE 0x00000004
/**
* Parser L3 checksum error
*/
#define DPNI_ERROR_L4CE 0x00000001
/**
* enum dpni_error_action - Defines DPNI behavior for errors
* @DPNI_ERROR_ACTION_DISCARD: Discard the frame
* @DPNI_ERROR_ACTION_CONTINUE: Continue with the normal flow
* @DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE: Send the frame to the error queue
*/
enum dpni_error_action {
DPNI_ERROR_ACTION_DISCARD = 0,
DPNI_ERROR_ACTION_CONTINUE = 1,
DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE = 2
};
/**
* struct dpni_error_cfg - Structure representing DPNI errors treatment
* @errors: Errors mask; use 'DPNI_ERROR__<X>
* @error_action: The desired action for the errors mask
* @set_frame_annotation: Set to '1' to mark the errors in frame annotation
* status (FAS); relevant only for the non-discard action
*/
struct dpni_error_cfg {
u32 errors;
enum dpni_error_action error_action;
int set_frame_annotation;
};
int dpni_set_errors_behavior(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
struct dpni_error_cfg *cfg);
/**
* DPNI buffer layout modification options
*/
/**
* Select to modify the time-stamp setting
*/
#define DPNI_BUF_LAYOUT_OPT_TIMESTAMP 0x00000001
/**
* Select to modify the parser-result setting; not applicable for Tx
*/
#define DPNI_BUF_LAYOUT_OPT_PARSER_RESULT 0x00000002
/**
* Select to modify the frame-status setting
*/
#define DPNI_BUF_LAYOUT_OPT_FRAME_STATUS 0x00000004
/**
* Select to modify the private-data-size setting
*/
#define DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE 0x00000008
/**
* Select to modify the data-alignment setting
*/
#define DPNI_BUF_LAYOUT_OPT_DATA_ALIGN 0x00000010
/**
* Select to modify the data-head-room setting
*/
#define DPNI_BUF_LAYOUT_OPT_DATA_HEAD_ROOM 0x00000020
/**
* Select to modify the data-tail-room setting
*/
#define DPNI_BUF_LAYOUT_OPT_DATA_TAIL_ROOM 0x00000040
/**
* struct dpni_buffer_layout - Structure representing DPNI buffer layout
* @options: Flags representing the suggested modifications to the buffer
* layout; Use any combination of 'DPNI_BUF_LAYOUT_OPT_<X>' flags
* @pass_timestamp: Pass timestamp value
* @pass_parser_result: Pass parser results
* @pass_frame_status: Pass frame status
* @private_data_size: Size kept for private data (in bytes)
* @data_align: Data alignment
* @data_head_room: Data head room
* @data_tail_room: Data tail room
*/
struct dpni_buffer_layout {
u32 options;
int pass_timestamp;
int pass_parser_result;
int pass_frame_status;
u16 private_data_size;
u16 data_align;
u16 data_head_room;
u16 data_tail_room;
};
/**
* enum dpni_queue_type - Identifies a type of queue targeted by the command
* @DPNI_QUEUE_RX: Rx queue
* @DPNI_QUEUE_TX: Tx queue
* @DPNI_QUEUE_TX_CONFIRM: Tx confirmation queue
* @DPNI_QUEUE_RX_ERR: Rx error queue
*/enum dpni_queue_type {
DPNI_QUEUE_RX,
DPNI_QUEUE_TX,
DPNI_QUEUE_TX_CONFIRM,
DPNI_QUEUE_RX_ERR,
};
int dpni_get_buffer_layout(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_queue_type qtype,
struct dpni_buffer_layout *layout);
int dpni_set_buffer_layout(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_queue_type qtype,
const struct dpni_buffer_layout *layout);
/**
* enum dpni_offload - Identifies a type of offload targeted by the command
* @DPNI_OFF_RX_L3_CSUM: Rx L3 checksum validation
* @DPNI_OFF_RX_L4_CSUM: Rx L4 checksum validation
* @DPNI_OFF_TX_L3_CSUM: Tx L3 checksum generation
* @DPNI_OFF_TX_L4_CSUM: Tx L4 checksum generation
*/
enum dpni_offload {
DPNI_OFF_RX_L3_CSUM,
DPNI_OFF_RX_L4_CSUM,
DPNI_OFF_TX_L3_CSUM,
DPNI_OFF_TX_L4_CSUM,
};
int dpni_set_offload(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_offload type,
u32 config);
int dpni_get_offload(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_offload type,
u32 *config);
int dpni_get_qdid(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_queue_type qtype,
u16 *qdid);
int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u16 *data_offset);
#define DPNI_STATISTICS_CNT 7
union dpni_statistics {
/**
* struct page_0 - Page_0 statistics structure
* @ingress_all_frames: Ingress frame count
* @ingress_all_bytes: Ingress byte count
* @ingress_multicast_frames: Ingress multicast frame count
* @ingress_multicast_bytes: Ingress multicast byte count
* @ingress_broadcast_frames: Ingress broadcast frame count
* @ingress_broadcast_bytes: Ingress broadcast byte count
*/
struct {
u64 ingress_all_frames;
u64 ingress_all_bytes;
u64 ingress_multicast_frames;
u64 ingress_multicast_bytes;
u64 ingress_broadcast_frames;
u64 ingress_broadcast_bytes;
} page_0;
/**
* struct page_1 - Page_1 statistics structure
* @egress_all_frames: Egress frame count
* @egress_all_bytes: Egress byte count
* @egress_multicast_frames: Egress multicast frame count
* @egress_multicast_bytes: Egress multicast byte count
* @egress_broadcast_frames: Egress broadcast frame count
* @egress_broadcast_bytes: Egress broadcast byte count
*/
struct {
u64 egress_all_frames;
u64 egress_all_bytes;
u64 egress_multicast_frames;
u64 egress_multicast_bytes;
u64 egress_broadcast_frames;
u64 egress_broadcast_bytes;
} page_1;
/**
* struct page_2 - Page_2 statistics structure
* @ingress_filtered_frames: Ingress filtered frame count
* @ingress_discarded_frames: Ingress discarded frame count
* @ingress_nobuffer_discards: Ingress discarded frame count
* due to lack of buffers
* @egress_discarded_frames: Egress discarded frame count
* @egress_confirmed_frames: Egress confirmed frame count
*/
struct {
u64 ingress_filtered_frames;
u64 ingress_discarded_frames;
u64 ingress_nobuffer_discards;
u64 egress_discarded_frames;
u64 egress_confirmed_frames;
} page_2;
/**
* struct raw - raw statistics structure
*/
struct {
u64 counter[DPNI_STATISTICS_CNT];
} raw;
};
int dpni_get_statistics(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 page,
union dpni_statistics *stat);
/**
* Enable auto-negotiation
*/
#define DPNI_LINK_OPT_AUTONEG 0x0000000000000001ULL
/**
* Enable half-duplex mode
*/
#define DPNI_LINK_OPT_HALF_DUPLEX 0x0000000000000002ULL
/**
* Enable pause frames
*/
#define DPNI_LINK_OPT_PAUSE 0x0000000000000004ULL
/**
* Enable a-symmetric pause frames
*/
#define DPNI_LINK_OPT_ASYM_PAUSE 0x0000000000000008ULL
/**
* struct - Structure representing DPNI link configuration
* @rate: Rate
* @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
*/
struct dpni_link_cfg {
u32 rate;
u64 options;
};
int dpni_set_link_cfg(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
const struct dpni_link_cfg *cfg);
/**
* struct dpni_link_state - Structure representing DPNI link state
* @rate: Rate
* @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
* @up: Link state; '0' for down, '1' for up
*/
struct dpni_link_state {
u32 rate;
u64 options;
int up;
};
int dpni_get_link_state(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
struct dpni_link_state *state);
int dpni_set_max_frame_length(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u16 max_frame_length);
int dpni_get_max_frame_length(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u16 *max_frame_length);
int dpni_set_multicast_promisc(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
int en);
int dpni_get_multicast_promisc(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
int *en);
int dpni_set_unicast_promisc(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
int en);
int dpni_get_unicast_promisc(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
int *en);
int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
const u8 mac_addr[6]);
int dpni_get_primary_mac_addr(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 mac_addr[6]);
int dpni_get_port_mac_addr(struct fsl_mc_io *mc_io,
u32 cm_flags,
u16 token,
u8 mac_addr[6]);
int dpni_add_mac_addr(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
const u8 mac_addr[6]);
int dpni_remove_mac_addr(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
const u8 mac_addr[6]);
int dpni_clear_mac_filters(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
int unicast,
int multicast);
/**
* enum dpni_dist_mode - DPNI distribution mode
* @DPNI_DIST_MODE_NONE: No distribution
* @DPNI_DIST_MODE_HASH: Use hash distribution; only relevant if
* the 'DPNI_OPT_DIST_HASH' option was set at DPNI creation
* @DPNI_DIST_MODE_FS: Use explicit flow steering; only relevant if
* the 'DPNI_OPT_DIST_FS' option was set at DPNI creation
*/
enum dpni_dist_mode {
DPNI_DIST_MODE_NONE = 0,
DPNI_DIST_MODE_HASH = 1,
DPNI_DIST_MODE_FS = 2
};
/**
* enum dpni_fs_miss_action - DPNI Flow Steering miss action
* @DPNI_FS_MISS_DROP: In case of no-match, drop the frame
* @DPNI_FS_MISS_EXPLICIT_FLOWID: In case of no-match, use explicit flow-id
* @DPNI_FS_MISS_HASH: In case of no-match, distribute using hash
*/
enum dpni_fs_miss_action {
DPNI_FS_MISS_DROP = 0,
DPNI_FS_MISS_EXPLICIT_FLOWID = 1,
DPNI_FS_MISS_HASH = 2
};
/**
* struct dpni_fs_tbl_cfg - Flow Steering table configuration
* @miss_action: Miss action selection
* @default_flow_id: Used when 'miss_action = DPNI_FS_MISS_EXPLICIT_FLOWID'
*/
struct dpni_fs_tbl_cfg {
enum dpni_fs_miss_action miss_action;
u16 default_flow_id;
};
int dpni_prepare_key_cfg(const struct dpkg_profile_cfg *cfg,
u8 *key_cfg_buf);
/**
* struct dpni_rx_tc_dist_cfg - Rx traffic class distribution configuration
* @dist_size: Set the distribution size;
* supported values: 1,2,3,4,6,7,8,12,14,16,24,28,32,48,56,64,96,
* 112,128,192,224,256,384,448,512,768,896,1024
* @dist_mode: Distribution mode
* @key_cfg_iova: I/O virtual address of 256 bytes DMA-able memory filled with
* the extractions to be used for the distribution key by calling
* dpni_prepare_key_cfg() relevant only when
* 'dist_mode != DPNI_DIST_MODE_NONE', otherwise it can be '0'
* @fs_cfg: Flow Steering table configuration; only relevant if
* 'dist_mode = DPNI_DIST_MODE_FS'
*/
struct dpni_rx_tc_dist_cfg {
u16 dist_size;
enum dpni_dist_mode dist_mode;
u64 key_cfg_iova;
struct dpni_fs_tbl_cfg fs_cfg;
};
int dpni_set_rx_tc_dist(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
u8 tc_id,
const struct dpni_rx_tc_dist_cfg *cfg);
/**
* enum dpni_dest - DPNI destination types
* @DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and
* does not generate FQDAN notifications; user is expected to
* dequeue from the queue based on polling or other user-defined
* method
* @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
* notifications to the specified DPIO; user is expected to dequeue
* from the queue only after notification is received
* @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate
* FQDAN notifications, but is connected to the specified DPCON
* object; user is expected to dequeue from the DPCON channel
*/
enum dpni_dest {
DPNI_DEST_NONE = 0,
DPNI_DEST_DPIO = 1,
DPNI_DEST_DPCON = 2
};
/**
* struct dpni_queue - Queue structure
* @user_context: User data, presented to the user along with any frames from
* this queue. Not relevant for Tx queues.
*/
struct dpni_queue {
/**
* struct destination - Destination structure
* @id: ID of the destination, only relevant if DEST_TYPE is > 0.
* Identifies either a DPIO or a DPCON object. Not relevant for
* Tx queues.
* @type: May be one of the following:
* 0 - No destination, queue can be manually queried, but will not
* push traffic or notifications to a DPIO;
* 1 - The destination is a DPIO. When traffic becomes available in
* the queue a FQDAN (FQ data available notification) will be
* generated to selected DPIO;
* 2 - The destination is a DPCON. The queue is associated with a
* DPCON object for the purpose of scheduling between multiple
* queues. The DPCON may be independently configured to
* generate notifications. Not relevant for Tx queues.
* @hold_active: Hold active, maintains a queue scheduled for longer
* in a DPIO during dequeue to reduce spread of traffic.
* Only relevant if queues are not affined to a single DPIO.
*/
struct {
u16 id;
enum dpni_dest type;
char hold_active;
u8 priority;
} destination;
u64 user_context;
struct {
u64 value;
char stash_control;
} flc;
};
/**
* struct dpni_queue_id - Queue identification, used for enqueue commands
* or queue control
* @fqid: FQID used for enqueueing to and/or configuration of this specific FQ
* @qdbin: Queueing bin, used to enqueue using QDID, DQBIN, QPRI. Only relevant
* for Tx queues.
*/
struct dpni_queue_id {
u32 fqid;
u16 qdbin;
};
/**
* Set User Context
*/
#define DPNI_QUEUE_OPT_USER_CTX 0x00000001
#define DPNI_QUEUE_OPT_DEST 0x00000002
#define DPNI_QUEUE_OPT_FLC 0x00000004
#define DPNI_QUEUE_OPT_HOLD_ACTIVE 0x00000008
int dpni_set_queue(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_queue_type qtype,
u8 tc,
u8 index,
u8 options,
const struct dpni_queue *queue);
int dpni_get_queue(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_queue_type qtype,
u8 tc,
u8 index,
struct dpni_queue *queue,
struct dpni_queue_id *qid);
/**
* enum dpni_congestion_unit - DPNI congestion units
* @DPNI_CONGESTION_UNIT_BYTES: bytes units
* @DPNI_CONGESTION_UNIT_FRAMES: frames units
*/
enum dpni_congestion_unit {
DPNI_CONGESTION_UNIT_BYTES = 0,
DPNI_CONGESTION_UNIT_FRAMES
};
/**
* enum dpni_congestion_point - Structure representing congestion point
* @DPNI_CP_QUEUE: Set taildrop per queue, identified by QUEUE_TYPE, TC and
* QUEUE_INDEX
* @DPNI_CP_GROUP: Set taildrop per queue group. Depending on options used to
* define the DPNI this can be either per TC (default) or per
* interface (DPNI_OPT_SHARED_CONGESTION set at DPNI create).
* QUEUE_INDEX is ignored if this type is used.
*/
enum dpni_congestion_point {
DPNI_CP_QUEUE,
DPNI_CP_GROUP,
};
/**
* struct dpni_taildrop - Structure representing the taildrop
* @enable: Indicates whether the taildrop is active or not.
* @units: Indicates the unit of THRESHOLD. Queue taildrop only supports
* byte units, this field is ignored and assumed = 0 if
* CONGESTION_POINT is 0.
* @threshold: Threshold value, in units identified by UNITS field. Value 0
* cannot be used as a valid taildrop threshold, THRESHOLD must
* be > 0 if the taildrop is enabled.
*/
struct dpni_taildrop {
char enable;
enum dpni_congestion_unit units;
u32 threshold;
};
int dpni_set_taildrop(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_congestion_point cg_point,
enum dpni_queue_type q_type,
u8 tc,
u8 q_index,
struct dpni_taildrop *taildrop);
int dpni_get_taildrop(struct fsl_mc_io *mc_io,
u32 cmd_flags,
u16 token,
enum dpni_congestion_point cg_point,
enum dpni_queue_type q_type,
u8 tc,
u8 q_index,
struct dpni_taildrop *taildrop);
/**
* struct dpni_rule_cfg - Rule configuration for table lookup
* @key_iova: I/O virtual address of the key (must be in DMA-able memory)
* @mask_iova: I/O virtual address of the mask (must be in DMA-able memory)
* @key_size: key and mask size (in bytes)
*/
struct dpni_rule_cfg {
u64 key_iova;
u64 mask_iova;
u8 key_size;
};
#endif /* __FSL_DPNI_H */

480
drivers/staging/fsl-dpaa2/ethernet/net.h Normal file
View File

@ -0,0 +1,480 @@
/* Copyright 2013-2015 Freescale Semiconductor Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the above-listed copyright holders nor the
* names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
*
* ALTERNATIVELY, this software may be distributed under the terms of the
* GNU General Public License ("GPL") as published by the Free Software
* Foundation, either version 2 of that License or (at your option) any
* later version.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FSL_NET_H
#define __FSL_NET_H
#define LAST_HDR_INDEX 0xFFFFFFFF
/*****************************************************************************/
/* Protocol fields */
/*****************************************************************************/
/************************* Ethernet fields *********************************/
#define NH_FLD_ETH_DA (1)
#define NH_FLD_ETH_SA (NH_FLD_ETH_DA << 1)
#define NH_FLD_ETH_LENGTH (NH_FLD_ETH_DA << 2)
#define NH_FLD_ETH_TYPE (NH_FLD_ETH_DA << 3)
#define NH_FLD_ETH_FINAL_CKSUM (NH_FLD_ETH_DA << 4)
#define NH_FLD_ETH_PADDING (NH_FLD_ETH_DA << 5)
#define NH_FLD_ETH_ALL_FIELDS ((NH_FLD_ETH_DA << 6) - 1)
#define NH_FLD_ETH_ADDR_SIZE 6
/*************************** VLAN fields ***********************************/
#define NH_FLD_VLAN_VPRI (1)
#define NH_FLD_VLAN_CFI (NH_FLD_VLAN_VPRI << 1)
#define NH_FLD_VLAN_VID (NH_FLD_VLAN_VPRI << 2)
#define NH_FLD_VLAN_LENGTH (NH_FLD_VLAN_VPRI << 3)
#define NH_FLD_VLAN_TYPE (NH_FLD_VLAN_VPRI << 4)
#define NH_FLD_VLAN_ALL_FIELDS ((NH_FLD_VLAN_VPRI << 5) - 1)
#define NH_FLD_VLAN_TCI (NH_FLD_VLAN_VPRI | \
NH_FLD_VLAN_CFI | \
NH_FLD_VLAN_VID)
/************************ IP (generic) fields ******************************/
#define NH_FLD_IP_VER (1)
#define NH_FLD_IP_DSCP (NH_FLD_IP_VER << 2)
#define NH_FLD_IP_ECN (NH_FLD_IP_VER << 3)
#define NH_FLD_IP_PROTO (NH_FLD_IP_VER << 4)
#define NH_FLD_IP_SRC (NH_FLD_IP_VER << 5)
#define NH_FLD_IP_DST (NH_FLD_IP_VER << 6)
#define NH_FLD_IP_TOS_TC (NH_FLD_IP_VER << 7)
#define NH_FLD_IP_ID (NH_FLD_IP_VER << 8)
#define NH_FLD_IP_ALL_FIELDS ((NH_FLD_IP_VER << 9) - 1)
#define NH_FLD_IP_PROTO_SIZE 1
/***************************** IPV4 fields *********************************/
#define NH_FLD_IPV4_VER (1)
#define NH_FLD_IPV4_HDR_LEN (NH_FLD_IPV4_VER << 1)
#define NH_FLD_IPV4_TOS (NH_FLD_IPV4_VER << 2)
#define NH_FLD_IPV4_TOTAL_LEN (NH_FLD_IPV4_VER << 3)
#define NH_FLD_IPV4_ID (NH_FLD_IPV4_VER << 4)
#define NH_FLD_IPV4_FLAG_D (NH_FLD_IPV4_VER << 5)
#define NH_FLD_IPV4_FLAG_M (NH_FLD_IPV4_VER << 6)
#define NH_FLD_IPV4_OFFSET (NH_FLD_IPV4_VER << 7)
#define NH_FLD_IPV4_TTL (NH_FLD_IPV4_VER << 8)
#define NH_FLD_IPV4_PROTO (NH_FLD_IPV4_VER << 9)
#define NH_FLD_IPV4_CKSUM (NH_FLD_IPV4_VER << 10)
#define NH_FLD_IPV4_SRC_IP (NH_FLD_IPV4_VER << 11)
#define NH_FLD_IPV4_DST_IP (NH_FLD_IPV4_VER << 12)
#define NH_FLD_IPV4_OPTS (NH_FLD_IPV4_VER << 13)
#define NH_FLD_IPV4_OPTS_COUNT (NH_FLD_IPV4_VER << 14)
#define NH_FLD_IPV4_ALL_FIELDS ((NH_FLD_IPV4_VER << 15) - 1)
#define NH_FLD_IPV4_ADDR_SIZE 4
#define NH_FLD_IPV4_PROTO_SIZE 1
/***************************** IPV6 fields *********************************/
#define NH_FLD_IPV6_VER (1)
#define NH_FLD_IPV6_TC (NH_FLD_IPV6_VER << 1)
#define NH_FLD_IPV6_SRC_IP (NH_FLD_IPV6_VER << 2)
#define NH_FLD_IPV6_DST_IP (NH_FLD_IPV6_VER << 3)
#define NH_FLD_IPV6_NEXT_HDR (NH_FLD_IPV6_VER << 4)
#define NH_FLD_IPV6_FL (NH_FLD_IPV6_VER << 5)
#define NH_FLD_IPV6_HOP_LIMIT (NH_FLD_IPV6_VER << 6)
#define NH_FLD_IPV6_ID (NH_FLD_IPV6_VER << 7)
#define NH_FLD_IPV6_ALL_FIELDS ((NH_FLD_IPV6_VER << 8) - 1)
#define NH_FLD_IPV6_ADDR_SIZE 16
#define NH_FLD_IPV6_NEXT_HDR_SIZE 1
/***************************** ICMP fields *********************************/
#define NH_FLD_ICMP_TYPE (1)
#define NH_FLD_ICMP_CODE (NH_FLD_ICMP_TYPE << 1)
#define NH_FLD_ICMP_CKSUM (NH_FLD_ICMP_TYPE << 2)
#define NH_FLD_ICMP_ID (NH_FLD_ICMP_TYPE << 3)
#define NH_FLD_ICMP_SQ_NUM (NH_FLD_ICMP_TYPE << 4)
#define NH_FLD_ICMP_ALL_FIELDS ((NH_FLD_ICMP_TYPE << 5) - 1)
#define NH_FLD_ICMP_CODE_SIZE 1
#define NH_FLD_ICMP_TYPE_SIZE 1
/***************************** IGMP fields *********************************/
#define NH_FLD_IGMP_VERSION (1)
#define NH_FLD_IGMP_TYPE (NH_FLD_IGMP_VERSION << 1)
#define NH_FLD_IGMP_CKSUM (NH_FLD_IGMP_VERSION << 2)
#define NH_FLD_IGMP_DATA (NH_FLD_IGMP_VERSION << 3)
#define NH_FLD_IGMP_ALL_FIELDS ((NH_FLD_IGMP_VERSION << 4) - 1)
/***************************** TCP fields **********************************/
#define NH_FLD_TCP_PORT_SRC (1)
#define NH_FLD_TCP_PORT_DST (NH_FLD_TCP_PORT_SRC << 1)
#define NH_FLD_TCP_SEQ (NH_FLD_TCP_PORT_SRC << 2)
#define NH_FLD_TCP_ACK (NH_FLD_TCP_PORT_SRC << 3)
#define NH_FLD_TCP_OFFSET (NH_FLD_TCP_PORT_SRC << 4)
#define NH_FLD_TCP_FLAGS (NH_FLD_TCP_PORT_SRC << 5)
#define NH_FLD_TCP_WINDOW (NH_FLD_TCP_PORT_SRC << 6)
#define NH_FLD_TCP_CKSUM (NH_FLD_TCP_PORT_SRC << 7)
#define NH_FLD_TCP_URGPTR (NH_FLD_TCP_PORT_SRC << 8)
#define NH_FLD_TCP_OPTS (NH_FLD_TCP_PORT_SRC << 9)
#define NH_FLD_TCP_OPTS_COUNT (NH_FLD_TCP_PORT_SRC << 10)
#define NH_FLD_TCP_ALL_FIELDS ((NH_FLD_TCP_PORT_SRC << 11) - 1)
#define NH_FLD_TCP_PORT_SIZE 2
/***************************** UDP fields **********************************/
#define NH_FLD_UDP_PORT_SRC (1)
#define NH_FLD_UDP_PORT_DST (NH_FLD_UDP_PORT_SRC << 1)
#define NH_FLD_UDP_LEN (NH_FLD_UDP_PORT_SRC << 2)
#define NH_FLD_UDP_CKSUM (NH_FLD_UDP_PORT_SRC << 3)
#define NH_FLD_UDP_ALL_FIELDS ((NH_FLD_UDP_PORT_SRC << 4) - 1)
#define NH_FLD_UDP_PORT_SIZE 2
/*************************** UDP-lite fields *******************************/
#define NH_FLD_UDP_LITE_PORT_SRC (1)
#define NH_FLD_UDP_LITE_PORT_DST (NH_FLD_UDP_LITE_PORT_SRC << 1)
#define NH_FLD_UDP_LITE_ALL_FIELDS \
((NH_FLD_UDP_LITE_PORT_SRC << 2) - 1)
#define NH_FLD_UDP_LITE_PORT_SIZE 2
/*************************** UDP-encap-ESP fields **************************/
#define NH_FLD_UDP_ENC_ESP_PORT_SRC (1)
#define NH_FLD_UDP_ENC_ESP_PORT_DST (NH_FLD_UDP_ENC_ESP_PORT_SRC << 1)
#define NH_FLD_UDP_ENC_ESP_LEN (NH_FLD_UDP_ENC_ESP_PORT_SRC << 2)
#define NH_FLD_UDP_ENC_ESP_CKSUM (NH_FLD_UDP_ENC_ESP_PORT_SRC << 3)
#define NH_FLD_UDP_ENC_ESP_SPI (NH_FLD_UDP_ENC_ESP_PORT_SRC << 4)
#define NH_FLD_UDP_ENC_ESP_SEQUENCE_NUM (NH_FLD_UDP_ENC_ESP_PORT_SRC << 5)
#define NH_FLD_UDP_ENC_ESP_ALL_FIELDS \
((NH_FLD_UDP_ENC_ESP_PORT_SRC << 6) - 1)
#define NH_FLD_UDP_ENC_ESP_PORT_SIZE 2
#define NH_FLD_UDP_ENC_ESP_SPI_SIZE 4
/***************************** SCTP fields *********************************/
#define NH_FLD_SCTP_PORT_SRC (1)
#define NH_FLD_SCTP_PORT_DST (NH_FLD_SCTP_PORT_SRC << 1)
#define NH_FLD_SCTP_VER_TAG (NH_FLD_SCTP_PORT_SRC << 2)
#define NH_FLD_SCTP_CKSUM (NH_FLD_SCTP_PORT_SRC << 3)
#define NH_FLD_SCTP_ALL_FIELDS ((NH_FLD_SCTP_PORT_SRC << 4) - 1)
#define NH_FLD_SCTP_PORT_SIZE 2
/***************************** DCCP fields *********************************/
#define NH_FLD_DCCP_PORT_SRC (1)
#define NH_FLD_DCCP_PORT_DST (NH_FLD_DCCP_PORT_SRC << 1)
#define NH_FLD_DCCP_ALL_FIELDS ((NH_FLD_DCCP_PORT_SRC << 2) - 1)
#define NH_FLD_DCCP_PORT_SIZE 2
/***************************** IPHC fields *********************************/
#define NH_FLD_IPHC_CID (1)
#define NH_FLD_IPHC_CID_TYPE (NH_FLD_IPHC_CID << 1)
#define NH_FLD_IPHC_HCINDEX (NH_FLD_IPHC_CID << 2)
#define NH_FLD_IPHC_GEN (NH_FLD_IPHC_CID << 3)
#define NH_FLD_IPHC_D_BIT (NH_FLD_IPHC_CID << 4)
#define NH_FLD_IPHC_ALL_FIELDS ((NH_FLD_IPHC_CID << 5) - 1)
/***************************** SCTP fields *********************************/
#define NH_FLD_SCTP_CHUNK_DATA_TYPE (1)
#define NH_FLD_SCTP_CHUNK_DATA_FLAGS (NH_FLD_SCTP_CHUNK_DATA_TYPE << 1)
#define NH_FLD_SCTP_CHUNK_DATA_LENGTH (NH_FLD_SCTP_CHUNK_DATA_TYPE << 2)
#define NH_FLD_SCTP_CHUNK_DATA_TSN (NH_FLD_SCTP_CHUNK_DATA_TYPE << 3)
#define NH_FLD_SCTP_CHUNK_DATA_STREAM_ID (NH_FLD_SCTP_CHUNK_DATA_TYPE << 4)
#define NH_FLD_SCTP_CHUNK_DATA_STREAM_SQN (NH_FLD_SCTP_CHUNK_DATA_TYPE << 5)
#define NH_FLD_SCTP_CHUNK_DATA_PAYLOAD_PID (NH_FLD_SCTP_CHUNK_DATA_TYPE << 6)
#define NH_FLD_SCTP_CHUNK_DATA_UNORDERED (NH_FLD_SCTP_CHUNK_DATA_TYPE << 7)
#define NH_FLD_SCTP_CHUNK_DATA_BEGGINING (NH_FLD_SCTP_CHUNK_DATA_TYPE << 8)
#define NH_FLD_SCTP_CHUNK_DATA_END (NH_FLD_SCTP_CHUNK_DATA_TYPE << 9)
#define NH_FLD_SCTP_CHUNK_DATA_ALL_FIELDS \
((NH_FLD_SCTP_CHUNK_DATA_TYPE << 10) - 1)
/*************************** L2TPV2 fields *********************************/
#define NH_FLD_L2TPV2_TYPE_BIT (1)
#define NH_FLD_L2TPV2_LENGTH_BIT (NH_FLD_L2TPV2_TYPE_BIT << 1)
#define NH_FLD_L2TPV2_SEQUENCE_BIT (NH_FLD_L2TPV2_TYPE_BIT << 2)
#define NH_FLD_L2TPV2_OFFSET_BIT (NH_FLD_L2TPV2_TYPE_BIT << 3)
#define NH_FLD_L2TPV2_PRIORITY_BIT (NH_FLD_L2TPV2_TYPE_BIT << 4)
#define NH_FLD_L2TPV2_VERSION (NH_FLD_L2TPV2_TYPE_BIT << 5)
#define NH_FLD_L2TPV2_LEN (NH_FLD_L2TPV2_TYPE_BIT << 6)
#define NH_FLD_L2TPV2_TUNNEL_ID (NH_FLD_L2TPV2_TYPE_BIT << 7)
#define NH_FLD_L2TPV2_SESSION_ID (NH_FLD_L2TPV2_TYPE_BIT << 8)
#define NH_FLD_L2TPV2_NS (NH_FLD_L2TPV2_TYPE_BIT << 9)
#define NH_FLD_L2TPV2_NR (NH_FLD_L2TPV2_TYPE_BIT << 10)
#define NH_FLD_L2TPV2_OFFSET_SIZE (NH_FLD_L2TPV2_TYPE_BIT << 11)
#define NH_FLD_L2TPV2_FIRST_BYTE (NH_FLD_L2TPV2_TYPE_BIT << 12)
#define NH_FLD_L2TPV2_ALL_FIELDS \
((NH_FLD_L2TPV2_TYPE_BIT << 13) - 1)
/*************************** L2TPV3 fields *********************************/
#define NH_FLD_L2TPV3_CTRL_TYPE_BIT (1)
#define NH_FLD_L2TPV3_CTRL_LENGTH_BIT (NH_FLD_L2TPV3_CTRL_TYPE_BIT << 1)
#define NH_FLD_L2TPV3_CTRL_SEQUENCE_BIT (NH_FLD_L2TPV3_CTRL_TYPE_BIT << 2)
#define NH_FLD_L2TPV3_CTRL_VERSION (NH_FLD_L2TPV3_CTRL_TYPE_BIT << 3)
#define NH_FLD_L2TPV3_CTRL_LENGTH (NH_FLD_L2TPV3_CTRL_TYPE_BIT << 4)
#define NH_FLD_L2TPV3_CTRL_CONTROL (NH_FLD_L2TPV3_CTRL_TYPE_BIT << 5)
#define NH_FLD_L2TPV3_CTRL_SENT (NH_FLD_L2TPV3_CTRL_TYPE_BIT << 6)
#define NH_FLD_L2TPV3_CTRL_RECV (NH_FLD_L2TPV3_CTRL_TYPE_BIT << 7)
#define NH_FLD_L2TPV3_CTRL_FIRST_BYTE (NH_FLD_L2TPV3_CTRL_TYPE_BIT << 8)
#define NH_FLD_L2TPV3_CTRL_ALL_FIELDS \
((NH_FLD_L2TPV3_CTRL_TYPE_BIT << 9) - 1)
#define NH_FLD_L2TPV3_SESS_TYPE_BIT (1)
#define NH_FLD_L2TPV3_SESS_VERSION (NH_FLD_L2TPV3_SESS_TYPE_BIT << 1)
#define NH_FLD_L2TPV3_SESS_ID (NH_FLD_L2TPV3_SESS_TYPE_BIT << 2)
#define NH_FLD_L2TPV3_SESS_COOKIE (NH_FLD_L2TPV3_SESS_TYPE_BIT << 3)
#define NH_FLD_L2TPV3_SESS_ALL_FIELDS \
((NH_FLD_L2TPV3_SESS_TYPE_BIT << 4) - 1)
/**************************** PPP fields ***********************************/
#define NH_FLD_PPP_PID (1)
#define NH_FLD_PPP_COMPRESSED (NH_FLD_PPP_PID << 1)
#define NH_FLD_PPP_ALL_FIELDS ((NH_FLD_PPP_PID << 2) - 1)
/************************** PPPoE fields ***********************************/
#define NH_FLD_PPPOE_VER (1)
#define NH_FLD_PPPOE_TYPE (NH_FLD_PPPOE_VER << 1)
#define NH_FLD_PPPOE_CODE (NH_FLD_PPPOE_VER << 2)
#define NH_FLD_PPPOE_SID (NH_FLD_PPPOE_VER << 3)
#define NH_FLD_PPPOE_LEN (NH_FLD_PPPOE_VER << 4)
#define NH_FLD_PPPOE_SESSION (NH_FLD_PPPOE_VER << 5)
#define NH_FLD_PPPOE_PID (NH_FLD_PPPOE_VER << 6)
#define NH_FLD_PPPOE_ALL_FIELDS ((NH_FLD_PPPOE_VER << 7) - 1)
/************************* PPP-Mux fields **********************************/
#define NH_FLD_PPPMUX_PID (1)
#define NH_FLD_PPPMUX_CKSUM (NH_FLD_PPPMUX_PID << 1)
#define NH_FLD_PPPMUX_COMPRESSED (NH_FLD_PPPMUX_PID << 2)
#define NH_FLD_PPPMUX_ALL_FIELDS ((NH_FLD_PPPMUX_PID << 3) - 1)
/*********************** PPP-Mux sub-frame fields **************************/
#define NH_FLD_PPPMUX_SUBFRM_PFF (1)
#define NH_FLD_PPPMUX_SUBFRM_LXT (NH_FLD_PPPMUX_SUBFRM_PFF << 1)
#define NH_FLD_PPPMUX_SUBFRM_LEN (NH_FLD_PPPMUX_SUBFRM_PFF << 2)
#define NH_FLD_PPPMUX_SUBFRM_PID (NH_FLD_PPPMUX_SUBFRM_PFF << 3)
#define NH_FLD_PPPMUX_SUBFRM_USE_PID (NH_FLD_PPPMUX_SUBFRM_PFF << 4)
#define NH_FLD_PPPMUX_SUBFRM_ALL_FIELDS \
((NH_FLD_PPPMUX_SUBFRM_PFF << 5) - 1)
/*************************** LLC fields ************************************/
#define NH_FLD_LLC_DSAP (1)
#define NH_FLD_LLC_SSAP (NH_FLD_LLC_DSAP << 1)
#define NH_FLD_LLC_CTRL (NH_FLD_LLC_DSAP << 2)
#define NH_FLD_LLC_ALL_FIELDS ((NH_FLD_LLC_DSAP << 3) - 1)
/*************************** NLPID fields **********************************/
#define NH_FLD_NLPID_NLPID (1)
#define NH_FLD_NLPID_ALL_FIELDS ((NH_FLD_NLPID_NLPID << 1) - 1)
/*************************** SNAP fields ***********************************/
#define NH_FLD_SNAP_OUI (1)
#define NH_FLD_SNAP_PID (NH_FLD_SNAP_OUI << 1)
#define NH_FLD_SNAP_ALL_FIELDS ((NH_FLD_SNAP_OUI << 2) - 1)
/*************************** LLC SNAP fields *******************************/
#define NH_FLD_LLC_SNAP_TYPE (1)
#define NH_FLD_LLC_SNAP_ALL_FIELDS ((NH_FLD_LLC_SNAP_TYPE << 1) - 1)
#define NH_FLD_ARP_HTYPE (1)
#define NH_FLD_ARP_PTYPE (NH_FLD_ARP_HTYPE << 1)
#define NH_FLD_ARP_HLEN (NH_FLD_ARP_HTYPE << 2)
#define NH_FLD_ARP_PLEN (NH_FLD_ARP_HTYPE << 3)
#define NH_FLD_ARP_OPER (NH_FLD_ARP_HTYPE << 4)
#define NH_FLD_ARP_SHA (NH_FLD_ARP_HTYPE << 5)
#define NH_FLD_ARP_SPA (NH_FLD_ARP_HTYPE << 6)
#define NH_FLD_ARP_THA (NH_FLD_ARP_HTYPE << 7)
#define NH_FLD_ARP_TPA (NH_FLD_ARP_HTYPE << 8)
#define NH_FLD_ARP_ALL_FIELDS ((NH_FLD_ARP_HTYPE << 9) - 1)
/*************************** RFC2684 fields ********************************/
#define NH_FLD_RFC2684_LLC (1)
#define NH_FLD_RFC2684_NLPID (NH_FLD_RFC2684_LLC << 1)
#define NH_FLD_RFC2684_OUI (NH_FLD_RFC2684_LLC << 2)
#define NH_FLD_RFC2684_PID (NH_FLD_RFC2684_LLC << 3)
#define NH_FLD_RFC2684_VPN_OUI (NH_FLD_RFC2684_LLC << 4)
#define NH_FLD_RFC2684_VPN_IDX (NH_FLD_RFC2684_LLC << 5)
#define NH_FLD_RFC2684_ALL_FIELDS ((NH_FLD_RFC2684_LLC << 6) - 1)
/*************************** User defined fields ***************************/
#define NH_FLD_USER_DEFINED_SRCPORT (1)
#define NH_FLD_USER_DEFINED_PCDID (NH_FLD_USER_DEFINED_SRCPORT << 1)
#define NH_FLD_USER_DEFINED_ALL_FIELDS \
((NH_FLD_USER_DEFINED_SRCPORT << 2) - 1)
/*************************** Payload fields ********************************/
#define NH_FLD_PAYLOAD_BUFFER (1)
#define NH_FLD_PAYLOAD_SIZE (NH_FLD_PAYLOAD_BUFFER << 1)
#define NH_FLD_MAX_FRM_SIZE (NH_FLD_PAYLOAD_BUFFER << 2)
#define NH_FLD_MIN_FRM_SIZE (NH_FLD_PAYLOAD_BUFFER << 3)
#define NH_FLD_PAYLOAD_TYPE (NH_FLD_PAYLOAD_BUFFER << 4)
#define NH_FLD_FRAME_SIZE (NH_FLD_PAYLOAD_BUFFER << 5)
#define NH_FLD_PAYLOAD_ALL_FIELDS ((NH_FLD_PAYLOAD_BUFFER << 6) - 1)
/*************************** GRE fields ************************************/
#define NH_FLD_GRE_TYPE (1)
#define NH_FLD_GRE_ALL_FIELDS ((NH_FLD_GRE_TYPE << 1) - 1)
/*************************** MINENCAP fields *******************************/
#define NH_FLD_MINENCAP_SRC_IP (1)
#define NH_FLD_MINENCAP_DST_IP (NH_FLD_MINENCAP_SRC_IP << 1)
#define NH_FLD_MINENCAP_TYPE (NH_FLD_MINENCAP_SRC_IP << 2)
#define NH_FLD_MINENCAP_ALL_FIELDS \
((NH_FLD_MINENCAP_SRC_IP << 3) - 1)
/*************************** IPSEC AH fields *******************************/
#define NH_FLD_IPSEC_AH_SPI (1)
#define NH_FLD_IPSEC_AH_NH (NH_FLD_IPSEC_AH_SPI << 1)
#define NH_FLD_IPSEC_AH_ALL_FIELDS ((NH_FLD_IPSEC_AH_SPI << 2) - 1)
/*************************** IPSEC ESP fields ******************************/
#define NH_FLD_IPSEC_ESP_SPI (1)
#define NH_FLD_IPSEC_ESP_SEQUENCE_NUM (NH_FLD_IPSEC_ESP_SPI << 1)
#define NH_FLD_IPSEC_ESP_ALL_FIELDS ((NH_FLD_IPSEC_ESP_SPI << 2) - 1)
#define NH_FLD_IPSEC_ESP_SPI_SIZE 4
/*************************** MPLS fields ***********************************/
#define NH_FLD_MPLS_LABEL_STACK (1)
#define NH_FLD_MPLS_LABEL_STACK_ALL_FIELDS \
((NH_FLD_MPLS_LABEL_STACK << 1) - 1)
/*************************** MACSEC fields *********************************/
#define NH_FLD_MACSEC_SECTAG (1)
#define NH_FLD_MACSEC_ALL_FIELDS ((NH_FLD_MACSEC_SECTAG << 1) - 1)
/*************************** GTP fields ************************************/
#define NH_FLD_GTP_TEID (1)
/* Protocol options */
/* Ethernet options */
#define NH_OPT_ETH_BROADCAST 1
#define NH_OPT_ETH_MULTICAST 2
#define NH_OPT_ETH_UNICAST 3
#define NH_OPT_ETH_BPDU 4
#define NH_ETH_IS_MULTICAST_ADDR(addr) (addr[0] & 0x01)
/* also applicable for broadcast */
/* VLAN options */
#define NH_OPT_VLAN_CFI 1
/* IPV4 options */
#define NH_OPT_IPV4_UNICAST 1
#define NH_OPT_IPV4_MULTICAST 2
#define NH_OPT_IPV4_BROADCAST 3
#define NH_OPT_IPV4_OPTION 4
#define NH_OPT_IPV4_FRAG 5
#define NH_OPT_IPV4_INITIAL_FRAG 6
/* IPV6 options */
#define NH_OPT_IPV6_UNICAST 1
#define NH_OPT_IPV6_MULTICAST 2
#define NH_OPT_IPV6_OPTION 3
#define NH_OPT_IPV6_FRAG 4
#define NH_OPT_IPV6_INITIAL_FRAG 5
/* General IP options (may be used for any version) */
#define NH_OPT_IP_FRAG 1
#define NH_OPT_IP_INITIAL_FRAG 2
#define NH_OPT_IP_OPTION 3
/* Minenc. options */
#define NH_OPT_MINENCAP_SRC_ADDR_PRESENT 1
/* GRE. options */
#define NH_OPT_GRE_ROUTING_PRESENT 1
/* TCP options */
#define NH_OPT_TCP_OPTIONS 1
#define NH_OPT_TCP_CONTROL_HIGH_BITS 2
#define NH_OPT_TCP_CONTROL_LOW_BITS 3
/* CAPWAP options */
#define NH_OPT_CAPWAP_DTLS 1
enum net_prot {
NET_PROT_NONE = 0,
NET_PROT_PAYLOAD,
NET_PROT_ETH,
NET_PROT_VLAN,
NET_PROT_IPV4,
NET_PROT_IPV6,
NET_PROT_IP,
NET_PROT_TCP,
NET_PROT_UDP,
NET_PROT_UDP_LITE,
NET_PROT_IPHC,
NET_PROT_SCTP,
NET_PROT_SCTP_CHUNK_DATA,
NET_PROT_PPPOE,
NET_PROT_PPP,
NET_PROT_PPPMUX,
NET_PROT_PPPMUX_SUBFRM,
NET_PROT_L2TPV2,
NET_PROT_L2TPV3_CTRL,
NET_PROT_L2TPV3_SESS,
NET_PROT_LLC,
NET_PROT_LLC_SNAP,
NET_PROT_NLPID,
NET_PROT_SNAP,
NET_PROT_MPLS,
NET_PROT_IPSEC_AH,
NET_PROT_IPSEC_ESP,
NET_PROT_UDP_ENC_ESP, /* RFC 3948 */
NET_PROT_MACSEC,
NET_PROT_GRE,
NET_PROT_MINENCAP,
NET_PROT_DCCP,
NET_PROT_ICMP,
NET_PROT_IGMP,
NET_PROT_ARP,
NET_PROT_CAPWAP_DATA,
NET_PROT_CAPWAP_CTRL,
NET_PROT_RFC2684,
NET_PROT_ICMPV6,
NET_PROT_FCOE,
NET_PROT_FIP,
NET_PROT_ISCSI,
NET_PROT_GTP,
NET_PROT_USER_DEFINED_L2,
NET_PROT_USER_DEFINED_L3,
NET_PROT_USER_DEFINED_L4,
NET_PROT_USER_DEFINED_L5,
NET_PROT_USER_DEFINED_SHIM1,
NET_PROT_USER_DEFINED_SHIM2,
NET_PROT_DUMMY_LAST
};
/*! IEEE8021.Q */
#define NH_IEEE8021Q_ETYPE 0x8100
#define NH_IEEE8021Q_HDR(etype, pcp, dei, vlan_id) \
((((u32)((etype) & 0xFFFF)) << 16) | \
(((u32)((pcp) & 0x07)) << 13) | \
(((u32)((dei) & 0x01)) << 12) | \
(((u32)((vlan_id) & 0xFFF))))
#endif /* __FSL_NET_H */