src/plugins/vmxnet3/vmxnet3.c

   1 /*
   2  * Copyright (c) 2018 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <vppinfra/types.h>
  17 #include <vlib/vlib.h>
  18 #include <vlib/pci/pci.h>
  19 #include <vnet/ethernet/ethernet.h>
  20 #include <vnet/plugin/plugin.h>
  21 #include <vpp/app/version.h>
  22
  23 #include <vmxnet3/vmxnet3.h>
  24
  25 #define PCI_VENDOR_ID_VMWARE                            0x15ad
  26 #define PCI_DEVICE_ID_VMWARE_VMXNET3                    0x07b0
  27
  28 vmxnet3_main_t vmxnet3_main;
  29
  30 static pci_device_id_t vmxnet3_pci_device_ids[] = {
  31   {
  32    .vendor_id = PCI_VENDOR_ID_VMWARE,
  33    .device_id = PCI_DEVICE_ID_VMWARE_VMXNET3},
  34   {0},
  35 };
  36
  37 static clib_error_t *
  38 vmxnet3_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index,
  39                                  u32 flags)
  40 {
  41   vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
  42   vmxnet3_main_t *vmxm = &vmxnet3_main;
  43   vmxnet3_device_t *vd = vec_elt_at_index (vmxm->devices, hi->dev_instance);
  44   uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
  45
  46   if (vd->flags & VMXNET3_DEVICE_F_ERROR)
  47     return clib_error_return (0, "device is in error state");
  48
  49   if (is_up)
  50     {
  51       vnet_hw_interface_set_flags (vnm, vd->hw_if_index,
  52                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
  53       vd->flags |= VMXNET3_DEVICE_F_ADMIN_UP;
  54     }
  55   else
  56     {
  57       vnet_hw_interface_set_flags (vnm, vd->hw_if_index, 0);
  58       vd->flags &= ~VMXNET3_DEVICE_F_ADMIN_UP;
  59     }
  60   return 0;
  61 }
  62
  63 static clib_error_t *
  64 vmxnet3_interface_rx_mode_change (vnet_main_t * vnm, u32 hw_if_index, u32 qid,
  65                                   vnet_hw_interface_rx_mode mode)
  66 {
  67   vmxnet3_main_t *vmxm = &vmxnet3_main;
  68   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
  69   vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, hw->dev_instance);
  70   vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, qid);
  71
  72   if (mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
  73     rxq->int_mode = 0;
  74   else
  75     rxq->int_mode = 1;
  76
  77   return 0;
  78 }
  79
  80 static void
  81 vmxnet3_set_interface_next_node (vnet_main_t * vnm, u32 hw_if_index,
  82                                  u32 node_index)
  83 {
  84   vmxnet3_main_t *vmxm = &vmxnet3_main;
  85   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
  86   vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, hw->dev_instance);
  87
  88   /* Shut off redirection */
  89   if (node_index == ~0)
  90     {
  91       vd->per_interface_next_index = node_index;
  92       return;
  93     }
  94
  95   vd->per_interface_next_index =
  96     vlib_node_add_next (vlib_get_main (), vmxnet3_input_node.index,
  97                         node_index);
  98 }
  99
 100 static void
 101 vmxnet3_clear_hw_interface_counters (u32 instance)
 102 {
 103   vmxnet3_main_t *vmxm = &vmxnet3_main;
 104   vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, instance);
 105   vmxnet3_tx_queue *tx = VMXNET3_TX_START (vd);
 106   vmxnet3_rx_queue *rx = VMXNET3_RX_START (vd);
 107   u16 qid;
 108
 109   /*
 110    * Set the "last_cleared_stats" to the current stats, so that
 111    * things appear to clear from a display perspective.
 112    */
 113   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_GET_STATS);
 114
 115   vec_foreach_index (qid, vd->txqs)
 116   {
 117     vmxnet3_tx_stats *txs = vec_elt_at_index (vd->tx_stats, qid);
 118     clib_memcpy (txs, &tx->stats, sizeof (*txs));
 119     tx++;
 120   }
 121   vec_foreach_index (qid, vd->rxqs)
 122   {
 123     vmxnet3_rx_stats *rxs = vec_elt_at_index (vd->rx_stats, qid);
 124     clib_memcpy (rxs, &rx->stats, sizeof (*rxs));
 125     rx++;
 126   }
 127 }
 128
 129 static char *vmxnet3_tx_func_error_strings[] = {
 130 #define _(n,s) s,
 131   foreach_vmxnet3_tx_func_error
 132 #undef _
 133 };
 134
 135 /* *INDENT-OFF* */
 136 VNET_DEVICE_CLASS (vmxnet3_device_class,) =
 137 {
 138   .name = "VMXNET3 interface",
 139   .format_device = format_vmxnet3_device,
 140   .format_device_name = format_vmxnet3_device_name,
 141   .admin_up_down_function = vmxnet3_interface_admin_up_down,
 142   .clear_counters = vmxnet3_clear_hw_interface_counters,
 143   .rx_mode_change_function = vmxnet3_interface_rx_mode_change,
 144   .rx_redirect_to_node = vmxnet3_set_interface_next_node,
 145   .tx_function_n_errors = VMXNET3_TX_N_ERROR,
 146   .tx_function_error_strings = vmxnet3_tx_func_error_strings,
 147 };
 148 /* *INDENT-ON* */
 149
 150 static u32
 151 vmxnet3_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw, u32 flags)
 152 {
 153   return 0;
 154 }
 155
 156 static void
 157 vmxnet3_write_mac (vmxnet3_device_t * vd)
 158 {
 159   u32 val;
 160
 161   memcpy (&val, vd->mac_addr, 4);
 162   vmxnet3_reg_write (vd, 1, VMXNET3_REG_MACL, val);
 163
 164   val = 0;
 165   memcpy (&val, vd->mac_addr + 4, 2);
 166   vmxnet3_reg_write (vd, 1, VMXNET3_REG_MACH, val);
 167 }
 168
 169 static clib_error_t *
 170 vmxnet3_provision_driver_shared (vlib_main_t * vm, vmxnet3_device_t * vd)
 171 {
 172   vmxnet3_shared *shared;
 173   u64 shared_dma;
 174   u16 qid, rid;
 175   vmxnet3_tx_queue *tx = VMXNET3_TX_START (vd);
 176   vmxnet3_rx_queue *rx = VMXNET3_RX_START (vd);
 177
 178   vd->driver_shared =
 179     vlib_physmem_alloc_aligned_on_numa (vm, sizeof (*vd->driver_shared), 512,
 180                                         vd->numa_node);
 181   if (vd->driver_shared == 0)
 182     return vlib_physmem_last_error (vm);
 183
 184   clib_memset (vd->driver_shared, 0, sizeof (*vd->driver_shared));
 185
 186   vec_foreach_index (qid, vd->txqs)
 187   {
 188     vmxnet3_txq_t *txq = vec_elt_at_index (vd->txqs, qid);
 189
 190     tx->cfg.desc_address = vmxnet3_dma_addr (vm, vd, txq->tx_desc);
 191     tx->cfg.comp_address = vmxnet3_dma_addr (vm, vd, txq->tx_comp);
 192     tx->cfg.num_desc = txq->size;
 193     tx->cfg.num_comp = txq->size;
 194     tx++;
 195   }
 196
 197   vec_foreach_index (qid, vd->rxqs)
 198   {
 199     vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, qid);
 200
 201     for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
 202       {
 203         rx->cfg.desc_address[rid] = vmxnet3_dma_addr (vm, vd,
 204                                                       rxq->rx_desc[rid]);
 205         rx->cfg.num_desc[rid] = rxq->size;
 206       }
 207     rx->cfg.comp_address = vmxnet3_dma_addr (vm, vd, rxq->rx_comp);
 208     rx->cfg.num_comp = rxq->size;
 209     rx++;
 210   }
 211
 212   shared = vd->driver_shared;
 213   shared->magic = VMXNET3_SHARED_MAGIC;
 214   shared->misc.version = VMXNET3_VERSION_MAGIC;
 215   if (sizeof (void *) == 4)
 216     shared->misc.guest_info = VMXNET3_GOS_BITS_32;
 217   else
 218     shared->misc.guest_info = VMXNET3_GOS_BITS_64;
 219   shared->misc.guest_info |= VMXNET3_GOS_TYPE_LINUX;
 220   shared->misc.version_support = VMXNET3_VERSION_SELECT;
 221   shared->misc.upt_features = VMXNET3_F_RXCSUM;
 222   if (vd->lro_enable)
 223     shared->misc.upt_features |= VMXNET3_F_LRO;
 224   shared->misc.max_num_rx_sg = 0;
 225   shared->misc.upt_version_support = VMXNET3_UPT_VERSION_SELECT;
 226   shared->misc.queue_desc_address = vmxnet3_dma_addr (vm, vd, vd->queues);
 227   shared->misc.queue_desc_len = sizeof (*tx) * vd->num_tx_queues +
 228     sizeof (*rx) * vd->num_rx_queues;
 229   shared->misc.mtu = VMXNET3_MTU;
 230   shared->misc.num_tx_queues = vd->num_tx_queues;
 231   shared->misc.num_rx_queues = vd->num_rx_queues;
 232   shared->interrupt.num_intrs = vd->num_intrs;
 233   shared->interrupt.event_intr_index = 1;
 234   shared->interrupt.control = VMXNET3_IC_DISABLE_ALL;
 235   shared->rx_filter.mode = VMXNET3_RXMODE_UCAST | VMXNET3_RXMODE_BCAST |
 236     VMXNET3_RXMODE_ALL_MULTI | VMXNET3_RXMODE_PROMISC;
 237   shared_dma = vmxnet3_dma_addr (vm, vd, shared);
 238
 239   vmxnet3_reg_write (vd, 1, VMXNET3_REG_DSAL, shared_dma);
 240   vmxnet3_reg_write (vd, 1, VMXNET3_REG_DSAH, shared_dma >> 32);
 241
 242   return 0;
 243 }
 244
 245 static inline void
 246 vmxnet3_enable_interrupt (vmxnet3_device_t * vd)
 247 {
 248   int i;
 249   vmxnet3_shared *shared = vd->driver_shared;
 250
 251   shared->interrupt.control &= ~VMXNET3_IC_DISABLE_ALL;
 252   for (i = 0; i < vd->num_intrs; i++)
 253     vmxnet3_reg_write (vd, 0, VMXNET3_REG_IMR + i * 8, 0);
 254 }
 255
 256 static inline void
 257 vmxnet3_disable_interrupt (vmxnet3_device_t * vd)
 258 {
 259   int i;
 260   vmxnet3_shared *shared = vd->driver_shared;
 261
 262   shared->interrupt.control |= VMXNET3_IC_DISABLE_ALL;
 263   for (i = 0; i < vd->num_intrs; i++)
 264     vmxnet3_reg_write (vd, 0, VMXNET3_REG_IMR + i * 8, 1);
 265 }
 266
 267 static clib_error_t *
 268 vmxnet3_rxq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
 269 {
 270   vmxnet3_rxq_t *rxq;
 271   vmxnet3_rx_stats *rxs;
 272   u16 rid;
 273
 274   vec_validate (vd->rx_stats, qid);
 275   rxs = vec_elt_at_index (vd->rx_stats, qid);
 276   clib_memset (rxs, 0, sizeof (*rxs));
 277
 278   vec_validate_aligned (vd->rxqs, qid, CLIB_CACHE_LINE_BYTES);
 279   rxq = vec_elt_at_index (vd->rxqs, qid);
 280   clib_memset (rxq, 0, sizeof (*rxq));
 281   rxq->size = qsz;
 282   for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
 283     {
 284       rxq->rx_desc[rid] = vlib_physmem_alloc_aligned_on_numa
 285         (vm, qsz * sizeof (*rxq->rx_desc[rid]), 512, vd->numa_node);
 286
 287       if (rxq->rx_desc[rid] == 0)
 288         return vlib_physmem_last_error (vm);
 289
 290       clib_memset (rxq->rx_desc[rid], 0, qsz * sizeof (*rxq->rx_desc[rid]));
 291     }
 292   rxq->rx_comp =
 293     vlib_physmem_alloc_aligned_on_numa (vm, qsz * sizeof (*rxq->rx_comp), 512,
 294                                         vd->numa_node);
 295   if (rxq->rx_comp == 0)
 296     return vlib_physmem_last_error (vm);
 297
 298   clib_memset (rxq->rx_comp, 0, qsz * sizeof (*rxq->rx_comp));
 299   for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
 300     {
 301       vmxnet3_rx_ring *ring;
 302
 303       ring = &rxq->rx_ring[rid];
 304       ring->gen = VMXNET3_RXF_GEN;
 305       ring->rid = rid;
 306       vec_validate_aligned (ring->bufs, rxq->size, CLIB_CACHE_LINE_BYTES);
 307     }
 308   rxq->rx_comp_ring.gen = VMXNET3_RXCF_GEN;
 309
 310   return 0;
 311 }
 312
 313 static clib_error_t *
 314 vmxnet3_txq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
 315 {
 316   vmxnet3_txq_t *txq;
 317   vmxnet3_tx_stats *txs;
 318   u32 size;
 319
 320   if (qid >= vd->num_tx_queues)
 321     {
 322       qid = qid % vd->num_tx_queues;
 323       txq = vec_elt_at_index (vd->txqs, qid);
 324       if (txq->lock == 0)
 325         clib_spinlock_init (&txq->lock);
 326       vd->flags |= VMXNET3_DEVICE_F_SHARED_TXQ_LOCK;
 327       return 0;
 328     }
 329
 330   vec_validate (vd->tx_stats, qid);
 331   txs = vec_elt_at_index (vd->tx_stats, qid);
 332   clib_memset (txs, 0, sizeof (*txs));
 333
 334   vec_validate_aligned (vd->txqs, qid, CLIB_CACHE_LINE_BYTES);
 335   txq = vec_elt_at_index (vd->txqs, qid);
 336   clib_memset (txq, 0, sizeof (*txq));
 337   txq->size = qsz;
 338   txq->reg_txprod = qid * 8 + VMXNET3_REG_TXPROD;
 339
 340   size = qsz * sizeof (*txq->tx_desc);
 341   txq->tx_desc =
 342     vlib_physmem_alloc_aligned_on_numa (vm, size, 512, vd->numa_node);
 343   if (txq->tx_desc == 0)
 344     return vlib_physmem_last_error (vm);
 345
 346   memset (txq->tx_desc, 0, size);
 347
 348   size = qsz * sizeof (*txq->tx_comp);
 349   txq->tx_comp =
 350     vlib_physmem_alloc_aligned_on_numa (vm, size, 512, vd->numa_node);
 351   if (txq->tx_comp == 0)
 352     return vlib_physmem_last_error (vm);
 353
 354   clib_memset (txq->tx_comp, 0, size);
 355   vec_validate_aligned (txq->tx_ring.bufs, txq->size, CLIB_CACHE_LINE_BYTES);
 356   txq->tx_ring.gen = VMXNET3_TXF_GEN;
 357   txq->tx_comp_ring.gen = VMXNET3_TXCF_GEN;
 358
 359   return 0;
 360 }
 361
 362 static clib_error_t *
 363 vmxnet3_device_init (vlib_main_t * vm, vmxnet3_device_t * vd,
 364                      vmxnet3_create_if_args_t * args)
 365 {
 366   vnet_main_t *vnm = vnet_get_main ();
 367   vmxnet3_main_t *vmxm = &vmxnet3_main;
 368   clib_error_t *error = 0;
 369   u32 ret, i, size;
 370   vlib_thread_main_t *tm = vlib_get_thread_main ();
 371
 372   /* Quiesce the device */
 373   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_QUIESCE_DEV);
 374   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 375   if (ret != 0)
 376     {
 377       error = clib_error_return (0, "error on quiescing device rc (%u)", ret);
 378       return error;
 379     }
 380
 381   /* Reset the device */
 382   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_RESET_DEV);
 383   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 384   if (ret != 0)
 385     {
 386       error = clib_error_return (0, "error on resetting device rc (%u)", ret);
 387       return error;
 388     }
 389
 390   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_VRRS);
 391   vd->version = count_leading_zeros (ret);
 392   vd->version = uword_bits - vd->version;
 393
 394   if (vd->version == 0)
 395     {
 396       error = clib_error_return (0, "unsupported hardware version %u",
 397                                  vd->version);
 398       return error;
 399     }
 400
 401   /* cap support version to 3 */
 402   vmxnet3_reg_write (vd, 1, VMXNET3_REG_VRRS,
 403                      1 << (clib_min (3, vd->version) - 1));
 404
 405   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_UVRS);
 406   if (ret & 1)
 407     vmxnet3_reg_write (vd, 1, VMXNET3_REG_UVRS, 1);
 408   else
 409     {
 410       error = clib_error_return (0, "unsupported upt version %u", ret);
 411       return error;
 412     }
 413
 414   /* LRO is only supported for version >= 3 */
 415   if ((vmxm->lro_configured) && (vd->version >= 3))
 416     {
 417       vd->lro_enable = 1;
 418       vnm->interface_main.gso_interface_count++;
 419     }
 420
 421   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_GET_LINK);
 422   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 423   if (ret & 1)
 424     {
 425       vd->flags |= VMXNET3_DEVICE_F_LINK_UP;
 426       vd->link_speed = ret >> 16;
 427     }
 428   else
 429     vd->flags &= ~VMXNET3_DEVICE_F_LINK_UP;
 430
 431   /* Get the mac address */
 432   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_MACL);
 433   clib_memcpy (vd->mac_addr, &ret, 4);
 434   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_MACH);
 435   clib_memcpy (vd->mac_addr + 4, &ret, 2);
 436
 437   size = sizeof (vmxnet3_rx_queue) * vd->num_rx_queues +
 438     sizeof (vmxnet3_tx_queue) * vd->num_tx_queues;
 439
 440   vd->queues =
 441     vlib_physmem_alloc_aligned_on_numa (vm, size, 512, vd->numa_node);
 442   if (vd->queues == 0)
 443     return vlib_physmem_last_error (vm);
 444
 445   clib_memset (vd->queues, 0, size);
 446
 447   error = vmxnet3_rxq_init (vm, vd, 0, args->rxq_size);
 448   if (error)
 449     return error;
 450
 451   for (i = 0; i < tm->n_vlib_mains; i++)
 452     {
 453       error = vmxnet3_txq_init (vm, vd, i, args->txq_size);
 454       if (error)
 455         return error;
 456     }
 457
 458   error = vmxnet3_provision_driver_shared (vm, vd);
 459   if (error)
 460     return error;
 461
 462   vmxnet3_write_mac (vd);
 463
 464   /* Activate device */
 465   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_ACTIVATE_DEV);
 466   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 467   if (ret != 0)
 468     {
 469       error =
 470         clib_error_return (0, "error on activating device rc (%u)", ret);
 471       return error;
 472     }
 473
 474   /* Disable interrupts */
 475   vmxnet3_disable_interrupt (vd);
 476
 477   vec_foreach_index (i, vd->rxqs)
 478   {
 479     vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, i);
 480
 481     vmxnet3_rxq_refill_ring0 (vm, vd, rxq);
 482     vmxnet3_rxq_refill_ring1 (vm, vd, rxq);
 483   }
 484   vd->flags |= VMXNET3_DEVICE_F_INITIALIZED;
 485
 486   vmxnet3_enable_interrupt (vd);
 487
 488   return error;
 489 }
 490
 491 static void
 492 vmxnet3_irq_0_handler (vlib_main_t * vm, vlib_pci_dev_handle_t h, u16 line)
 493 {
 494   vnet_main_t *vnm = vnet_get_main ();
 495   vmxnet3_main_t *vmxm = &vmxnet3_main;
 496   uword pd = vlib_pci_get_private_data (vm, h);
 497   vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, pd);
 498   u16 qid = line;
 499
 500   if (vec_len (vd->rxqs) > qid && vd->rxqs[qid].int_mode != 0)
 501     vnet_device_input_set_interrupt_pending (vnm, vd->hw_if_index, qid);
 502 }
 503
 504 static void
 505 vmxnet3_irq_1_handler (vlib_main_t * vm, vlib_pci_dev_handle_t h, u16 line)
 506 {
 507   vnet_main_t *vnm = vnet_get_main ();
 508   vmxnet3_main_t *vmxm = &vmxnet3_main;
 509   uword pd = vlib_pci_get_private_data (vm, h);
 510   vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, pd);
 511   u32 ret;
 512
 513   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_GET_LINK);
 514   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 515   if (ret & 1)
 516     {
 517       vd->flags |= VMXNET3_DEVICE_F_LINK_UP;
 518       vd->link_speed = ret >> 16;
 519       vnet_hw_interface_set_link_speed (vnm, vd->hw_if_index,
 520                                         vd->link_speed * 1000);
 521       vnet_hw_interface_set_flags (vnm, vd->hw_if_index,
 522                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
 523     }
 524   else
 525     {
 526       vd->flags &= ~VMXNET3_DEVICE_F_LINK_UP;
 527       vnet_hw_interface_set_flags (vnm, vd->hw_if_index, 0);
 528     }
 529 }
 530
 531 static u8
 532 vmxnet3_queue_size_valid (u16 qsz)
 533 {
 534   if (qsz < 64 || qsz > 4096)
 535     return 0;
 536   if ((qsz % 64) != 0)
 537     return 0;
 538   return 1;
 539 }
 540
 541 static u8
 542 vmxnet3_queue_num_valid (u16 num)
 543 {
 544   vlib_thread_main_t *tm = vlib_get_thread_main ();
 545
 546   if ((num > VMXNET3_TXQ_MAX) || (num > tm->n_vlib_mains))
 547     return 0;
 548   return 1;
 549 }
 550
 551 void
 552 vmxnet3_create_if (vlib_main_t * vm, vmxnet3_create_if_args_t * args)
 553 {
 554   vnet_main_t *vnm = vnet_get_main ();
 555   vmxnet3_main_t *vmxm = &vmxnet3_main;
 556   vmxnet3_device_t *vd;
 557   vlib_pci_dev_handle_t h;
 558   clib_error_t *error = 0;
 559
 560   if (args->txq_num == 0)
 561     args->txq_num = 1;
 562   if (!vmxnet3_queue_num_valid (args->txq_num))
 563     {
 564       args->rv = VNET_API_ERROR_INVALID_VALUE;
 565       args->error =
 566         clib_error_return (error,
 567                            "number of queues must be <= %u and <= number of "
 568                            "CPU's assigned to VPP", VMXNET3_TXQ_MAX);
 569       vlib_log (VLIB_LOG_LEVEL_ERR, vmxm->log_default, "%U: %s",
 570                 format_vlib_pci_addr, &args->addr,
 571                 "number of queues must be <= %u and <= number of "
 572                 "CPU's assigned to VPP", VMXNET3_TXQ_MAX);
 573       return;
 574     }
 575   if (args->rxq_size == 0)
 576     args->rxq_size = VMXNET3_NUM_RX_DESC;
 577   if (args->txq_size == 0)
 578     args->txq_size = VMXNET3_NUM_TX_DESC;
 579
 580   if (!vmxnet3_queue_size_valid (args->rxq_size) ||
 581       !vmxnet3_queue_size_valid (args->txq_size))
 582     {
 583       args->rv = VNET_API_ERROR_INVALID_VALUE;
 584       args->error =
 585         clib_error_return (error,
 586                            "queue size must be <= 4096, >= 64, "
 587                            "and multiples of 64");
 588       vlib_log (VLIB_LOG_LEVEL_ERR, vmxm->log_default, "%U: %s",
 589                 format_vlib_pci_addr, &args->addr,
 590                 "queue size must be <= 4096, >= 64, and multiples of 64");
 591       return;
 592     }
 593
 594   /* *INDENT-OFF* */
 595   pool_foreach (vd, vmxm->devices, ({
 596     if (vd->pci_addr.as_u32 == args->addr.as_u32)
 597       {
 598         args->rv = VNET_API_ERROR_INVALID_VALUE;
 599         args->error =
 600           clib_error_return (error, "PCI address in use");
 601         vlib_log (VLIB_LOG_LEVEL_ERR, vmxm->log_default, "%U: %s",
 602                   format_vlib_pci_addr, &args->addr, "pci address in use");
 603         return;
 604       }
 605   }));
 606   /* *INDENT-ON* */
 607
 608   pool_get (vmxm->devices, vd);
 609   vd->num_tx_queues = args->txq_num;
 610   vd->dev_instance = vd - vmxm->devices;
 611   vd->per_interface_next_index = ~0;
 612   vd->pci_addr = args->addr;
 613
 614   if (args->enable_elog)
 615     vd->flags |= VMXNET3_DEVICE_F_ELOG;
 616
 617   if ((error =
 618        vlib_pci_device_open (vm, &args->addr, vmxnet3_pci_device_ids, &h)))
 619     {
 620       pool_put (vmxm->devices, vd);
 621       args->rv = VNET_API_ERROR_INVALID_INTERFACE;
 622       args->error =
 623         clib_error_return (error, "pci-addr %U", format_vlib_pci_addr,
 624                            &args->addr);
 625       vlib_log (VLIB_LOG_LEVEL_ERR, vmxm->log_default, "%U: %s",
 626                 format_vlib_pci_addr, &args->addr,
 627                 "error encountered on pci device open");
 628       return;
 629     }
 630
 631   /*
 632    * Do not use vmxnet3_log_error prior to this line since the macro
 633    * references vd->pci_dev_handle
 634    */
 635   vd->pci_dev_handle = h;
 636   vd->numa_node = vlib_pci_get_numa_node (vm, h);
 637   vd->num_rx_queues = 1;
 638   vd->num_intrs = 2;
 639
 640   vlib_pci_set_private_data (vm, h, vd->dev_instance);
 641
 642   if ((error = vlib_pci_bus_master_enable (vm, h)))
 643     {
 644       vmxnet3_log_error (vd, "error encountered on pci bus master enable");
 645       goto error;
 646     }
 647
 648   if ((error = vlib_pci_map_region (vm, h, 0, (void **) &vd->bar[0])))
 649     {
 650       vmxnet3_log_error (vd, "error encountered on pci map region for bar 0");
 651       goto error;
 652     }
 653
 654   if ((error = vlib_pci_map_region (vm, h, 1, (void **) &vd->bar[1])))
 655     {
 656       vmxnet3_log_error (vd, "error encountered on pci map region for bar 1");
 657       goto error;
 658     }
 659
 660   if ((error = vlib_pci_register_msix_handler (vm, h, 0, 1,
 661                                                &vmxnet3_irq_0_handler)))
 662     {
 663       vmxnet3_log_error (vd,
 664                          "error encountered on pci register msix handler 0");
 665       goto error;
 666     }
 667
 668   if ((error = vlib_pci_register_msix_handler (vm, h, 1, 1,
 669                                                &vmxnet3_irq_1_handler)))
 670     {
 671       vmxnet3_log_error (vd,
 672                          "error encountered on pci register msix handler 1");
 673       goto error;
 674     }
 675
 676   if ((error = vlib_pci_enable_msix_irq (vm, h, 0, 2)))
 677     {
 678       vmxnet3_log_error (vd, "error encountered on pci enable msix irq");
 679       goto error;
 680     }
 681
 682   if ((error = vlib_pci_intr_enable (vm, h)))
 683     {
 684       vmxnet3_log_error (vd, "error encountered on pci interrupt enable");
 685       goto error;
 686     }
 687
 688   if ((error = vmxnet3_device_init (vm, vd, args)))
 689     {
 690       vmxnet3_log_error (vd, "error encountered on device init");
 691       goto error;
 692     }
 693
 694   /* create interface */
 695   error = ethernet_register_interface (vnm, vmxnet3_device_class.index,
 696                                        vd->dev_instance, vd->mac_addr,
 697                                        &vd->hw_if_index, vmxnet3_flag_change);
 698
 699   if (error)
 700     {
 701       vmxnet3_log_error (vd,
 702                          "error encountered on ethernet register interface");
 703       goto error;
 704     }
 705
 706   vnet_sw_interface_t *sw = vnet_get_hw_sw_interface (vnm, vd->hw_if_index);
 707   vd->sw_if_index = sw->sw_if_index;
 708   args->sw_if_index = sw->sw_if_index;
 709
 710   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, vd->hw_if_index);
 711   hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_INT_MODE;
 712   if (vd->lro_enable)
 713     hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_GSO;
 714
 715   vnet_hw_interface_set_input_node (vnm, vd->hw_if_index,
 716                                     vmxnet3_input_node.index);
 717   vnet_hw_interface_assign_rx_thread (vnm, vd->hw_if_index, 0, ~0);
 718   vnet_hw_interface_set_link_speed (vnm, vd->hw_if_index,
 719                                     vd->link_speed * 1000);
 720   if (vd->flags & VMXNET3_DEVICE_F_LINK_UP)
 721     vnet_hw_interface_set_flags (vnm, vd->hw_if_index,
 722                                  VNET_HW_INTERFACE_FLAG_LINK_UP);
 723   else
 724     vnet_hw_interface_set_flags (vnm, vd->hw_if_index, 0);
 725   return;
 726
 727 error:
 728   vmxnet3_delete_if (vm, vd);
 729   args->rv = VNET_API_ERROR_INVALID_INTERFACE;
 730   args->error = error;
 731 }
 732
 733 void
 734 vmxnet3_delete_if (vlib_main_t * vm, vmxnet3_device_t * vd)
 735 {
 736   vnet_main_t *vnm = vnet_get_main ();
 737   vmxnet3_main_t *vmxm = &vmxnet3_main;
 738   u32 i, bi;
 739   u16 desc_idx;
 740
 741   /* Quiesce the device */
 742   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_QUIESCE_DEV);
 743
 744   /* Reset the device */
 745   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_RESET_DEV);
 746
 747   if (vd->hw_if_index)
 748     {
 749       vnet_hw_interface_set_flags (vnm, vd->hw_if_index, 0);
 750       vnet_hw_interface_unassign_rx_thread (vnm, vd->hw_if_index, 0);
 751       ethernet_delete_interface (vnm, vd->hw_if_index);
 752     }
 753
 754   vlib_pci_device_close (vm, vd->pci_dev_handle);
 755
 756   /* *INDENT-OFF* */
 757   vec_foreach_index (i, vd->rxqs)
 758     {
 759       vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, i);
 760       u16 mask = rxq->size - 1;
 761       u16 rid;
 762
 763       for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
 764         {
 765           vmxnet3_rx_ring *ring;
 766
 767           ring = &rxq->rx_ring[rid];
 768           desc_idx = (ring->consume + 1) & mask;
 769           vlib_buffer_free_from_ring (vm, ring->bufs, desc_idx, rxq->size,
 770                                       ring->fill);
 771           vec_free (ring->bufs);
 772           vlib_physmem_free (vm, rxq->rx_desc[rid]);
 773         }
 774       vlib_physmem_free (vm, rxq->rx_comp);
 775     }
 776   /* *INDENT-ON* */
 777   vec_free (vd->rxqs);
 778   vec_free (vd->rx_stats);
 779
 780   /* *INDENT-OFF* */
 781   vec_foreach_index (i, vd->txqs)
 782     {
 783       vmxnet3_txq_t *txq = vec_elt_at_index (vd->txqs, i);
 784       u16 mask = txq->size - 1;
 785       u16 end_idx;
 786
 787       desc_idx = txq->tx_ring.consume;
 788       end_idx = txq->tx_ring.produce;
 789       while (desc_idx != end_idx)
 790         {
 791           bi = txq->tx_ring.bufs[desc_idx];
 792           vlib_buffer_free_no_next (vm, &bi, 1);
 793           desc_idx++;
 794           desc_idx &= mask;
 795         }
 796       clib_spinlock_free (&txq->lock);
 797       vec_free (txq->tx_ring.bufs);
 798       vlib_physmem_free (vm, txq->tx_desc);
 799       vlib_physmem_free (vm, txq->tx_comp);
 800     }
 801   /* *INDENT-ON* */
 802   vec_free (vd->txqs);
 803   vec_free (vd->tx_stats);
 804
 805   vlib_physmem_free (vm, vd->driver_shared);
 806   vlib_physmem_free (vm, vd->queues);
 807
 808   clib_error_free (vd->error);
 809   clib_memset (vd, 0, sizeof (*vd));
 810   pool_put (vmxm->devices, vd);
 811
 812   if (vd->lro_enable)
 813     vnm->interface_main.gso_interface_count--;
 814 }
 815
 816 /*
 817  * fd.io coding-style-patch-verification: ON
 818  *
 819  * Local Variables:
 820  * eval: (c-set-style "gnu")
 821  * End:
 822  */