pci: make device id tables const

[dpdk.git] / lib / librte_pmd_bond / rte_eth_bond_api.c

diff --git a/lib/librte_pmd_bond/rte_eth_bond_api.c b/lib/librte_pmd_bond/rte_eth_bond_api.c
index c8fb42c..e91a623 100644 (file)
--- a/lib/librte_pmd_bond/rte_eth_bond_api.c
+++ b/lib/librte_pmd_bond/rte_eth_bond_api.c
@@ -111,12 +111,27 @@ void
 activate_slave(struct rte_eth_dev *eth_dev, uint8_t port_id)
 {
        struct bond_dev_private *internals = eth_dev->data->dev_private;
+       uint8_t active_count = internals->active_slave_count;
 
        if (internals->mode == BONDING_MODE_8023AD)
                bond_mode_8023ad_activate_slave(eth_dev, port_id);
 
+       if (internals->mode == BONDING_MODE_TLB
+                       || internals->mode == BONDING_MODE_ALB) {
+
+               internals->tlb_slaves_order[active_count] = port_id;
+       }
+
+       RTE_VERIFY(internals->active_slave_count <
+                       (RTE_DIM(internals->active_slaves) - 1));
+
        internals->active_slaves[internals->active_slave_count] = port_id;
        internals->active_slave_count++;
+
+       if (internals->mode == BONDING_MODE_TLB)
+               bond_tlb_activate_slave(internals);
+       if (internals->mode == BONDING_MODE_ALB)
+               bond_mode_alb_client_list_upd(eth_dev);
 }
 
 void
@@ -129,7 +144,9 @@ deactivate_slave(struct rte_eth_dev *eth_dev, uint8_t port_id)
        if (internals->mode == BONDING_MODE_8023AD) {
                bond_mode_8023ad_stop(eth_dev);
                bond_mode_8023ad_deactivate_slave(eth_dev, port_id);
-       }
+       } else if (internals->mode == BONDING_MODE_TLB
+                       || internals->mode == BONDING_MODE_ALB)
+               bond_tlb_disable(internals);
 
        slave_pos = find_slave_by_id(internals->active_slaves, active_count,
                        port_id);
@@ -144,10 +161,19 @@ deactivate_slave(struct rte_eth_dev *eth_dev, uint8_t port_id)
                                        sizeof(internals->active_slaves[0]));
        }
 
+       RTE_VERIFY(active_count < RTE_DIM(internals->active_slaves));
        internals->active_slave_count = active_count;
 
-       if (eth_dev->data->dev_started && internals->mode == BONDING_MODE_8023AD)
-               bond_mode_8023ad_start(eth_dev);
+       if (eth_dev->data->dev_started) {
+               if (internals->mode == BONDING_MODE_8023AD) {
+                       bond_mode_8023ad_start(eth_dev);
+               } else if (internals->mode == BONDING_MODE_TLB) {
+                       bond_tlb_enable(internals);
+               } else if (internals->mode == BONDING_MODE_ALB) {
+                       bond_tlb_enable(internals);
+                       bond_mode_alb_client_list_upd(eth_dev);
+               }
+       }
 }
 
 uint8_t
@@ -204,24 +230,19 @@ rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id)
                goto err;
        }
 
-       pci_drv = rte_zmalloc_socket(name, sizeof(*pci_drv), 0, socket_id);
-       if (pci_drv == NULL) {
-               RTE_BOND_LOG(ERR, "Unable to malloc pci_drv on socket");
-               goto err;
-       }
+       pci_drv = &eth_drv->pci_drv;
+
        pci_id_table = rte_zmalloc_socket(name, sizeof(*pci_id_table), 0, socket_id);
-       if (pci_drv == NULL) {
+       if (pci_id_table == NULL) {
                RTE_BOND_LOG(ERR, "Unable to malloc pci_id_table on socket");
                goto err;
        }
+       pci_id_table->device_id = PCI_ANY_ID;
+       pci_id_table->subsystem_device_id = PCI_ANY_ID;
+       pci_id_table->vendor_id = PCI_ANY_ID;
+       pci_id_table->subsystem_vendor_id = PCI_ANY_ID;
 
        pci_drv->id_table = pci_id_table;
-
-       pci_drv->id_table->device_id = PCI_ANY_ID;
-       pci_drv->id_table->subsystem_device_id = PCI_ANY_ID;
-       pci_drv->id_table->vendor_id = PCI_ANY_ID;
-       pci_drv->id_table->subsystem_vendor_id = PCI_ANY_ID;
-
        pci_drv->drv_flags = RTE_PCI_DRV_INTR_LSC;
 
        internals = rte_zmalloc_socket(name, sizeof(*internals), 0, socket_id);
@@ -231,7 +252,7 @@ rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id)
        }
 
        /* reserve an ethdev entry */
-       eth_dev = rte_eth_dev_allocate(name);
+       eth_dev = rte_eth_dev_allocate(name, RTE_ETH_DEV_VIRTUAL);
        if (eth_dev == NULL) {
                RTE_BOND_LOG(ERR, "Unable to allocate rte_eth_dev");
                goto err;
@@ -240,14 +261,12 @@ rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id)
        pci_dev->numa_node = socket_id;
        pci_drv->name = driver_name;
 
