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 char *vmxnet3_tx_func_error_strings[] = {
 101 #define _(n,s) s,
 102   foreach_vmxnet3_tx_func_error
 103 #undef _
 104 };
 105
 106 /* *INDENT-OFF* */
 107 VNET_DEVICE_CLASS (vmxnet3_device_class,) =
 108 {
 109   .name = "VMXNET3 interface",
 110   .format_device = format_vmxnet3_device,
 111   .format_device_name = format_vmxnet3_device_name,
 112   .admin_up_down_function = vmxnet3_interface_admin_up_down,
 113   .rx_mode_change_function = vmxnet3_interface_rx_mode_change,
 114   .rx_redirect_to_node = vmxnet3_set_interface_next_node,
 115   .tx_function_n_errors = VMXNET3_TX_N_ERROR,
 116   .tx_function_error_strings = vmxnet3_tx_func_error_strings,
 117 };
 118 /* *INDENT-ON* */
 119
 120 static u32
 121 vmxnet3_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw, u32 flags)
 122 {
 123   return 0;
 124 }
 125
 126 static void
 127 vmxnet3_write_mac (vmxnet3_device_t * vd)
 128 {
 129   u32 val;
 130
 131   memcpy (&val, vd->mac_addr, 4);
 132   vmxnet3_reg_write (vd, 1, VMXNET3_REG_MACL, val);
 133
 134   val = 0;
 135   memcpy (&val, vd->mac_addr + 4, 2);
 136   vmxnet3_reg_write (vd, 1, VMXNET3_REG_MACH, val);
 137 }
 138
 139 static clib_error_t *
 140 vmxnet3_provision_driver_shared (vlib_main_t * vm, vmxnet3_device_t * vd)
 141 {
 142   vmxnet3_main_t *vmxm = &vmxnet3_main;
 143   vmxnet3_shared *shared;
 144   vmxnet3_queues *q;
 145   u64 shared_dma;
 146   clib_error_t *error;
 147   u16 qid = 0, rid;
 148   vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, qid);
 149   vmxnet3_txq_t *txq = vec_elt_at_index (vd->txqs, qid);
 150
 151   vd->dma = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
 152                                         sizeof (*vd->dma), 512);
 153   if (error)
 154     return error;
 155
 156   memset (vd->dma, 0, sizeof (*vd->dma));
 157
 158   q = &vd->dma->queues;
 159   q->tx.cfg.desc_address = vmxnet3_dma_addr (vm, vd, txq->tx_desc);
 160   q->tx.cfg.comp_address = vmxnet3_dma_addr (vm, vd, txq->tx_comp);
 161   q->tx.cfg.num_desc = txq->size;
 162   q->tx.cfg.num_comp = txq->size;
 163   for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
 164     {
 165       q->rx.cfg.desc_address[rid] = vmxnet3_dma_addr (vm, vd,
 166                                                       rxq->rx_desc[rid]);
 167       q->rx.cfg.num_desc[rid] = rxq->size;
 168     }
 169   q->rx.cfg.comp_address = vmxnet3_dma_addr (vm, vd, rxq->rx_comp);
 170   q->rx.cfg.num_comp = rxq->size;
 171
 172   shared = &vd->dma->shared;
 173   shared->magic = VMXNET3_SHARED_MAGIC;
 174   shared->misc.version = VMXNET3_VERSION_MAGIC;
 175   if (sizeof (void *) == 4)
 176     shared->misc.guest_info = VMXNET3_GOS_BITS_32;
 177   else
 178     shared->misc.guest_info = VMXNET3_GOS_BITS_64;
 179   shared->misc.guest_info |= VMXNET3_GOS_TYPE_LINUX;
 180   shared->misc.version_support = VMXNET3_VERSION_SELECT;
 181   shared->misc.upt_version_support = VMXNET3_UPT_VERSION_SELECT;
 182   shared->misc.queue_desc_address = vmxnet3_dma_addr (vm, vd, q);
 183   shared->misc.queue_desc_len = sizeof (*q);
 184   shared->misc.mtu = VMXNET3_MTU;
 185   shared->misc.num_tx_queues = vd->num_tx_queues;
 186   shared->misc.num_rx_queues = vd->num_rx_queues;
 187   shared->interrupt.num_intrs = vd->num_intrs;
 188   shared->interrupt.event_intr_index = 1;
 189   shared->interrupt.control = VMXNET3_IC_DISABLE_ALL;
 190   shared->rx_filter.mode = VMXNET3_RXMODE_UCAST | VMXNET3_RXMODE_BCAST |
 191     VMXNET3_RXMODE_ALL_MULTI;
 192   shared_dma = vmxnet3_dma_addr (vm, vd, shared);
 193
 194   vmxnet3_reg_write (vd, 1, VMXNET3_REG_DSAL, shared_dma);
 195   vmxnet3_reg_write (vd, 1, VMXNET3_REG_DSAH, shared_dma >> 32);
 196
 197   return 0;
 198 }
 199
 200 static inline void
 201 vmxnet3_enable_interrupt (vmxnet3_device_t * vd)
 202 {
 203   int i;
 204   vmxnet3_shared *shared = &vd->dma->shared;
 205
 206   shared->interrupt.control &= ~VMXNET3_IC_DISABLE_ALL;
 207   for (i = 0; i < vd->num_intrs; i++)
 208     vmxnet3_reg_write (vd, 0, VMXNET3_REG_IMR + i * 8, 0);
 209 }
 210
 211 static inline void
 212 vmxnet3_disable_interrupt (vmxnet3_device_t * vd)
 213 {
 214   int i;
 215   vmxnet3_shared *shared = &vd->dma->shared;
 216
 217   shared->interrupt.control |= VMXNET3_IC_DISABLE_ALL;
 218   for (i = 0; i < vd->num_intrs; i++)
 219     vmxnet3_reg_write (vd, 0, VMXNET3_REG_IMR + i * 8, 1);
 220 }
 221
 222 static clib_error_t *
 223 vmxnet3_rxq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
 224 {
 225   vmxnet3_main_t *vmxm = &vmxnet3_main;
 226   vmxnet3_rxq_t *rxq;
 227   clib_error_t *error;
 228   u16 rid;
 229
 230   vec_validate_aligned (vd->rxqs, qid, CLIB_CACHE_LINE_BYTES);
 231   rxq = vec_elt_at_index (vd->rxqs, qid);
 232   memset (rxq, 0, sizeof (*rxq));
 233   rxq->size = qsz;
 234   for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
 235     {
 236       rxq->rx_desc[rid] =
 237         vlib_physmem_alloc_aligned (vm, vmxm->physmem_region,
 238                                     &error, qsz * sizeof (*rxq->rx_desc[rid]),
 239                                     512);
 240       if (error)
 241         return error;
 242       memset (rxq->rx_desc[rid], 0, qsz * sizeof (*rxq->rx_desc[rid]));
 243     }
 244   rxq->rx_comp = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
 245                                              qsz * sizeof (*rxq->rx_comp),
 246                                              512);
 247   if (error)
 248     return error;
 249   memset (rxq->rx_comp, 0, qsz * sizeof (*rxq->rx_comp));
 250   for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
 251     {
 252       vmxnet3_rx_ring *ring;
 253
 254       ring = &rxq->rx_ring[rid];
 255       ring->gen = VMXNET3_RXF_GEN;
 256       vec_validate_aligned (ring->bufs, rxq->size, CLIB_CACHE_LINE_BYTES);
 257     }
 258   rxq->rx_comp_ring.gen = VMXNET3_RXCF_GEN;
 259
 260   return 0;
 261 }
 262
 263 static clib_error_t *
 264 vmxnet3_txq_init (vlib_main_t * vm, vmxnet3_device_t * vd, u16 qid, u16 qsz)
 265 {
 266   vmxnet3_main_t *vmxm = &vmxnet3_main;
 267   vmxnet3_txq_t *txq;
 268   clib_error_t *error;
 269
 270   if (qid >= vd->num_tx_queues)
 271     {
 272       qid = qid % vd->num_tx_queues;
 273       txq = vec_elt_at_index (vd->txqs, qid);
 274       if (txq->lock == 0)
 275         clib_spinlock_init (&txq->lock);
 276       vd->flags |= VMXNET3_DEVICE_F_SHARED_TXQ_LOCK;
 277     }
 278
 279   vec_validate_aligned (vd->txqs, qid, CLIB_CACHE_LINE_BYTES);
 280   txq = vec_elt_at_index (vd->txqs, qid);
 281   memset (txq, 0, sizeof (*txq));
 282   txq->size = qsz;
 283   txq->tx_desc = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
 284                                              qsz * sizeof (*txq->tx_desc),
 285                                              512);
 286   if (error)
 287     return error;
 288   memset (txq->tx_desc, 0, qsz * sizeof (*txq->tx_desc));
 289   txq->tx_comp = vlib_physmem_alloc_aligned (vm, vmxm->physmem_region, &error,
 290                                              qsz * sizeof (*txq->tx_comp),
 291                                              512);
 292   if (error)
 293     return error;
 294   memset (txq->tx_comp, 0, qsz * sizeof (*txq->tx_comp));
 295   vec_validate_aligned (txq->tx_ring.bufs, txq->size, CLIB_CACHE_LINE_BYTES);
 296   txq->tx_ring.gen = VMXNET3_TXF_GEN;
 297   txq->tx_comp_ring.gen = VMXNET3_TXCF_GEN;
 298
 299   return 0;
 300 }
 301
 302 static clib_error_t *
 303 vmxnet3_device_init (vlib_main_t * vm, vmxnet3_device_t * vd,
 304                      vmxnet3_create_if_args_t * args)
 305 {
 306   clib_error_t *error = 0;
 307   u32 ret, i;
 308   vmxnet3_main_t *vmxm = &vmxnet3_main;
 309   vlib_thread_main_t *tm = vlib_get_thread_main ();
 310
 311   vd->num_tx_queues = 1;
 312   vd->num_rx_queues = 1;
 313   vd->num_intrs = 2;
 314
 315   /* Quiesce the device */
 316   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_QUIESCE_DEV);
 317   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 318   if (ret != 0)
 319     {
 320       error = clib_error_return (0, "error on quisecing device rc (%u)", ret);
 321       return error;
 322     }
 323
 324   /* Reset the device */
 325   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_RESET_DEV);
 326   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 327   if (ret != 0)
 328     {
 329       error = clib_error_return (0, "error on resetting device rc (%u)", ret);
 330       return error;
 331     }
 332
 333   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_VRRS);
 334   vd->version = count_leading_zeros (ret);
 335   vd->version = uword_bits - vd->version;
 336
 337   if (vd->version == 0 || vd->version > 3)
 338     {
 339       error = clib_error_return (0, "unsupported hardware version %u",
 340                                  vd->version);
 341       return error;
 342     }
 343
 344   vmxnet3_reg_write (vd, 1, VMXNET3_REG_VRRS, 1 << (vd->version - 1));
 345
 346   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_UVRS);
 347   if (ret & 1)
 348     vmxnet3_reg_write (vd, 1, VMXNET3_REG_UVRS, 1);
 349   else
 350     {
 351       error = clib_error_return (0, "unsupported upt version %u", ret);
 352       return error;
 353     }
 354
 355   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_GET_LINK);
 356   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 357   if (ret & 1)
 358     {
 359       vd->flags |= VMXNET3_DEVICE_F_LINK_UP;
 360       vd->link_speed = ret >> 16;
 361     }
 362   else
 363     {
 364       vd->flags &= ~VMXNET3_DEVICE_F_LINK_UP;
 365     }
 366
 367   /* Get the mac address */
 368   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_MACL);
 369   clib_memcpy (vd->mac_addr, &ret, 4);
 370   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_MACH);
 371   clib_memcpy (vd->mac_addr + 4, &ret, 2);
 372
 373   if (vmxm->physmem_region_alloc == 0)
 374     {
 375       u32 flags = VLIB_PHYSMEM_F_INIT_MHEAP | VLIB_PHYSMEM_F_HUGETLB;
 376       error =
 377         vlib_physmem_region_alloc (vm, "vmxnet3 descriptors", 4 << 20, 0,
 378                                    flags, &vmxm->physmem_region);
 379       if (error)
 380         return error;
 381       vmxm->physmem_region_alloc = 1;
 382     }
 383
 384   error = vmxnet3_rxq_init (vm, vd, 0, args->rxq_size);
 385   if (error)
 386     return error;
 387
 388   for (i = 0; i < tm->n_vlib_mains; i++)
 389     {
 390       error = vmxnet3_txq_init (vm, vd, i, args->txq_size);
 391       if (error)
 392         return error;
 393     }
 394
 395   error = vmxnet3_provision_driver_shared (vm, vd);
 396   if (error)
 397     return error;
 398
 399   vmxnet3_write_mac (vd);
 400
 401   /* Activate device */
 402   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_ACTIVATE_DEV);
 403   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 404   if (ret != 0)
 405     {
 406       error =
 407         clib_error_return (0, "error on activating device rc (%u)", ret);
 408       return error;
 409     }
 410
 411   /* Disable interrupts */
 412   vmxnet3_disable_interrupt (vd);
 413
 414   vec_foreach_index (i, vd->rxqs)
 415   {
 416     vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, i);
 417
 418     vmxnet3_rxq_refill_ring0 (vm, vd, rxq);
 419     vmxnet3_rxq_refill_ring1 (vm, vd, rxq);
 420   }
 421   vd->flags |= VMXNET3_DEVICE_F_INITIALIZED;
 422
 423   vmxnet3_enable_interrupt (vd);
 424
 425   return error;
 426 }
 427
 428 static void
 429 vmxnet3_irq_0_handler (vlib_pci_dev_handle_t h, u16 line)
 430 {
 431   vnet_main_t *vnm = vnet_get_main ();
 432   vmxnet3_main_t *vmxm = &vmxnet3_main;
 433   uword pd = vlib_pci_get_private_data (h);
 434   vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, pd);
 435   u16 qid = line;
 436
 437   if (vec_len (vd->rxqs) > qid && vd->rxqs[qid].int_mode != 0)
 438     vnet_device_input_set_interrupt_pending (vnm, vd->hw_if_index, qid);
 439 }
 440
 441 static void
 442 vmxnet3_irq_1_handler (vlib_pci_dev_handle_t h, u16 line)
 443 {
 444   vnet_main_t *vnm = vnet_get_main ();
 445   vmxnet3_main_t *vmxm = &vmxnet3_main;
 446   uword pd = vlib_pci_get_private_data (h);
 447   vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, pd);
 448   u32 ret;
 449
 450   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_GET_LINK);
 451   ret = vmxnet3_reg_read (vd, 1, VMXNET3_REG_CMD);
 452   if (ret & 1)
 453     {
 454       vd->flags |= VMXNET3_DEVICE_F_LINK_UP;
 455       vd->link_speed = ret >> 16;
 456       vnet_hw_interface_set_flags (vnm, vd->hw_if_index,
 457                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
 458     }
 459   else
 460     {
 461       vd->flags &= ~VMXNET3_DEVICE_F_LINK_UP;
 462       vnet_hw_interface_set_flags (vnm, vd->hw_if_index, 0);
 463     }
 464 }
 465
 466 static u8
 467 vmxnet3_queue_size_valid (u16 qsz)
 468 {
 469   if (qsz < 64 || qsz > 4096)
 470     return 0;
 471   if ((qsz % 64) != 0)
 472     return 0;
 473   return 1;
 474 }
 475
 476 void
 477 vmxnet3_create_if (vlib_main_t * vm, vmxnet3_create_if_args_t * args)
 478 {
 479   vnet_main_t *vnm = vnet_get_main ();
 480   vmxnet3_main_t *vmxm = &vmxnet3_main;
 481   vmxnet3_device_t *vd;
 482   vlib_pci_dev_handle_t h;
 483   clib_error_t *error = 0;
 484
 485   if (args->rxq_size == 0)
 486     args->rxq_size = VMXNET3_NUM_RX_DESC;
 487   if (args->txq_size == 0)
 488     args->txq_size = VMXNET3_NUM_TX_DESC;
 489
 490   if (!vmxnet3_queue_size_valid (args->rxq_size) ||
 491       !vmxnet3_queue_size_valid (args->txq_size))
 492     {
 493       args->rv = VNET_API_ERROR_INVALID_VALUE;
 494       args->error =
 495         clib_error_return (error,
 496                            "queue size must be <= 4096, >= 64, "
 497                            "and multiples of 64");
 498       return;
 499     }
 500
 501   /* *INDENT-OFF* */
 502   pool_foreach (vd, vmxm->devices, ({
 503     if (vd->pci_addr.as_u32 == args->addr.as_u32)
 504       {
 505         args->rv = VNET_API_ERROR_INVALID_VALUE;
 506         args->error =
 507           clib_error_return (error, "PCI address in use");
 508         return;
 509       }
 510   }));
 511   /* *INDENT-ON* */
 512
 513   pool_get (vmxm->devices, vd);
 514   vd->dev_instance = vd - vmxm->devices;
 515   vd->per_interface_next_index = ~0;
 516   vd->pci_addr = args->addr;
 517
 518   if (args->enable_elog)
 519     vd->flags |= VMXNET3_DEVICE_F_ELOG;
 520
 521   if ((error =
 522        vlib_pci_device_open (&args->addr, vmxnet3_pci_device_ids, &h)))
 523     {
 524       pool_put (vmxm->devices, vd);
 525       args->rv = VNET_API_ERROR_INVALID_INTERFACE;
 526       args->error =
 527         clib_error_return (error, "pci-addr %U", format_vlib_pci_addr,
 528                            &args->addr);
 529       return;
 530     }
 531   vd->pci_dev_handle = h;
 532
 533   vlib_pci_set_private_data (h, vd->dev_instance);
 534
 535   if ((error = vlib_pci_bus_master_enable (h)))
 536     goto error;
 537
 538   if ((error = vlib_pci_map_region (h, 0, (void **) &vd->bar[0])))
 539     goto error;
 540
 541   if ((error = vlib_pci_map_region (h, 1, (void **) &vd->bar[1])))
 542     goto error;
 543
 544   if ((error = vlib_pci_register_msix_handler (h, 0, 1,
 545                                                &vmxnet3_irq_0_handler)))
 546     goto error;
 547
 548   if ((error = vlib_pci_register_msix_handler (h, 1, 1,
 549                                                &vmxnet3_irq_1_handler)))
 550     goto error;
 551
 552   if ((error = vlib_pci_enable_msix_irq (h, 0, 2)))
 553     goto error;
 554
 555   if ((error = vlib_pci_intr_enable (h)))
 556     goto error;
 557
 558   if ((error = vmxnet3_device_init (vm, vd, args)))
 559     goto error;
 560
 561   /* create interface */
 562   error = ethernet_register_interface (vnm, vmxnet3_device_class.index,
 563                                        vd->dev_instance, vd->mac_addr,
 564                                        &vd->hw_if_index, vmxnet3_flag_change);
 565
 566   if (error)
 567     goto error;
 568
 569   vnet_sw_interface_t *sw = vnet_get_hw_sw_interface (vnm, vd->hw_if_index);
 570   vd->sw_if_index = sw->sw_if_index;
 571   args->sw_if_index = sw->sw_if_index;
 572
 573   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, vd->hw_if_index);
 574   hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_INT_MODE;
 575   vnet_hw_interface_set_input_node (vnm, vd->hw_if_index,
 576                                     vmxnet3_input_node.index);
 577   vnet_hw_interface_assign_rx_thread (vnm, vd->hw_if_index, 0, ~0);
 578   if (vd->flags & VMXNET3_DEVICE_F_LINK_UP)
 579     vnet_hw_interface_set_flags (vnm, vd->hw_if_index,
 580                                  VNET_HW_INTERFACE_FLAG_LINK_UP);
 581   else
 582     vnet_hw_interface_set_flags (vnm, vd->hw_if_index, 0);
 583   return;
 584
 585 error:
 586   vmxnet3_delete_if (vm, vd);
 587   args->rv = VNET_API_ERROR_INVALID_INTERFACE;
 588   args->error = error;
 589 }
 590
 591 void
 592 vmxnet3_delete_if (vlib_main_t * vm, vmxnet3_device_t * vd)
 593 {
 594   vnet_main_t *vnm = vnet_get_main ();
 595   vmxnet3_main_t *vmxm = &vmxnet3_main;
 596   u32 i, bi;
 597   u16 desc_idx;
 598
 599   /* Quiesce the device */
 600   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_QUIESCE_DEV);
 601
 602   /* Reset the device */
 603   vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_RESET_DEV);
 604
 605   if (vd->hw_if_index)
 606     {
 607       vnet_hw_interface_set_flags (vnm, vd->hw_if_index, 0);
 608       vnet_hw_interface_unassign_rx_thread (vnm, vd->hw_if_index, 0);
 609       ethernet_delete_interface (vnm, vd->hw_if_index);
 610     }
 611
 612   vlib_pci_device_close (vd->pci_dev_handle);
 613
 614   /* *INDENT-OFF* */
 615   vec_foreach_index (i, vd->rxqs)
 616     {
 617       vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, i);
 618       u16 mask = rxq->size - 1;
 619       u16 rid;
 620
 621       for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
 622         {
 623           vmxnet3_rx_ring *ring;
 624
 625           ring = &rxq->rx_ring[rid];
 626           desc_idx = ring->consume;
 627           while (ring->fill)
 628             {
 629               desc_idx &= mask;
 630               bi = ring->bufs[desc_idx];
 631               vlib_buffer_free_no_next (vm, &bi, 1);
 632               ring->fill--;
 633               desc_idx++;
 634             }
 635           vec_free (ring->bufs);
 636           vlib_physmem_free (vm, vmxm->physmem_region, rxq->rx_desc[rid]);
 637         }
 638       vlib_physmem_free (vm, vmxm->physmem_region, rxq->rx_comp);
 639     }
 640   /* *INDENT-ON* */
 641   vec_free (vd->rxqs);
 642
 643   /* *INDENT-OFF* */
 644   vec_foreach_index (i, vd->txqs)
 645     {
 646       vmxnet3_txq_t *txq = vec_elt_at_index (vd->txqs, i);
 647       u16 mask = txq->size - 1;
 648       u16 end_idx;
 649
 650       desc_idx = txq->tx_ring.consume;
 651       end_idx = txq->tx_ring.produce;
 652       while (desc_idx != end_idx)
 653         {
 654           bi = txq->tx_ring.bufs[desc_idx];
 655           vlib_buffer_free_no_next (vm, &bi, 1);
 656           desc_idx++;
 657           desc_idx &= mask;
 658         }
 659       clib_spinlock_free (&txq->lock);
 660       vec_free (txq->tx_ring.bufs);
 661       vlib_physmem_free (vm, vmxm->physmem_region, txq->tx_desc);
 662       vlib_physmem_free (vm, vmxm->physmem_region, txq->tx_comp);
 663     }
 664   /* *INDENT-ON* */
 665   vec_free (vd->txqs);
 666
 667   vlib_physmem_free (vm, vmxm->physmem_region, vd->dma);
 668
 669   clib_error_free (vd->error);
 670   memset (vd, 0, sizeof (*vd));
 671   pool_put (vmxm->devices, vd);
 672 }
 673
 674 /*
 675  * fd.io coding-style-patch-verification: ON
 676  *
 677  * Local Variables:
 678  * eval: (c-set-style "gnu")
 679  * End:
 680  */