drivers/infiniband/hw/hfi1/netdev_rx.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
   2 /*
   3  * Copyright(c) 2020 Intel Corporation.
   4  *
   5  */
   6
   7 /*
   8  * This file contains HFI1 support for netdev RX functionality
   9  */
  10
  11 #include "sdma.h"
  12 #include "verbs.h"
  13 #include "netdev.h"
  14 #include "hfi.h"
  15
  16 #include <linux/netdevice.h>
  17 #include <linux/etherdevice.h>
  18 #include <rdma/ib_verbs.h>
  19
  20 static int hfi1_netdev_setup_ctxt(struct hfi1_netdev_rx *rx,
  21                                   struct hfi1_ctxtdata *uctxt)
  22 {
  23         unsigned int rcvctrl_ops;
  24         struct hfi1_devdata *dd = rx->dd;
  25         int ret;
  26
  27         uctxt->rhf_rcv_function_map = netdev_rhf_rcv_functions;
  28         uctxt->do_interrupt = &handle_receive_interrupt_napi_sp;
  29
  30         /* Now allocate the RcvHdr queue and eager buffers. */
  31         ret = hfi1_create_rcvhdrq(dd, uctxt);
  32         if (ret)
  33                 goto done;
  34
  35         ret = hfi1_setup_eagerbufs(uctxt);
  36         if (ret)
  37                 goto done;
  38
  39         clear_rcvhdrtail(uctxt);
  40
  41         rcvctrl_ops = HFI1_RCVCTRL_CTXT_DIS;
  42         rcvctrl_ops |= HFI1_RCVCTRL_INTRAVAIL_DIS;
  43
  44         if (!HFI1_CAP_KGET_MASK(uctxt->flags, MULTI_PKT_EGR))
  45                 rcvctrl_ops |= HFI1_RCVCTRL_ONE_PKT_EGR_ENB;
  46         if (HFI1_CAP_KGET_MASK(uctxt->flags, NODROP_EGR_FULL))
  47                 rcvctrl_ops |= HFI1_RCVCTRL_NO_EGR_DROP_ENB;
  48         if (HFI1_CAP_KGET_MASK(uctxt->flags, NODROP_RHQ_FULL))
  49                 rcvctrl_ops |= HFI1_RCVCTRL_NO_RHQ_DROP_ENB;
  50         if (HFI1_CAP_KGET_MASK(uctxt->flags, DMA_RTAIL))
  51                 rcvctrl_ops |= HFI1_RCVCTRL_TAILUPD_ENB;
  52
  53         hfi1_rcvctrl(uctxt->dd, rcvctrl_ops, uctxt);
  54 done:
  55         return ret;
  56 }
  57
  58 static int hfi1_netdev_allocate_ctxt(struct hfi1_devdata *dd,
  59                                      struct hfi1_ctxtdata **ctxt)
  60 {
  61         struct hfi1_ctxtdata *uctxt;
  62         int ret;
  63
  64         if (dd->flags & HFI1_FROZEN)
  65                 return -EIO;
  66
  67         ret = hfi1_create_ctxtdata(dd->pport, dd->node, &uctxt);
  68         if (ret < 0) {
  69                 dd_dev_err(dd, "Unable to create ctxtdata, failing open\n");
  70                 return -ENOMEM;
  71         }
  72
  73         uctxt->flags = HFI1_CAP_KGET(MULTI_PKT_EGR) |
  74                 HFI1_CAP_KGET(NODROP_RHQ_FULL) |
  75                 HFI1_CAP_KGET(NODROP_EGR_FULL) |
  76                 HFI1_CAP_KGET(DMA_RTAIL);
  77         /* Netdev contexts are always NO_RDMA_RTAIL */
  78         uctxt->fast_handler = handle_receive_interrupt_napi_fp;
  79         uctxt->slow_handler = handle_receive_interrupt_napi_sp;
  80         hfi1_set_seq_cnt(uctxt, 1);
  81         uctxt->is_vnic = true;
  82
  83         hfi1_stats.sps_ctxts++;
  84
  85         dd_dev_info(dd, "created netdev context %d\n", uctxt->ctxt);
  86         *ctxt = uctxt;
  87
  88         return 0;
  89 }
  90
  91 static void hfi1_netdev_deallocate_ctxt(struct hfi1_devdata *dd,
  92                                         struct hfi1_ctxtdata *uctxt)
  93 {
  94         flush_wc();
  95
  96         /*
  97          * Disable receive context and interrupt available, reset all
  98          * RcvCtxtCtrl bits to default values.
  99          */
 100         hfi1_rcvctrl(dd, HFI1_RCVCTRL_CTXT_DIS |
 101                      HFI1_RCVCTRL_TIDFLOW_DIS |
 102                      HFI1_RCVCTRL_INTRAVAIL_DIS |
 103                      HFI1_RCVCTRL_ONE_PKT_EGR_DIS |
 104                      HFI1_RCVCTRL_NO_RHQ_DROP_DIS |
 105                      HFI1_RCVCTRL_NO_EGR_DROP_DIS, uctxt);
 106
 107         if (uctxt->msix_intr != CCE_NUM_MSIX_VECTORS)
 108                 msix_free_irq(dd, uctxt->msix_intr);
 109
 110         uctxt->msix_intr = CCE_NUM_MSIX_VECTORS;
 111         uctxt->event_flags = 0;
 112
 113         hfi1_clear_tids(uctxt);
 114         hfi1_clear_ctxt_pkey(dd, uctxt);
 115
 116         hfi1_stats.sps_ctxts--;
 117
 118         hfi1_free_ctxt(uctxt);
 119 }
 120
 121 static int hfi1_netdev_allot_ctxt(struct hfi1_netdev_rx *rx,
 122                                   struct hfi1_ctxtdata **ctxt)
 123 {
 124         int rc;
 125         struct hfi1_devdata *dd = rx->dd;
 126
 127         rc = hfi1_netdev_allocate_ctxt(dd, ctxt);
 128         if (rc) {
 129                 dd_dev_err(dd, "netdev ctxt alloc failed %d\n", rc);
 130                 return rc;
 131         }
 132
 133         rc = hfi1_netdev_setup_ctxt(rx, *ctxt);
 134         if (rc) {
 135                 dd_dev_err(dd, "netdev ctxt setup failed %d\n", rc);
 136                 hfi1_netdev_deallocate_ctxt(dd, *ctxt);
 137                 *ctxt = NULL;
 138         }
 139
 140         return rc;
 141 }
 142
 143 /**
 144  * hfi1_num_netdev_contexts - Count of netdev recv contexts to use.
 145  * @dd: device on which to allocate netdev contexts
 146  * @available_contexts: count of available receive contexts
 147  * @cpu_mask: mask of possible cpus to include for contexts
 148  *
 149  * Return: count of physical cores on a node or the remaining available recv
 150  * contexts for netdev recv context usage up to the maximum of
 151  * HFI1_MAX_NETDEV_CTXTS.
 152  * A value of 0 can be returned when acceleration is explicitly turned off,
 153  * a memory allocation error occurs or when there are no available contexts.
 154  *
 155  */
 156 u32 hfi1_num_netdev_contexts(struct hfi1_devdata *dd, u32 available_contexts,
 157                              struct cpumask *cpu_mask)
 158 {
 159         cpumask_var_t node_cpu_mask;
 160         unsigned int available_cpus;
 161
 162         if (!HFI1_CAP_IS_KSET(AIP))
 163                 return 0;
 164
 165         /* Always give user contexts priority over netdev contexts */
 166         if (available_contexts == 0) {
 167                 dd_dev_info(dd, "No receive contexts available for netdevs.\n");
 168                 return 0;
 169         }
 170
 171         if (!zalloc_cpumask_var(&node_cpu_mask, GFP_KERNEL)) {
 172                 dd_dev_err(dd, "Unable to allocate cpu_mask for netdevs.\n");
 173                 return 0;
 174         }
 175
 176         cpumask_and(node_cpu_mask, cpu_mask, cpumask_of_node(dd->node));
 177
 178         available_cpus = cpumask_weight(node_cpu_mask);
 179
 180         free_cpumask_var(node_cpu_mask);
 181
 182         return min3(available_cpus, available_contexts,
 183                     (u32)HFI1_MAX_NETDEV_CTXTS);
 184 }
 185
 186 static int hfi1_netdev_rxq_init(struct hfi1_netdev_rx *rx)
 187 {
 188         int i;
 189         int rc;
 190         struct hfi1_devdata *dd = rx->dd;
 191         struct net_device *dev = &rx->rx_napi;
 192
 193         rx->num_rx_q = dd->num_netdev_contexts;
 194         rx->rxq = kcalloc_node(rx->num_rx_q, sizeof(*rx->rxq),
 195                                GFP_KERNEL, dd->node);
 196
 197         if (!rx->rxq) {
 198                 dd_dev_err(dd, "Unable to allocate netdev queue data\n");
 199                 return (-ENOMEM);
 200         }
 201
 202         for (i = 0; i < rx->num_rx_q; i++) {
 203                 struct hfi1_netdev_rxq *rxq = &rx->rxq[i];
 204
 205                 rc = hfi1_netdev_allot_ctxt(rx, &rxq->rcd);
 206                 if (rc)
 207                         goto bail_context_irq_failure;
 208
 209                 hfi1_rcd_get(rxq->rcd);
 210                 rxq->rx = rx;
 211                 rxq->rcd->napi = &rxq->napi;
 212                 dd_dev_info(dd, "Setting rcv queue %d napi to context %d\n",
 213                             i, rxq->rcd->ctxt);
 214                 /*
 215                  * Disable BUSY_POLL on this NAPI as this is not supported
 216                  * right now.
 217                  */
 218                 set_bit(NAPI_STATE_NO_BUSY_POLL, &rxq->napi.state);
 219                 netif_napi_add(dev, &rxq->napi, hfi1_netdev_rx_napi, 64);
 220                 rc = msix_netdev_request_rcd_irq(rxq->rcd);
 221                 if (rc)
 222                         goto bail_context_irq_failure;
 223         }
 224
 225         return 0;
 226
 227 bail_context_irq_failure:
 228         dd_dev_err(dd, "Unable to allot receive context\n");
 229         for (; i >= 0; i--) {
 230                 struct hfi1_netdev_rxq *rxq = &rx->rxq[i];
 231
 232                 if (rxq->rcd) {
 233                         hfi1_netdev_deallocate_ctxt(dd, rxq->rcd);
 234                         hfi1_rcd_put(rxq->rcd);
 235                         rxq->rcd = NULL;
 236                 }
 237         }
 238         kfree(rx->rxq);
 239         rx->rxq = NULL;
 240
 241         return rc;
 242 }
 243
 244 static void hfi1_netdev_rxq_deinit(struct hfi1_netdev_rx *rx)
 245 {
 246         int i;
 247         struct hfi1_devdata *dd = rx->dd;
 248
 249         for (i = 0; i < rx->num_rx_q; i++) {
 250                 struct hfi1_netdev_rxq *rxq = &rx->rxq[i];
 251
 252                 netif_napi_del(&rxq->napi);
 253                 hfi1_netdev_deallocate_ctxt(dd, rxq->rcd);
 254                 hfi1_rcd_put(rxq->rcd);
 255                 rxq->rcd = NULL;
 256         }
 257
 258         kfree(rx->rxq);
 259         rx->rxq = NULL;
 260         rx->num_rx_q = 0;
 261 }
 262
 263 static void enable_queues(struct hfi1_netdev_rx *rx)
 264 {
 265         int i;
 266
 267         for (i = 0; i < rx->num_rx_q; i++) {
 268                 struct hfi1_netdev_rxq *rxq = &rx->rxq[i];
 269
 270                 dd_dev_info(rx->dd, "enabling queue %d on context %d\n", i,
 271                             rxq->rcd->ctxt);
 272                 napi_enable(&rxq->napi);
 273                 hfi1_rcvctrl(rx->dd,
 274                              HFI1_RCVCTRL_CTXT_ENB | HFI1_RCVCTRL_INTRAVAIL_ENB,
 275                              rxq->rcd);
 276         }
 277 }
 278
 279 static void disable_queues(struct hfi1_netdev_rx *rx)
 280 {
 281         int i;
 282
 283         msix_netdev_synchronize_irq(rx->dd);
 284
 285         for (i = 0; i < rx->num_rx_q; i++) {
 286                 struct hfi1_netdev_rxq *rxq = &rx->rxq[i];
 287
 288                 dd_dev_info(rx->dd, "disabling queue %d on context %d\n", i,
 289                             rxq->rcd->ctxt);
 290
 291                 /* wait for napi if it was scheduled */
 292                 hfi1_rcvctrl(rx->dd,
 293                              HFI1_RCVCTRL_CTXT_DIS | HFI1_RCVCTRL_INTRAVAIL_DIS,
 294                              rxq->rcd);
 295                 napi_synchronize(&rxq->napi);
 296                 napi_disable(&rxq->napi);
 297         }
 298 }
 299
 300 /**
 301  * hfi1_netdev_rx_init - Incrememnts netdevs counter. When called first time,
 302  * it allocates receive queue data and calls netif_napi_add
 303  * for each queue.
 304  *
 305  * @dd: hfi1 dev data
 306  */
 307 int hfi1_netdev_rx_init(struct hfi1_devdata *dd)
 308 {
 309         struct hfi1_netdev_rx *rx = dd->netdev_rx;
 310         int res;
 311
 312         if (atomic_fetch_inc(&rx->netdevs))
 313                 return 0;
 314
 315         mutex_lock(&hfi1_mutex);
 316         res = hfi1_netdev_rxq_init(rx);
 317         mutex_unlock(&hfi1_mutex);
 318         return res;
 319 }
 320
 321 /**
 322  * hfi1_netdev_rx_destroy - Decrements netdevs counter, when it reaches 0
 323  * napi is deleted and receive queses memory is freed.
 324  *
 325  * @dd: hfi1 dev data
 326  */
 327 int hfi1_netdev_rx_destroy(struct hfi1_devdata *dd)
 328 {
 329         struct hfi1_netdev_rx *rx = dd->netdev_rx;
 330
 331         /* destroy the RX queues only if it is the last netdev going away */
 332         if (atomic_fetch_add_unless(&rx->netdevs, -1, 0) == 1) {
 333                 mutex_lock(&hfi1_mutex);
 334                 hfi1_netdev_rxq_deinit(rx);
 335                 mutex_unlock(&hfi1_mutex);
 336         }
 337
 338         return 0;
 339 }
 340
 341 /**
 342  * hfi1_alloc_rx - Allocates the rx support structure
 343  * @dd: hfi1 dev data
 344  *
 345  * Allocate the rx structure to support gathering the receive
 346  * resources and the dummy netdev.
 347  *
 348  * Updates dd struct pointer upon success.
 349  *
 350  * Return: 0 (success) -error on failure
 351  *
 352  */
 353 int hfi1_alloc_rx(struct hfi1_devdata *dd)
 354 {
 355         struct hfi1_netdev_rx *rx;
 356
 357         dd_dev_info(dd, "allocating rx size %ld\n", sizeof(*rx));
 358         rx = kzalloc_node(sizeof(*rx), GFP_KERNEL, dd->node);
 359
 360         if (!rx)
 361                 return -ENOMEM;
 362         rx->dd = dd;
 363         init_dummy_netdev(&rx->rx_napi);
 364
 365         xa_init(&rx->dev_tbl);
 366         atomic_set(&rx->enabled, 0);
 367         atomic_set(&rx->netdevs, 0);
 368         dd->netdev_rx = rx;
 369
 370         return 0;
 371 }
 372
 373 void hfi1_free_rx(struct hfi1_devdata *dd)
 374 {
 375         if (dd->netdev_rx) {
 376                 dd_dev_info(dd, "hfi1 rx freed\n");
 377                 kfree(dd->netdev_rx);
 378                 dd->netdev_rx = NULL;
 379         }
 380 }
 381
 382 /**
 383  * hfi1_netdev_enable_queues - This is napi enable function.
 384  * It enables napi objects associated with queues.
 385  * When at least one device has called it it increments atomic counter.
 386  * Disable function decrements counter and when it is 0,
 387  * calls napi_disable for every queue.
 388  *
 389  * @dd: hfi1 dev data
 390  */
 391 void hfi1_netdev_enable_queues(struct hfi1_devdata *dd)
 392 {
 393         struct hfi1_netdev_rx *rx;
 394
 395         if (!dd->netdev_rx)
 396                 return;
 397
 398         rx = dd->netdev_rx;
 399         if (atomic_fetch_inc(&rx->enabled))
 400                 return;
 401
 402         mutex_lock(&hfi1_mutex);
 403         enable_queues(rx);
 404         mutex_unlock(&hfi1_mutex);
 405 }
 406
 407 void hfi1_netdev_disable_queues(struct hfi1_devdata *dd)
 408 {
 409         struct hfi1_netdev_rx *rx;
 410
 411         if (!dd->netdev_rx)
 412                 return;
 413
 414         rx = dd->netdev_rx;
 415         if (atomic_dec_if_positive(&rx->enabled))
 416                 return;
 417
 418         mutex_lock(&hfi1_mutex);
 419         disable_queues(rx);
 420         mutex_unlock(&hfi1_mutex);
 421 }
 422
 423 /**
 424  * hfi1_netdev_add_data - Registers data with unique identifier
 425  * to be requested later this is needed for VNIC and IPoIB VLANs
 426  * implementations.
 427  * This call is protected by mutex idr_lock.
 428  *
 429  * @dd: hfi1 dev data
 430  * @id: requested integer id up to INT_MAX
 431  * @data: data to be associated with index
 432  */
 433 int hfi1_netdev_add_data(struct hfi1_devdata *dd, int id, void *data)
 434 {
 435         struct hfi1_netdev_rx *rx = dd->netdev_rx;
 436
 437         return xa_insert(&rx->dev_tbl, id, data, GFP_NOWAIT);
 438 }
 439
 440 /**
 441  * hfi1_netdev_remove_data - Removes data with previously given id.
 442  * Returns the reference to removed entry.
 443  *
 444  * @dd: hfi1 dev data
 445  * @id: requested integer id up to INT_MAX
 446  */
 447 void *hfi1_netdev_remove_data(struct hfi1_devdata *dd, int id)
 448 {
 449         struct hfi1_netdev_rx *rx = dd->netdev_rx;
 450
 451         return xa_erase(&rx->dev_tbl, id);
 452 }
 453
 454 /**
 455  * hfi1_netdev_get_data - Gets data with given id
 456  *
 457  * @dd: hfi1 dev data
 458  * @id: requested integer id up to INT_MAX
 459  */
 460 void *hfi1_netdev_get_data(struct hfi1_devdata *dd, int id)
 461 {
 462         struct hfi1_netdev_rx *rx = dd->netdev_rx;
 463
 464         return xa_load(&rx->dev_tbl, id);
 465 }
 466
 467 /**
 468  * hfi1_netdev_get_first_data - Gets first entry with greater or equal id.
 469  *
 470  * @dd: hfi1 dev data
 471  * @start_id: requested integer id up to INT_MAX
 472  */
 473 void *hfi1_netdev_get_first_data(struct hfi1_devdata *dd, int *start_id)
 474 {
 475         struct hfi1_netdev_rx *rx = dd->netdev_rx;
 476         unsigned long index = *start_id;
 477         void *ret;
 478
 479         ret = xa_find(&rx->dev_tbl, &index, UINT_MAX, XA_PRESENT);
 480         *start_id = (int)index;
 481         return ret;
 482 }