numam-dpdk/drivers/net/octeontx2/otx2_link.c
Ferruh Yigit 5723fbed4f ethdev: remove underscore prefix from internal API
'_rte_eth_dev_callback_process()' & '_rte_eth_dev_reset()' internal APIs
has unconventional underscore ('_') prefix.
Although this is not documented most probably this is to mark them as
internal. Since we have '__rte_internal' flag to mark this, removing '_'
from API names.

For '_rte_eth_dev_reset()', there is already a public API named
'rte_eth_dev_reset()', so renaming '_rte_eth_dev_reset()' to
'rte_eth_dev_internal_reset'.

Signed-off-by: Ferruh Yigit <ferruh.yigit@intel.com>
Acked-by: Andrew Rybchenko <arybchenko@solarflare.com>
Acked-by: David Marchand <david.marchand@redhat.com>
Acked-by: Sachin Saxena <sachin.saxena@nxp.com>
2020-09-18 18:55:08 +02:00

265 lines
6.1 KiB
C

/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(C) 2019 Marvell International Ltd.
*/
#include <rte_common.h>
#include <rte_ethdev_pci.h>
#include "otx2_ethdev.h"
void
otx2_nix_toggle_flag_link_cfg(struct otx2_eth_dev *dev, bool set)
{
if (set)
dev->flags |= OTX2_LINK_CFG_IN_PROGRESS_F;
else
dev->flags &= ~OTX2_LINK_CFG_IN_PROGRESS_F;
rte_wmb();
}
static inline int
nix_wait_for_link_cfg(struct otx2_eth_dev *dev)
{
uint16_t wait = 1000;
do {
rte_rmb();
if (!(dev->flags & OTX2_LINK_CFG_IN_PROGRESS_F))
break;
wait--;
rte_delay_ms(1);
} while (wait);
return wait ? 0 : -1;
}
static void
nix_link_status_print(struct rte_eth_dev *eth_dev, struct rte_eth_link *link)
{
if (link && link->link_status)
otx2_info("Port %d: Link Up - speed %u Mbps - %s",
(int)(eth_dev->data->port_id),
(uint32_t)link->link_speed,
link->link_duplex == ETH_LINK_FULL_DUPLEX ?
"full-duplex" : "half-duplex");
else
otx2_info("Port %d: Link Down", (int)(eth_dev->data->port_id));
}
void
otx2_eth_dev_link_status_update(struct otx2_dev *dev,
struct cgx_link_user_info *link)
{
struct otx2_eth_dev *otx2_dev = (struct otx2_eth_dev *)dev;
struct rte_eth_link eth_link;
struct rte_eth_dev *eth_dev;
if (!link || !dev)
return;
eth_dev = otx2_dev->eth_dev;
if (!eth_dev || !eth_dev->data->dev_conf.intr_conf.lsc)
return;
if (nix_wait_for_link_cfg(otx2_dev)) {
otx2_err("Timeout waiting for link_cfg to complete");
return;
}
eth_link.link_status = link->link_up;
eth_link.link_speed = link->speed;
eth_link.link_autoneg = ETH_LINK_AUTONEG;
eth_link.link_duplex = link->full_duplex;
otx2_dev->speed = link->speed;
otx2_dev->duplex = link->full_duplex;
/* Print link info */
nix_link_status_print(eth_dev, &eth_link);
/* Update link info */
rte_eth_linkstatus_set(eth_dev, &eth_link);
/* Set the flag and execute application callbacks */
rte_eth_dev_callback_process(eth_dev, RTE_ETH_EVENT_INTR_LSC, NULL);
}
static int
lbk_link_update(struct rte_eth_link *link)
{
link->link_status = ETH_LINK_UP;
link->link_speed = ETH_SPEED_NUM_100G;
link->link_autoneg = ETH_LINK_FIXED;
link->link_duplex = ETH_LINK_FULL_DUPLEX;
return 0;
}
static int
cgx_link_update(struct otx2_eth_dev *dev, struct rte_eth_link *link)
{
struct otx2_mbox *mbox = dev->mbox;
struct cgx_link_info_msg *rsp;
int rc;
otx2_mbox_alloc_msg_cgx_get_linkinfo(mbox);
rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
if (rc)
return rc;
link->link_status = rsp->link_info.link_up;
link->link_speed = rsp->link_info.speed;
link->link_autoneg = ETH_LINK_AUTONEG;
if (rsp->link_info.full_duplex)
link->link_duplex = rsp->link_info.full_duplex;
return 0;
}
int
otx2_nix_link_update(struct rte_eth_dev *eth_dev, int wait_to_complete)
{
struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
struct rte_eth_link link;
int rc;
RTE_SET_USED(wait_to_complete);
memset(&link, 0, sizeof(struct rte_eth_link));
if (otx2_dev_is_sdp(dev))
return 0;
if (otx2_dev_is_lbk(dev))
rc = lbk_link_update(&link);
else
rc = cgx_link_update(dev, &link);
if (rc)
return rc;
return rte_eth_linkstatus_set(eth_dev, &link);
}
static int
nix_dev_set_link_state(struct rte_eth_dev *eth_dev, uint8_t enable)
{
struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
struct otx2_mbox *mbox = dev->mbox;
struct cgx_set_link_state_msg *req;
req = otx2_mbox_alloc_msg_cgx_set_link_state(mbox);
req->enable = enable;
return otx2_mbox_process(mbox);
}
int
otx2_nix_dev_set_link_up(struct rte_eth_dev *eth_dev)
{
struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
int rc, i;
if (otx2_dev_is_vf_or_sdp(dev))
return -ENOTSUP;
rc = nix_dev_set_link_state(eth_dev, 1);
if (rc)
goto done;
/* Start tx queues */
for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
otx2_nix_tx_queue_start(eth_dev, i);
done:
return rc;
}
int
otx2_nix_dev_set_link_down(struct rte_eth_dev *eth_dev)
{
struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
int i;
if (otx2_dev_is_vf_or_sdp(dev))
return -ENOTSUP;
/* Stop tx queues */
for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
otx2_nix_tx_queue_stop(eth_dev, i);
return nix_dev_set_link_state(eth_dev, 0);
}
static int
cgx_change_mode(struct otx2_eth_dev *dev, struct cgx_set_link_mode_args *cfg)
{
struct otx2_mbox *mbox = dev->mbox;
struct cgx_set_link_mode_req *req;
req = otx2_mbox_alloc_msg_cgx_set_link_mode(mbox);
req->args.speed = cfg->speed;
req->args.duplex = cfg->duplex;
req->args.an = cfg->an;
return otx2_mbox_process(mbox);
}
#define SPEED_NONE 0
static inline uint32_t
nix_parse_link_speeds(struct otx2_eth_dev *dev, uint32_t link_speeds)
{
uint32_t link_speed = SPEED_NONE;
/* 50G and 100G to be supported for board version C0 and above */
if (!otx2_dev_is_Ax(dev)) {
if (link_speeds & ETH_LINK_SPEED_100G)
link_speed = 100000;
if (link_speeds & ETH_LINK_SPEED_50G)
link_speed = 50000;
}
if (link_speeds & ETH_LINK_SPEED_40G)
link_speed = 40000;
if (link_speeds & ETH_LINK_SPEED_25G)
link_speed = 25000;
if (link_speeds & ETH_LINK_SPEED_20G)
link_speed = 20000;
if (link_speeds & ETH_LINK_SPEED_10G)
link_speed = 10000;
if (link_speeds & ETH_LINK_SPEED_5G)
link_speed = 5000;
if (link_speeds & ETH_LINK_SPEED_1G)
link_speed = 1000;
return link_speed;
}
static inline uint8_t
nix_parse_eth_link_duplex(uint32_t link_speeds)
{
if ((link_speeds & ETH_LINK_SPEED_10M_HD) ||
(link_speeds & ETH_LINK_SPEED_100M_HD))
return ETH_LINK_HALF_DUPLEX;
else
return ETH_LINK_FULL_DUPLEX;
}
int
otx2_apply_link_speed(struct rte_eth_dev *eth_dev)
{
struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
struct rte_eth_conf *conf = &eth_dev->data->dev_conf;
struct cgx_set_link_mode_args cfg;
/* If VF/SDP/LBK, link attributes cannot be changed */
if (otx2_dev_is_vf_or_sdp(dev) || otx2_dev_is_lbk(dev))
return 0;
memset(&cfg, 0, sizeof(struct cgx_set_link_mode_args));
cfg.speed = nix_parse_link_speeds(dev, conf->link_speeds);
if (cfg.speed != SPEED_NONE && cfg.speed != dev->speed) {
cfg.duplex = nix_parse_eth_link_duplex(conf->link_speeds);
cfg.an = (conf->link_speeds & ETH_LINK_SPEED_FIXED) == 0;
return cgx_change_mode(dev, &cfg);
}
return 0;
}