src/plugins/dev_iavf/port.c

   1 /* SPDX-License-Identifier: Apache-2.0
   2  * Copyright (c) 2023 Cisco Systems, Inc.
   3  */
   4
   5 #include <vnet/vnet.h>
   6 #include <vnet/dev/dev.h>
   7 #include <vnet/dev/pci.h>
   8 #include <vnet/dev/counters.h>
   9 #include <dev_iavf/iavf.h>
  10 #include <dev_iavf/iavf_regs.h>
  11 #include <dev_iavf/virtchnl.h>
  12 #include <dev_iavf/virtchnl_funcs.h>
  13 #include <vnet/ethernet/ethernet.h>
  14
  15 VLIB_REGISTER_LOG_CLASS (iavf_log, static) = {
  16   .class_name = "iavf",
  17   .subclass_name = "port",
  18 };
  19
  20 static const u8 default_rss_key[] = {
  21   0x44, 0x39, 0x79, 0x6b, 0xb5, 0x4c, 0x50, 0x23, 0xb6, 0x75, 0xea, 0x5b, 0x12,
  22   0x4f, 0x9f, 0x30, 0xb8, 0xa2, 0xc0, 0x3d, 0xdf, 0xdc, 0x4d, 0x02, 0xa0, 0x8c,
  23   0x9b, 0x33, 0x4a, 0xf6, 0x4a, 0x4c, 0x05, 0xc6, 0xfa, 0x34, 0x39, 0x58, 0xd8,
  24   0x55, 0x7d, 0x99, 0x58, 0x3a, 0xe1, 0x38, 0xc9, 0x2e, 0x81, 0x15, 0x03, 0x66,
  25 };
  26
  27 const static iavf_dyn_ctl dyn_ctln_disabled = {};
  28 const static iavf_dyn_ctl dyn_ctln_enabled = {
  29   .intena = 1,
  30   .clearpba = 1,
  31   .interval = IAVF_ITR_INT / 2,
  32 };
  33 const static iavf_dyn_ctl dyn_ctln_wb_on_itr = {
  34   .itr_indx = 1,
  35   .interval = 2,
  36   .wb_on_itr = 1,
  37 };
  38
  39 vnet_dev_rv_t
  40 iavf_port_vlan_strip_disable (vlib_main_t *vm, vnet_dev_port_t *port)
  41 {
  42   vnet_dev_t *dev = port->dev;
  43   iavf_port_t *ap = vnet_dev_get_port_data (port);
  44   virtchnl_vlan_caps_t vc;
  45   vnet_dev_rv_t rv;
  46   u32 outer, inner;
  47   const u32 mask = VIRTCHNL_VLAN_ETHERTYPE_8100;
  48
  49   if ((ap->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_VLAN_V2) == 0)
  50     return iavf_vc_op_disable_vlan_stripping (vm, dev);
  51
  52   if ((rv = iavf_vc_op_get_offload_vlan_v2_caps (vm, dev, &vc)))
  53     return rv;
  54
  55   outer = vc.offloads.stripping_support.outer;
  56   inner = vc.offloads.stripping_support.inner;
  57
  58   outer = outer & VIRTCHNL_VLAN_TOGGLE ? outer & mask : 0;
  59   inner = inner & VIRTCHNL_VLAN_TOGGLE ? inner & mask : 0;
  60
  61   virtchnl_vlan_setting_t vs = {
  62     .vport_id = ap->vsi_id,
  63     .outer_ethertype_setting = outer,
  64     .inner_ethertype_setting = inner,
  65   };
  66
  67   return iavf_vc_op_disable_vlan_stripping_v2 (vm, dev, &vs);
  68 }
  69
  70 vnet_dev_rv_t
  71 iavf_port_init_rss (vlib_main_t *vm, vnet_dev_port_t *port)
  72 {
  73   vnet_dev_t *dev = port->dev;
  74   iavf_port_t *ap = vnet_dev_get_port_data (port);
  75   u16 keylen = clib_min (sizeof (default_rss_key), ap->rss_key_size);
  76   u8 buffer[VIRTCHNL_MSG_SZ (virtchnl_rss_key_t, key, keylen)];
  77   virtchnl_rss_key_t *key = (virtchnl_rss_key_t *) buffer;
  78
  79   if (!port->attr.caps.rss)
  80     return VNET_DEV_OK;
  81
  82   /* config RSS key */
  83   *key = (virtchnl_rss_key_t){
  84     .vsi_id = ap->vsi_id,
  85     .key_len = keylen,
  86   };
  87
  88   clib_memcpy (key->key, default_rss_key, sizeof (default_rss_key));
  89
  90   return iavf_vc_op_config_rss_key (vm, dev, key);
  91 }
  92
  93 vnet_dev_rv_t
  94 iavf_port_update_rss_lut (vlib_main_t *vm, vnet_dev_port_t *port)
  95 {
  96   vnet_dev_t *dev = port->dev;
  97   iavf_port_t *ap = vnet_dev_get_port_data (port);
  98   u16 lut_size = clib_min (IAVF_MAX_RSS_LUT_SIZE, ap->rss_lut_size);
  99   u8 buffer[VIRTCHNL_MSG_SZ (virtchnl_rss_lut_t, lut, lut_size)];
 100   virtchnl_rss_lut_t *lut = (virtchnl_rss_lut_t *) buffer;
 101   u32 enabled_rxq_bmp = 0;
 102
 103   if (!port->attr.caps.rss)
 104     return VNET_DEV_OK;
 105
 106   *lut = (virtchnl_rss_lut_t){
 107     .vsi_id = ap->vsi_id,
 108     .lut_entries = lut_size,
 109   };
 110
 111   foreach_vnet_dev_port_rx_queue (q, port)
 112     if (q->enabled)
 113       enabled_rxq_bmp |= 1ULL << q->queue_id;
 114
 115   /* config RSS LUT */
 116   for (u32 i = 0, j; i < lut->lut_entries;)
 117     foreach_set_bit_index (j, enabled_rxq_bmp)
 118       {
 119         lut->lut[i++] = j;
 120         if (i >= lut->lut_entries)
 121           break;
 122       }
 123
 124   return iavf_vc_op_config_rss_lut (vm, dev, lut);
 125 }
 126
 127 vnet_dev_rv_t
 128 iavf_port_init_vsi_queues (vlib_main_t *vm, vnet_dev_port_t *port)
 129 {
 130   vnet_dev_t *dev = port->dev;
 131   iavf_port_t *ap = vnet_dev_get_port_data (port);
 132   virtchnl_queue_pair_info_t *qpi;
 133   u16 vsi_id = ap->vsi_id;
 134   u16 data_size = vlib_buffer_get_default_data_size (vm);
 135   u16 max_frame_size = port->max_rx_frame_size;
 136   u8 buffer[VIRTCHNL_MSG_SZ (virtchnl_vsi_queue_config_info_t, qpair,
 137                              ap->num_qp)];
 138   virtchnl_vsi_queue_config_info_t *ci =
 139     (virtchnl_vsi_queue_config_info_t *) buffer;
 140
 141   *ci = (virtchnl_vsi_queue_config_info_t){
 142     .num_queue_pairs = ap->num_qp,
 143     .vsi_id = vsi_id,
 144   };
 145
 146   for (u16 i = 0; i < ap->num_qp; i++)
 147     ci->qpair[i] = (virtchnl_queue_pair_info_t){
 148       .rxq = { .vsi_id = vsi_id, .queue_id = i },
 149       .txq = { .vsi_id = vsi_id, .queue_id = i },
 150     };
 151
 152   foreach_vnet_dev_port_rx_queue (q, port)
 153     {
 154       iavf_rxq_t *arq = vnet_dev_get_rx_queue_data (q);
 155       qpi = ci->qpair + q->queue_id;
 156       qpi->rxq.ring_len = q->size;
 157       qpi->rxq.databuffer_size = data_size;
 158       qpi->rxq.dma_ring_addr = vnet_dev_get_dma_addr (vm, dev, arq->descs);
 159       qpi->rxq.max_pkt_size = max_frame_size;
 160     }
 161
 162   foreach_vnet_dev_port_tx_queue (q, port)
 163     {
 164       iavf_txq_t *atq = vnet_dev_get_tx_queue_data (q);
 165       qpi = ci->qpair + q->queue_id;
 166       qpi->txq.ring_len = q->size;
 167       qpi->txq.dma_ring_addr = vnet_dev_get_dma_addr (vm, dev, atq->descs);
 168     }
 169
 170   return iavf_vc_op_config_vsi_queues (vm, dev, ci);
 171 }
 172
 173 vnet_dev_rv_t
 174 iavf_port_rx_irq_config (vlib_main_t *vm, vnet_dev_port_t *port, int enable)
 175 {
 176   vnet_dev_t *dev = port->dev;
 177   iavf_device_t *ad = vnet_dev_get_data (dev);
 178   iavf_port_t *ap = vnet_dev_get_port_data (port);
 179   u16 n_rx_vectors = ap->n_rx_vectors;
 180   u8 buffer[VIRTCHNL_MSG_SZ (virtchnl_irq_map_info_t, vecmap, n_rx_vectors)];
 181   u8 n_intr_mode_queues_per_vector[n_rx_vectors];
 182   u8 n_queues_per_vector[n_rx_vectors];
 183   virtchnl_irq_map_info_t *im = (virtchnl_irq_map_info_t *) buffer;
 184   vnet_dev_rv_t rv;
 185
 186   log_debug (dev, "intr mode per queue bitmap 0x%x",
 187              ap->intr_mode_per_rxq_bitmap);
 188
 189   for (u32 i = 0; i < n_rx_vectors; i++)
 190     n_intr_mode_queues_per_vector[i] = n_queues_per_vector[i] = 0;
 191
 192   *im = (virtchnl_irq_map_info_t){
 193     .num_vectors = n_rx_vectors,
 194   };
 195
 196   if (port->attr.caps.interrupt_mode)
 197     {
 198       for (u16 i = 0; i < im->num_vectors; i++)
 199         im->vecmap[i] = (virtchnl_vector_map_t){
 200           .vsi_id = ap->vsi_id,
 201           .vector_id = i + 1,
 202         };
 203       if (enable)
 204         foreach_vnet_dev_port_rx_queue (rxq, port)
 205           if (rxq->enabled)
 206             {
 207               u32 i = rxq->rx_thread_index;
 208               im->vecmap[i].rxq_map |= 1 << rxq->queue_id;
 209               n_queues_per_vector[i]++;
 210               n_intr_mode_queues_per_vector[i] +=
 211                 u64_is_bit_set (ap->intr_mode_per_rxq_bitmap, rxq->queue_id);
 212             }
 213     }
 214   else
 215     {
 216       im->vecmap[0] = (virtchnl_vector_map_t){
 217         .vsi_id = ap->vsi_id,
 218         .vector_id = 1,
 219       };
 220       if (enable)
 221         foreach_vnet_dev_port_rx_queue (rxq, port)
 222           if (rxq->enabled)
 223             im->vecmap[0].rxq_map |= 1 << rxq->queue_id;
 224     }
 225
 226   if ((rv = iavf_vc_op_config_irq_map (vm, dev, im)))
 227     return rv;
 228
 229   for (int i = 0; i < n_rx_vectors; i++)
 230     {
 231       u32 val;
 232
 233       if (enable == 0 || n_queues_per_vector[i] == 0)
 234         val = dyn_ctln_disabled.as_u32;
 235       else if (ap->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_WB_ON_ITR &&
 236                n_intr_mode_queues_per_vector[i] == 0)
 237         val = dyn_ctln_wb_on_itr.as_u32;
 238       else
 239         val = dyn_ctln_enabled.as_u32;
 240
 241       iavf_reg_write (ad, IAVF_VFINT_DYN_CTLN (i), val);
 242       log_debug (dev, "VFINT_DYN_CTLN(%u) set to 0x%x", i, val);
 243     }
 244
 245   return rv;
 246 }
 247
 248 static void
 249 avf_msix_n_handler (vlib_main_t *vm, vnet_dev_t *dev, u16 line)
 250 {
 251   iavf_device_t *ad = vnet_dev_get_data (dev);
 252   vnet_dev_port_t *port = vnet_dev_get_port_by_id (dev, 0);
 253
 254   line--;
 255
 256   iavf_reg_write (ad, IAVF_VFINT_DYN_CTLN (line), dyn_ctln_enabled.as_u32);
 257   vlib_node_set_interrupt_pending (vlib_get_main_by_index (line),
 258                                    port->intf.rx_node_index);
 259 }
 260
 261 vnet_dev_rv_t
 262 iavf_port_init (vlib_main_t *vm, vnet_dev_port_t *port)
 263 {
 264   vnet_dev_t *dev = port->dev;
 265   iavf_port_t *ap = vnet_dev_get_port_data (port);
 266   vnet_dev_rv_t rv;
 267
 268   log_debug (port->dev, "port %u", port->port_id);
 269
 270   ap->intr_mode_per_rxq_bitmap = 0;
 271   foreach_vnet_dev_port_rx_queue (q, port)
 272     if (q->interrupt_mode)
 273       u64_bit_set (&ap->intr_mode_per_rxq_bitmap, q->queue_id, 1);
 274
 275   if ((rv = iavf_port_vlan_strip_disable (vm, port)))
 276     return rv;
 277
 278   if ((rv = iavf_port_init_rss (vm, port)))
 279     return rv;
 280
 281   vnet_dev_pci_msix_add_handler (vm, dev, &avf_msix_n_handler, 1,
 282                                  ap->n_rx_vectors);
 283   vnet_dev_pci_msix_enable (vm, dev, 1, ap->n_rx_vectors);
 284   for (u32 i = 1; i < ap->n_rx_vectors; i++)
 285     vnet_dev_pci_msix_set_polling_thread (vm, dev, i + 1, i);
 286
 287   if (port->dev->poll_stats)
 288     iavf_port_add_counters (vm, port);
 289
 290   return VNET_DEV_OK;
 291 }
 292
 293 static vnet_dev_rv_t
 294 iavf_enable_disable_queues (vlib_main_t *vm, vnet_dev_port_t *port, int enable)
 295 {
 296   iavf_port_t *ap = vnet_dev_get_port_data (port);
 297
 298   virtchnl_queue_select_t qs = {
 299     .vsi_id = ap->vsi_id,
 300   };
 301
 302   foreach_vnet_dev_port_rx_queue (q, port)
 303     if ((enable && q->enabled) || (!enable && q->started))
 304       qs.rx_queues |= 1ULL << q->queue_id;
 305
 306   foreach_vnet_dev_port_tx_queue (q, port)
 307     if ((enable && q->enabled) || (!enable && q->started))
 308       qs.tx_queues |= 1ULL << q->queue_id;
 309
 310   return enable ? iavf_vc_op_enable_queues (vm, port->dev, &qs) :
 311                         iavf_vc_op_disable_queues (vm, port->dev, &qs);
 312 }
 313
 314 vnet_dev_rv_t
 315 iavf_port_start (vlib_main_t *vm, vnet_dev_port_t *port)
 316 {
 317   vnet_dev_rv_t rv;
 318
 319   log_debug (port->dev, "port %u", port->port_id);
 320
 321   foreach_vnet_dev_port_rx_queue (q, port)
 322     if (q->enabled)
 323       if ((rv = iavf_rx_queue_start (vm, q)))
 324         goto done;
 325
 326   foreach_vnet_dev_port_tx_queue (q, port)
 327     if ((rv = iavf_tx_queue_start (vm, q)))
 328       goto done;
 329
 330   if ((rv = iavf_port_update_rss_lut (vm, port)))
 331     goto done;
 332
 333   /* configure qpairs */
 334   if ((rv = iavf_port_init_vsi_queues (vm, port)))
 335     goto done;
 336
 337   if ((rv = iavf_port_rx_irq_config (vm, port, /* enable */ 1)))
 338     goto done;
 339
 340   if ((rv = iavf_enable_disable_queues (vm, port, 1)))
 341     goto done;
 342
 343   if (port->dev->poll_stats)
 344     vnet_dev_poll_port_add (vm, port, 1, iavf_port_poll_stats);
 345
 346 done:
 347   if (rv)
 348     {
 349       foreach_vnet_dev_port_rx_queue (q, port)
 350         iavf_rx_queue_stop (vm, q);
 351       foreach_vnet_dev_port_tx_queue (q, port)
 352         iavf_tx_queue_stop (vm, q);
 353     }
 354   return rv;
 355 }
 356
 357 void
 358 iavf_port_stop (vlib_main_t *vm, vnet_dev_port_t *port)
 359 {
 360   log_debug (port->dev, "port %u", port->port_id);
 361
 362   iavf_enable_disable_queues (vm, port, /* enable */ 0);
 363   iavf_port_rx_irq_config (vm, port, /* disable */ 0);
 364
 365   if (port->dev->poll_stats)
 366     vnet_dev_poll_port_remove (vm, port, iavf_port_poll_stats);
 367
 368   foreach_vnet_dev_port_rx_queue (rxq, port)
 369     iavf_rx_queue_stop (vm, rxq);
 370
 371   foreach_vnet_dev_port_tx_queue (txq, port)
 372     iavf_tx_queue_stop (vm, txq);
 373
 374   vnet_dev_port_state_change (vm, port,
 375                               (vnet_dev_port_state_changes_t){
 376                                 .change.link_state = 1,
 377                                 .change.link_speed = 1,
 378                                 .link_speed = 0,
 379                                 .link_state = 0,
 380                               });
 381 }
 382
 383 vnet_dev_rv_t
 384 iavf_port_cfg_change_validate (vlib_main_t *vm, vnet_dev_port_t *port,
 385                                vnet_dev_port_cfg_change_req_t *req)
 386 {
 387   vnet_dev_rv_t rv = VNET_DEV_OK;
 388
 389   switch (req->type)
 390     {
 391     case VNET_DEV_PORT_CFG_MAX_RX_FRAME_SIZE:
 392       if (port->started)
 393         rv = VNET_DEV_ERR_PORT_STARTED;
 394       break;
 395
 396     case VNET_DEV_PORT_CFG_PROMISC_MODE:
 397     case VNET_DEV_PORT_CFG_CHANGE_PRIMARY_HW_ADDR:
 398     case VNET_DEV_PORT_CFG_ADD_SECONDARY_HW_ADDR:
 399     case VNET_DEV_PORT_CFG_REMOVE_SECONDARY_HW_ADDR:
 400       break;
 401
 402     default:
 403       rv = VNET_DEV_ERR_NOT_SUPPORTED;
 404     };
 405
 406   return rv;
 407 }
 408
 409 static vnet_dev_rv_t
 410 iavf_port_add_del_eth_addr (vlib_main_t *vm, vnet_dev_port_t *port,
 411                             vnet_dev_hw_addr_t *addr, int is_add,
 412                             int is_primary)
 413 {
 414   iavf_port_t *ap = vnet_dev_get_port_data (port);
 415   virtchnl_ether_addr_list_t al = {
 416     .vsi_id = ap->vsi_id,
 417     .num_elements = 1,
 418     .list[0].primary = is_primary ? 1 : 0,
 419     .list[0].extra = is_primary ? 0 : 1,
 420   };
 421
 422   clib_memcpy (al.list[0].addr, addr, sizeof (al.list[0].addr));
 423
 424   return is_add ? iavf_vc_op_add_eth_addr (vm, port->dev, &al) :
 425                         iavf_vc_op_del_eth_addr (vm, port->dev, &al);
 426 }
 427
 428 static vnet_dev_rv_t
 429 iavf_port_cfg_rxq_int_mode_change (vlib_main_t *vm, vnet_dev_port_t *port,
 430                                    u16 qid, u8 state, u8 all)
 431 {
 432   vnet_dev_rv_t rv = VNET_DEV_OK;
 433   iavf_port_t *ap = vnet_dev_get_port_data (port);
 434   vnet_dev_t *dev = port->dev;
 435   char *ed = state ? "ena" : "disa";
 436   char qstr[16];
 437   u64 old, new = 0;
 438
 439   state = state != 0;
 440   old = ap->intr_mode_per_rxq_bitmap;
 441
 442   if (all)
 443     {
 444       snprintf (qstr, sizeof (qstr), "all queues");
 445       if (state)
 446         foreach_vnet_dev_port_rx_queue (q, port)
 447           u64_bit_set (&new, q->queue_id, 1);
 448     }
 449   else
 450     {
 451       snprintf (qstr, sizeof (qstr), "queue %u", qid);
 452       new = old;
 453       u64_bit_set (&new, qid, state);
 454     }
 455
 456   if (new == old)
 457     {
 458       log_warn (dev, "interrupt mode already %sbled on %s", ed, qstr);
 459       return rv;
 460     }
 461
 462   ap->intr_mode_per_rxq_bitmap = new;
 463
 464   if (port->started)
 465     {
 466       if ((rv = iavf_port_rx_irq_config (vm, port, 1)))
 467         {
 468           ap->intr_mode_per_rxq_bitmap = old;
 469           log_err (dev, "failed to %sble interrupt mode on %s", ed, qstr);
 470           return rv;
 471         }
 472     }
 473
 474   log_debug (dev, "interrupt mode %sbled on %s, new bitmap is 0x%x", ed, qstr,
 475              new);
 476   return rv;
 477 }
 478
 479 vnet_dev_rv_t
 480 iavf_port_cfg_change (vlib_main_t *vm, vnet_dev_port_t *port,
 481                       vnet_dev_port_cfg_change_req_t *req)
 482 {
 483   vnet_dev_t *dev = port->dev;
 484   iavf_port_t *ap = vnet_dev_get_port_data (port);
 485   vnet_dev_rv_t rv = VNET_DEV_OK;
 486
 487   switch (req->type)
 488     {
 489     case VNET_DEV_PORT_CFG_PROMISC_MODE:
 490       {
 491         virtchnl_promisc_info_t pi = {
 492           .vsi_id = ap->vsi_id,
 493           .unicast_promisc = req->promisc,
 494           .multicast_promisc = req->promisc,
 495         };
 496
 497         rv = iavf_vc_op_config_promisc_mode (vm, dev, &pi);
 498       }
 499       break;
 500
 501     case VNET_DEV_PORT_CFG_CHANGE_PRIMARY_HW_ADDR:
 502       rv = iavf_port_add_del_eth_addr (vm, port, &port->primary_hw_addr,
 503                                        /* is_add */ 0,
 504                                        /* is_primary */ 1);
 505       if (rv == VNET_DEV_OK)
 506         rv = iavf_port_add_del_eth_addr (vm, port, &req->addr,
 507                                          /* is_add */ 1,
 508                                          /* is_primary */ 1);
 509       break;
 510
 511     case VNET_DEV_PORT_CFG_ADD_SECONDARY_HW_ADDR:
 512       rv = iavf_port_add_del_eth_addr (vm, port, &req->addr,
 513                                        /* is_add */ 1,
 514                                        /* is_primary */ 0);
 515       break;
 516
 517     case VNET_DEV_PORT_CFG_REMOVE_SECONDARY_HW_ADDR:
 518       rv = iavf_port_add_del_eth_addr (vm, port, &req->addr,
 519                                        /* is_add */ 0,
 520                                        /* is_primary */ 0);
 521       break;
 522
 523     case VNET_DEV_PORT_CFG_MAX_RX_FRAME_SIZE:
 524       break;
 525
 526     case VNET_DEV_PORT_CFG_RXQ_INTR_MODE_ENABLE:
 527       rv = iavf_port_cfg_rxq_int_mode_change (vm, port, req->queue_id, 1,
 528                                               req->all_queues);
 529       break;
 530
 531     case VNET_DEV_PORT_CFG_RXQ_INTR_MODE_DISABLE:
 532       rv = iavf_port_cfg_rxq_int_mode_change (vm, port, req->queue_id, 0,
 533                                               req->all_queues);
 534       break;
 535
 536     default:
 537       return VNET_DEV_ERR_NOT_SUPPORTED;
 538     };
 539
 540   return rv;
 541 }