LXR linux/drivers/net/ethernet/intel/ice/ice

   1// SPDX-License-Identifier: GPL-2.0
   2/* Copyright (C) 2021, Intel Corporation. */
   3
   4/* Inter-Driver Communication */
   5#include "ice.h"
   6#include "ice_lib.h"
   7#include "ice_dcb_lib.h"
   8
   9/**
  10 * ice_get_auxiliary_drv - retrieve iidc_auxiliary_drv struct
  11 * @pf: pointer to PF struct
  12 *
  13 * This function has to be called with a device_lock on the
  14 * pf->adev.dev to avoid race conditions.
  15 */
  16static struct iidc_auxiliary_drv *ice_get_auxiliary_drv(struct ice_pf *pf)
  17{
  18        struct auxiliary_device *adev;
  19
  20        adev = pf->adev;
  21        if (!adev || !adev->dev.driver)
  22                return NULL;
  23
  24        return container_of(adev->dev.driver, struct iidc_auxiliary_drv,
  25                            adrv.driver);
  26}
  27
  28/**
  29 * ice_send_event_to_aux - send event to RDMA AUX driver
  30 * @pf: pointer to PF struct
  31 * @event: event struct
  32 */
  33void ice_send_event_to_aux(struct ice_pf *pf, struct iidc_event *event)
  34{
  35        struct iidc_auxiliary_drv *iadrv;
  36
  37        if (WARN_ON_ONCE(!in_task()))
  38                return;
  39
  40        mutex_lock(&pf->adev_mutex);
  41        if (!pf->adev)
  42                goto finish;
  43
  44        device_lock(&pf->adev->dev);
  45        iadrv = ice_get_auxiliary_drv(pf);
  46        if (iadrv && iadrv->event_handler)
  47                iadrv->event_handler(pf, event);
  48        device_unlock(&pf->adev->dev);
  49finish:
  50        mutex_unlock(&pf->adev_mutex);
  51}
  52
  53/**
  54 * ice_add_rdma_qset - Add Leaf Node for RDMA Qset
  55 * @pf: PF struct
  56 * @qset: Resource to be allocated
  57 */
  58int ice_add_rdma_qset(struct ice_pf *pf, struct iidc_rdma_qset_params *qset)
  59{
  60        u16 max_rdmaqs[ICE_MAX_TRAFFIC_CLASS];
  61        struct ice_vsi *vsi;
  62        struct device *dev;
  63        u32 qset_teid;
  64        u16 qs_handle;
  65        int status;
  66        int i;
  67
  68        if (WARN_ON(!pf || !qset))
  69                return -EINVAL;
  70
  71        dev = ice_pf_to_dev(pf);
  72
  73        if (!ice_is_rdma_ena(pf))
  74                return -EINVAL;
  75
  76        vsi = ice_get_main_vsi(pf);
  77        if (!vsi) {
  78                dev_err(dev, "RDMA QSet invalid VSI\n");
  79                return -EINVAL;
  80        }
  81
  82        ice_for_each_traffic_class(i)
  83                max_rdmaqs[i] = 0;
  84
  85        max_rdmaqs[qset->tc]++;
  86        qs_handle = qset->qs_handle;
  87
  88        status = ice_cfg_vsi_rdma(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc,
  89                                  max_rdmaqs);
  90        if (status) {
  91                dev_err(dev, "Failed VSI RDMA Qset config\n");
  92                return status;
  93        }
  94
  95        status = ice_ena_vsi_rdma_qset(vsi->port_info, vsi->idx, qset->tc,
  96                                       &qs_handle, 1, &qset_teid);
  97        if (status) {
  98                dev_err(dev, "Failed VSI RDMA Qset enable\n");
  99                return status;
 100        }
 101        vsi->qset_handle[qset->tc] = qset->qs_handle;
 102        qset->teid = qset_teid;
 103
 104        return 0;
 105}
 106EXPORT_SYMBOL_GPL(ice_add_rdma_qset);
 107
 108/**
 109 * ice_del_rdma_qset - Delete leaf node for RDMA Qset
 110 * @pf: PF struct
 111 * @qset: Resource to be freed
 112 */
 113int ice_del_rdma_qset(struct ice_pf *pf, struct iidc_rdma_qset_params *qset)
 114{
 115        struct ice_vsi *vsi;
 116        u32 teid;
 117        u16 q_id;
 118
 119        if (WARN_ON(!pf || !qset))
 120                return -EINVAL;
 121
 122        vsi = ice_find_vsi(pf, qset->vport_id);
 123        if (!vsi) {
 124                dev_err(ice_pf_to_dev(pf), "RDMA Invalid VSI\n");
 125                return -EINVAL;
 126        }
 127
 128        q_id = qset->qs_handle;
 129        teid = qset->teid;
 130
 131        vsi->qset_handle[qset->tc] = 0;
 132
 133        return ice_dis_vsi_rdma_qset(vsi->port_info, 1, &teid, &q_id);
 134}
 135EXPORT_SYMBOL_GPL(ice_del_rdma_qset);
 136
 137/**
 138 * ice_rdma_request_reset - accept request from RDMA to perform a reset
 139 * @pf: struct for PF
 140 * @reset_type: type of reset
 141 */
 142int ice_rdma_request_reset(struct ice_pf *pf, enum iidc_reset_type reset_type)
 143{
 144        enum ice_reset_req reset;
 145
 146        if (WARN_ON(!pf))
 147                return -EINVAL;
 148
 149        switch (reset_type) {
 150        case IIDC_PFR:
 151                reset = ICE_RESET_PFR;
 152                break;
 153        case IIDC_CORER:
 154                reset = ICE_RESET_CORER;
 155                break;
 156        case IIDC_GLOBR:
 157                reset = ICE_RESET_GLOBR;
 158                break;
 159        default:
 160                dev_err(ice_pf_to_dev(pf), "incorrect reset request\n");
 161                return -EINVAL;
 162        }
 163
 164        return ice_schedule_reset(pf, reset);
 165}
 166EXPORT_SYMBOL_GPL(ice_rdma_request_reset);
 167
 168/**
 169 * ice_rdma_update_vsi_filter - update main VSI filters for RDMA
 170 * @pf: pointer to struct for PF
 171 * @vsi_id: VSI HW idx to update filter on
 172 * @enable: bool whether to enable or disable filters
 173 */
 174int ice_rdma_update_vsi_filter(struct ice_pf *pf, u16 vsi_id, bool enable)
 175{
 176        struct ice_vsi *vsi;
 177        int status;
 178
 179        if (WARN_ON(!pf))
 180                return -EINVAL;
 181
 182        vsi = ice_find_vsi(pf, vsi_id);
 183        if (!vsi)
 184                return -EINVAL;
 185
 186        status = ice_cfg_rdma_fltr(&pf->hw, vsi->idx, enable);
 187        if (status) {
 188                dev_err(ice_pf_to_dev(pf), "Failed to  %sable RDMA filtering\n",
 189                        enable ? "en" : "dis");
 190        } else {
 191                if (enable)
 192                        vsi->info.q_opt_flags |= ICE_AQ_VSI_Q_OPT_PE_FLTR_EN;
 193                else
 194                        vsi->info.q_opt_flags &= ~ICE_AQ_VSI_Q_OPT_PE_FLTR_EN;
 195        }
 196
 197        return status;
 198}
 199EXPORT_SYMBOL_GPL(ice_rdma_update_vsi_filter);
 200
 201/**
 202 * ice_get_qos_params - parse QoS params for RDMA consumption
 203 * @pf: pointer to PF struct
 204 * @qos: set of QoS values
 205 */
 206void ice_get_qos_params(struct ice_pf *pf, struct iidc_qos_params *qos)
 207{
 208        struct ice_dcbx_cfg *dcbx_cfg;
 209        unsigned int i;
 210        u32 up2tc;
 211
 212        dcbx_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 213        up2tc = rd32(&pf->hw, PRTDCB_TUP2TC);
 214
 215        qos->num_tc = ice_dcb_get_num_tc(dcbx_cfg);
 216        for (i = 0; i < IIDC_MAX_USER_PRIORITY; i++)
 217                qos->up2tc[i] = (up2tc >> (i * 3)) & 0x7;
 218
 219        for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
 220                qos->tc_info[i].rel_bw = dcbx_cfg->etscfg.tcbwtable[i];
 221
 222        qos->pfc_mode = dcbx_cfg->pfc_mode;
 223        if (qos->pfc_mode == IIDC_DSCP_PFC_MODE)
 224                for (i = 0; i < IIDC_MAX_DSCP_MAPPING; i++)
 225                        qos->dscp_map[i] = dcbx_cfg->dscp_map[i];
 226}
 227EXPORT_SYMBOL_GPL(ice_get_qos_params);
 228
 229/**
 230 * ice_reserve_rdma_qvector - Reserve vector resources for RDMA driver
 231 * @pf: board private structure to initialize
 232 */
 233static int ice_reserve_rdma_qvector(struct ice_pf *pf)
 234{
 235        if (ice_is_rdma_ena(pf)) {
 236                int index;
 237
 238                index = ice_get_res(pf, pf->irq_tracker, pf->num_rdma_msix,
 239                                    ICE_RES_RDMA_VEC_ID);
 240                if (index < 0)
 241                        return index;
 242                pf->num_avail_sw_msix -= pf->num_rdma_msix;
 243                pf->rdma_base_vector = (u16)index;
 244        }
 245        return 0;
 246}
 247
 248/**
 249 * ice_adev_release - function to be mapped to AUX dev's release op
 250 * @dev: pointer to device to free
 251 */
 252static void ice_adev_release(struct device *dev)
 253{
 254        struct iidc_auxiliary_dev *iadev;
 255
 256        iadev = container_of(dev, struct iidc_auxiliary_dev, adev.dev);
 257        kfree(iadev);
 258}
 259
 260/**
 261 * ice_plug_aux_dev - allocate and register AUX device
 262 * @pf: pointer to pf struct
 263 */
 264int ice_plug_aux_dev(struct ice_pf *pf)
 265{
 266        struct iidc_auxiliary_dev *iadev;
 267        struct auxiliary_device *adev;
 268        int ret;
 269
 270        /* if this PF doesn't support a technology that requires auxiliary
 271         * devices, then gracefully exit
 272         */
 273        if (!ice_is_rdma_ena(pf))
 274                return 0;
 275
 276        iadev = kzalloc(sizeof(*iadev), GFP_KERNEL);
 277        if (!iadev)
 278                return -ENOMEM;
 279
 280        adev = &iadev->adev;
 281        iadev->pf = pf;
 282
 283        adev->id = pf->aux_idx;
 284        adev->dev.release = ice_adev_release;
 285        adev->dev.parent = &pf->pdev->dev;
 286        adev->name = pf->rdma_mode & IIDC_RDMA_PROTOCOL_ROCEV2 ? "roce" : "iwarp";
 287
 288        ret = auxiliary_device_init(adev);
 289        if (ret) {
 290                kfree(iadev);
 291                return ret;
 292        }
 293
 294        ret = auxiliary_device_add(adev);
 295        if (ret) {
 296                auxiliary_device_uninit(adev);
 297                return ret;
 298        }
 299
 300        mutex_lock(&pf->adev_mutex);
 301        pf->adev = adev;
 302        mutex_unlock(&pf->adev_mutex);
 303
 304        return 0;
 305}
 306
 307/* ice_unplug_aux_dev - unregister and free AUX device
 308 * @pf: pointer to pf struct
 309 */
 310void ice_unplug_aux_dev(struct ice_pf *pf)
 311{
 312        struct auxiliary_device *adev;
 313
 314        mutex_lock(&pf->adev_mutex);
 315        adev = pf->adev;
 316        pf->adev = NULL;
 317        mutex_unlock(&pf->adev_mutex);
 318
 319        if (adev) {
 320                auxiliary_device_delete(adev);
 321                auxiliary_device_uninit(adev);
 322        }
 323}
 324
 325/**
 326 * ice_init_rdma - initializes PF for RDMA use
 327 * @pf: ptr to ice_pf
 328 */
 329int ice_init_rdma(struct ice_pf *pf)
 330{
 331        struct device *dev = &pf->pdev->dev;
 332        int ret;
 333
 334        /* Reserve vector resources */
 335        ret = ice_reserve_rdma_qvector(pf);
 336        if (ret < 0) {
 337                dev_err(dev, "failed to reserve vectors for RDMA\n");
 338                return ret;
 339        }
 340        pf->rdma_mode |= IIDC_RDMA_PROTOCOL_ROCEV2;
 341        return ice_plug_aux_dev(pf);
 342}
 343