diff options
Diffstat (limited to 'sys/dev/ice/ice_rdma.h')
| -rw-r--r-- | sys/dev/ice/ice_rdma.h | 383 |
1 files changed, 383 insertions, 0 deletions
diff --git a/sys/dev/ice/ice_rdma.h b/sys/dev/ice/ice_rdma.h new file mode 100644 index 000000000000..68aa2f2099e7 --- /dev/null +++ b/sys/dev/ice/ice_rdma.h @@ -0,0 +1,383 @@ +/* SPDX-License-Identifier: BSD-3-Clause */ +/* Copyright (c) 2024, Intel Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @file ice_rdma.h + * @brief header file for RDMA client interface functions + * + * Contains definitions and function calls shared by the ice driver and the + * RDMA client interface driver. + * + * Since these definitions are shared between drivers it is important that any + * changes are considered carefully for backwards compatibility. + */ +#ifndef _ICE_RDMA_H_ +#define _ICE_RDMA_H_ + +/* + * The RDMA client interface version is used to help determine + * incompatibilities between the interface definition shared between the main + * driver and the client driver. + * + * It will follows the semantic version guidelines, that is: + * Given the version number MAJOR.MINOR.PATCH, increment the: + * + * MAJOR version when you make incompatible changes, + * MINOR version when you add functionality in a backwards-compatible manner, and + * PATCH version when you make backwards-compatible bug fixes. + * + * Any change to this file, or one of the kobject interface files must come + * with an associated change in one of the MAJOR, MINOR, or PATCH versions, + * and care must be taken that backwards incompatible changes MUST increment + * the MAJOR version. + * + * Note: Until the MAJOR version is set to at least 1, the above semantic + * version guarantees may not hold, and this interface should not be + * considered stable. + */ +#define ICE_RDMA_MAJOR_VERSION 1 +#define ICE_RDMA_MINOR_VERSION 1 +#define ICE_RDMA_PATCH_VERSION 0 + +/** + * @def ICE_RDMA_MAX_MSIX + * @brief Maximum number of MSI-X vectors that will be reserved + * + * Defines the maximum number of MSI-X vectors that an RDMA interface will + * have reserved in advance. Does not guarantee that many vectors have + * actually been enabled. + */ +#define ICE_RDMA_MAX_MSIX 64 + +/** + * @struct ice_rdma_info + * @brief RDMA information from the client driver + * + * The RDMA client driver will fill in this structure and pass its contents + * back to the main driver using the ice_rdma_register function. + * + * It should fill the version in with the ICE_RDMA_* versions as defined in + * the ice_rdma.h header. + * + * Additionally it must provide a pointer to a kobject class which extends the + * ice_rdma_di_class with the operations defined in the rdma_if.m interface. + * + * If the version specified is not compatible, then the registration will + * of the RDMA driver will fail. + * + * @var ice_rdma_info::major_version + * describe major changes in the interface + * @var ice_rdma_info::minor_version + * describe changes and fixes with backward compatibility + * @var ice_rdma_info::patch_version + * changes without impact on compatibility or features + * @var ice_rdma_info::rdma_class + * kobject class + */ +struct ice_rdma_info { + uint16_t major_version; + uint16_t minor_version; + uint16_t patch_version; + + kobj_class_t rdma_class; +}; + +#define ICE_RDMA_MAX_USER_PRIORITY 8 +#define ICE_RDMA_MAX_MSIX 64 + +/* Declare the ice_rdma_di kobject class */ +DECLARE_CLASS(ice_rdma_di_class); + +/** + * @struct ice_rdma_msix_mapping + * @brief MSI-X mapping requested by the peer RDMA driver + * + * Defines a mapping for MSI-X vectors being requested by the peer RDMA driver + * for a given PF. + * + */ +struct ice_rdma_msix_mapping { + uint8_t itr_indx; + int aeq_vector; + int ceq_cnt; + int *ceq_vector; +}; + +/** + * @struct ice_rdma_msix + * @brief RDMA MSI-X vectors reserved for the peer RDMA driver + * + * Defines the segment of the MSI-X vectors for use by the RDMA driver. These + * are reserved by the PF when it initializes. + */ +struct ice_rdma_msix { + int base; + int count; +}; + +/** + * @struct ice_qos_info + * @brief QoS information to be shared with RDMA driver + */ +struct ice_qos_info { + uint64_t tc_ctx; + uint8_t rel_bw; + uint8_t prio_type; + uint8_t egress_virt_up; + uint8_t ingress_virt_up; +}; + +/** + * @struct ice_qos_app_priority_table + * @brief Application priority data + */ +struct ice_qos_app_priority_table { + uint16_t prot_id; + uint8_t priority; + uint8_t selector; +}; + +#define IEEE_8021QAZ_MAX_TCS 8 +#define ICE_TC_MAX_USER_PRIORITY 8 +#define ICE_QOS_MAX_APPS 32 +#define ICE_QOS_DSCP_NUM_VAL 64 + +/** + * @struct ice_qos_params + * @brief Holds all necessary data for RDMA to work with DCB + * + * Struct to hold QoS info + * @var ice_qos_params::tc_info + * traffic class information + * @var ice_qos_params::up2tc + * mapping from user priority to traffic class + * @var ice_qos_params::vsi_relative_bw + * bandwidth settings + * @var ice_qos_params::vsi_priority_type + * priority type + * @var ice_qos_params::num_apps + * app count + * @var ice_qos_params::pfc_mode + * PFC mode + * @var ice_qos_params::dscp_map + * dscp mapping + * @var ice_qos_params::apps + * apps + * @var ice_qos_params::num_tc + * number of traffic classes +}; + */ +struct ice_qos_params { + struct ice_qos_info tc_info[IEEE_8021QAZ_MAX_TCS]; + uint8_t up2tc[ICE_TC_MAX_USER_PRIORITY]; + uint8_t vsi_relative_bw; + uint8_t vsi_priority_type; + uint32_t num_apps; + uint8_t pfc_mode; + uint8_t dscp_map[ICE_QOS_DSCP_NUM_VAL]; + struct ice_qos_app_priority_table apps[ICE_QOS_MAX_APPS]; + uint8_t num_tc; +}; + +/** + * @struct ice_rdma_peer + * @brief RDMA driver information + * + * Shared structure used by the RDMA client driver when talking with the main + * device driver. + * + * Because the definition of this structure is shared between the two drivers, + * its ABI should be handled carefully. + * + * @var ice_rdma_peer::ifp + * pointer to ifnet structure + * @var ice_rdma_peer::dev + * device pointer + * @var ice_rdma_peer::pci_mem + * information about PCI + * @var ice_rdma_peer::initial_qos_info + * initial information on QoS + * @var ice_rdma_peer::msix + * info about msix vectors + * @var ice_rdma_peer::mtu + * initial mtu size + * @var ice_rdma_peer::pf_vsi_num + * id of vsi + * @var ice_rdma_peer::pf_id + * id of PF + */ +struct ice_rdma_peer { + /** + * The KOBJ_FIELDS macro must come first, in order for it to be used + * as a kobject. + */ + KOBJ_FIELDS; + + struct ifnet *ifp; + device_t dev; + struct resource *pci_mem; + struct ice_qos_params initial_qos_info; + struct ice_rdma_msix msix; + uint16_t mtu; + uint16_t pf_vsi_num; + uint8_t pf_id; +}; + +/** + * @enum ice_res_type + * @brief enum for type of resource registration + * + * enum for type of resource registration. + * created for plausible compatibility with IDC + */ +enum ice_res_type { + ICE_INVAL_RES = 0x0, + ICE_RDMA_QSET_ALLOC = 0x8, + ICE_RDMA_QSET_FREE = 0x18, +}; + +/** + * @struct ice_rdma_qset_params + * @brief struct to hold per RDMA Qset info + * + * @var ice_rdma_qset_params::teid + * qset teid + * @var ice_rdma_qset_params::qs_handle + * qset from rdma driver + * @var ice_rdma_qset_params::vsi_id + * vsi index + * @var ice_rdma_qset_params::tc + * traffic class to which qset should belong to + * @var ice_rdma_qset_params::reserved + * for future use + */ +struct ice_rdma_qset_params { + uint32_t teid; + uint16_t qs_handle; + uint16_t vsi_id; + uint8_t tc; + uint8_t reserved[3]; +}; + +#define ICE_MAX_TXQ_PER_TXQG 128 +/** + * @struct ice_rdma_qset_update + * @brief struct used to register and unregister qsets for RDMA driver + * + * @var ice_rdma_qset_update::res_type + * ALLOC or FREE + * @var ice_rdma_qset_update::cnt_req + * how many qsets are requested + * @var ice_rdma_qset_update::res_allocated + * how many qsets are allocated + * @var ice_rdma_qset_update::qsets + * rdma qset info + */ +struct ice_rdma_qset_update { + enum ice_res_type res_type; + uint16_t cnt_req; + uint16_t res_allocated; + uint32_t res_handle; + struct ice_rdma_qset_params qsets; +}; + +/** + * @enum ice_rdma_event_type + * @brief enum for type of event from base driver + */ +enum ice_rdma_event_type { + ICE_RDMA_EVENT_NONE = 0, + ICE_RDMA_EVENT_LINK_CHANGE, + ICE_RDMA_EVENT_MTU_CHANGE, + ICE_RDMA_EVENT_TC_CHANGE, + ICE_RDMA_EVENT_API_CHANGE, + ICE_RDMA_EVENT_CRIT_ERR, + ICE_RDMA_EVENT_RESET, + ICE_RDMA_EVENT_QSET_REGISTER, + ICE_RDMA_EVENT_VSI_FILTER_UPDATE, + ICE_RDMA_EVENT_LAST +}; + +/** + * @struct ice_rdma_event + * @brief struct for event information to pass to RDMA driver + * + * @var ice_rdma_event::type + * event type + */ +struct ice_rdma_event { + enum ice_rdma_event_type type; + union { + /* link change event */ + struct { + int linkstate; + uint64_t baudrate; + }; + /* MTU change event */ + int mtu; + /* + * TC/QoS/DCB change event + * prep: if true, this is a pre-event, post-event otherwise + */ + struct { + struct ice_qos_params port_qos; + bool prep; + }; + /* + * CRIT_ERR event + */ + uint32_t oicr_reg; + }; +}; + +/** + * @struct ice_rdma_request + * @brief struct with data for a request from the RDMA driver + * + * @var ice_rdma_request::type + * event type + */ +struct ice_rdma_request { + enum ice_rdma_event_type type; + union { + struct { + struct ice_rdma_qset_update res; + }; + struct { + bool enable_filter; + }; + }; +}; + +int ice_rdma_register(struct ice_rdma_info *info); +int ice_rdma_unregister(void); + +#endif |