/*

   * Copyright (C) 2013-2016 Freescale Semiconductor
   * Copyright 2017 NXP

   *
   * SPDX-License-Identifier:	GPL-2.0+
   */
  #ifndef _FSL_DPNI_H
  #define _FSL_DPNI_H
  
  /* DPNI Version */

  #define DPNI_VER_MAJOR				7
  #define DPNI_VER_MINOR				3

  
  /* Command IDs */

  #define DPNI_CMDID_OPEN				0x8011
  #define DPNI_CMDID_CLOSE			0x8001
  #define DPNI_CMDID_CREATE			0x9011
  #define DPNI_CMDID_DESTROY			0x9811
  #define DPNI_CMDID_GET_API_VERSION              0xa011
  
  #define DPNI_CMDID_ENABLE			0x0021
  #define DPNI_CMDID_DISABLE			0x0031
  #define DPNI_CMDID_GET_ATTR			0x0041
  #define DPNI_CMDID_RESET			0x0051
  
  #define DPNI_CMDID_SET_POOLS			0x2002
  #define DPNI_CMDID_SET_BUFFER_LAYOUT		0x2651
  #define DPNI_CMDID_GET_BUFFER_LAYOUT		0x2641
  #define DPNI_CMDID_SET_ERRORS_BEHAVIOR		0x20B1
  
  #define DPNI_CMDID_GET_QDID			0x2101
  #define DPNI_CMDID_GET_TX_DATA_OFFSET		0x2121
  #define DPNI_CMDID_GET_LINK_STATE		0x2151
  #define DPNI_CMDID_SET_LINK_CFG			0x21A1
  
  #define DPNI_CMDID_SET_PRIM_MAC			0x2241
  #define DPNI_CMDID_GET_PRIM_MAC			0x2251
  #define DPNI_CMDID_ADD_MAC_ADDR			0x2261
  #define DPNI_CMDID_REMOVE_MAC_ADDR		0x2271
  
  #define DPNI_CMDID_GET_STATISTICS		0x25D1
  #define DPNI_CMDID_RESET_STATISTICS		0x25E1
  #define DPNI_CMDID_GET_QUEUE			0x25F1
  #define DPNI_CMDID_SET_QUEUE			0x2601
  #define DPNI_CMDID_SET_TX_CONFIRMATION_MODE	0x2661

  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_CMD_OPEN(cmd, dpni_id) \
  	MC_CMD_OP(cmd,	 0,	0,	32,	int,	dpni_id)

  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_PREP_CFG(param, cfg) \

  do { \

  	MC_PREP_OP(param, 0, 0,   32, uint16_t, cfg->adv.options); \
  	MC_PREP_OP(param, 0, 32,   8, uint16_t, cfg->adv.num_queues); \
  	MC_PREP_OP(param, 0, 40,   8, uint16_t, cfg->adv.num_tcs); \
  	MC_PREP_OP(param, 0, 48,   8, uint16_t, cfg->adv.mac_entries); \
  	MC_PREP_OP(param, 1, 0,   8, uint16_t, cfg->adv.vlan_entries); \
  	MC_PREP_OP(param, 1, 16,   8, uint16_t, cfg->adv.qos_entries); \
  	MC_PREP_OP(param, 1, 32,   16, uint16_t, cfg->adv.fs_entries); \

  } while (0)

  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_EXT_CFG(param, cfg) \

  do { \

  	MC_EXT_OP(param, 0, 0,   32, uint16_t, cfg->adv.options); \
  	MC_EXT_OP(param, 0, 32,   8, uint16_t, cfg->adv.num_queues); \
  	MC_EXT_OP(param, 0, 40,   8, uint16_t, cfg->adv.num_tcs); \
  	MC_EXT_OP(param, 0, 48,   8, uint16_t, cfg->adv.mac_entries); \
  	MC_EXT_OP(param, 1, 0,   8, uint16_t, cfg->adv.vlan_entries); \
  	MC_EXT_OP(param, 1, 16,   8, uint16_t, cfg->adv.qos_entries); \
  	MC_EXT_OP(param, 1, 32,   16, uint16_t, cfg->adv.fs_entries); \

  } while (0)

  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_CMD_CREATE(cmd, cfg) \
  do { \

  	MC_CMD_OP(cmd, 0, 0,	32,	uint32_t,  cfg->adv.options); \
  	MC_CMD_OP(cmd, 0, 32,	8,	uint8_t,   cfg->adv.num_queues); \
  	MC_CMD_OP(cmd, 0, 40,	8,	uint8_t,   cfg->adv.num_tcs); \
  	MC_CMD_OP(cmd, 0, 48,	8,	uint8_t,   cfg->adv.mac_entries); \
  	MC_CMD_OP(cmd, 1, 0,	8,	uint8_t,   cfg->adv.vlan_entries); \
  	MC_CMD_OP(cmd, 1, 16,	8,	uint8_t,   cfg->adv.qos_entries); \
  	MC_CMD_OP(cmd, 1, 32,	16,	uint8_t,   cfg->adv.fs_entries); \

  } while (0)

  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_CMD_SET_POOLS(cmd, cfg) \
  do { \
  	MC_CMD_OP(cmd, 0, 0,  8,  uint8_t,  cfg->num_dpbp); \

  	MC_CMD_OP(cmd, 0, 8,  1,  int,      cfg->pools[0].backup_pool); \
  	MC_CMD_OP(cmd, 0, 9,  1,  int,      cfg->pools[1].backup_pool); \
  	MC_CMD_OP(cmd, 0, 10, 1,  int,      cfg->pools[2].backup_pool); \
  	MC_CMD_OP(cmd, 0, 11, 1,  int,      cfg->pools[3].backup_pool); \
  	MC_CMD_OP(cmd, 0, 12, 1,  int,      cfg->pools[4].backup_pool); \
  	MC_CMD_OP(cmd, 0, 13, 1,  int,      cfg->pools[5].backup_pool); \
  	MC_CMD_OP(cmd, 0, 14, 1,  int,      cfg->pools[6].backup_pool); \
  	MC_CMD_OP(cmd, 0, 15, 1,  int,      cfg->pools[7].backup_pool); \

  	MC_CMD_OP(cmd, 0, 32, 32, int,      cfg->pools[0].dpbp_id); \
  	MC_CMD_OP(cmd, 4, 32, 16, uint16_t, cfg->pools[0].buffer_size);\
  	MC_CMD_OP(cmd, 1, 0,  32, int,      cfg->pools[1].dpbp_id); \
  	MC_CMD_OP(cmd, 4, 48, 16, uint16_t, cfg->pools[1].buffer_size);\
  	MC_CMD_OP(cmd, 1, 32, 32, int,      cfg->pools[2].dpbp_id); \
  	MC_CMD_OP(cmd, 5, 0,  16, uint16_t, cfg->pools[2].buffer_size);\
  	MC_CMD_OP(cmd, 2, 0,  32, int,      cfg->pools[3].dpbp_id); \
  	MC_CMD_OP(cmd, 5, 16, 16, uint16_t, cfg->pools[3].buffer_size);\
  	MC_CMD_OP(cmd, 2, 32, 32, int,      cfg->pools[4].dpbp_id); \
  	MC_CMD_OP(cmd, 5, 32, 16, uint16_t, cfg->pools[4].buffer_size);\
  	MC_CMD_OP(cmd, 3, 0,  32, int,      cfg->pools[5].dpbp_id); \
  	MC_CMD_OP(cmd, 5, 48, 16, uint16_t, cfg->pools[5].buffer_size);\
  	MC_CMD_OP(cmd, 3, 32, 32, int,      cfg->pools[6].dpbp_id); \
  	MC_CMD_OP(cmd, 6, 0,  16, uint16_t, cfg->pools[6].buffer_size);\
  	MC_CMD_OP(cmd, 4, 0,  32, int,      cfg->pools[7].dpbp_id); \
  	MC_CMD_OP(cmd, 6, 16, 16, uint16_t, cfg->pools[7].buffer_size);\
  } while (0)
  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_RSP_GET_ATTR(cmd, attr) \
  do { \

  	MC_RSP_OP(cmd, 0, 0,  32, int,	    attr->options);\
  	MC_RSP_OP(cmd, 0, 32,  8,  uint8_t,  attr->max_num_queues); \
  	MC_RSP_OP(cmd, 0, 40,  8,  uint8_t,  attr->max_num_tcs); \
  	MC_RSP_OP(cmd, 0, 48,  8,  uint8_t,  attr->max_mac_entries); \
  	MC_RSP_OP(cmd, 1,  0,  8,  uint8_t,  attr->max_vlan_entries); \
  	MC_RSP_OP(cmd, 1, 16,  8,  uint8_t,  attr->max_qos_entries); \
  	MC_RSP_OP(cmd, 1, 32, 16,  uint16_t,  attr->max_fs_entries); \
  	MC_RSP_OP(cmd, 2,  0,  8,  uint8_t,  attr->max_qos_key_size); \
  	MC_RSP_OP(cmd, 2,  8,  8,  uint8_t,  attr->max_fs_key_size); \
  	MC_RSP_OP(cmd, 2, 16, 16,  uint16_t,  attr->wriop_version); \

  } while (0)
  
  /*                cmd, param, offset, width, type, arg_name */

  #define DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg) \
  do { \
  	MC_CMD_OP(cmd, 0, 0,  32, uint32_t, cfg->errors); \
  	MC_CMD_OP(cmd, 0, 32, 4,  enum dpni_error_action, cfg->error_action); \
  	MC_CMD_OP(cmd, 0, 36, 1,  int,      cfg->set_frame_annotation); \
  } while (0)
  
  /*                cmd, param, offset, width, type, arg_name */

  #define DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, queue) \

  do { \

  	MC_CMD_OP(cmd, 0, 0,  8, enum dpni_queue_type, queue); \
  	MC_CMD_OP(cmd, 1, 0,  16, uint16_t, layout->private_data_size); \
  	MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_align); \
  	MC_CMD_OP(cmd, 0, 32, 16, uint16_t, layout->options); \
  	MC_CMD_OP(cmd, 0, 48,  1,  int,	    layout->pass_timestamp); \
  	MC_CMD_OP(cmd, 0, 49,  1,  int,	    layout->pass_parser_result); \
  	MC_CMD_OP(cmd, 0, 50,  1,  int,	    layout->pass_frame_status); \
  	MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_head_room); \
  	MC_CMD_OP(cmd, 1, 48, 16, uint16_t, layout->data_tail_room); \

  } while (0)
  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_RSP_GET_QDID(cmd, qdid) \
  	MC_RSP_OP(cmd, 0, 0,  16, uint16_t, qdid)
  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_RSP_GET_TX_DATA_OFFSET(cmd, data_offset) \
  	MC_RSP_OP(cmd, 0, 0,  16, uint16_t, data_offset)
  
  /*                cmd, param, offset, width, type, arg_name */

  #define DPNI_CMD_SET_LINK_CFG(cmd, cfg) \
  do { \

  	MC_CMD_OP(cmd, 1, 0,  32, uint32_t, cfg->rate);\

  	MC_CMD_OP(cmd, 2, 0,  64, uint64_t, cfg->options);\
  } while (0)
  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_RSP_GET_LINK_STATE(cmd, state) \
  do { \
  	MC_RSP_OP(cmd, 0, 32,  1, int,      state->up);\

  	MC_RSP_OP(cmd, 1, 0,  32, uint32_t, state->rate);\

  	MC_RSP_OP(cmd, 2, 0,  64, uint64_t, state->options);\
  } while (0)
  
  
  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
  do { \
  	MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
  	MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
  	MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
  	MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
  	MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
  	MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
  } while (0)
  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
  do { \
  	MC_RSP_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
  	MC_RSP_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
  	MC_RSP_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
  	MC_RSP_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
  	MC_RSP_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
  	MC_RSP_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
  } while (0)
  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr) \
  do { \
  	MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
  	MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
  	MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
  	MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
  	MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
  	MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
  } while (0)
  
  /*                cmd, param, offset, width, type, arg_name */
  #define DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr) \
  do { \
  	MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
  	MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
  	MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
  	MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
  	MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
  	MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
  } while (0)

  #define DPNI_CMD_GET_QUEUE(cmd, type, tc, index) \

  do { \

  	MC_CMD_OP(cmd, 0,  0,  8, enum dpni_queue_type, type); \
  	MC_CMD_OP(cmd, 0,  8,  8, uint8_t, tc); \
  	MC_CMD_OP(cmd, 0, 16,  8, uint8_t, index); \

  } while (0)

  #define DPNI_RSP_GET_QUEUE(cmd, queue) \

  do { \

  	MC_RSP_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
  	MC_RSP_OP(cmd, 1, 56,  4, enum dpni_dest, (queue)->destination.type); \
  	MC_RSP_OP(cmd, 1, 62,  1, char, (queue)->destination.stash_ctrl); \
  	MC_RSP_OP(cmd, 1, 63,  1, char, (queue)->destination.hold_active); \
  	MC_RSP_OP(cmd, 2,  0, 64, uint64_t, (queue)->flc); \
  	MC_RSP_OP(cmd, 3,  0, 64, uint64_t, (queue)->user_context); \
  	MC_RSP_OP(cmd, 4,  0, 32, uint32_t, (queue)->fqid); \
  	MC_RSP_OP(cmd, 4, 32, 16, uint16_t, (queue)->qdbin); \

  } while (0)

  #define DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue) \

  do { \

  	MC_CMD_OP(cmd, 0,  0,  8, enum dpni_queue_type, type); \
  	MC_CMD_OP(cmd, 0,  8,  8, uint8_t, tc); \
  	MC_CMD_OP(cmd, 0, 16,  8, uint8_t, index); \
  	MC_CMD_OP(cmd, 0, 24,  8, uint8_t, (queue)->options); \
  	MC_CMD_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
  	MC_CMD_OP(cmd, 1, 56,  4, enum dpni_dest, (queue)->destination.type); \
  	MC_CMD_OP(cmd, 1, 62,  1, char, (queue)->destination.stash_ctrl); \
  	MC_CMD_OP(cmd, 1, 63,  1, char, (queue)->destination.hold_active); \
  	MC_CMD_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
  	MC_CMD_OP(cmd, 2,  0, 64, uint64_t, (queue)->flc); \
  	MC_CMD_OP(cmd, 3,  0, 64, uint64_t, (queue)->user_context); \

  } while (0)

  /*			cmd, param, offset, width, type, arg_name */
  #define DPNI_CMD_GET_STATISTICS(cmd, page) \
  	MC_CMD_OP(cmd, 0, 0, 8, uint8_t, page)

  
  /*                cmd, param, offset, width, type, arg_name */

  #define DPNI_RSP_GET_STATISTICS(cmd, stat) \

  do { \

  	MC_RSP_OP(cmd, 0, 0, 64, uint64_t, (stat)->counter0); \
  	MC_RSP_OP(cmd, 1, 0, 64, uint64_t, (stat)->counter1); \
  	MC_RSP_OP(cmd, 2, 0, 64, uint64_t, (stat)->counter2); \
  	MC_RSP_OP(cmd, 3, 0, 64, uint64_t, (stat)->counter3); \
  	MC_RSP_OP(cmd, 4, 0, 64, uint64_t, (stat)->counter4); \
  	MC_RSP_OP(cmd, 5, 0, 64, uint64_t, (stat)->counter5); \
  	MC_RSP_OP(cmd, 6, 0, 64, uint64_t, (stat)->counter6); \

  } while (0)

  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
  };

  /**
   * Data Path Network Interface API

   * Contains initialization APIs and runtime control APIs for DPNI
   */
  
  struct fsl_mc_io;
  
  /* 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_rx_flow() */
  #define DPNI_ALL_TCS				(uint8_t)(-1)
  /* All flows within traffic class considered; see dpni_set_rx_flow() */
  #define DPNI_ALL_TC_FLOWS			(uint16_t)(-1)
  /* Generate new flow ID; see dpni_set_tx_flow() */
  #define DPNI_NEW_FLOW_ID			(uint16_t)(-1)

  /* use for common tx-conf queue; see dpni_set_tx_conf_<x>() */
  #define DPNI_COMMON_TX_CONF			(uint16_t)(-1)

  
  /**
   * dpni_open() - Open a control session for the specified object
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @dpni_id:	DPNI unique ID
   * @token:	Returned token; use in subsequent API calls
   *
   * This function can be used to open a control session for an
   * already created object; an object may have been declared in
   * the DPL or by calling the dpni_create() function.
   * This function returns a unique authentication token,
   * associated with the specific object ID and the specific MC
   * portal; this token must be used in all subsequent commands for
   * this specific object.
   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_open(struct fsl_mc_io	*mc_io,
  	      uint32_t		cmd_flags,
  	      int		dpni_id,
  	      uint16_t		*token);

  
  /**
   * dpni_close() - Close the control session of the object
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   *
   * After this function is called, no further operations are
   * allowed on the object without opening a new control session.
   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_close(struct fsl_mc_io	*mc_io,
  	       uint32_t		cmd_flags,
  	       uint16_t		token);

  /* DPNI configuration options */
  
  /**
   * Allow different distribution key profiles for different traffic classes;
   * if not set, a single key profile is assumed
   */
  #define DPNI_OPT_ALLOW_DIST_KEY_PER_TC		0x00000001
  
  /**
   * Disable all non-error transmit confirmation; error frames are reported
   * back to a common Tx error queue
   */
  #define DPNI_OPT_TX_CONF_DISABLED		0x00000002
  
  /* Disable per-sender private Tx confirmation/error queue */
  #define DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED	0x00000004
  
  /**
   * Support distribution based on hashed key;
   * allows statistical distribution over receive queues in a traffic class
   */
  #define DPNI_OPT_DIST_HASH			0x00000010
  
  /**
   * Support distribution based on flow steering;
   * allows explicit control of distribution over receive queues in a traffic
   * class
   */
  #define DPNI_OPT_DIST_FS			0x00000020
  
  /* Unicast filtering support */
  #define DPNI_OPT_UNICAST_FILTER			0x00000080
  /* Multicast filtering support */
  #define DPNI_OPT_MULTICAST_FILTER		0x00000100
  /* VLAN filtering support */
  #define DPNI_OPT_VLAN_FILTER			0x00000200
  /* Support IP reassembly on received packets */
  #define DPNI_OPT_IPR				0x00000800
  /* Support IP fragmentation on transmitted packets */
  #define DPNI_OPT_IPF				0x00001000
  /* VLAN manipulation support */
  #define DPNI_OPT_VLAN_MANIPULATION		0x00010000
  /* Support masking of QoS lookup keys */
  #define DPNI_OPT_QOS_MASK_SUPPORT		0x00020000
  /* Support masking of Flow Steering lookup keys */
  #define DPNI_OPT_FS_MASK_SUPPORT		0x00040000

  /**

   * 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,
  };
  
  struct dpni_cfg {
  		uint8_t mac_addr[6];
  	struct {
  		uint32_t		options;
  		uint16_t		fs_entries;
  		uint8_t			num_queues;
  		uint8_t			num_tcs;
  		uint8_t			mac_entries;
  		uint8_t			vlan_entries;
  		uint8_t			qos_entries;
  	} adv;
  };
  
  /**

   * struct dpni_extended_cfg - Structure representing extended DPNI configuration
   * @tc_cfg: TCs configuration
   * @ipr_cfg: IP reassembly configuration

   */

  struct dpni_extended_cfg {
  	/**
  	 * struct tc_cfg - TC configuration
  	 * @max_dist: Maximum distribution size for Rx traffic class;
  	 *	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;
  	 *	value '0' will be treated as '1'.
  	 *	other unsupported values will be round down to the nearest
  	 *	supported value.
  	 * @max_fs_entries: Maximum FS entries for Rx traffic class;
  	 *	'0' means no support for this TC;
  	 */
  	struct {
  		uint16_t	max_dist;
  		uint16_t	max_fs_entries;
  	} tc_cfg[DPNI_MAX_TC];
  	/**
  	 * struct ipr_cfg - Structure representing IP reassembly configuration
  	 * @max_reass_frm_size: Maximum size of the reassembled frame
  	 * @min_frag_size_ipv4: Minimum fragment size of IPv4 fragments
  	 * @min_frag_size_ipv6: Minimum fragment size of IPv6 fragments
  	 * @max_open_frames_ipv4: Maximum concurrent IPv4 packets in reassembly
  	 *		process
  	 * @max_open_frames_ipv6: Maximum concurrent IPv6 packets in reassembly
  	 *		process
  	 */
  	struct {
  		uint16_t max_reass_frm_size;
  		uint16_t min_frag_size_ipv4;
  		uint16_t min_frag_size_ipv6;
  		uint16_t max_open_frames_ipv4;
  		uint16_t max_open_frames_ipv6;
  	} ipr_cfg;

  };
  
  /**

   * dpni_prepare_cfg() - function prepare parameters
   * @cfg: cfg structure
   * @cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA

   *
   * This function has to be called before dpni_create()
   */

  int dpni_prepare_cfg(const struct dpni_cfg	*cfg,
  		     uint8_t			*cfg_buf);

  /**
   * dpni_create() - Create the DPNI object
   * @mc_io:	Pointer to MC portal's I/O object

   * @token:	Authentication token.

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
   * @cfg:	Configuration structure

   * @obj_id:	Returned obj_id; use in subsequent API calls

   *
   * Create the DPNI object, allocate required resources and
   * perform required initialization.
   *
   * The object can be created either by declaring it in the
   * DPL file, or by calling this function.
   *
   * This function returns a unique authentication token,
   * associated with the specific object ID and the specific MC
   * portal; this token must be used in all subsequent calls to
   * this specific object. For objects that are created using the
   * DPL file, call dpni_open() function to get an authentication
   * token first.
   *
   * Return:	'0' on Success; Error code otherwise.
   */
  int dpni_create(struct fsl_mc_io	*mc_io,

  		uint16_t		token,

  		uint32_t		cmd_flags,
  		const struct dpni_cfg	*cfg,

  		uint32_t		*obj_id);

  
  /**
   * dpni_destroy() - Destroy the DPNI object and release all its resources.
   * @mc_io:	Pointer to MC portal's I/O object

   * @token:	Authentication token.

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @obj_id:	Returned obj_id; use in subsequent API calls

   *
   * Return:	'0' on Success; error code otherwise.
   */
  int dpni_destroy(struct fsl_mc_io	*mc_io,

  		 uint16_t		token,

  		 uint32_t		cmd_flags,

  		 uint32_t		obj_id);

  
  /**

   * 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 {
  	uint8_t num_dpbp;
  	/**
  	 * struct pools - Buffer pools parameters
  	 * @dpbp_id: DPBP object ID
  	 * @buffer_size: Buffer size

  	 * @backup_pool: Backup pool

  	 */
  	struct {

  		int		dpbp_id;
  		uint16_t	buffer_size;
  		int		backup_pool;

  	} pools[DPNI_MAX_DPBP];
  };
  
  /**
   * dpni_set_pools() - Set buffer pools configuration
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @cfg:	Buffer pools configuration
   *
   * mandatory for DPNI operation
   * warning:Allowed only when DPNI is disabled
   *
   * Return:	'0' on Success; Error code otherwise.
   */
  int dpni_set_pools(struct fsl_mc_io		*mc_io,

  		   uint32_t			cmd_flags,

  		   uint16_t			token,
  		   const struct dpni_pools_cfg	*cfg);
  
  /**
   * dpni_enable() - Enable the DPNI, allow sending and receiving frames.

   * @mc_io:	Pointer to MC portal's I/O object
   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:		Token of DPNI object
   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_enable(struct fsl_mc_io	*mc_io,
  		uint32_t		cmd_flags,
  		uint16_t		token);

  
  /**
   * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_disable(struct fsl_mc_io	*mc_io,
  		 uint32_t		cmd_flags,
  		 uint16_t		token);

  
  
  /**

   * dpni_reset() - Reset the DPNI, returns the object to initial state.

   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_reset(struct fsl_mc_io	*mc_io,
  	       uint32_t		cmd_flags,
  	       uint16_t		token);

  
  /**
   * struct dpni_attr - Structure representing DPNI attributes

   * @options: Mask of available options; reflects the value as was given in
   *		object's creation

   * @max_num_queues: Number of queues available (for both Tx and Rx)
   * @max_num_tcs: Maximum number of traffic classes (for both Tx and Rx)
   * @max_mac_entries: Maximum number of traffic classes (for both Tx and Rx)

   * @max_unicast_filters: Maximum number of unicast filters
   * @max_multicast_filters: Maximum number of multicast filters

   * @max_vlan_entries: Maximum number of VLAN filters

   * @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in QoS table

   * @max_fs_entries: declares the maximum entries in flow steering table

   * @max_qos_key_size: Maximum key size for the QoS look-up

   * @max_fs_key_size: Maximum key size for the flow steering
   * @wriop_version: Indicates revision of WRIOP hardware block

   */
  struct dpni_attr {

  	uint32_t id;

  	uint32_t options;

  	uint8_t max_num_queues;
  	uint8_t max_num_tcs;
  	uint8_t max_mac_entries;
  	uint8_t max_vlan_entries;

  	uint8_t max_qos_entries;

  	uint16_t max_fs_entries;

  	uint8_t max_qos_key_size;

  	uint8_t max_fs_key_size;
  	uint16_t wriop_version;

  };

  /**
   * dpni_get_attributes() - Retrieve DPNI attributes.

   * @mc_io:	Pointer to MC portal's I/O object
   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object

   * @attr:	Object's attributes

   *
   * Return:	'0' on Success; Error code otherwise.
   */
  int dpni_get_attributes(struct fsl_mc_io	*mc_io,

  			uint32_t		cmd_flags,

  			uint16_t		token,
  			struct dpni_attr	*attr);

  /**

   * dpni_extract_cfg() - extract the parameters
   * @cfg: cfg structure
   * @cfg_buf: 256 bytes of DMA-able memory

   *
   * This function has to be called after dpni_get_attributes()
   */

  int dpni_extract_cfg(struct dpni_cfg	*cfg,
  		     const uint8_t	*cfg_buf);

  
  /**
   * 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 {
  	uint32_t		errors;
  	enum dpni_error_action	error_action;
  	int			set_frame_annotation;
  };
  
  /**
   * dpni_set_errors_behavior() - Set errors behavior
   * @mc_io:	Pointer to MC portal's I/O object
   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
   * @token:	Token of DPNI object
   * @cfg:	Errors configuration
   *
   * this function may be called numerous times with different
   * error masks
   *
   * Return:	'0' on Success; Error code otherwise.
   */
  int dpni_set_errors_behavior(struct fsl_mc_io		*mc_io,
  			     uint32_t			cmd_flags,
  			     uint16_t			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 {

  	uint16_t options;

  	int pass_timestamp;
  	int pass_parser_result;
  	int pass_frame_status;
  	uint16_t private_data_size;
  	uint16_t data_align;
  	uint16_t data_head_room;
  	uint16_t data_tail_room;
  };
  
  /**

   * dpni_get_buffer_layout() - Retrieve buffer layout attributes.

   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @layout:	Returns buffer layout attributes

   * @type:	DPNI queue type

   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_get_buffer_layout(struct fsl_mc_io			*mc_io,
  			   uint32_t				cmd_flags,
  			   uint16_t				token,
  			   const struct dpni_buffer_layout	*layout,
  			   enum dpni_queue_type			type);

  /**

   * dpni_set_buffer_layout() - Set buffer layout configuration.

   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @layout:	Buffer layout configuration

   * @type:	DPNI queue type

   *
   * Return:	'0' on Success; Error code otherwise.
   *
   * @warning	Allowed only when DPNI is disabled
   */

  int dpni_set_buffer_layout(struct fsl_mc_io			*mc_io,
  			   uint32_t				cmd_flags,
  			   uint16_t				token,
  			   const struct dpni_buffer_layout	*layout,
  			   enum dpni_queue_type			type);

  /**

   * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
   *			for enqueue operations

   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object

   * @qdid:	Returned virtual QDID value that should be used as an argument
   *			in all enqueue operations

   *
   * Return:	'0' on Success; Error code otherwise.

   */

  int dpni_get_qdid(struct fsl_mc_io	*mc_io,
  		  uint32_t		cmd_flags,
  		  uint16_t		token,
  		  uint16_t		*qdid);

  
  /**
   * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @data_offset: Tx data offset (from start of buffer)
   *
   * Return:	'0' on Success; Error code otherwise.
   */
  int dpni_get_tx_data_offset(struct fsl_mc_io	*mc_io,

  			    uint32_t		cmd_flags,

  			    uint16_t		token,
  			    uint16_t		*data_offset);

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

  	uint32_t rate;

  	uint64_t options;
  };
  
  /**
   * dpni_set_link_cfg() - set the link configuration.
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @cfg:	Link configuration
   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_set_link_cfg(struct fsl_mc_io			*mc_io,
  		      uint32_t				cmd_flags,
  		      uint16_t				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 {

  	uint32_t rate;

  	uint64_t options;
  	int up;
  };
  
  /**
   * dpni_get_link_state() - Return the link state (either up or down)
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @state:	Returned link state;
   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_get_link_state(struct fsl_mc_io	*mc_io,
  			uint32_t		cmd_flags,
  			uint16_t		token,
  			struct dpni_link_state	*state);

  
  /**
   * dpni_set_primary_mac_addr() - Set the primary MAC address
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @mac_addr:	MAC address to set as primary address
   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
  			      uint32_t		cmd_flags,

  			      uint16_t		token,
  			      const uint8_t	mac_addr[6]);

  /**
   * dpni_get_primary_mac_addr() - Get the primary MAC address
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @mac_addr:	Returned MAC address
   *
   * Return:	'0' on Success; Error code otherwise.
   */
  int dpni_get_primary_mac_addr(struct fsl_mc_io	*mc_io,

  			      uint32_t		cmd_flags,

  			      uint16_t		token,
  			      uint8_t		mac_addr[6]);

  /**
   * dpni_add_mac_addr() - Add MAC address filter
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @mac_addr:	MAC address to add
   *
   * Return:	'0' on Success; Error code otherwise.
   */
  int dpni_add_mac_addr(struct fsl_mc_io	*mc_io,

  		      uint32_t		cmd_flags,

  		      uint16_t		token,
  		      const uint8_t	mac_addr[6]);
  
  /**
   * dpni_remove_mac_addr() - Remove MAC address filter
   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object
   * @mac_addr:	MAC address to remove
   *
   * Return:	'0' on Success; Error code otherwise.
   */
  int dpni_remove_mac_addr(struct fsl_mc_io	*mc_io,

  			 uint32_t		cmd_flags,

  			 uint16_t		token,
  			 const uint8_t		mac_addr[6]);
  
  /**
   * 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_dest_cfg - Structure representing DPNI destination parameters
   * @dest_type: Destination type
   * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type
   * @priority: Priority selection within the DPIO or DPCON channel; valid values
   *		are 0-1 or 0-7, depending on the number of priorities in that
   *		channel; not relevant for 'DPNI_DEST_NONE' option
   */
  struct dpni_dest_cfg {
  	enum dpni_dest dest_type;
  	int dest_id;
  	uint8_t priority;
  };

  /**
   * enum dpni_flc_type - DPNI FLC types
   * @DPNI_FLC_USER_DEFINED: select the FLC to be used for user defined value
   * @DPNI_FLC_STASH: select the FLC to be used for stash control
   */
  enum dpni_flc_type {
  	DPNI_FLC_USER_DEFINED = 0,
  	DPNI_FLC_STASH = 1,
  };
  
  /**
   * enum dpni_stash_size - DPNI FLC stashing size
   * @DPNI_STASH_SIZE_0B: no stash
   * @DPNI_STASH_SIZE_64B: stashes 64 bytes
   * @DPNI_STASH_SIZE_128B: stashes 128 bytes
   * @DPNI_STASH_SIZE_192B: stashes 192 bytes
   */
  enum dpni_stash_size {
  	DPNI_STASH_SIZE_0B = 0,
  	DPNI_STASH_SIZE_64B = 1,
  	DPNI_STASH_SIZE_128B = 2,
  	DPNI_STASH_SIZE_192B = 3,
  };
  
  /* DPNI FLC stash options */
  
  /* stashes the whole annotation area (up to 192 bytes) */
  #define DPNI_FLC_STASH_FRAME_ANNOTATION	0x00000001
  
  /**
   * struct dpni_flc_cfg - Structure representing DPNI FLC configuration
   * @flc_type: FLC type
   * @options: Mask of available options;
   *	use 'DPNI_FLC_STASH_<X>' values
   * @frame_data_size: Size of frame data to be stashed
   * @flow_context_size: Size of flow context to be stashed
   * @flow_context: 1. In case flc_type is 'DPNI_FLC_USER_DEFINED':
   *			this value will be provided in the frame descriptor
   *			(FD[FLC])
   *		  2. In case flc_type is 'DPNI_FLC_STASH':
   *			this value will be I/O virtual address of the
   *			flow-context;
   *			Must be cacheline-aligned and DMA-able memory
   */
  struct dpni_flc_cfg {
  	enum dpni_flc_type flc_type;
  	uint32_t options;
  	enum dpni_stash_size frame_data_size;
  	enum dpni_stash_size flow_context_size;
  	uint64_t flow_context;
  };

  /* DPNI queue modification options */
  
  /* Select to modify the user's context associated with the queue */
  #define DPNI_QUEUE_OPT_USER_CTX		0x00000001
  /* Select to modify the queue's destination */
  #define DPNI_QUEUE_OPT_DEST		0x00000002

  /** Select to modify the flow-context parameters;
   * not applicable for Tx-conf/Err queues as the FD comes from the user
   */
  #define DPNI_QUEUE_OPT_FLC		0x00000004

  /* Select to modify the queue's order preservation */
  #define DPNI_QUEUE_OPT_ORDER_PRESERVATION 0x00000008

  /* Select to modify the queue's tail-drop threshold */
  #define DPNI_QUEUE_OPT_TAILDROP_THRESHOLD 0x00000010

  
  /**
   * struct dpni_queue_cfg - Structure representing queue configuration
   * @options: Flags representing the suggested modifications to the queue;
   *		Use any combination of 'DPNI_QUEUE_OPT_<X>' flags
   * @user_ctx: User context value provided in the frame descriptor of each
   *		dequeued frame; valid only if 'DPNI_QUEUE_OPT_USER_CTX'
   *		is contained in 'options'
   * @dest_cfg: Queue destination parameters;
   *		valid only if 'DPNI_QUEUE_OPT_DEST' is contained in 'options'

   * @flc_cfg: Flow context configuration; in case the TC's distribution
   *		is either NONE or HASH the FLC's settings of flow#0 are used.
   *		in the case of FS (flow-steering) the flow's FLC settings
   *		are used.
   *		valid only if 'DPNI_QUEUE_OPT_FLC' is contained in 'options'

   * @order_preservation_en: enable/disable order preservation;
   *		valid only if 'DPNI_QUEUE_OPT_ORDER_PRESERVATION' is contained
   *		in 'options'

   * @tail_drop_threshold: set the queue's tail drop threshold in bytes;
   *		'0' value disable the threshold; maximum value is 0xE000000;
   *		valid only if 'DPNI_QUEUE_OPT_TAILDROP_THRESHOLD' is contained
   *		in 'options'

   */
  struct dpni_queue_cfg {
  	uint32_t options;
  	uint64_t user_ctx;
  	struct dpni_dest_cfg dest_cfg;

  	struct dpni_flc_cfg flc_cfg;

  	int order_preservation_en;

  	uint32_t tail_drop_threshold;

  };
  
  /**
   * struct dpni_queue_attr - Structure representing queue attributes
   * @user_ctx: User context value provided in the frame descriptor of each
   *	dequeued frame
   * @dest_cfg: Queue destination configuration

   * @flc_cfg: Flow context configuration

   * @order_preservation_en: enable/disable order preservation

   * @tail_drop_threshold: queue's tail drop threshold in bytes;

   * @fqid: Virtual fqid value to be used for dequeue operations
   */
  struct dpni_queue_attr {
  	uint64_t user_ctx;
  	struct dpni_dest_cfg dest_cfg;

  	struct dpni_flc_cfg flc_cfg;

  	int order_preservation_en;

  	uint32_t tail_drop_threshold;

  	uint32_t fqid;
  };
  
  /* DPNI Tx flow modification options */
  
  /* Select to modify the settings for dedicate Tx confirmation/error */
  #define DPNI_TX_FLOW_OPT_TX_CONF_ERROR	0x00000001

  /*!< Select to modify the L3 checksum generation setting */
  #define DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN	0x00000010
  /*!< Select to modify the L4 checksum generation setting */
  #define DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN	0x00000020
  
  /**

   * dpni_get_api_version - Retrieve DPNI Major and Minor version info.
   *

   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @major_ver:	DPNI major version
   * @minor_ver:	DPNI minor version

   *

   * Return:     '0' on Success; Error code otherwise.
   */
  int dpni_get_api_version(struct fsl_mc_io *mc_io,
  			 u32 cmd_flags,
  			 u16 *major_ver,
  			 u16 *minor_ver);
  
  /**
   * enum dpni_confirmation_mode - Defines DPNI options supported for Tx
   * confirmation
   * @DPNI_CONF_AFFINE: For each Tx queue set associated with a sender there is
   * an affine Tx Confirmation queue
   * @DPNI_CONF_SINGLE: All Tx queues are associated with a single Tx
   * confirmation queue
   * @DPNI_CONF_DISABLE: Tx frames are not confirmed.  This must be associated
   * with proper FD set-up to have buffers release to a Buffer Pool, otherwise
   * buffers will be leaked.
   */
  enum dpni_confirmation_mode {
  	DPNI_CONF_AFFINE,
  	DPNI_CONF_SINGLE,
  	DPNI_CONF_DISABLE,

  };

  struct dpni_tx_confirmation_mode {
  	uint32_t pad;
  	uint8_t confirmation_mode;
  };

  
  /**

   * struct dpni_queue - Queue structure
   * @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.
   * @flc:   FLC value for traffic dequeued from this queue.
   * @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 won't
  	*             push traffic or notifications to a DPIO;
  	*         1 - The destination is 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 purpose of scheduling between multiple
  	*             queues. The DPCON may be independently configured to
  	*             generate notifications. Not relevant for Tx queues.
  	* @hold_active: Hold active
  	*/
  	struct {
  		uint32_t id;
  		enum dpni_dest type;
  		char hold_active;
  		char stash_ctrl;
  	} destination;
  	uint8_t  options;
  	uint32_t fqid;
  	uint16_t qdbin;
  	uint64_t flc;
  	uint64_t user_context;

  };
  
  /**

   * dpni_set_queue() - Set queue parameters
   * @mc_io:      Pointer to MC portal's I/O object
   * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
   * @token:      Token of DPNI object
   * @type:       Type of queue
   * @tc:         Traffic class, in range 0 to NUM_TCS - 1
   * @index:      Selects the specific queue out of the set allocated for the same
   *              TC. Value must be in range 0 to NUM_QUEUES - 1
   * @queue:      Queue structure

   *

   * Return:     '0' on Success; Error code otherwise.
   */
  int dpni_set_queue(struct fsl_mc_io		*mc_io,
  		   uint32_t			cmd_flags,
  		   uint16_t			token,
  		   enum dpni_queue_type		type,
  		   uint8_t			tc,
  		   uint8_t			index,
  		   const struct dpni_queue	*queue);
  
  /**
   * dpni_get_queue() - Get queue parameters
   * @mc_io:      Pointer to MC portal's I/O object
   * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
   * @token:      Token of DPNI object
   * @type:       Type of queue
   * @tc:         Traffic class, in range 0 to NUM_TCS - 1
   * @index:      Selects the specific queue out of the set allocated for the same
   *              TC. Value must be in range 0 to NUM_QUEUES - 1
   * @queue:      Queue structure

   *

   * Return:      '0' on Success; Error code otherwise.

   */

  int dpni_get_queue(struct fsl_mc_io		*mc_io,
  		   uint32_t			cmd_flags,
  		   uint16_t			token,
  		   enum dpni_queue_type		type,
  		   uint8_t			tc,
  		   uint8_t			index,
  		   struct dpni_queue		*queue);

  
  /**

   * dpni_set_tx_confirmation_mode() - Set TX conf mode
   * @mc_io:      Pointer to MC portal's I/O object
   * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
   * @token:      Token of DPNI object
   * @mode:       DPNI confirmation mode type
   *
   * Return:      '0' on Success; Error code otherwise.

   */

  int dpni_set_tx_confirmation_mode(struct fsl_mc_io	*mc_io,
  				  uint32_t		cmd_flags,
  				  uint16_t		token,
  				  enum dpni_confirmation_mode mode);
  struct dpni_statistics {
  	/**
  	 * 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
  	 *
  	 * 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
  	 *
  	 * 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
  	 */
  
  	uint64_t counter0;
  	uint64_t counter1;
  	uint64_t counter2;
  	uint64_t counter3;
  	uint64_t counter4;
  	uint64_t counter5;
  	uint64_t counter6;

  };
  
  /**

   * dpni_get_statistics() - Get DPNI statistics

   * @mc_io:	Pointer to MC portal's I/O object
   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'
   * @token:	Token of DPNI object

   * @page:	Selects the statistics page to retrieve, see DPNI_GET_STATISTICS
   *		output. Pages are numbered 0 to 2.
   * @stat:	Structure containing the statistics

   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_get_statistics(struct fsl_mc_io *mc_io,
  			uint32_t cmd_flags,
  			uint16_t token,
  			uint8_t page,
  			struct dpni_statistics *stat);

  
  /**

   * dpni_reset_statistics() - Clears DPNI statistics

   * @mc_io:	Pointer to MC portal's I/O object

   * @cmd_flags:	Command flags; one or more of 'MC_CMD_FLAG_'

   * @token:	Token of DPNI object

   *
   * Return:	'0' on Success; Error code otherwise.
   */

  int dpni_reset_statistics(struct fsl_mc_io *mc_io,
  			  uint32_t cmd_flags,
  			  uint16_t token);

  #endif /* _FSL_DPNI_H */