lib/librte_ether/rte_ethdev.h

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2012 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  */
  34
  35 #ifndef _RTE_ETHDEV_H_
  36 #define _RTE_ETHDEV_H_
  37
  38 /**
  39  * @file
  40  *
  41  * RTE Ethernet Device API
  42  *
  43  * The Ethernet Device API is composed of two parts:
  44  *
  45  * - The application-oriented Ethernet API that includes functions to setup
  46  *   an Ethernet device (configure it, setup its RX and TX queues and start it),
  47  *   to get its MAC address, the speed and the status of its physical link,
  48  *   to receive and to transmit packets, and so on.
  49  *
  50  * - The driver-oriented Ethernet API that exports a function allowing
  51  *   an Ethernet Poll Mode Driver (PMD) to simultaneously register itself as
  52  *   an Ethernet device driver and as a PCI driver for a set of matching PCI
  53  *   [Ethernet] devices classes.
  54  *
  55  * By default, all the functions of the Ethernet Device API exported by a PMD
  56  * are lock-free functions which assume to not be invoked in parallel on
  57  * different logical cores to work on the same target object.  For instance,
  58  * the receive function of a PMD cannot be invoked in parallel on two logical
  59  * cores to poll the same RX queue [of the same port]. Of course, this function
  60  * can be invoked in parallel by different logical cores on different RX queues.
  61  * It is the responsibility of the upper level application to enforce this rule.
  62  *
  63  * If needed, parallel accesses by multiple logical cores to shared queues
  64  * shall be explicitly protected by dedicated inline lock-aware functions
  65  * built on top of their corresponding lock-free functions of the PMD API.
  66  *
  67  * In all functions of the Ethernet API, the Ethernet device is
  68  * designated by an integer >= 0 named the device port identifier.
  69  *
  70  * At the Ethernet driver level, Ethernet devices are represented by a generic
  71  * data structure of type *rte_eth_dev*.
  72  *
  73  * Ethernet devices are dynamically registered during the PCI probing phase
  74  * performed at EAL initialization time.
  75  * When an Ethernet device is being probed, an *rte_eth_dev* structure and
  76  * a new port identifier are allocated for that device. Then, the eth_dev_init()
  77  * function supplied by the Ethernet driver matching the probed PCI
  78  * device is invoked to properly initialize the device.
  79  *
  80  * The role of the device init function consists of resetting the hardware,
  81  * checking access to Non-volatile Memory (NVM), reading the MAC address
  82  * from NVM etc.
  83  *
  84  * If the device init operation is successful, the correspondence between
  85  * the port identifier assigned to the new device and its associated
  86  * *rte_eth_dev* structure is effectively registered.
  87  * Otherwise, both the *rte_eth_dev* structure and the port identifier are
  88  * freed.
  89  *
  90  * The functions exported by the application Ethernet API to setup a device
  91  * designated by its port identifier must be invoked in the following order:
  92  *     - rte_eth_dev_configure()
  93  *     - rte_eth_tx_queue_setup()
  94  *     - rte_eth_rx_queue_setup()
  95  *     - rte_eth_dev_start()
  96  *
  97  * Then, the network application can invoke, in any order, the functions
  98  * exported by the Ethernet API to get the MAC address of a given device, to
  99  * get the speed and the status of a device physical link, to receive/transmit
 100  * [burst of] packets, and so on.
 101  *
 102  * If the application wants to change the configuration (i.e. call
 103  * rte_eth_dev_configure(), rte_eth_tx_queue_setup(), or
 104  * rte_eth_rx_queue_setup()), it must call rte_eth_dev_stop() first to stop the
 105  * device and then do the reconfiguration before calling rte_eth_dev_start()
 106  * again. The tramsit and receive functions should not be invoked when the
 107  * device is stopped.
 108  *
 109  * Please note that some configuration is not stored between calls to
 110  * rte_eth_dev_stop()/rte_eth_dev_start(). The following configuration will
 111  * be retained:
 112  *
 113  *     - flow control settings
 114  *     - receive mode configuration (promiscuous mode, hardware checksum mode,
 115  *       RSS/VMDQ settings etc.)
 116  *     - VLAN filtering configuration
 117  *     - MAC addresses supplied to MAC address array
 118  *     - flow director filtering mode (but not filtering rules)
 119  *     - NIC queue statistics mappings
 120  *
 121  * Any other configuration will not be stored and will need to be re-entered
 122  * after a call to rte_eth_dev_start().
 123  *
 124  * Finally, a network application can close an Ethernet device by invoking the
 125  * rte_eth_dev_close() function.
 126  *
 127  * Each function of the application Ethernet API invokes a specific function
 128  * of the PMD that controls the target device designated by its port
 129  * identifier.
 130  * For this purpose, all device-specific functions of an Ethernet driver are
 131  * supplied through a set of pointers contained in a generic structure of type
 132  * *eth_dev_ops*.
 133  * The address of the *eth_dev_ops* structure is stored in the *rte_eth_dev*
 134  * structure by the device init function of the Ethernet driver, which is
 135  * invoked during the PCI probing phase, as explained earlier.
 136  *
 137  * In other words, each function of the Ethernet API simply retrieves the
 138  * *rte_eth_dev* structure associated with the device port identifier and
 139  * performs an indirect invocation of the corresponding driver function
 140  * supplied in the *eth_dev_ops* structure of the *rte_eth_dev* structure.
 141  *
 142  * For performance reasons, the address of the burst-oriented RX and TX
 143  * functions of the Ethernet driver are not contained in the *eth_dev_ops*
 144  * structure. Instead, they are directly stored at the beginning of the
 145  * *rte_eth_dev* structure to avoid an extra indirect memory access during
 146  * their invocation.
 147  *
 148  * RTE ethernet device drivers do not use interrupts for transmitting or
 149  * receiving. Instead, Ethernet drivers export Poll-Mode receive and transmit
 150  * functions to applications.
 151  * Both receive and transmit functions are packet-burst oriented to minimize
 152  * their cost per packet through the following optimizations:
 153  *
 154  * - Sharing among multiple packets the incompressible cost of the
 155  *   invocation of receive/transmit functions.
 156  *
 157  * - Enabling receive/transmit functions to take advantage of burst-oriented
 158  *   hardware features (L1 cache, prefetch instructions, NIC head/tail
 159  *   registers) to minimize the number of CPU cycles per packet, for instance,
 160  *   by avoiding useless read memory accesses to ring descriptors, or by
 161  *   systematically using arrays of pointers that exactly fit L1 cache line
 162  *   boundaries and sizes.
 163  *
 164  * The burst-oriented receive function does not provide any error notification,
 165  * to avoid the corresponding overhead. As a hint, the upper-level application
 166  * might check the status of the device link once being systematically returned
 167  * a 0 value by the receive function of the driver for a given number of tries.
 168  */
 169
 170 #ifdef __cplusplus
 171 extern "C" {
 172 #endif
 173
 174 #include <stdint.h>
 175
 176 #include <rte_log.h>
 177 #include <rte_interrupts.h>
 178 #include <rte_pci.h>
 179 #include <rte_mbuf.h>
 180 #include "rte_ether.h"
 181
 182 /**
 183  * A structure used to retrieve statistics for an Ethernet port.
 184  */
 185 struct rte_eth_stats {
 186         uint64_t ipackets;  /**< Total number of successfully received packets. */
 187         uint64_t opackets;  /**< Total number of successfully transmitted packets.*/
 188         uint64_t ibytes;    /**< Total number of successfully received bytes. */
 189         uint64_t obytes;    /**< Total number of successfully transmitted bytes. */
 190         uint64_t ierrors;   /**< Total number of erroneous received packets. */
 191         uint64_t oerrors;   /**< Total number of failed transmitted packets. */
 192         uint64_t imcasts;   /**< Total number of multicast received packets. */
 193         uint64_t rx_nombuf; /**< Total number of RX mbuf allocation failures. */
 194         uint64_t fdirmatch; /**< Total number of RX packets matching a filter. */
 195         uint64_t fdirmiss;  /**< Total number of RX packets not matching any filter. */
 196         uint64_t q_ipackets[RTE_ETHDEV_QUEUE_STAT_CNTRS];
 197         /**< Total number of queue RX packets. */
 198         uint64_t q_opackets[RTE_ETHDEV_QUEUE_STAT_CNTRS];
 199         /**< Total number of queue TX packets. */
 200         uint64_t q_ibytes[RTE_ETHDEV_QUEUE_STAT_CNTRS];
 201         /**< Total number of successfully received queue bytes. */
 202         uint64_t q_obytes[RTE_ETHDEV_QUEUE_STAT_CNTRS];
 203         /**< Total number of successfully transmitted queue bytes. */
 204         uint64_t q_errors[RTE_ETHDEV_QUEUE_STAT_CNTRS];
 205         /**< Total number of queue packets received that are dropped. */
 206 };
 207
 208 /**
 209  * A structure used to retrieve link-level information of an Ethernet port.
 210  */
 211 struct rte_eth_link {
 212         uint16_t link_speed;      /**< ETH_LINK_SPEED_[10, 100, 1000, 10000] */
 213         uint16_t link_duplex;     /**< ETH_LINK_[HALF_DUPLEX, FULL_DUPLEX] */
 214         uint8_t  link_status : 1; /**< 1 -> link up, 0 -> link down */
 215 }__attribute__((aligned(8)));     /**< aligned for atomic64 read/write */
 216
 217 #define ETH_LINK_SPEED_AUTONEG  0       /**< Auto-negotiate link speed. */
 218 #define ETH_LINK_SPEED_10       10      /**< 10 megabits/second. */
 219 #define ETH_LINK_SPEED_100      100     /**< 100 megabits/second. */
 220 #define ETH_LINK_SPEED_1000     1000    /**< 1 gigabits/second. */
 221 #define ETH_LINK_SPEED_10000    10000   /**< 10 gigabits/second. */
 222
 223 #define ETH_LINK_AUTONEG_DUPLEX 0       /**< Auto-negotiate duplex. */
 224 #define ETH_LINK_HALF_DUPLEX    1       /**< Half-duplex connection. */
 225 #define ETH_LINK_FULL_DUPLEX    2       /**< Full-duplex connection. */
 226
 227 /**
 228  * A structure used to configure the ring threshold registers of an RX/TX
 229  * queue for an Ethernet port.
 230  */
 231 struct rte_eth_thresh {
 232         uint8_t pthresh; /**< Ring prefetch threshold. */
 233         uint8_t hthresh; /**< Ring host threshold. */
 234         uint8_t wthresh; /**< Ring writeback threshold. */
 235 };
 236
 237 /**
 238  *  A set of values to identify what method is to be used to route
 239  *  packets to multiple queues.
 240  */
 241 enum rte_eth_rx_mq_mode {
 242         ETH_RSS     = 0,     /**< Default to RSS mode */
 243         ETH_VMDQ_DCB,        /**< Use VMDQ+DCB to route traffic to queues */
 244         ETH_DCB_RX           /**< For RX side,only DCB is on. */
 245 };
 246
 247 /**
 248  * A set of values to identify what method is to be used to transmit
 249  * packets using multi-TCs.
 250  */
 251 enum rte_eth_tx_mq_mode {
 252         ETH_DCB_NONE    = 0,    /**< It is not in DCB mode. */
 253         ETH_VMDQ_DCB_TX,        /**< For TX side,both DCB and VT is on. */
 254         ETH_DCB_TX              /**< For TX side,only DCB is on. */
 255 };
 256
 257 /**
 258  * A structure used to configure the RX features of an Ethernet port.
 259  */
 260 struct rte_eth_rxmode {
 261         /** The multi-queue packet distribution mode to be used, e.g. RSS. */
 262         enum rte_eth_rx_mq_mode mq_mode;
 263         uint32_t max_rx_pkt_len;  /**< Only used if jumbo_frame enabled. */
 264         uint16_t split_hdr_size;  /**< hdr buf size (header_split enabled).*/
 265         uint8_t header_split : 1, /**< Header Split enable. */
 266                 hw_ip_checksum   : 1, /**< IP/UDP/TCP checksum offload enable. */
 267                 hw_vlan_filter   : 1, /**< VLAN filter enable. */
 268                 jumbo_frame      : 1, /**< Jumbo Frame Receipt enable. */
 269                 hw_strip_crc     : 1; /**< Enable CRC stripping by hardware. */
 270 };
 271
 272 /**
 273  * A structure used to configure the Receive Side Scaling (RSS) feature
 274  * of an Ethernet port.
 275  * If not NULL, the *rss_key* pointer of the *rss_conf* structure points
 276  * to an array of 40 bytes holding the RSS key to use for hashing specific
 277  * header fields of received packets.
 278  * Otherwise, a default random hash key is used by the device driver.
 279  *
 280  * The *rss_hf* field of the *rss_conf* structure indicates the different
 281  * types of IPv4/IPv6 packets to which the RSS hashing must be applied.
 282  * Supplying an *rss_hf* equal to zero disables the RSS feature.
 283  */
 284 struct rte_eth_rss_conf {
 285         uint8_t  *rss_key;   /**< If not NULL, 40-byte hash key. */
 286         uint16_t rss_hf;     /**< Hash functions to apply - see below. */
 287 };
 288
 289 #define ETH_RSS_IPV4        0x0001 /**< IPv4 packet. */
 290 #define ETH_RSS_IPV4_TCP    0x0002 /**< IPv4/TCP packet. */
 291 #define ETH_RSS_IPV6        0x0004 /**< IPv6 packet. */
 292 #define ETH_RSS_IPV6_EX     0x0008 /**< IPv6 packet with extension headers.*/
 293 #define ETH_RSS_IPV6_TCP    0x0010 /**< IPv6/TCP packet. */
 294 #define ETH_RSS_IPV6_TCP_EX 0x0020 /**< IPv6/TCP with extension headers. */
 295 /* Intel RSS extensions to UDP packets */
 296 #define ETH_RSS_IPV4_UDP    0x0040 /**< IPv4/UDP packet. */
 297 #define ETH_RSS_IPV6_UDP    0x0080 /**< IPv6/UDP packet. */
 298 #define ETH_RSS_IPV6_UDP_EX 0x0100 /**< IPv6/UDP with extension headers. */
 299
 300 /* Definitions used for VMDQ and DCB functionality */
 301 #define ETH_VMDQ_MAX_VLAN_FILTERS   64 /**< Maximum nb. of VMDQ vlan filters. */
 302 #define ETH_DCB_NUM_USER_PRIORITIES 8  /**< Maximum nb. of DCB priorities. */
 303 #define ETH_VMDQ_DCB_NUM_QUEUES     128 /**< Maximum nb. of VMDQ DCB queues. */
 304 #define ETH_DCB_NUM_QUEUES          128 /**< Maximum nb. of DCB queues. */
 305
 306 /* DCB capability defines */
 307 #define ETH_DCB_PG_SUPPORT      0x00000001 /**< Priority Group(ETS) support. */
 308 #define ETH_DCB_PFC_SUPPORT     0x00000002 /**< Priority Flow Control support. */
 309
 310 /**
 311  * This enum indicates the possible number of traffic classes
 312  * in DCB configratioins
 313  */
 314 enum rte_eth_nb_tcs {
 315         ETH_4_TCS = 4, /**< 4 TCs with DCB. */
 316         ETH_8_TCS = 8  /**< 8 TCs with DCB. */
 317 };
 318
 319 /**
 320  * This enum indicates the possible number of queue pools
 321  * in VMDQ+DCB configurations.
 322  */
 323 enum rte_eth_nb_pools {
 324         ETH_16_POOLS = 16, /**< 16 pools with DCB. */
 325         ETH_32_POOLS = 32  /**< 32 pools with DCB. */
 326 };
 327
 328 /* This structure may be extended in future. */
 329 struct rte_eth_dcb_rx_conf {
 330         enum rte_eth_nb_tcs nb_tcs; /**< Possible DCB TCs, 4 or 8 TCs */
 331         uint8_t dcb_queue[ETH_DCB_NUM_USER_PRIORITIES];
 332         /**< Possible DCB queue,4 or 8. */
 333 };
 334
 335 struct rte_eth_vmdq_dcb_tx_conf {
 336         enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools. */
 337         uint8_t dcb_queue[ETH_DCB_NUM_USER_PRIORITIES];
 338         /**< Possible DCB queue,4 or 8. */
 339 };
 340
 341 struct rte_eth_dcb_tx_conf {
 342         enum rte_eth_nb_tcs nb_tcs; /**< possible DCB TCs, 4 or 8 TCs. */
 343         uint8_t dcb_queue[ETH_DCB_NUM_USER_PRIORITIES];
 344         /**< Possible DCB queue,4 or 8. */
 345 };
 346
 347 /**
 348  * A structure used to configure the VMDQ+DCB feature
 349  * of an Ethernet port.
 350  *
 351  * Using this feature, packets are routed to a pool of queues, based
 352  * on the vlan id in the vlan tag, and then to a specific queue within
 353  * that pool, using the user priority vlan tag field.
 354  *
 355  * A default pool may be used, if desired, to route all traffic which
 356  * does not match the vlan filter rules.
 357  */
 358 struct rte_eth_vmdq_dcb_conf {
 359         enum rte_eth_nb_pools nb_queue_pools; /**< With DCB, 16 or 32 pools */
 360         uint8_t enable_default_pool; /**< If non-zero, use a default pool */
 361         uint8_t default_pool; /**< The default pool, if applicable */
 362         uint8_t nb_pool_maps; /**< We can have up to 64 filters/mappings */
 363         struct {
 364                 uint16_t vlan_id; /**< The vlan id of the received frame */
 365                 uint64_t pools;   /**< Bitmask of pools for packet rx */
 366         } pool_map[ETH_VMDQ_MAX_VLAN_FILTERS]; /**< VMDq vlan pool maps. */
 367         uint8_t dcb_queue[ETH_DCB_NUM_USER_PRIORITIES];
 368         /**< Selects a queue in a pool */
 369 };
 370
 371 /**
 372  * A structure used to configure the TX features of an Ethernet port.
 373  */
 374 struct rte_eth_txmode {
 375         enum rte_eth_tx_mq_mode mq_mode; /**< TX multi-queues mode. */
 376 };
 377
 378 /**
 379  * A structure used to configure an RX ring of an Ethernet port.
 380  */
 381 struct rte_eth_rxconf {
 382         struct rte_eth_thresh rx_thresh; /**< RX ring threshold registers. */
 383         uint16_t rx_free_thresh; /**< Drives the freeing of RX descriptors. */
 384 };
 385
 386 /**
 387  * A structure used to configure a TX ring of an Ethernet port.
 388  */
 389 struct rte_eth_txconf {
 390         struct rte_eth_thresh tx_thresh; /**< TX ring threshold registers. */
 391         uint16_t tx_rs_thresh; /**< Drives the setting of RS bit on TXDs. */
 392         uint16_t tx_free_thresh; /**< Drives the freeing of TX buffers. */
 393 };
 394
 395 /**
 396  * This enum indicates the flow control mode
 397  */
 398 enum rte_eth_fc_mode {
 399         RTE_FC_NONE = 0, /**< Disable flow control. */
 400         RTE_FC_RX_PAUSE, /**< RX pause frame, enable flowctrl on TX side. */
 401         RTE_FC_TX_PAUSE, /**< TX pause frame, enable flowctrl on RX side. */
 402         RTE_FC_FULL      /**< Enable flow control on both side. */
 403 };
 404
 405 /**
 406  * A structure used to configure Ethernet flow control parameter.
 407  * These parameters will be configured into the register of the NIC.
 408  * Please refer to the corresponding data sheet for proper value.
 409  */
 410 struct rte_eth_fc_conf {
 411         uint32_t high_water;  /**< High threshold value to trigger XOFF */
 412         uint32_t low_water;   /**< Low threshold value to trigger XON */
 413         uint16_t pause_time;  /**< Pause quota in the Pause frame */
 414         uint16_t send_xon;    /**< Is XON frame need be sent */
 415         enum rte_eth_fc_mode mode;  /**< Link flow control mode */
 416 };
 417
 418 /**
 419  *  Flow Director setting modes: none (default), signature or perfect.
 420  */
 421 enum rte_fdir_mode {
 422         RTE_FDIR_MODE_NONE      = 0, /**< Disable FDIR support. */
 423         RTE_FDIR_MODE_SIGNATURE,     /**< Enable FDIR signature filter mode. */
 424         RTE_FDIR_MODE_PERFECT,       /**< Enable FDIR perfect filter mode. */
 425 };
 426
 427 /**
 428  *  Memory space that can be configured to store Flow Director filters
 429  *  in the board memory.
 430  */
 431 enum rte_fdir_pballoc_type {
 432         RTE_FDIR_PBALLOC_64K = 0,  /**< 64k. */
 433         RTE_FDIR_PBALLOC_128K,     /**< 128k. */
 434         RTE_FDIR_PBALLOC_256K,     /**< 256k. */
 435 };
 436
 437 /**
 438  *  Select report mode of FDIR hash information in RX descriptors.
 439  */
 440 enum rte_fdir_status_mode {
 441         RTE_FDIR_NO_REPORT_STATUS = 0, /**< Never report FDIR hash. */
 442         RTE_FDIR_REPORT_STATUS, /**< Only report FDIR hash for matching pkts. */
 443         RTE_FDIR_REPORT_STATUS_ALWAYS, /**< Always report FDIR hash. */
 444 };
 445
 446 /**
 447  * A structure used to configure the Flow Director (FDIR) feature
 448  * of an Ethernet port.
 449  *
 450  * If mode is RTE_FDIR_DISABLE, the pballoc value is ignored.
 451  */
 452 struct rte_fdir_conf {
 453         enum rte_fdir_mode mode; /**< Flow Director mode. */
 454         enum rte_fdir_pballoc_type pballoc; /**< Space for FDIR filters. */
 455         enum rte_fdir_status_mode status;  /**< How to report FDIR hash. */
 456         /* Offset of flexbytes field in RX packets (in 16-bit word units). */
 457         uint8_t flexbytes_offset;
 458         /* RX queue of packets matching a "drop" filter in perfect mode. */
 459         uint8_t drop_queue;
 460 };
 461
 462 /**
 463  *  Possible l4type of FDIR filters.
 464  */
 465 enum rte_l4type {
 466         RTE_FDIR_L4TYPE_NONE = 0,       /**< None. */
 467         RTE_FDIR_L4TYPE_UDP,            /**< UDP. */
 468         RTE_FDIR_L4TYPE_TCP,            /**< TCP. */
 469         RTE_FDIR_L4TYPE_SCTP,           /**< SCTP. */
 470 };
 471
 472 /**
 473  *  Select IPv4 or IPv6 FDIR filters.
 474  */
 475 enum rte_iptype {
 476         RTE_FDIR_IPTYPE_IPV4 = 0,     /**< IPv4. */
 477         RTE_FDIR_IPTYPE_IPV6 ,        /**< IPv6. */
 478 };
 479
 480 /**
 481  *  A structure used to define a FDIR packet filter.
 482  */
 483 struct rte_fdir_filter {
 484         uint16_t flex_bytes; /**< Flex bytes value to match. */
 485         uint16_t vlan_id; /**< VLAN ID value to match, 0 otherwise. */
 486         uint16_t port_src; /**< Source port to match, 0 otherwise. */
 487         uint16_t port_dst; /**< Destination port to match, 0 otherwise. */
 488         union {
 489                 uint32_t ipv4_addr; /**< IPv4 source address to match. */
 490                 uint32_t ipv6_addr[4]; /**< IPv6 source address to match. */
 491         } ip_src; /**< IPv4/IPv6 source address to match (union of above). */
 492         union {
 493                 uint32_t ipv4_addr; /**< IPv4 destination address to match. */
 494                 uint32_t ipv6_addr[4]; /**< IPv6 destination address to match */
 495         } ip_dst; /**< IPv4/IPv6 destination address to match (union of above). */
 496         enum rte_l4type l4type; /**< l4type to match: NONE/UDP/TCP/SCTP. */
 497         enum rte_iptype iptype; /**< IP packet type to match: IPv4 or IPv6. */
 498 };
 499
 500 /**
 501  *  A structure used to configure FDIR masks that are used by the device
 502  *  to match the various fields of RX packet headers.
 503  *  @note The only_ip_flow field has the opposite meaning compared to other
 504  *  masks!
 505  */
 506 struct rte_fdir_masks {
 507         /** When set to 1, packet l4type is \b NOT relevant in filters, and
 508            source and destination port masks must be set to zero. */
 509         uint8_t only_ip_flow;
 510         /** If set to 1, vlan_id is relevant in filters. */
 511         uint8_t vlan_id;
 512         /** If set to 1, vlan_prio is relevant in filters. */
 513         uint8_t vlan_prio;
 514         /** If set to 1, flexbytes is relevant in filters. */
 515         uint8_t flexbytes;
 516         /** Mask of Destination IPv4 Address. All bits set to 1 define the
 517             relevant bits to use in the destination address of an IPv4 packet
 518             when matching it against FDIR filters. */
 519         uint32_t dst_ipv4_mask;
 520         /** Mask of Source IPv4 Address. All bits set to 1 define
 521             the relevant bits to use in the source address of an IPv4 packet
 522             when matching it against FDIR filters. */
 523         uint32_t src_ipv4_mask;
 524         /** Mask of Source IPv6 Address. All bits set to 1 define the
 525             relevant BYTES to use in the source address of an IPv6 packet
 526             when matching it against FDIR filters. */
 527         uint16_t src_ipv6_mask;
 528         /** Mask of Source Port. All bits set to 1 define the relevant
 529             bits to use in the source port of an IP packets when matching it
 530             against FDIR filters. */
 531         uint16_t src_port_mask;
 532         /** Mask of Destination Port. All bits set to 1 define the relevant
 533             bits to use in the destination port of an IP packet when matching it
 534             against FDIR filters. */
 535         uint16_t dst_port_mask;
 536 };
 537
 538 /**
 539  *  A structure used to report the status of the flow director filters in use.
 540  */
 541 struct rte_eth_fdir {
 542         /** Number of filters with collision indication. */
 543         uint16_t collision;
 544         /** Number of free (non programmed) filters. */
 545         uint16_t free;
 546         /** The Lookup hash value of the added filter that updated the value
 547            of the MAXLEN field */
 548         uint16_t maxhash;
 549         /** Longest linked list of filters in the table. */
 550         uint8_t maxlen;
 551         /** Number of added filters. */
 552         uint64_t add;
 553         /** Number of removed filters. */
 554         uint64_t remove;
 555         /** Number of failed added filters (no more space in device). */
 556         uint64_t f_add;
 557         /** Number of failed removed filters. */
 558         uint64_t f_remove;
 559 };
 560
 561 /**
 562  * A structure used to enable/disable specific device interrupts.
 563  */
 564 struct rte_intr_conf {
 565         /** enable/disable lsc interrupt. 0 (default) - disable, 1 enable */
 566         uint16_t lsc;
 567 };
 568
 569 /**
 570  * A structure used to configure an Ethernet port.
 571  * Depending upon the RX multi-queue mode, extra advanced
 572  * configuration settings may be needed.
 573  */
 574 struct rte_eth_conf {
 575         uint16_t link_speed;
 576         /**< ETH_LINK_SPEED_10[0|00|000], or 0 for autonegotation */
 577         uint16_t link_duplex;
 578         /**< ETH_LINK_[HALF_DUPLEX|FULL_DUPLEX], or 0 for autonegotation */
 579         struct rte_eth_rxmode rxmode; /**< Port RX configuration. */
 580         struct rte_eth_txmode txmode; /**< Port TX configuration. */
 581         union {
 582                 struct rte_eth_rss_conf rss_conf; /**< Port RSS configuration */
 583                 struct rte_eth_vmdq_dcb_conf vmdq_dcb_conf;
 584                 /**< Port vmdq+dcb configuration. */
 585                 struct rte_eth_dcb_rx_conf dcb_rx_conf;
 586                 /**< Port dcb RX configuration. */
 587         } rx_adv_conf; /**< Port RX filtering configuration (union). */
 588         union {
 589                 struct rte_eth_vmdq_dcb_tx_conf vmdq_dcb_tx_conf;
 590                 /**< Port vmdq+dcb TX configuration. */
 591                 struct rte_eth_dcb_tx_conf dcb_tx_conf;
 592                 /**< Port dcb TX configuration. */
 593         } tx_adv_conf; /**< Port TX DCB configuration (union). */
 594         /** Currently,Priority Flow Control(PFC) are supported,if DCB with PFC
 595             is needed,and the variable must be set ETH_DCB_PFC_SUPPORT. */
 596         uint32_t dcb_capability_en;
 597         struct rte_fdir_conf fdir_conf; /**< FDIR configuration. */
 598         struct rte_intr_conf intr_conf; /**< Interrupt mode configuration. */
 599 };
 600
 601 /**
 602  * A structure used to retrieve the contextual information of
 603  * an Ethernet device, such as the controlling driver of the device,
 604  * its PCI context, etc...
 605  */
 606 struct rte_eth_dev_info {
 607         struct rte_pci_device *pci_dev; /**< Device PCI information. */
 608         const char *driver_name; /**< Device Driver name. */
 609         uint32_t min_rx_bufsize; /**< Minimum size of RX buffer. */
 610         uint32_t max_rx_pktlen; /**< Maximum configurable length of RX pkt. */
 611         uint16_t max_rx_queues; /**< Maximum number of RX queues. */
 612         uint16_t max_tx_queues; /**< Maximum number of TX queues. */
 613         uint32_t max_mac_addrs; /**< Maximum number of MAC addresses. */
 614 };
 615
 616 struct rte_eth_dev;
 617 struct igb_rx_queue;
 618 struct igb_tx_queue;
 619
 620 struct rte_eth_dev_callback;
 621 /** @internal Structure to keep track of registered callbacks */
 622 TAILQ_HEAD(rte_eth_dev_cb_list, rte_eth_dev_callback);
 623
 624 /*
 625  * Definitions of all functions exported by an Ethernet driver through the
 626  * the generic structure of type *eth_dev_ops* supplied in the *rte_eth_dev*
 627  * structure associated with an Ethernet device.
 628  */
 629
 630 typedef int  (*eth_dev_configure_t)(struct rte_eth_dev *dev, uint16_t nb_rx_q,
 631                                     uint16_t nb_tx_q);
 632 /**< @internal Ethernet device configuration. */
 633
 634 typedef int  (*eth_dev_start_t)(struct rte_eth_dev *dev);
 635 /**< @internal Function used to start a configured Ethernet device. */
 636
 637 typedef void (*eth_dev_stop_t)(struct rte_eth_dev *dev);
 638 /**< @internal Function used to stop a configured Ethernet device. */
 639
 640 typedef void (*eth_dev_close_t)(struct rte_eth_dev *dev);
 641 /**< @internal Function used to close a configured Ethernet device. */
 642
 643 typedef void (*eth_promiscuous_enable_t)(struct rte_eth_dev *dev);
 644 /**< @internal Function used to enable the RX promiscuous mode of an Ethernet device. */
 645
 646 typedef void (*eth_promiscuous_disable_t)(struct rte_eth_dev *dev);
 647 /**< @internal Function used to disable the RX promiscuous mode of an Ethernet device. */
 648
 649 typedef void (*eth_allmulticast_enable_t)(struct rte_eth_dev *dev);
 650 /**< @internal Enable the receipt of all multicast packets by an Ethernet device. */
 651
 652 typedef void (*eth_allmulticast_disable_t)(struct rte_eth_dev *dev);
 653 /**< @internal Disable the receipt of all multicast packets by an Ethernet device. */
 654
 655 typedef int (*eth_link_update_t)(struct rte_eth_dev *dev,
 656                                 int wait_to_complete);
 657 /**< @internal Get link speed, duplex mode and state (up/down) of an Ethernet device. */
 658
 659 typedef void (*eth_stats_get_t)(struct rte_eth_dev *dev,
 660                                 struct rte_eth_stats *igb_stats);
 661 /**< @internal Get global I/O statistics of an Ethernet device. */
 662
 663 typedef void (*eth_stats_reset_t)(struct rte_eth_dev *dev);
 664 /**< @internal Reset global I/O statistics of an Ethernet device to 0. */
 665
 666 typedef int (*eth_queue_stats_mapping_set_t)(struct rte_eth_dev *dev,
 667                                              uint16_t queue_id,
 668                                              uint8_t stat_idx,
 669                                              uint8_t is_rx);
 670 /**< @internal Set a queue statistics mapping for a tx/rx queue of an Ethernet device. */
 671
 672 typedef void (*eth_dev_infos_get_t)(struct rte_eth_dev *dev,
 673                                     struct rte_eth_dev_info *dev_info);
 674 /**< @internal Get specific informations of an Ethernet device. */
 675
 676 typedef int (*eth_rx_queue_setup_t)(struct rte_eth_dev *dev,
 677                                     uint16_t rx_queue_id,
 678                                     uint16_t nb_rx_desc,
 679                                     unsigned int socket_id,
 680                                     const struct rte_eth_rxconf *rx_conf,
 681                                     struct rte_mempool *mb_pool);
 682 /**< @internal Set up a receive queue of an Ethernet device. */
 683
 684 typedef int (*eth_tx_queue_setup_t)(struct rte_eth_dev *dev,
 685                                     uint16_t tx_queue_id,
 686                                     uint16_t nb_tx_desc,
 687                                     unsigned int socket_id,
 688                                     const struct rte_eth_txconf *tx_conf);
 689 /**< @internal Setup a transmit queue of an Ethernet device. */
 690
 691 typedef void (*vlan_filter_set_t)(struct rte_eth_dev *dev,
 692                                   uint16_t vlan_id,
 693                                   int on);
 694 /**< @internal filtering of a VLAN Tag Identifier by an Ethernet device. */
 695
 696 typedef uint16_t (*eth_rx_burst_t)(struct igb_rx_queue *rxq,
 697                                    struct rte_mbuf **rx_pkts,
 698                                    uint16_t nb_pkts);
 699 /**< @internal Retrieve input packets from a receive queue of an Ethernet device. */
 700
 701 typedef uint16_t (*eth_tx_burst_t)(struct igb_tx_queue *txq,
 702                                    struct rte_mbuf **tx_pkts,
 703                                    uint16_t nb_pkts);
 704 /**< @internal Send output packets on a transmit queue of an Ethernet device. */
 705
 706 typedef int (*fdir_add_signature_filter_t)(struct rte_eth_dev *dev,
 707                                            struct rte_fdir_filter *fdir_ftr,
 708                                            uint8_t rx_queue);
 709 /**< @internal Setup a new signature filter rule on an Ethernet device */
 710
 711 typedef int (*fdir_update_signature_filter_t)(struct rte_eth_dev *dev,
 712                                               struct rte_fdir_filter *fdir_ftr,
 713                                               uint8_t rx_queue);
 714 /**< @internal Update a signature filter rule on an Ethernet device */
 715
 716 typedef int (*fdir_remove_signature_filter_t)(struct rte_eth_dev *dev,
 717                                               struct rte_fdir_filter *fdir_ftr);
 718 /**< @internal Remove a  signature filter rule on an Ethernet device */
 719
 720 typedef void (*fdir_infos_get_t)(struct rte_eth_dev *dev,
 721                                  struct rte_eth_fdir *fdir);
 722 /**< @internal Get information about fdir status */
 723
 724 typedef int (*fdir_add_perfect_filter_t)(struct rte_eth_dev *dev,
 725                                          struct rte_fdir_filter *fdir_ftr,
 726                                          uint16_t soft_id, uint8_t rx_queue,
 727                                          uint8_t drop);
 728 /**< @internal Setup a new perfect filter rule on an Ethernet device */
 729
 730 typedef int (*fdir_update_perfect_filter_t)(struct rte_eth_dev *dev,
 731                                             struct rte_fdir_filter *fdir_ftr,
 732                                             uint16_t soft_id, uint8_t rx_queue,
 733                                             uint8_t drop);
 734 /**< @internal Update a perfect filter rule on an Ethernet device */
 735
 736 typedef int (*fdir_remove_perfect_filter_t)(struct rte_eth_dev *dev,
 737                                             struct rte_fdir_filter *fdir_ftr,
 738                                             uint16_t soft_id);
 739 /**< @internal Remove a perfect filter rule on an Ethernet device */
 740
 741 typedef int (*fdir_set_masks_t)(struct rte_eth_dev *dev,
 742                                 struct rte_fdir_masks *fdir_masks);
 743 /**< @internal Setup flow director masks on an Ethernet device */
 744
 745 typedef int (*flow_ctrl_set_t)(struct rte_eth_dev *dev,
 746                                 struct rte_eth_fc_conf *fc_conf);
 747 /**< @internal Setup flow control parameter on an Ethernet device */
 748
 749 typedef int (*eth_dev_led_on_t)(struct rte_eth_dev *dev);
 750 /**< @internal Turn on SW controllable LED on an Ethernet device */
 751
 752 typedef int (*eth_dev_led_off_t)(struct rte_eth_dev *dev);
 753 /**< @internal Turn off SW controllable LED on an Ethernet device */
 754
 755 typedef void (*eth_mac_addr_remove_t)(struct rte_eth_dev *dev, uint32_t index);
 756 /**< @internal Remove MAC address from receive address register */
 757
 758 typedef void (*eth_mac_addr_add_t)(struct rte_eth_dev *dev,
 759                                   struct ether_addr *mac_addr,
 760                                   uint32_t index,
 761                                   uint32_t vmdq);
 762 /**< @internal Set a MAC address into Receive Address Address Register */
 763
 764 /**
 765  * @internal A structure containing the functions exported by an Ethernet driver.
 766  */
 767 struct eth_dev_ops {
 768         eth_dev_configure_t        dev_configure; /**< Configure device. */
 769         eth_dev_start_t            dev_start;     /**< Start device. */
 770         eth_dev_stop_t             dev_stop;      /**< Stop device. */
 771         eth_dev_close_t            dev_close;     /**< Close device. */
 772         eth_promiscuous_enable_t   promiscuous_enable; /**< Promiscuous ON. */
 773         eth_promiscuous_disable_t  promiscuous_disable;/**< Promiscuous OFF. */
 774         eth_allmulticast_enable_t  allmulticast_enable;/**< RX multicast ON. */
 775         eth_allmulticast_disable_t allmulticast_disable;/**< RX multicast OF. */
 776         eth_link_update_t          link_update;   /**< Get device link state. */
 777         eth_stats_get_t            stats_get;     /**< Get device statistics. */
 778         eth_stats_reset_t          stats_reset;   /**< Reset device statistics. */
 779         eth_queue_stats_mapping_set_t queue_stats_mapping_set;
 780         /**< Configure per queue stat counter mapping. */
 781         eth_dev_infos_get_t        dev_infos_get; /**< Get device info. */
 782         vlan_filter_set_t          vlan_filter_set;  /**< Filter VLAN Setup. */
 783         eth_rx_queue_setup_t       rx_queue_setup;/**< Set up device RX queue.*/
 784         eth_tx_queue_setup_t       tx_queue_setup;/**< Set up device TX queue.*/
 785         eth_dev_led_on_t           dev_led_on;    /**< Turn on LED. */
 786         eth_dev_led_off_t          dev_led_off;   /**< Turn off LED. */
 787         flow_ctrl_set_t            flow_ctrl_set; /**< Setup flow control. */
 788         eth_mac_addr_remove_t      mac_addr_remove; /**< Remove MAC address */
 789         eth_mac_addr_add_t         mac_addr_add;  /**< Add a MAC address */
 790
 791         /** Add a signature filter. */
 792         fdir_add_signature_filter_t fdir_add_signature_filter;
 793         /** Update a signature filter. */
 794         fdir_update_signature_filter_t fdir_update_signature_filter;
 795         /** Remove a signature filter. */
 796         fdir_remove_signature_filter_t fdir_remove_signature_filter;
 797         /** Get information about FDIR status. */
 798         fdir_infos_get_t fdir_infos_get;
 799         /** Add a perfect filter. */
 800         fdir_add_perfect_filter_t fdir_add_perfect_filter;
 801         /** Update a perfect filter. */
 802         fdir_update_perfect_filter_t fdir_update_perfect_filter;
 803         /** Remove a perfect filter. */
 804         fdir_remove_perfect_filter_t fdir_remove_perfect_filter;
 805         /** Setup masks for FDIR filtering. */
 806         fdir_set_masks_t fdir_set_masks;
 807 };
 808
 809 /**
 810  * @internal
 811  * The generic data structure associated with each ethernet device.
 812  *
 813  * Pointers to burst-oriented packet receive and transmit functions are
 814  * located at the beginning of the structure, along with the pointer to
 815  * where all the data elements for the particular device are stored in shared
 816  * memory. This split allows the function pointer and driver data to be per-
 817  * process, while the actual configuration data for the device is shared.
 818  */
 819 struct rte_eth_dev {
 820         eth_rx_burst_t rx_pkt_burst; /**< Pointer to PMD receive function. */
 821         eth_tx_burst_t tx_pkt_burst; /**< Pointer to PMD transmit function. */
 822         struct rte_eth_dev_data *data;  /**< Pointer to device data */
 823         const struct eth_driver *driver;/**< Driver for this device */
 824         struct eth_dev_ops *dev_ops;    /**< Functions exported by PMD */
 825         struct rte_pci_device *pci_dev; /**< PCI info. supplied by probing */
 826         struct rte_eth_dev_cb_list callbacks; /**< User application callbacks */
 827 };
 828
 829 /**
 830  * @internal
 831  * The data part, with no function pointers, associated with each ethernet device.
 832  *
 833  * This structure is safe to place in shared memory to be common among different
 834  * processes in a multi-process configuration.
 835  */
 836 struct rte_eth_dev_data {
 837         struct igb_rx_queue **rx_queues; /**< Array of pointers to RX queues. */
 838         struct igb_tx_queue **tx_queues; /**< Array of pointers to TX queues. */
 839         uint16_t nb_rx_queues; /**< Number of RX queues. */
 840         uint16_t nb_tx_queues; /**< Number of TX queues. */
 841
 842         void *dev_private;              /**< PMD-specific private data */
 843
 844         struct rte_eth_link dev_link;
 845         /**< Link-level information & status */
 846
 847         struct rte_eth_conf dev_conf;   /**< Configuration applied to device. */
 848         uint16_t max_frame_size;        /**< Default is ETHER_MAX_LEN (1518). */
 849
 850         uint64_t rx_mbuf_alloc_failed; /**< RX ring mbuf allocation failures. */
 851         struct ether_addr* mac_addrs;/**< Device Ethernet Link address. */
 852         uint8_t port_id;           /**< Device [external] port identifier. */
 853         uint8_t promiscuous   : 1, /**< RX promiscuous mode ON(1) / OFF(0). */
 854                 scattered_rx : 1,  /**< RX of scattered packets is ON(1) / OFF(0) */
 855                 all_multicast : 1, /**< RX all multicast mode ON(1) / OFF(0). */
 856                 dev_started : 1;   /**< Device state: STARTED(1) / STOPPED(0). */
 857 };
 858
 859 /**
 860  * @internal
 861  * The pool of *rte_eth_dev* structures. The size of the pool
 862  * is configured at compile-time in the <rte_ethdev.c> file.
 863  */
 864 extern struct rte_eth_dev rte_eth_devices[];
 865
 866 /**
 867  * Get the total number of Ethernet devices that have been successfully
 868  * initialized by the [matching] Ethernet driver during the PCI probing phase.
 869  * All devices whose port identifier is in the range
 870  * [0,  rte_eth_dev_count() - 1] can be operated on by network applications.
 871  *
 872  * @return
 873  *   - The total number of usable Ethernet devices.
 874  */
 875 extern uint8_t rte_eth_dev_count(void);
 876
 877 struct eth_driver;
 878 /**
 879  * @internal
 880  * Initialization function of an Ethernet driver invoked for each matching
 881  * Ethernet PCI device detected during the PCI probing phase.
 882  *
 883  * @param eth_drv
 884  *   The pointer to the [matching] Ethernet driver structure supplied by
 885  *   the PMD when it registered itself.
 886  * @param eth_dev
 887  *   The *eth_dev* pointer is the address of the *rte_eth_dev* structure
 888  *   associated with the matching device and which have been [automatically]
 889  *   allocated in the *rte_eth_devices* array.
 890  *   The *eth_dev* structure is supplied to the driver initialization function
 891  *   with the following fields already initialized:
 892  *
 893  *   - *pci_dev*: Holds the pointers to the *rte_pci_device* structure which
 894  *     contains the generic PCI information of the matching device.
 895  *
 896  *   - *dev_private*: Holds a pointer to the device private data structure.
 897  *
 898  *   - *max_frame_size*: Contains the default Ethernet maximum frame length
 899  *     (1518).
 900  *
 901  *   - *port_id*: Contains the port index of the device (actually the index
 902  *     of the *eth_dev* structure in the *rte_eth_devices* array).
 903  *
 904  * @return
 905  *   - 0: Success, the device is properly initialized by the driver.
 906  *        In particular, the driver MUST have set up the *dev_ops* pointer
 907  *        of the *eth_dev* structure.
 908  *   - <0: Error code of the device initialization failure.
 909  */
 910 typedef int (*eth_dev_init_t)(struct eth_driver  *eth_drv,
 911                               struct rte_eth_dev *eth_dev);
 912
 913 /**
 914  * @internal
 915  * The structure associated with a PMD Ethernet driver.
 916  *
 917  * Each Ethernet driver acts as a PCI driver and is represented by a generic
 918  * *eth_driver* structure that holds:
 919  *
 920  * - An *rte_pci_driver* structure (which must be the first field).
 921  *
 922  * - The *eth_dev_init* function invoked for each matching PCI device.
 923  *
 924  * - The size of the private data to allocate for each matching device.
 925  */
 926 struct eth_driver {
 927         struct rte_pci_driver pci_drv;    /**< The PMD is also a PCI driver. */
 928         eth_dev_init_t eth_dev_init;      /**< Device init function. */
 929         unsigned int dev_private_size;    /**< Size of device private data. */
 930 };
 931
 932 /**
 933  * @internal
 934  * A function invoked by the initialization function of an Ethernet driver
 935  * to simultaneously register itself as a PCI driver and as an Ethernet
 936  * Poll Mode Driver (PMD).
 937  *
 938  * @param eth_drv
 939  *   The pointer to the *eth_driver* structure associated with
 940  *   the Ethernet driver.
 941  */
 942 extern void rte_eth_driver_register(struct eth_driver *eth_drv);
 943
 944 /**
 945  * The initialization function of the driver for
 946  * Intel(r) IGB Gigabit Ethernet Controller devices.
 947  * This function is invoked once at EAL start time.
 948  * @return
 949  *   0 on success
 950  */
 951 extern int rte_igb_pmd_init(void);
 952
 953 /**
 954  * The initialization function of the driver for
 955  * Intel(r) EM Gigabit Ethernet Controller devices.
 956  * This function is invoked once at EAL start time.
 957  * @return
 958  *   0 on success
 959  */
 960 extern int rte_em_pmd_init(void);
 961
 962 /**
 963  * The initialization function of the driver for 1Gbps Intel IGB_VF
 964  * Ethernet devices.
 965  * Invoked once at EAL start time.
 966  * @return
 967  *   0 on success
 968  */
 969 extern int rte_igbvf_pmd_init(void);
 970
 971 /**
 972  * The initialization function of the driver for 10Gbps Intel IXGBE
 973  * Ethernet devices.
 974  * Invoked once at EAL start time.
 975  * @return
 976  *   0 on success
 977  */
 978 extern int rte_ixgbe_pmd_init(void);
 979
 980 /**
 981  * The initialization function of the driver for 10Gbps Intel IXGBE_VF
 982  * Ethernet devices.
 983  * Invoked once at EAL start time.
 984  * @return
 985  *   0 on success
 986  */
 987 extern int rte_ixgbevf_pmd_init(void);
 988
 989 /**
 990  * The initialization function of *all* supported and enabled drivers.
 991  * Right now, the following PMDs are supported:
 992  *  - igb
 993  *  - igbvf
 994  *  - em
 995  *  - ixgbe
 996  *  - ixgbevf
 997  * This function is invoked once at EAL start time.
 998  * @return
 999  *   0 on success.
1000  *   Error code of the device initialization failure,
1001  *   -ENODEV if there are no drivers available
1002  *   (e.g. if all driver config options are = n).
1003  */
1004 static inline
1005 int rte_pmd_init_all(void)
1006 {
1007         int ret = -ENODEV;
1008
1009 #ifdef RTE_LIBRTE_IGB_PMD
1010         if ((ret = rte_igb_pmd_init()) != 0) {
1011                 RTE_LOG(ERR, PMD, "Cannot init igb PMD\n");
1012                 return (ret);
1013         }
1014         if ((ret = rte_igbvf_pmd_init()) != 0) {
1015                 RTE_LOG(ERR, PMD, "Cannot init igbvf PMD\n");
1016                 return (ret);
1017         }
1018 #endif /* RTE_LIBRTE_IGB_PMD */
1019
1020 #ifdef RTE_LIBRTE_EM_PMD
1021         if ((ret = rte_em_pmd_init()) != 0) {
1022                 RTE_LOG(ERR, PMD, "Cannot init em PMD\n");
1023                 return (ret);
1024         }
1025 #endif /* RTE_LIBRTE_EM_PMD */
1026
1027 #ifdef RTE_LIBRTE_IXGBE_PMD
1028         if ((ret = rte_ixgbe_pmd_init()) != 0) {
1029                 RTE_LOG(ERR, PMD, "Cannot init ixgbe PMD\n");
1030                 return (ret);
1031         }
1032         if ((ret = rte_ixgbevf_pmd_init()) != 0) {
1033                 RTE_LOG(ERR, PMD, "Cannot init ixgbevf PMD\n");
1034                 return (ret);
1035         }
1036 #endif /* RTE_LIBRTE_IXGBE_PMD */
1037
1038         if (ret == -ENODEV)
1039                 RTE_LOG(ERR, PMD, "No PMD(s) are configured\n");
1040         return (ret);
1041 }
1042
1043 /**
1044  * Configure an Ethernet device.
1045  * This function must be invoked first before any other function in the
1046  * Ethernet API. This function can also be re-invoked when a device is in the
1047  * stopped state.
1048  *
1049  * @param port_id
1050  *   The port identifier of the Ethernet device to configure.
1051  * @param nb_rx_queue
1052  *   The number of receive queues to set up for the Ethernet device.
1053  * @param nb_tx_queue
1054  *   The number of transmit queues to set up for the Ethernet device.
1055  * @param eth_conf
1056  *   The pointer to the configuration data to be used for the Ethernet device.
1057  *   The *rte_eth_conf* structure includes:
1058  *     -  the hardware offload features to activate, with dedicated fields for
1059  *        each statically configurable offload hardware feature provided by
1060  *        Ethernet devices, such as IP checksum or VLAN tag stripping for
1061  *        example.
1062  *     - the Receive Side Scaling (RSS) configuration when using multiple RX
1063  *         queues per port.
1064  *
1065  *   Embedding all configuration information in a single data structure
1066  *   is the more flexible method that allows the addition of new features
1067  *   without changing the syntax of the API.
1068  * @return
1069  *   - 0: Success, device configured.
1070  *   - <0: Error code returned by the driver configuration function.
1071  */
1072 extern int rte_eth_dev_configure(uint8_t port_id,
1073                                  uint16_t nb_rx_queue,
1074                                  uint16_t nb_tx_queue,
1075                                  const struct rte_eth_conf *eth_conf);
1076
1077 /**
1078  * Allocate and set up a receive queue for an Ethernet device.
1079  *
1080  * The function allocates a contiguous block of memory for *nb_rx_desc*
1081  * receive descriptors from a memory zone associated with *socket_id*
1082  * and initializes each receive descriptor with a network buffer allocated
1083  * from the memory pool *mb_pool*.
1084  *
1085  * @param port_id
1086  *   The port identifier of the Ethernet device.
1087  * @param rx_queue_id
1088  *   The index of the receive queue to set up.
1089  *   The value must be in the range [0, nb_rx_queue - 1] previously supplied
1090  *   to rte_eth_dev_configure().
1091  * @param nb_rx_desc
1092  *   The number of receive descriptors to allocate for the receive ring.
1093  * @param socket_id
1094  *   The *socket_id* argument is the socket identifier in case of NUMA.
1095  *   The value can be *SOCKET_ID_ANY* if there is no NUMA constraint for
1096  *   the DMA memory allocated for the receive descriptors of the ring.
1097  * @param rx_conf
1098  *   The pointer to the configuration data to be used for the receive queue.
1099  *   The *rx_conf* structure contains an *rx_thresh* structure with the values
1100  *   of the Prefetch, Host, and Write-Back threshold registers of the receive
1101  *   ring.
1102  * @param mb_pool
1103  *   The pointer to the memory pool from which to allocate *rte_mbuf* network
1104  *   memory buffers to populate each descriptor of the receive ring.
1105  * @return
1106  *   - 0: Success, receive queue correctly set up.
1107  *   - -EINVAL: The size of network buffers which can be allocated from the
1108  *      memory pool does not fit the various buffer sizes allowed by the
1109  *      device controller.
1110  *   - -ENOMEM: Unable to allocate the receive ring descriptors or to
1111  *      allocate network memory buffers from the memory pool when
1112  *      initializing receive descriptors.
1113  */
1114 extern int rte_eth_rx_queue_setup(uint8_t port_id, uint16_t rx_queue_id,
1115                                   uint16_t nb_rx_desc, unsigned int socket_id,
1116                                   const struct rte_eth_rxconf *rx_conf,
1117                                   struct rte_mempool *mb_pool);
1118
1119 /**
1120  * Allocate and set up a transmit queue for an Ethernet device.
1121  *
1122  * @param port_id
1123  *   The port identifier of the Ethernet device.
1124  * @param tx_queue_id
1125  *   The index of the transmit queue to set up.
1126  *   The value must be in the range [0, nb_tx_queue - 1] previously supplied
1127  *   to rte_eth_dev_configure().
1128  * @param nb_tx_desc
1129  *   The number of transmit descriptors to allocate for the transmit ring.
1130  * @param socket_id
1131  *   The *socket_id* argument is the socket identifier in case of NUMA.
1132  *   Its value can be *SOCKET_ID_ANY* if there is no NUMA constraint for
1133  *   the DMA memory allocated for the transmit descriptors of the ring.
1134  * @param tx_conf
1135  *   The pointer to the configuration data to be used for the transmit queue.
1136  *   The *tx_conf* structure contains the following data:
1137  *   - The *tx_thresh* structure with the values of the Prefetch, Host, and
1138  *     Write-Back threshold registers of the transmit ring.
1139  *     When setting Write-Back threshold to the value greater then zero,
1140  *     *tx_rs_thresh* value should be explicitly set to one.
1141  *   - The *tx_free_thresh* value indicates the [minimum] number of network
1142  *     buffers that must be pending in the transmit ring to trigger their
1143  *     [implicit] freeing by the driver transmit function.
1144  *   - The *tx_rs_thresh* value indicates the [minimum] number of transmit
1145  *     descriptors that must be pending in the transmit ring before setting the
1146  *     RS bit on a descriptor by the driver transmit function.
1147  *     The *tx_rs_thresh* value should be less or equal then
1148  *     *tx_free_thresh* value, and both of them should be less then
1149  *     *nb_tx_desc* - 3.
1150  *
1151  *     Note that setting *tx_free_thresh* or *tx_rs_thresh* value to 0 forces
1152  *     the transmit function to use default values.
1153  * @return
1154  *   - 0: Success, the transmit queue is correctly set up.
1155  *   - -ENOMEM: Unable to allocate the transmit ring descriptors.
1156  */
1157 extern int rte_eth_tx_queue_setup(uint8_t port_id, uint16_t tx_queue_id,
1158                                   uint16_t nb_tx_desc, unsigned int socket_id,
1159                                   const struct rte_eth_txconf *tx_conf);
1160
1161 /**
1162  * Start an Ethernet device.
1163  *
1164  * The device start step is the last one and consists of setting the configured
1165  * offload features and in starting the transmit and the receive units of the
1166  * device.
1167  * On success, all basic functions exported by the Ethernet API (link status,
1168  * receive/transmit, and so on) can be invoked.
1169  *
1170  * @param port_id
1171  *   The port identifier of the Ethernet device.
1172  * @return
1173  *   - 0: Success, Ethernet device started.
1174  *   - <0: Error code of the driver device start function.
1175  */
1176 extern int rte_eth_dev_start(uint8_t port_id);
1177
1178 /**
1179  * Stop an Ethernet device. The device can be restarted with a call to
1180  * rte_eth_dev_start()
1181  *
1182  * @param port_id
1183  *   The port identifier of the Ethernet device.
1184  */
1185 extern void rte_eth_dev_stop(uint8_t port_id);
1186
1187 /**
1188  * Close an Ethernet device. The device cannot be restarted!
1189  *
1190  * @param port_id
1191  *   The port identifier of the Ethernet device.
1192  */
1193 extern void rte_eth_dev_close(uint8_t port_id);
1194
1195 /**
1196  * Enable receipt in promiscuous mode for an Ethernet device.
1197  *
1198  * @param port_id
1199  *   The port identifier of the Ethernet device.
1200  */
1201 extern void rte_eth_promiscuous_enable(uint8_t port_id);
1202
1203 /**
1204  * Disable receipt in promiscuous mode for an Ethernet device.
1205  *
1206  * @param port_id
1207  *   The port identifier of the Ethernet device.
1208  */
1209 extern void rte_eth_promiscuous_disable(uint8_t port_id);
1210
1211 /**
1212  * Return the value of promiscuous mode for an Ethernet device.
1213  *
1214  * @param port_id
1215  *   The port identifier of the Ethernet device.
1216  * @return
1217  *   - (1) if promiscuous is enabled
1218  *   - (0) if promiscuous is disabled.
1219  *   - (-1) on error
1220  */
1221 extern int rte_eth_promiscuous_get(uint8_t port_id);
1222
1223 /**
1224  * Enable the receipt of any multicast frame by an Ethernet device.
1225  *
1226  * @param port_id
1227  *   The port identifier of the Ethernet device.
1228  */
1229 extern void rte_eth_allmulticast_enable(uint8_t port_id);
1230
1231 /**
1232  * Disable the receipt of all multicast frames by an Ethernet device.
1233  *
1234  * @param port_id
1235  *   The port identifier of the Ethernet device.
1236  */
1237 extern void rte_eth_allmulticast_disable(uint8_t port_id);
1238
1239 /**
1240  * Return the value of allmulticast mode for an Ethernet device.
1241  *
1242  * @param port_id
1243  *   The port identifier of the Ethernet device.
1244  * @return
1245  *   - (1) if allmulticast is enabled
1246  *   - (0) if allmulticast is disabled.
1247  *   - (-1) on error
1248  */
1249 extern int rte_eth_allmulticast_get(uint8_t port_id);
1250
1251 /**
1252  * Retrieve the status (ON/OFF), the speed (in Mbps) and the mode (HALF-DUPLEX
1253  * or FULL-DUPLEX) of the physical link of an Ethernet device. It might need
1254  * to wait up to 9 seconds in it.
1255  *
1256  * @param port_id
1257  *   The port identifier of the Ethernet device.
1258  * @param link
1259  *   A pointer to an *rte_eth_link* structure to be filled with
1260  *   the status, the speed and the mode of the Ethernet device link.
1261  */
1262 extern void rte_eth_link_get(uint8_t port_id, struct rte_eth_link *link);
1263
1264 /**
1265  * Retrieve the status (ON/OFF), the speed (in Mbps) and the mode (HALF-DUPLEX
1266  * or FULL-DUPLEX) of the physical link of an Ethernet device. It is a no-wait
1267  * version of rte_eth_link_get().
1268  *
1269  * @param port_id
1270  *   The port identifier of the Ethernet device.
1271  * @param link
1272  *   A pointer to an *rte_eth_link* structure to be filled with
1273  *   the status, the speed and the mode of the Ethernet device link.
1274  */
1275 extern void rte_eth_link_get_nowait(uint8_t port_id,
1276                                 struct rte_eth_link *link);
1277
1278 /**
1279  * Retrieve the general I/O statistics of an Ethernet device.
1280  *
1281  * @param port_id
1282  *   The port identifier of the Ethernet device.
1283  * @param stats
1284  *   A pointer to a structure of type *rte_eth_stats* to be filled with
1285  *   the values of device counters for the following set of statistics:
1286  *   - *ipackets* with the total of successfully received packets.
1287  *   - *opackets* with the total of successfully transmitted packets.
1288  *   - *ibytes*   with the total of successfully received bytes.
1289  *   - *obytes*   with the total of successfully transmitted bytes.
1290  *   - *ierrors*  with the total of erroneous received packets.
1291  *   - *oerrors*  with the total of failed transmitted packets.
1292  */
1293 extern void rte_eth_stats_get(uint8_t port_id, struct rte_eth_stats *stats);
1294
1295 /**
1296  * Reset the general I/O statistics of an Ethernet device.
1297  *
1298  * @param port_id
1299  *   The port identifier of the Ethernet device.
1300  */
1301 extern void rte_eth_stats_reset(uint8_t port_id);
1302
1303 /**
1304  *  Set a mapping for the specified transmit queue to the specified per-queue
1305  *  statistics counter.
1306  *
1307  * @param port_id
1308  *   The port identifier of the Ethernet device.
1309  * @param tx_queue_id
1310  *   The index of the transmit queue for which a queue stats mapping is required.
1311  *   The value must be in the range [0, nb_tx_queue - 1] previously supplied
1312  *   to rte_eth_dev_configure().
1313  * @param stat_idx
1314  *   The per-queue packet statistics functionality number that the transmit
1315  *   queue is to be assigned.
1316  *   The value must be in the range [0, RTE_MAX_ETHPORT_QUEUE_STATS_MAPS - 1].
1317  * @return
1318  *   Zero if successful. Non-zero otherwise.
1319  */
1320 extern int rte_eth_dev_set_tx_queue_stats_mapping(uint8_t port_id,
1321                                                   uint16_t tx_queue_id,
1322                                                   uint8_t stat_idx);
1323
1324 /**
1325  *  Set a mapping for the specified receive queue to the specified per-queue
1326  *  statistics counter.
1327  *
1328  * @param port_id
1329  *   The port identifier of the Ethernet device.
1330  * @param rx_queue_id
1331  *   The index of the receive queue for which a queue stats mapping is required.
1332  *   The value must be in the range [0, nb_rx_queue - 1] previously supplied
1333  *   to rte_eth_dev_configure().
1334  * @param stat_idx
1335  *   The per-queue packet statistics functionality number that the receive
1336  *   queue is to be assigned.
1337  *   The value must be in the range [0, RTE_MAX_ETHPORT_QUEUE_STATS_MAPS - 1].
1338  * @return
1339  *   Zero if successful. Non-zero otherwise.
1340  */
1341 extern int rte_eth_dev_set_rx_queue_stats_mapping(uint8_t port_id,
1342                                                   uint16_t rx_queue_id,
1343                                                   uint8_t stat_idx);
1344
1345 /**
1346  * Retrieve the Ethernet address of an Ethernet device.
1347  *
1348  * @param port_id
1349  *   The port identifier of the Ethernet device.
1350  * @param mac_addr
1351  *   A pointer to a structure of type *ether_addr* to be filled with
1352  *   the Ethernet address of the Ethernet device.
1353  */
1354 extern void rte_eth_macaddr_get(uint8_t port_id, struct ether_addr *mac_addr);
1355
1356 /**
1357  * Retrieve the contextual information of an Ethernet device.
1358  *
1359  * @param port_id
1360  *   The port identifier of the Ethernet device.
1361  * @param dev_info
1362  *   A pointer to a structure of type *rte_eth_dev_info* to be filled with
1363  *   the contextual information of the Ethernet device.
1364  */
1365 extern void rte_eth_dev_info_get(uint8_t port_id,
1366                                  struct rte_eth_dev_info *dev_info);
1367
1368 /**
1369  * Enable/Disable hardware filtering by an Ethernet device of received
1370  * VLAN packets tagged with a given VLAN Tag Identifier.
1371  *
1372  * @param port_id
1373  *   The port identifier of the Ethernet device.
1374  * @param vlan_id
1375  *   The VLAN Tag Identifier whose filtering must be enabled or disabled.
1376  * @param on
1377  *   If > 0, enable VLAN filtering of VLAN packets tagged with *vlan_id*.
1378  *   Otherwise, disable VLAN filtering of VLAN packets tagged with *vlan_id*.
1379  * @return
1380  *   - (0) if successful.
1381  *   - (-ENOSUP) if hardware-assisted VLAN filtering not configured.
1382  *   - (-ENODEV) if *port_id* invalid.
1383  *   - (-ENOSYS) if VLAN filtering on *port_id* disabled.
1384  *   - (-EINVAL) if *vlan_id* > 4095.
1385  */
1386 extern int rte_eth_dev_vlan_filter(uint8_t port_id, uint16_t vlan_id, int on);
1387
1388 /**
1389  *
1390  * Retrieve a burst of input packets from a receive queue of an Ethernet
1391  * device. The retrieved packets are stored in *rte_mbuf* structures whose
1392  * pointers are supplied in the *rx_pkts* array.
1393  *
1394  * The rte_eth_rx_burst() function loops, parsing the RX ring of the
1395  * receive queue, up to *nb_pkts* packets, and for each completed RX
1396  * descriptor in the ring, it performs the following operations:
1397  *
1398  * - Initialize the *rte_mbuf* data structure associated with the
1399  *   RX descriptor according to the information provided by the NIC into
1400  *   that RX descriptor.
1401  *
1402  * - Store the *rte_mbuf* data structure into the next entry of the
1403  *   *rx_pkts* array.
1404  *
1405  * - Replenish the RX descriptor with a new *rte_mbuf* buffer
1406  *   allocated from the memory pool associated with the receive queue at
1407  *   initialization time.
1408  *
1409  * When retrieving an input packet that was scattered by the controller
1410  * into multiple receive descriptors, the rte_eth_rx_burst() function
1411  * appends the associated *rte_mbuf* buffers to the first buffer of the
1412  * packet.
1413  *
1414  * The rte_eth_rx_burst() function returns the number of packets
1415  * actually retrieved, which is the number of *rte_mbuf* data structures
1416  * effectively supplied into the *rx_pkts* array.
1417  * A return value equal to *nb_pkts* indicates that the RX queue contained
1418  * at least *rx_pkts* packets, and this is likely to signify that other
1419  * received packets remain in the input queue. Applications implementing
1420  * a "retrieve as much received packets as possible" policy can check this
1421  * specific case and keep invoking the rte_eth_rx_burst() function until
1422  * a value less than *nb_pkts* is returned.
1423  *
1424  * This receive method has the following advantages:
1425  *
1426  * - It allows a run-to-completion network stack engine to retrieve and
1427  *   to immediately process received packets in a fast burst-oriented
1428  *   approach, avoiding the overhead of unnecessary intermediate packet
1429  *   queue/dequeue operations.
1430  *
1431  * - Conversely, it also allows an asynchronous-oriented processing
1432  *   method to retrieve bursts of received packets and to immediately
1433  *   queue them for further parallel processing by another logical core,
1434  *   for instance. However, instead of having received packets being
1435  *   individually queued by the driver, this approach allows the invoker
1436  *   of the rte_eth_rx_burst() function to queue a burst of retrieved
1437  *   packets at a time and therefore dramatically reduce the cost of
1438  *   enqueue/dequeue operations per packet.
1439  *
1440  * - It allows the rte_eth_rx_burst() function of the driver to take
1441  *   advantage of burst-oriented hardware features (CPU cache,
1442  *   prefetch instructions, and so on) to minimize the number of CPU
1443  *   cycles per packet.
1444  *
1445  * To summarize, the proposed receive API enables many
1446  * burst-oriented optimizations in both synchronous and asynchronous
1447  * packet processing environments with no overhead in both cases.
1448  *
1449  * The rte_eth_rx_burst() function does not provide any error
1450  * notification to avoid the corresponding overhead. As a hint, the
1451  * upper-level application might check the status of the device link once
1452  * being systematically returned a 0 value for a given number of tries.
1453  *
1454  * @param port_id
1455  *   The port identifier of the Ethernet device.
1456  * @param queue_id
1457  *   The index of the receive queue from which to retrieve input packets.
1458  *   The value must be in the range [0, nb_rx_queue - 1] previously supplied
1459  *   to rte_eth_dev_configure().
1460  * @param rx_pkts
1461  *   The address of an array of pointers to *rte_mbuf* structures that
1462  *   must be large enough to store *nb_pkts* pointers in it.
1463  * @param nb_pkts
1464  *   The maximum number of packets to retrieve.
1465  * @return
1466  *   The number of packets actually retrieved, which is the number
1467  *   of pointers to *rte_mbuf* structures effectively supplied to the
1468  *   *rx_pkts* array.
1469  */
1470 #ifdef RTE_LIBRTE_ETHDEV_DEBUG
1471 extern uint16_t rte_eth_rx_burst(uint8_t port_id, uint16_t queue_id,
1472                                  struct rte_mbuf **rx_pkts, uint16_t nb_pkts);
1473 #else
1474 static inline uint16_t
1475 rte_eth_rx_burst(uint8_t port_id, uint16_t queue_id,
1476                  struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
1477 {
1478         struct rte_eth_dev *dev;
1479
1480         dev = &rte_eth_devices[port_id];
1481         return (*dev->rx_pkt_burst)(dev->data->rx_queues[queue_id], rx_pkts, nb_pkts);
1482 }
1483 #endif
1484
1485 /**
1486  * Send a burst of output packets on a transmit queue of an Ethernet device.
1487  *
1488  * The rte_eth_tx_burst() function is invoked to transmit output packets
1489  * on the output queue *queue_id* of the Ethernet device designated by its
1490  * *port_id*.
1491  * The *nb_pkts* parameter is the number of packets to send which are
1492  * supplied in the *tx_pkts* array of *rte_mbuf* structures.
1493  * The rte_eth_tx_burst() function loops, sending *nb_pkts* packets,
1494  * up to the number of transmit descriptors available in the TX ring of the
1495  * transmit queue.
1496  * For each packet to send, the rte_eth_tx_burst() function performs
1497  * the following operations:
1498  *
1499  * - Pick up the next available descriptor in the transmit ring.
1500  *
1501  * - Free the network buffer previously sent with that descriptor, if any.
1502  *
1503  * - Initialize the transmit descriptor with the information provided
1504  *   in the *rte_mbuf data structure.
1505  *
1506  * In the case of a segmented packet composed of a list of *rte_mbuf* buffers,
1507  * the rte_eth_tx_burst() function uses several transmit descriptors
1508  * of the ring.
1509  *
1510  * The rte_eth_tx_burst() function returns the number of packets it
1511  * actually sent. A return value equal to *nb_pkts* means that all packets
1512  * have been sent, and this is likely to signify that other output packets
1513  * could be immediately transmitted again. Applications that implement a
1514  * "send as many packets to transmit as possible" policy can check this
1515  * specific case and keep invoking the rte_eth_tx_burst() function until
1516  * a value less than *nb_pkts* is returned.
1517  *
1518  * It is the responsibility of the rte_eth_tx_burst() function to
1519  * transparently free the memory buffers of packets previously sent.
1520  * This feature is driven by the *tx_free_thresh* value supplied to the
1521  * rte_eth_dev_configure() function at device configuration time.
1522  * When the number of previously sent packets reached the "minimum transmit
1523  * packets to free" threshold, the rte_eth_tx_burst() function must
1524  * [attempt to] free the *rte_mbuf*  buffers of those packets whose
1525  * transmission was effectively completed.
1526  *
1527  * @param port_id
1528  *   The port identifier of the Ethernet device.
1529  * @param queue_id
1530  *   The index of the transmit queue through which output packets must be
1531  *   sent.
1532  *   The value must be in the range [0, nb_tx_queue - 1] previously supplied
1533  *   to rte_eth_dev_configure().
1534  * @param tx_pkts
1535  *   The address of an array of *nb_pkts* pointers to *rte_mbuf* structures
1536  *   which contain the output packets.
1537  * @param nb_pkts
1538  *   The maximum number of packets to transmit.
1539  * @return
1540  *   The number of output packets actually stored in transmit descriptors of
1541  *   the transmit ring. The return value can be less than the value of the
1542  *   *tx_pkts* parameter when the transmit ring is full or has been filled up.
1543  */
1544 #ifdef RTE_LIBRTE_ETHDEV_DEBUG
1545 extern uint16_t rte_eth_tx_burst(uint8_t port_id, uint16_t queue_id,
1546                                  struct rte_mbuf **tx_pkts, uint16_t nb_pkts);
1547 #else
1548 static inline uint16_t
1549 rte_eth_tx_burst(uint8_t port_id, uint16_t queue_id,
1550                  struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
1551 {
1552         struct rte_eth_dev *dev;
1553
1554         dev = &rte_eth_devices[port_id];
1555         return (*dev->tx_pkt_burst)(dev->data->tx_queues[queue_id], tx_pkts, nb_pkts);
1556 }
1557 #endif
1558
1559 /**
1560  * Setup a new signature filter rule on an Ethernet device
1561  *
1562  * @param port_id
1563  *   The port identifier of the Ethernet device.
1564  * @param fdir_filter
1565  *   The pointer to the fdir filter structure describing the signature filter
1566  *   rule.
1567  *   The *rte_fdir_filter* structure includes the values of the different fields
1568  *   to match: source and destination IP addresses, vlan id, flexbytes, source
1569  *   and destination ports, and so on.
1570  * @param rx_queue
1571  *   The index of the RX queue where to store RX packets matching the added
1572  *   signature filter defined in fdir_filter.
1573  * @return
1574  *   - (0) if successful.
1575  *   - (-ENOTSUP) if hardware doesn't support flow director mode.
1576  *   - (-ENODEV) if *port_id* invalid.
1577  *   - (-ENOSYS) if the FDIR mode is not configured in signature mode
1578  *               on *port_id*.
1579  *   - (-EINVAL) if the fdir_filter information is not correct.
1580  */
1581 int rte_eth_dev_fdir_add_signature_filter(uint8_t port_id,
1582                                           struct rte_fdir_filter *fdir_filter,
1583                                           uint8_t rx_queue);
1584
1585 /**
1586  * Update a signature filter rule on an Ethernet device.
1587  * If the rule doesn't exits, it is created.
1588  *
1589  * @param port_id
1590  *   The port identifier of the Ethernet device.
1591  * @param fdir_ftr
1592  *   The pointer to the structure describing the signature filter rule.
1593  *   The *rte_fdir_filter* structure includes the values of the different fields
1594  *   to match: source and destination IP addresses, vlan id, flexbytes, source
1595  *   and destination ports, and so on.
1596  * @param rx_queue
1597  *   The index of the RX queue where to store RX packets matching the added
1598  *   signature filter defined in fdir_ftr.
1599  * @return
1600  *   - (0) if successful.
1601  *   - (-ENOTSUP) if hardware doesn't support flow director mode.
1602  *   - (-ENODEV) if *port_id* invalid.
1603  *   - (-ENOSYS) if the flow director mode is not configured in signature mode
1604  *     on *port_id*.
1605  *   - (-EINVAL) if the fdir_filter information is not correct.
1606  */
1607 int rte_eth_dev_fdir_update_signature_filter(uint8_t port_id,
1608                                              struct rte_fdir_filter *fdir_ftr,
1609                                              uint8_t rx_queue);
1610
1611 /**
1612  * Remove a signature filter rule on an Ethernet device.
1613  *
1614  * @param port_id
1615  *   The port identifier of the Ethernet device.
1616  * @param fdir_ftr
1617  *   The pointer to the structure describing the signature filter rule.
1618  *   The *rte_fdir_filter* structure includes the values of the different fields
1619  *   to match: source and destination IP addresses, vlan id, flexbytes, source
1620  *   and destination ports, and so on.
1621  * @return
1622  *   - (0) if successful.
1623  *   - (-ENOTSUP) if hardware doesn't support flow director mode.
1624  *   - (-ENODEV) if *port_id* invalid.
1625  *   - (-ENOSYS) if the flow director mode is not configured in signature mode
1626  *     on *port_id*.
1627  *   - (-EINVAL) if the fdir_filter information is not correct.
1628  */
1629 int rte_eth_dev_fdir_remove_signature_filter(uint8_t port_id,
1630                                              struct rte_fdir_filter *fdir_ftr);
1631
1632 /**
1633  * Retrieve the flow director information of an Ethernet device.
1634  *
1635  * @param port_id
1636  *   The port identifier of the Ethernet device.
1637  * @param fdir
1638  *   A pointer to a structure of type *rte_eth_dev_fdir* to be filled with
1639  *   the flow director information of the Ethernet device.
1640  * @return
1641  *   - (0) if successful.
1642  *   - (-ENOTSUP) if hardware doesn't support flow director mode.
1643  *   - (-ENODEV) if *port_id* invalid.
1644  *   - (-ENOSYS) if the flow director mode is not configured on *port_id*.
1645  */
1646 int rte_eth_dev_fdir_get_infos(uint8_t port_id, struct rte_eth_fdir *fdir);
1647
1648 /**
1649  * Add a new perfect filter rule on an Ethernet device.
1650  *
1651  * @param port_id
1652  *   The port identifier of the Ethernet device.
1653  * @param fdir_filter
1654  *   The pointer to the structure describing the perfect filter rule.
1655  *   The *rte_fdir_filter* structure includes the values of the different fields
1656  *   to match: source and destination IP addresses, vlan id, flexbytes, source
1657  *   and destination ports, and so on.
1658  *   IPv6 are not supported.
1659  * @param soft_id
1660  *    The 16-bit value supplied in the field hash.fdir.id of mbuf for RX
1661  *    packets matching the perfect filter.
1662  * @param rx_queue
1663  *   The index of the RX queue where to store RX packets matching the added
1664  *   perfect filter defined in fdir_filter.
1665  * @param drop
1666  *    If drop is set to 1, matching RX packets are stored into the RX drop
1667  *    queue defined in the rte_fdir_conf.
1668  * @return
1669  *   - (0) if successful.
1670  *   - (-ENOTSUP) if hardware doesn't support flow director mode.
1671  *   - (-ENODEV) if *port_id* invalid.
1672  *   - (-ENOSYS) if the flow director mode is not configured in perfect mode
1673  *               on *port_id*.
1674  *   - (-EINVAL) if the fdir_filter information is not correct.
1675  */
1676 int rte_eth_dev_fdir_add_perfect_filter(uint8_t port_id,
1677                                         struct rte_fdir_filter *fdir_filter,
1678                                         uint16_t soft_id, uint8_t rx_queue,
1679                                         uint8_t drop);
1680
1681 /**
1682  * Update a perfect filter rule on an Ethernet device.
1683  * If the rule doesn't exits, it is created.
1684  *
1685  * @param port_id
1686  *   The port identifier of the Ethernet device.
1687  * @param fdir_filter
1688  *   The pointer to the structure describing the perfect filter rule.
1689  *   The *rte_fdir_filter* structure includes the values of the different fields
1690  *   to match: source and destination IP addresses, vlan id, flexbytes, source
1691  *   and destination ports, and so on.
1692  *   IPv6 are not supported.
1693  * @param soft_id
1694  *    The 16-bit value supplied in the field hash.fdir.id of mbuf for RX
1695  *    packets matching the perfect filter.
1696  * @param rx_queue
1697  *   The index of the RX queue where to store RX packets matching the added
1698  *   perfect filter defined in fdir_filter.
1699  * @param drop
1700  *    If drop is set to 1, matching RX packets are stored into the RX drop
1701  *    queue defined in the rte_fdir_conf.
1702  * @return
1703  *   - (0) if successful.
1704  *   - (-ENOTSUP) if hardware doesn't support flow director mode.
1705  *   - (-ENODEV) if *port_id* invalid.
1706  *   - (-ENOSYS) if the flow director mode is not configured in perfect mode
1707  *      on *port_id*.
1708  *   - (-EINVAL) if the fdir_filter information is not correct.
1709  */
1710 int rte_eth_dev_fdir_update_perfect_filter(uint8_t port_id,
1711                                            struct rte_fdir_filter *fdir_filter,
1712                                            uint16_t soft_id, uint8_t rx_queue,
1713                                            uint8_t drop);
1714
1715 /**
1716  * Remove a perfect filter rule on an Ethernet device.
1717  *
1718  * @param port_id
1719  *   The port identifier of the Ethernet device.
1720  * @param fdir_filter
1721  *   The pointer to the structure describing the perfect filter rule.
1722  *   The *rte_fdir_filter* structure includes the values of the different fields
1723  *   to match: source and destination IP addresses, vlan id, flexbytes, source
1724  *   and destination ports, and so on.
1725  *   IPv6 are not supported.
1726  * @param soft_id
1727  *    The soft_id value provided when adding/updating the removed filter.
1728  * @return
1729  *   - (0) if successful.
1730  *   - (-ENOTSUP) if hardware doesn't support flow director mode.
1731  *   - (-ENODEV) if *port_id* invalid.
1732  *   - (-ENOSYS) if the flow director mode is not configured in perfect mode
1733  *      on *port_id*.
1734  *   - (-EINVAL) if the fdir_filter information is not correct.
1735  */
1736 int rte_eth_dev_fdir_remove_perfect_filter(uint8_t port_id,
1737                                            struct rte_fdir_filter *fdir_filter,
1738                                            uint16_t soft_id);
1739 /**
1740  * Configure globally the masks for flow director mode for an Ethernet device.
1741  * For example, the device can match packets with only the first 24 bits of
1742  * the IPv4 source address.
1743  *
1744  * The following fields can be masked: IPv4 addresses and L4 port numbers.
1745  * The following fields can be either enabled or disabled completely for the
1746  * matching functionality: VLAN ID tag; VLAN Priority + CFI bit; Flexible 2-byte
1747  * tuple.
1748  * IPv6 masks are not supported.
1749  *
1750  * All filters must comply with the masks previously configured.
1751  * For example, with a mask equal to 255.255.255.0 for the source IPv4 address,
1752  * all IPv4 filters must be created with a source IPv4 address that fits the
1753  * "X.X.X.0" format.
1754  *
1755  * This function flushes all filters that have been previously added in
1756  * the device.
1757  *
1758  * @param port_id
1759  *   The port identifier of the Ethernet device.
1760  * @param fdir_mask
1761  *   The pointer to the fdir mask structure describing relevant headers fields
1762  *   and relevant bits to use when matching packets addresses and ports.
1763  *   IPv6 masks are not supported.
1764  * @return
1765  *   - (0) if successful.
1766  *   - (-ENOTSUP) if hardware doesn't support flow director mode.
1767  *   - (-ENODEV) if *port_id* invalid.
1768  *   - (-ENOSYS) if the flow director mode is not configured in perfect
1769  *      mode on *port_id*.
1770  *   - (-EINVAL) if the fdir_filter information is not correct
1771  */
1772 int rte_eth_dev_fdir_set_masks(uint8_t port_id,
1773                                struct rte_fdir_masks *fdir_mask);
1774
1775 /**
1776  * The eth device event type for interrupt, and maybe others in the future.
1777  */
1778 enum rte_eth_event_type {
1779         RTE_ETH_EVENT_UNKNOWN,  /**< unknown event type */
1780         RTE_ETH_EVENT_INTR_LSC, /**< lsc interrupt event */
1781         RTE_ETH_EVENT_MAX       /**< max value of this enum */
1782 };
1783
1784 typedef void (*rte_eth_dev_cb_fn)(uint8_t port_id, \
1785                 enum rte_eth_event_type event, void *cb_arg);
1786 /**< user application callback to be registered for interrupts */
1787
1788
1789
1790 /**
1791  * Register a callback function for specific port id.
1792  *
1793  * @param port_id
1794  *  Port id.
1795  * @param event
1796  *  Event interested.
1797  * @param cb_fn
1798  *  User supplied callback function to be called.
1799  * @param cb_arg
1800  *  Pointer to the parameters for the registered callback.
1801  *
1802  * @return
1803  *  - On success, zero.
1804  *  - On failure, a negative value.
1805  */
1806 int rte_eth_dev_callback_register(uint8_t port_id,
1807                         enum rte_eth_event_type event,
1808                 rte_eth_dev_cb_fn cb_fn, void *cb_arg);
1809
1810 /**
1811  * Unregister a callback function for specific port id.
1812  *
1813  * @param port_id
1814  *  Port id.
1815  * @param event
1816  *  Event interested.
1817  * @param cb_fn
1818  *  User supplied callback function to be called.
1819  * @param cb_arg
1820  *  Pointer to the parameters for the registered callback. -1 means to
1821  *  remove all for the same callback address and same event.
1822  *
1823  * @return
1824  *  - On success, zero.
1825  *  - On failure, a negative value.
1826  */
1827 int rte_eth_dev_callback_unregister(uint8_t port_id,
1828                         enum rte_eth_event_type event,
1829                 rte_eth_dev_cb_fn cb_fn, void *cb_arg);
1830
1831 /**
1832  * @internal Executes all the user application registered callbacks for
1833  * the specific device. It is for DPDK internal user only. User
1834  * application should not call it directly.
1835  *
1836  * @param dev
1837  *  Pointer to struct rte_eth_dev.
1838  * @param event
1839  *  Eth device interrupt event type.
1840  *
1841  * @return
1842  *  void
1843  */
1844 void _rte_eth_dev_callback_process(struct rte_eth_dev *dev,
1845                                 enum rte_eth_event_type event);
1846
1847 /**
1848  * Turn on the LED on the Ethernet device.
1849  * This function turns on the LED on the Ethernet device.
1850  *
1851  * @param port_id
1852  *   The port identifier of the Ethernet device.
1853  * @return
1854  *   - (0) if successful.
1855  *   - (-ENOTSUP) if underlying hardware OR driver doesn't support
1856  *     that operation.
1857  *   - (-ENODEV) if *port_id* invalid.
1858  */
1859 int  rte_eth_led_on(uint8_t port_id);
1860
1861 /**
1862  * Turn off the LED on the Ethernet device.
1863  * This function turns off the LED on the Ethernet device.
1864  *
1865  * @param port_id
1866  *   The port identifier of the Ethernet device.
1867  * @return
1868  *   - (0) if successful.
1869  *   - (-ENOTSUP) if underlying hardware OR driver doesn't support
1870  *     that operation.
1871  *   - (-ENODEV) if *port_id* invalid.
1872  */
1873 int  rte_eth_led_off(uint8_t port_id);
1874
1875 /**
1876  * Configure the Ethernet link flow control for Ethernet device
1877  *
1878  * @param port_id
1879  *   The port identifier of the Ethernet device.
1880  * @param fc_conf
1881  *   The pointer to the structure of the flow control parameters.
1882  * @return
1883  *   - (0) if successful.
1884  *   - (-ENOTSUP) if hardware doesn't support flow control mode.
1885  *   - (-ENODEV)  if *port_id* invalid.
1886  *   - (-EINVAL)  if bad parameter
1887  *   - (-EIO)     if flow control setup failure
1888  */
1889 int rte_eth_dev_flow_ctrl_set(uint8_t port_id,
1890                                 struct rte_eth_fc_conf *fc_conf);
1891
1892 /**
1893  * Add a MAC address to an internal array of addresses used to enable whitelist
1894  * filtering to accept packets only if the destination MAC address matches.
1895  *
1896  * @param port
1897  *   The port identifier of the Ethernet device.
1898  * @param mac_addr
1899  *   The MAC address to add.
1900  * @param pool
1901  *   VMDq pool index to associate address with (if VMDq is enabled). If VMDq is
1902  *   not enabled, this should be set to 0.
1903  * @return
1904  *   - (0) if successfully added or *mac_addr" was already added.
1905  *   - (-ENOTSUP) if hardware doesn't support this feature.
1906  *   - (-ENODEV) if *port* is invalid.
1907  *   - (-ENOSPC) if no more MAC addresses can be added.
1908  *   - (-EINVAL) if MAC address is invalid.
1909  */
1910 int rte_eth_dev_mac_addr_add(uint8_t port, struct ether_addr *mac_addr,
1911                                 uint32_t pool);
1912
1913 /**
1914  * Remove a MAC address from the internal array of addresses.
1915  *
1916  * @param port
1917  *   The port identifier of the Ethernet device.
1918  * @param mac_addr
1919  *   MAC address to remove.
1920  * @return
1921  *   - (0) if successful, or *mac_addr* didn't exist.
1922  *   - (-ENOTSUP) if hardware doesn't support.
1923  *   - (-ENODEV) if *port* invalid.
1924  *   - (-EADDRINUSE) if attempting to remove the default MAC address
1925  */
1926 int rte_eth_dev_mac_addr_remove(uint8_t port, struct ether_addr *mac_addr);
1927
1928
1929 #ifdef __cplusplus
1930 }
1931 #endif
1932
1933 #endif /* _RTE_ETHDEV_H_ */