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