-/*-
- * BSD LICENSE
- *
- * Copyright (c) 2015-2017 Atomic Rules LLC
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- * * Neither the name of copyright holder nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright (c) 2015-2018 Atomic Rules LLC
*/
#include <unistd.h>
#include <sys/stat.h>
#include <dlfcn.h>
+#include <rte_bus_pci.h>
#include <rte_ethdev_pci.h>
#include <rte_kvargs.h>
#include "ark_global.h"
#include "ark_logs.h"
-#include "ark_ethdev.h"
#include "ark_ethdev_tx.h"
#include "ark_ethdev_rx.h"
#include "ark_mpu.h"
static int eth_ark_dev_start(struct rte_eth_dev *dev);
static void eth_ark_dev_stop(struct rte_eth_dev *dev);
static void eth_ark_dev_close(struct rte_eth_dev *dev);
-static void eth_ark_dev_info_get(struct rte_eth_dev *dev,
- struct rte_eth_dev_info *dev_info);
+static int eth_ark_dev_info_get(struct rte_eth_dev *dev,
+ struct rte_eth_dev_info *dev_info);
static int eth_ark_dev_link_update(struct rte_eth_dev *dev,
int wait_to_complete);
static int eth_ark_dev_set_link_up(struct rte_eth_dev *dev);
static int eth_ark_dev_set_link_down(struct rte_eth_dev *dev);
-static void eth_ark_dev_stats_get(struct rte_eth_dev *dev,
+static int eth_ark_dev_stats_get(struct rte_eth_dev *dev,
struct rte_eth_stats *stats);
-static void eth_ark_dev_stats_reset(struct rte_eth_dev *dev);
-static void eth_ark_set_default_mac_addr(struct rte_eth_dev *dev,
- struct ether_addr *mac_addr);
+static int eth_ark_dev_stats_reset(struct rte_eth_dev *dev);
+static int eth_ark_set_default_mac_addr(struct rte_eth_dev *dev,
+ struct rte_ether_addr *mac_addr);
static int eth_ark_macaddr_add(struct rte_eth_dev *dev,
- struct ether_addr *mac_addr,
+ struct rte_ether_addr *mac_addr,
uint32_t index,
uint32_t pool);
static void eth_ark_macaddr_remove(struct rte_eth_dev *dev,
uint32_t index);
+static int eth_ark_set_mtu(struct rte_eth_dev *dev, uint16_t size);
/*
* The packet generator is a functional block used to generate packet
#define ARK_TX_MAX_QUEUE (4096 * 4)
#define ARK_TX_MIN_QUEUE (256)
+int ark_logtype;
+
static const char * const valid_arguments[] = {
ARK_PKTGEN_ARG,
ARK_PKTCHKR_ARG,
.mac_addr_add = eth_ark_macaddr_add,
.mac_addr_remove = eth_ark_macaddr_remove,
.mac_addr_set = eth_ark_set_default_mac_addr,
+
+ .mtu_set = eth_ark_set_mtu,
};
static int
(int (*)(struct rte_eth_dev *, void *))
dlsym(ark->d_handle, "dev_set_link_down");
ark->user_ext.stats_get =
- (void (*)(struct rte_eth_dev *, struct rte_eth_stats *,
+ (int (*)(struct rte_eth_dev *, struct rte_eth_stats *,
void *))
dlsym(ark->d_handle, "stats_get");
ark->user_ext.stats_reset =
(void (*)(struct rte_eth_dev *, void *))
dlsym(ark->d_handle, "stats_reset");
ark->user_ext.mac_addr_add =
- (void (*)(struct rte_eth_dev *, struct ether_addr *, uint32_t,
- uint32_t, void *))
+ (void (*)(struct rte_eth_dev *, struct rte_ether_addr *,
+ uint32_t, uint32_t, void *))
dlsym(ark->d_handle, "mac_addr_add");
ark->user_ext.mac_addr_remove =
(void (*)(struct rte_eth_dev *, uint32_t, void *))
dlsym(ark->d_handle, "mac_addr_remove");
ark->user_ext.mac_addr_set =
- (void (*)(struct rte_eth_dev *, struct ether_addr *,
+ (void (*)(struct rte_eth_dev *, struct rte_ether_addr *,
void *))
dlsym(ark->d_handle, "mac_addr_set");
+ ark->user_ext.set_mtu =
+ (int (*)(struct rte_eth_dev *, uint16_t,
+ void *))
+ dlsym(ark->d_handle, "set_mtu");
return found;
}
static int
eth_ark_dev_init(struct rte_eth_dev *dev)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
struct rte_pci_device *pci_dev;
int ret;
int port_count = 1;
/* Use dummy function until setup */
dev->rx_pkt_burst = ð_ark_recv_pkts_noop;
dev->tx_pkt_burst = ð_ark_xmit_pkts_noop;
+ /* Let rte_eth_dev_close() release the port resources */
+ dev->data->dev_flags |= RTE_ETH_DEV_CLOSE_REMOVE;
ark->bar0 = (uint8_t *)pci_dev->mem_resource[0].addr;
ark->a_bar = (uint8_t *)pci_dev->mem_resource[2].addr;
/* We are a single function multi-port device. */
ret = ark_config_device(dev);
+ if (ret)
+ return -1;
+
dev->dev_ops = &ark_eth_dev_ops;
- dev->data->dev_flags |= RTE_ETH_DEV_DETACHABLE;
- dev->data->mac_addrs = rte_zmalloc("ark", ETHER_ADDR_LEN, 0);
+ dev->data->mac_addrs = rte_zmalloc("ark", RTE_ETHER_ADDR_LEN, 0);
if (!dev->data->mac_addrs) {
PMD_DRV_LOG(ERR,
"Failed to allocated memory for storing mac address"
}
if (ark->user_ext.dev_init) {
- ark->user_data = ark->user_ext.dev_init(dev, ark->a_bar, 0);
- if (!ark->user_data) {
+ ark->user_data[dev->data->port_id] =
+ ark->user_ext.dev_init(dev, ark->a_bar, 0);
+ if (!ark->user_data[dev->data->port_id]) {
PMD_DRV_LOG(INFO,
"Failed to initialize PMD extension!"
" continuing without it\n");
*/
if (ark->user_ext.dev_get_port_count)
port_count =
- ark->user_ext.dev_get_port_count(dev, ark->user_data);
+ ark->user_ext.dev_get_port_count(dev,
+ ark->user_data[dev->data->port_id]);
ark->num_ports = port_count;
for (p = 0; p < port_count; p++) {
if (p == 0) {
/* First port is already allocated by DPDK */
eth_dev = ark->eth_dev;
+ rte_eth_dev_probing_finish(eth_dev);
continue;
}
rte_eth_copy_pci_info(eth_dev, pci_dev);
- eth_dev->data->mac_addrs = rte_zmalloc(name, ETHER_ADDR_LEN, 0);
+ eth_dev->data->mac_addrs = rte_zmalloc(name,
+ RTE_ETHER_ADDR_LEN, 0);
if (!eth_dev->data->mac_addrs) {
PMD_DRV_LOG(ERR,
"Memory allocation for MAC failed!"
goto error;
}
- if (ark->user_ext.dev_init)
- ark->user_data =
+ if (ark->user_ext.dev_init) {
+ ark->user_data[eth_dev->data->port_id] =
ark->user_ext.dev_init(dev, ark->a_bar, p);
+ }
+
+ rte_eth_dev_probing_finish(eth_dev);
}
return ret;
- error:
- if (dev->data->mac_addrs)
- rte_free(dev->data->mac_addrs);
+error:
+ rte_free(dev->data->mac_addrs);
+ dev->data->mac_addrs = NULL;
return -1;
}
static int
ark_config_device(struct rte_eth_dev *dev)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
uint16_t num_q, i;
struct ark_mpu_t *mpu;
*/
ark->start_pg = 0;
ark->pg = ark_pktgen_init(ark->pktgen.v, 0, 1);
+ if (ark->pg == NULL)
+ return -1;
ark_pktgen_reset(ark->pg);
ark->pc = ark_pktchkr_init(ark->pktchkr.v, 0, 1);
+ if (ark->pc == NULL)
+ return -1;
ark_pktchkr_stop(ark->pc);
ark->pd = ark_pktdir_init(ark->pktdir.v);
+ if (ark->pd == NULL)
+ return -1;
/* Verify HW */
if (ark_udm_verify(ark->udm.v))
static int
eth_ark_dev_uninit(struct rte_eth_dev *dev)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
if (ark->user_ext.dev_uninit)
- ark->user_ext.dev_uninit(dev, ark->user_data);
+ ark->user_ext.dev_uninit(dev,
+ ark->user_data[dev->data->port_id]);
ark_pktgen_uninit(ark->pg);
ark_pktchkr_uninit(ark->pc);
dev->dev_ops = NULL;
dev->rx_pkt_burst = NULL;
dev->tx_pkt_burst = NULL;
- rte_free(dev->data->mac_addrs);
return 0;
}
eth_ark_dev_configure(struct rte_eth_dev *dev)
{
PMD_FUNC_LOG(DEBUG, "\n");
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
eth_ark_dev_set_link_up(dev);
if (ark->user_ext.dev_configure)
- return ark->user_ext.dev_configure(dev, ark->user_data);
+ return ark->user_ext.dev_configure(dev,
+ ark->user_data[dev->data->port_id]);
return 0;
}
static int
eth_ark_dev_start(struct rte_eth_dev *dev)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
int i;
PMD_FUNC_LOG(DEBUG, "\n");
}
if (ark->user_ext.dev_start)
- ark->user_ext.dev_start(dev, ark->user_data);
+ ark->user_ext.dev_start(dev,
+ ark->user_data[dev->data->port_id]);
return 0;
}
{
uint16_t i;
int status;
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
struct ark_mpu_t *mpu;
PMD_FUNC_LOG(DEBUG, "\n");
/* Stop the extension first */
if (ark->user_ext.dev_stop)
- ark->user_ext.dev_stop(dev, ark->user_data);
+ ark->user_ext.dev_stop(dev,
+ ark->user_data[dev->data->port_id]);
/* Stop the packet generator */
if (ark->start_pg)
for (i = 0; i < dev->data->nb_tx_queues; i++) {
status = eth_ark_tx_queue_stop(dev, i);
if (status != 0) {
- uint8_t port = dev->data->port_id;
+ uint16_t port = dev->data->port_id;
PMD_DRV_LOG(ERR,
"tx_queue stop anomaly"
" port %u, queue %u\n",
ark_udm_dump_stats(ark->udm.v, "Post stop");
ark_udm_dump_perf(ark->udm.v, "Post stop");
- for (i = 0; i < dev->data->nb_tx_queues; i++)
+ for (i = 0; i < dev->data->nb_rx_queues; i++)
eth_ark_rx_dump_queue(dev, i, __func__);
/* Stop the packet checker if it is running */
static void
eth_ark_dev_close(struct rte_eth_dev *dev)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
uint16_t i;
if (ark->user_ext.dev_close)
- ark->user_ext.dev_close(dev, ark->user_data);
+ ark->user_ext.dev_close(dev,
+ ark->user_data[dev->data->port_id]);
eth_ark_dev_stop(dev);
eth_ark_udm_force_close(dev);
eth_ark_dev_rx_queue_release(dev->data->rx_queues[i]);
dev->data->rx_queues[i] = 0;
}
+
+ rte_free(dev->data->mac_addrs);
+ dev->data->mac_addrs = 0;
}
-static void
+static int
eth_ark_dev_info_get(struct rte_eth_dev *dev,
struct rte_eth_dev_info *dev_info)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
struct ark_mpu_t *tx_mpu = RTE_PTR_ADD(ark->bar0, ARK_MPU_TX_BASE);
struct ark_mpu_t *rx_mpu = RTE_PTR_ADD(ark->bar0, ARK_MPU_RX_BASE);
uint16_t ports = ark->num_ports;
ETH_LINK_SPEED_40G |
ETH_LINK_SPEED_50G |
ETH_LINK_SPEED_100G);
- dev_info->pci_dev = RTE_ETH_DEV_TO_PCI(dev);
+
+ return 0;
}
static int
{
PMD_DEBUG_LOG(DEBUG, "link status = %d\n",
dev->data->dev_link.link_status);
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
if (ark->user_ext.link_update) {
return ark->user_ext.link_update
(dev, wait_to_complete,
- ark->user_data);
+ ark->user_data[dev->data->port_id]);
}
return 0;
}
eth_ark_dev_set_link_up(struct rte_eth_dev *dev)
{
dev->data->dev_link.link_status = 1;
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
if (ark->user_ext.dev_set_link_up)
- return ark->user_ext.dev_set_link_up(dev, ark->user_data);
+ return ark->user_ext.dev_set_link_up(dev,
+ ark->user_data[dev->data->port_id]);
return 0;
}
eth_ark_dev_set_link_down(struct rte_eth_dev *dev)
{
dev->data->dev_link.link_status = 0;
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
if (ark->user_ext.dev_set_link_down)
- return ark->user_ext.dev_set_link_down(dev, ark->user_data);
+ return ark->user_ext.dev_set_link_down(dev,
+ ark->user_data[dev->data->port_id]);
return 0;
}
-static void
+static int
eth_ark_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
{
uint16_t i;
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
stats->ipackets = 0;
stats->ibytes = 0;
for (i = 0; i < dev->data->nb_rx_queues; i++)
eth_rx_queue_stats_get(dev->data->rx_queues[i], stats);
if (ark->user_ext.stats_get)
- ark->user_ext.stats_get(dev, stats, ark->user_data);
+ return ark->user_ext.stats_get(dev, stats,
+ ark->user_data[dev->data->port_id]);
+ return 0;
}
-static void
+static int
eth_ark_dev_stats_reset(struct rte_eth_dev *dev)
{
uint16_t i;
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
for (i = 0; i < dev->data->nb_tx_queues; i++)
- eth_tx_queue_stats_reset(dev->data->rx_queues[i]);
+ eth_tx_queue_stats_reset(dev->data->tx_queues[i]);
for (i = 0; i < dev->data->nb_rx_queues; i++)
eth_rx_queue_stats_reset(dev->data->rx_queues[i]);
if (ark->user_ext.stats_reset)
- ark->user_ext.stats_reset(dev, ark->user_data);
+ ark->user_ext.stats_reset(dev,
+ ark->user_data[dev->data->port_id]);
+
+ return 0;
}
static int
eth_ark_macaddr_add(struct rte_eth_dev *dev,
- struct ether_addr *mac_addr,
+ struct rte_ether_addr *mac_addr,
uint32_t index,
uint32_t pool)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
if (ark->user_ext.mac_addr_add) {
ark->user_ext.mac_addr_add(dev,
mac_addr,
index,
pool,
- ark->user_data);
+ ark->user_data[dev->data->port_id]);
return 0;
}
return -ENOTSUP;
static void
eth_ark_macaddr_remove(struct rte_eth_dev *dev, uint32_t index)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
if (ark->user_ext.mac_addr_remove)
- ark->user_ext.mac_addr_remove(dev, index, ark->user_data);
+ ark->user_ext.mac_addr_remove(dev, index,
+ ark->user_data[dev->data->port_id]);
}
-static void
+static int
eth_ark_set_default_mac_addr(struct rte_eth_dev *dev,
- struct ether_addr *mac_addr)
+ struct rte_ether_addr *mac_addr)
{
- struct ark_adapter *ark =
- (struct ark_adapter *)dev->data->dev_private;
+ struct ark_adapter *ark = dev->data->dev_private;
+
+ if (ark->user_ext.mac_addr_set) {
+ ark->user_ext.mac_addr_set(dev, mac_addr,
+ ark->user_data[dev->data->port_id]);
+ return 0;
+ }
+ return -ENOTSUP;
+}
+
+static int
+eth_ark_set_mtu(struct rte_eth_dev *dev, uint16_t size)
+{
+ struct ark_adapter *ark = dev->data->dev_private;
- if (ark->user_ext.mac_addr_set)
- ark->user_ext.mac_addr_set(dev, mac_addr, ark->user_data);
+ if (ark->user_ext.set_mtu)
+ return ark->user_ext.set_mtu(dev, size,
+ ark->user_data[dev->data->port_id]);
+
+ return -ENOTSUP;
}
static inline int
ARK_PKTGEN_ARG "=<filename> "
ARK_PKTCHKR_ARG "=<filename> "
ARK_PKTDIR_ARG "=<bitmap>");
+
+RTE_INIT(ark_init_log)
+{
+ ark_logtype = rte_log_register("pmd.net.ark");
+ if (ark_logtype >= 0)
+ rte_log_set_level(ark_logtype, RTE_LOG_NOTICE);
+}