-       eth_drv->pci_drv = (struct rte_pci_driver)(*pci_drv);
        eth_dev->driver = eth_drv;
-
        eth_dev->data->dev_private = internals;
        eth_dev->data->nb_rx_queues = (uint16_t)1;
        eth_dev->data->nb_tx_queues = (uint16_t)1;
 
-       TAILQ_INIT(&(eth_dev->callbacks));
+       TAILQ_INIT(&(eth_dev->link_intr_cbs));
 
        eth_dev->data->dev_link.link_status = 0;
 
@@ -268,6 +287,7 @@ rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id)
        internals->mode = BONDING_MODE_INVALID;
        internals->current_primary_port = 0;
        internals->balance_xmit_policy = BALANCE_XMIT_POLICY_LAYER2;
+       internals->xmit_hash = xmit_l2_hash;
        internals->user_defined_mac = 0;
        internals->link_props_set = 0;
 
@@ -279,6 +299,8 @@ rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id)
 
        internals->slave_count = 0;
        internals->active_slave_count = 0;
+       internals->rx_offload_capa = 0;
+       internals->tx_offload_capa = 0;
 
        memset(internals->active_slaves, 0, sizeof(internals->active_slaves));
        memset(internals->slaves, 0, sizeof(internals->slaves));
@@ -294,16 +316,11 @@ rte_eth_bond_create(const char *name, uint8_t mode, uint8_t socket_id)
        return eth_dev->data->port_id;
 
 err:
-       if (pci_dev)
-               rte_free(pci_dev);
-       if (pci_drv)
-               rte_free(pci_drv);
-       if (pci_id_table)
-               rte_free(pci_id_table);
-       if (eth_drv)
-               rte_free(eth_drv);
-       if (internals)
-               rte_free(internals);
+       rte_free(pci_dev);
+       rte_free(pci_id_table);
+       rte_free(eth_drv);
+       rte_free(internals);
+
        return -1;
 }
 
@@ -314,6 +331,7 @@ __eth_bond_slave_add_lock_free(uint8_t bonded_port_id, uint8_t slave_port_id)
        struct bond_dev_private *internals;
        struct bond_dev_private *temp_internals;
        struct rte_eth_link link_props;
+       struct rte_eth_dev_info dev_info;
 
        int i, j;
 
@@ -345,6 +363,9 @@ __eth_bond_slave_add_lock_free(uint8_t bonded_port_id, uint8_t slave_port_id)
        /* Add slave details to bonded device */
        slave_add(internals, slave_eth_dev);
 
+       memset(&dev_info, 0, sizeof(dev_info));
+       rte_eth_dev_info_get(slave_port_id, &dev_info);
+
        if (internals->slave_count < 1) {
                /* if MAC is not user defined then use MAC of first slave add to
                 * bonded device */
@@ -357,6 +378,11 @@ __eth_bond_slave_add_lock_free(uint8_t bonded_port_id, uint8_t slave_port_id)
 
                /* Make primary slave */
                internals->primary_port = slave_port_id;
+
+               /* Take the first dev's offload capabilities */
+               internals->rx_offload_capa = dev_info.rx_offload_capa;
+               internals->tx_offload_capa = dev_info.tx_offload_capa;
+
        } else {
                /* Check slave link properties are supported if props are set,
                 * all slaves must be the same */
@@ -372,6 +398,8 @@ __eth_bond_slave_add_lock_free(uint8_t bonded_port_id, uint8_t slave_port_id)
                        link_properties_set(bonded_eth_dev,
                                        &(slave_eth_dev->data->dev_link));
                }
+               internals->rx_offload_capa &= dev_info.rx_offload_capa;
+               internals->tx_offload_capa &= dev_info.tx_offload_capa;
        }
 
        internals->slave_count++;
@@ -497,7 +525,10 @@ __eth_bond_slave_remove_lock_free(uint8_t bonded_port_id, uint8_t slave_port_id)
                        memset(rte_eth_devices[bonded_port_id].data->mac_addrs, 0,
                                        sizeof(*(rte_eth_devices[bonded_port_id].data->mac_addrs)));
        }
-
+       if (internals->slave_count == 0) {
+               internals->rx_offload_capa = 0;
+               internals->tx_offload_capa = 0;
+       }
        return 0;
 }
 
@@ -694,9 +725,16 @@ rte_eth_bond_xmit_policy_set(uint8_t bonded_port_id, uint8_t policy)
 
        switch (policy) {
        case BALANCE_XMIT_POLICY_LAYER2:
+               internals->balance_xmit_policy = policy;
+               internals->xmit_hash = xmit_l2_hash;
+               break;
        case BALANCE_XMIT_POLICY_LAYER23:
+               internals->balance_xmit_policy = policy;
+               internals->xmit_hash = xmit_l23_hash;
+               break;
        case BALANCE_XMIT_POLICY_LAYER34:
                internals->balance_xmit_policy = policy;
+               internals->xmit_hash = xmit_l34_hash;
                break;
 
        default: