UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'mlx5-fixes' 

Saeed Mahameed says:

====================
Mellanox 100G mlx5 fixes 2016-08-16

This series includes some bug fixes for mlx5e driver.

From Saeed and Tariq, Optimize MTU change to not reset when it is not required.

From Paul, Command interface message length check to speedup firmware
command preparation.

From Mohamad, Save pci state when pci error is detected.

From Amir, Flow counters "lastuse" update fix.

From Hadar, Use correct flow dissector key on flower offloading.
Plus a small optimization for switchdev hardware id query.

From Or, three patches to address some E-Switch offloads issues.

For -stable of 4.6.y and 4.7.y:
    net/mlx5e: Use correct flow dissector key on flower offloading
    net/mlx5: Fix pci error recovery flow
    net/mlx5: Added missing check of msg length in verifying its signature
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2016-08-19 16:09:57 -07:00
parent 98a384eca9 f96750f8d6
commit 187335cdfe
9 changed files with 142 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
drivers/net/ethernet/mellanox/mlx5/core/cmd.c
View File

@ -143,13 +143,14 @@ static struct mlx5_cmd_layout *get_inst(struct mlx5_cmd *cmd, int idx)
return cmd->cmd_buf + (idx << cmd->log_stride); return cmd->cmd_buf + (idx << cmd->log_stride);
} }
static u8 xor8_buf(void *buf, int len) static u8 xor8_buf(void *buf, size_t offset, int len)
{ {
u8 *ptr = buf; u8 *ptr = buf;
u8 sum = 0; u8 sum = 0;
int i; int i;
int end = len + offset;
for (i = 0; i < len; i++) for (i = offset; i < end; i++)
sum ^= ptr[i]; sum ^= ptr[i];
return sum; return sum;
@ -157,41 +158,49 @@ static u8 xor8_buf(void *buf, int len)
static int verify_block_sig(struct mlx5_cmd_prot_block *block) static int verify_block_sig(struct mlx5_cmd_prot_block *block)
{ {
if (xor8_buf(block->rsvd0, sizeof(*block) - sizeof(block->data) - 1) != 0xff) size_t rsvd0_off = offsetof(struct mlx5_cmd_prot_block, rsvd0);
int xor_len = sizeof(*block) - sizeof(block->data) - 1;
if (xor8_buf(block, rsvd0_off, xor_len) != 0xff)
return -EINVAL; return -EINVAL;
if (xor8_buf(block, sizeof(*block)) != 0xff) if (xor8_buf(block, 0, sizeof(*block)) != 0xff)
return -EINVAL; return -EINVAL;
return 0; return 0;
} }
static void calc_block_sig(struct mlx5_cmd_prot_block *block, u8 token, static void calc_block_sig(struct mlx5_cmd_prot_block *block)
int csum)
{ {
block->token = token; int ctrl_xor_len = sizeof(*block) - sizeof(block->data) - 2;
if (csum) { size_t rsvd0_off = offsetof(struct mlx5_cmd_prot_block, rsvd0);
block->ctrl_sig = ~xor8_buf(block->rsvd0, sizeof(*block) -
sizeof(block->data) - 2); block->ctrl_sig = ~xor8_buf(block, rsvd0_off, ctrl_xor_len);
block->sig = ~xor8_buf(block, sizeof(*block) - 1); block->sig = ~xor8_buf(block, 0, sizeof(*block) - 1);
}
} }
static void calc_chain_sig(struct mlx5_cmd_msg *msg, u8 token, int csum) static void calc_chain_sig(struct mlx5_cmd_msg *msg)
{ {
struct mlx5_cmd_mailbox *next = msg->next; struct mlx5_cmd_mailbox *next = msg->next;
int size = msg->len;
int blen = size - min_t(int, sizeof(msg->first.data), size);
int n = (blen + MLX5_CMD_DATA_BLOCK_SIZE - 1)
/ MLX5_CMD_DATA_BLOCK_SIZE;
int i = 0;
while (next) { for (i = 0; i < n && next; i++) {
calc_block_sig(next->buf, token, csum); calc_block_sig(next->buf);
next = next->next; next = next->next;
} }
} }
static void set_signature(struct mlx5_cmd_work_ent *ent, int csum) static void set_signature(struct mlx5_cmd_work_ent *ent, int csum)
{ {
ent->lay->sig = ~xor8_buf(ent->lay, sizeof(*ent->lay)); ent->lay->sig = ~xor8_buf(ent->lay, 0, sizeof(*ent->lay));
calc_chain_sig(ent->in, ent->token, csum); if (csum) {
calc_chain_sig(ent->out, ent->token, csum); calc_chain_sig(ent->in);
calc_chain_sig(ent->out);
}
} }
static void poll_timeout(struct mlx5_cmd_work_ent *ent) static void poll_timeout(struct mlx5_cmd_work_ent *ent)
@ -222,12 +231,17 @@ static int verify_signature(struct mlx5_cmd_work_ent *ent)
struct mlx5_cmd_mailbox *next = ent->out->next; struct mlx5_cmd_mailbox *next = ent->out->next;
int err; int err;
u8 sig; u8 sig;
int size = ent->out->len;
int blen = size - min_t(int, sizeof(ent->out->first.data), size);
int n = (blen + MLX5_CMD_DATA_BLOCK_SIZE - 1)
/ MLX5_CMD_DATA_BLOCK_SIZE;
int i = 0;
sig = xor8_buf(ent->lay, sizeof(*ent->lay)); sig = xor8_buf(ent->lay, 0, sizeof(*ent->lay));
if (sig != 0xff) if (sig != 0xff)
return -EINVAL; return -EINVAL;
while (next) { for (i = 0; i < n && next; i++) {
err = verify_block_sig(next->buf); err = verify_block_sig(next->buf);
if (err) if (err)
return err; return err;
@ -656,7 +670,6 @@ static void cmd_work_handler(struct work_struct *work)
spin_unlock_irqrestore(&cmd->alloc_lock, flags); spin_unlock_irqrestore(&cmd->alloc_lock, flags);
} }
ent->token = alloc_token(cmd);
cmd->ent_arr[ent->idx] = ent; cmd->ent_arr[ent->idx] = ent;
lay = get_inst(cmd, ent->idx); lay = get_inst(cmd, ent->idx);
ent->lay = lay; ent->lay = lay;
@ -766,7 +779,8 @@ static u8 *get_status_ptr(struct mlx5_outbox_hdr *out)
static int mlx5_cmd_invoke(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *in, static int mlx5_cmd_invoke(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *in,
struct mlx5_cmd_msg *out, void *uout, int uout_size, struct mlx5_cmd_msg *out, void *uout, int uout_size,
mlx5_cmd_cbk_t callback, mlx5_cmd_cbk_t callback,
void *context, int page_queue, u8 *status) void *context, int page_queue, u8 *status,
u8 token)
{ {
struct mlx5_cmd *cmd = &dev->cmd; struct mlx5_cmd *cmd = &dev->cmd;
struct mlx5_cmd_work_ent *ent; struct mlx5_cmd_work_ent *ent;
@ -783,6 +797,8 @@ static int mlx5_cmd_invoke(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *in,
if (IS_ERR(ent)) if (IS_ERR(ent))
return PTR_ERR(ent); return PTR_ERR(ent);
ent->token = token;
if (!callback) if (!callback)
init_completion(&ent->done); init_completion(&ent->done);
@ -854,7 +870,8 @@ static const struct file_operations fops = {
.write = dbg_write, .write = dbg_write,
}; };
static int mlx5_copy_to_msg(struct mlx5_cmd_msg *to, void *from, int size) static int mlx5_copy_to_msg(struct mlx5_cmd_msg *to, void *from, int size,
u8 token)
{ {
struct mlx5_cmd_prot_block *block; struct mlx5_cmd_prot_block *block;
struct mlx5_cmd_mailbox *next; struct mlx5_cmd_mailbox *next;
@ -880,6 +897,7 @@ static int mlx5_copy_to_msg(struct mlx5_cmd_msg *to, void *from, int size)
memcpy(block->data, from, copy); memcpy(block->data, from, copy);
from += copy; from += copy;
size -= copy; size -= copy;
block->token = token;
next = next->next; next = next->next;
} }
@ -949,7 +967,8 @@ static void free_cmd_box(struct mlx5_core_dev *dev,
} }
static struct mlx5_cmd_msg *mlx5_alloc_cmd_msg(struct mlx5_core_dev *dev, static struct mlx5_cmd_msg *mlx5_alloc_cmd_msg(struct mlx5_core_dev *dev,
gfp_t flags, int size) gfp_t flags, int size,
u8 token)
{ {
struct mlx5_cmd_mailbox *tmp, *head = NULL; struct mlx5_cmd_mailbox *tmp, *head = NULL;
struct mlx5_cmd_prot_block *block; struct mlx5_cmd_prot_block *block;
@ -978,6 +997,7 @@ static struct mlx5_cmd_msg *mlx5_alloc_cmd_msg(struct mlx5_core_dev *dev,
tmp->next = head; tmp->next = head;
block->next = cpu_to_be64(tmp->next ? tmp->next->dma : 0); block->next = cpu_to_be64(tmp->next ? tmp->next->dma : 0);
block->block_num = cpu_to_be32(n - i - 1); block->block_num = cpu_to_be32(n - i - 1);
block->token = token;
head = tmp; head = tmp;
} }
msg->next = head; msg->next = head;
@ -1352,7 +1372,7 @@ static struct mlx5_cmd_msg *alloc_msg(struct mlx5_core_dev *dev, int in_size,
} }
if (IS_ERR(msg)) if (IS_ERR(msg))
msg = mlx5_alloc_cmd_msg(dev, gfp, in_size); msg = mlx5_alloc_cmd_msg(dev, gfp, in_size, 0);
return msg; return msg;
} }
@ -1377,6 +1397,7 @@ static int cmd_exec(struct mlx5_core_dev *dev, void *in, int in_size, void *out,
int err; int err;
u8 status = 0; u8 status = 0;
u32 drv_synd; u32 drv_synd;
u8 token;
if (pci_channel_offline(dev->pdev) || if (pci_channel_offline(dev->pdev) ||
dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) { dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) {
@ -1395,20 +1416,22 @@ static int cmd_exec(struct mlx5_core_dev *dev, void *in, int in_size, void *out,
return err; return err;
} }
err = mlx5_copy_to_msg(inb, in, in_size); token = alloc_token(&dev->cmd);
err = mlx5_copy_to_msg(inb, in, in_size, token);
if (err) { if (err) {
mlx5_core_warn(dev, "err %d\n", err); mlx5_core_warn(dev, "err %d\n", err);
goto out_in; goto out_in;
} }
outb = mlx5_alloc_cmd_msg(dev, gfp, out_size); outb = mlx5_alloc_cmd_msg(dev, gfp, out_size, token);
if (IS_ERR(outb)) { if (IS_ERR(outb)) {
err = PTR_ERR(outb); err = PTR_ERR(outb);
goto out_in; goto out_in;
} }
err = mlx5_cmd_invoke(dev, inb, outb, out, out_size, callback, context, err = mlx5_cmd_invoke(dev, inb, outb, out, out_size, callback, context,
pages_queue, &status); pages_queue, &status, token);
if (err) if (err)
goto out_out; goto out_out;
@ -1476,7 +1499,7 @@ static int create_msg_cache(struct mlx5_core_dev *dev)
INIT_LIST_HEAD(&cmd->cache.med.head); INIT_LIST_HEAD(&cmd->cache.med.head);
for (i = 0; i < NUM_LONG_LISTS; i++) { for (i = 0; i < NUM_LONG_LISTS; i++) {
msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, LONG_LIST_SIZE); msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, LONG_LIST_SIZE, 0);
if (IS_ERR(msg)) { if (IS_ERR(msg)) {
err = PTR_ERR(msg); err = PTR_ERR(msg);
goto ex_err; goto ex_err;
@ -1486,7 +1509,7 @@ static int create_msg_cache(struct mlx5_core_dev *dev)
} }
for (i = 0; i < NUM_MED_LISTS; i++) { for (i = 0; i < NUM_MED_LISTS; i++) {
msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, MED_LIST_SIZE); msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, MED_LIST_SIZE, 0);
if (IS_ERR(msg)) { if (IS_ERR(msg)) {
err = PTR_ERR(msg); err = PTR_ERR(msg);
goto ex_err; goto ex_err;

21
drivers/net/ethernet/mellanox/mlx5/core/en_main.c
View File

@ -1826,10 +1826,6 @@ int mlx5e_open_locked(struct net_device *netdev)
netif_set_real_num_tx_queues(netdev, num_txqs); netif_set_real_num_tx_queues(netdev, num_txqs);
netif_set_real_num_rx_queues(netdev, priv->params.num_channels); netif_set_real_num_rx_queues(netdev, priv->params.num_channels);
err = mlx5e_set_dev_port_mtu(netdev);
if (err)
goto err_clear_state_opened_flag;
err = mlx5e_open_channels(priv); err = mlx5e_open_channels(priv);
if (err) { if (err) {
netdev_err(netdev, "%s: mlx5e_open_channels failed, %d\n", netdev_err(netdev, "%s: mlx5e_open_channels failed, %d\n",
@ -2573,6 +2569,7 @@ static int mlx5e_change_mtu(struct net_device *netdev, int new_mtu)
u16 max_mtu; u16 max_mtu;
u16 min_mtu; u16 min_mtu;
int err = 0; int err = 0;
bool reset;
mlx5_query_port_max_mtu(mdev, &max_mtu, 1); mlx5_query_port_max_mtu(mdev, &max_mtu, 1);
@ -2588,13 +2585,18 @@ static int mlx5e_change_mtu(struct net_device *netdev, int new_mtu)
mutex_lock(&priv->state_lock); mutex_lock(&priv->state_lock);
reset = !priv->params.lro_en &&
(priv->params.rq_wq_type !=
MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ);
was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state); was_opened = test_bit(MLX5E_STATE_OPENED, &priv->state);
if (was_opened) if (was_opened && reset)
mlx5e_close_locked(netdev); mlx5e_close_locked(netdev);
netdev->mtu = new_mtu; netdev->mtu = new_mtu;
mlx5e_set_dev_port_mtu(netdev);
if (was_opened) if (was_opened && reset)
err = mlx5e_open_locked(netdev); err = mlx5e_open_locked(netdev);
mutex_unlock(&priv->state_lock); mutex_unlock(&priv->state_lock);
@ -3385,6 +3387,7 @@ static void mlx5e_nic_enable(struct mlx5e_priv *priv)
queue_work(priv->wq, &priv->set_rx_mode_work); queue_work(priv->wq, &priv->set_rx_mode_work);
if (MLX5_CAP_GEN(mdev, vport_group_manager)) { if (MLX5_CAP_GEN(mdev, vport_group_manager)) {
mlx5_query_nic_vport_mac_address(mdev, 0, rep.hw_id);
rep.load = mlx5e_nic_rep_load; rep.load = mlx5e_nic_rep_load;
rep.unload = mlx5e_nic_rep_unload; rep.unload = mlx5e_nic_rep_unload;
rep.vport = 0; rep.vport = 0;
@ -3463,6 +3466,8 @@ void *mlx5e_create_netdev(struct mlx5_core_dev *mdev,
mlx5e_init_l2_addr(priv); mlx5e_init_l2_addr(priv);
mlx5e_set_dev_port_mtu(netdev);
err = register_netdev(netdev); err = register_netdev(netdev);
if (err) { if (err) {
mlx5_core_err(mdev, "register_netdev failed, %d\n", err); mlx5_core_err(mdev, "register_netdev failed, %d\n", err);
@ -3501,16 +3506,20 @@ static void mlx5e_register_vport_rep(struct mlx5_core_dev *mdev)
struct mlx5_eswitch *esw = mdev->priv.eswitch; struct mlx5_eswitch *esw = mdev->priv.eswitch;
int total_vfs = MLX5_TOTAL_VPORTS(mdev); int total_vfs = MLX5_TOTAL_VPORTS(mdev);
int vport; int vport;
u8 mac[ETH_ALEN];
if (!MLX5_CAP_GEN(mdev, vport_group_manager)) if (!MLX5_CAP_GEN(mdev, vport_group_manager))
return; return;
mlx5_query_nic_vport_mac_address(mdev, 0, mac);
for (vport = 1; vport < total_vfs; vport++) { for (vport = 1; vport < total_vfs; vport++) {
struct mlx5_eswitch_rep rep; struct mlx5_eswitch_rep rep;
rep.load = mlx5e_vport_rep_load; rep.load = mlx5e_vport_rep_load;
rep.unload = mlx5e_vport_rep_unload; rep.unload = mlx5e_vport_rep_unload;
rep.vport = vport; rep.vport = vport;
ether_addr_copy(rep.hw_id, mac);
mlx5_eswitch_register_vport_rep(esw, &rep); mlx5_eswitch_register_vport_rep(esw, &rep);
} }
} }

5
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
View File

@ -135,17 +135,16 @@ static const struct ethtool_ops mlx5e_rep_ethtool_ops = {
int mlx5e_attr_get(struct net_device *dev, struct switchdev_attr *attr) int mlx5e_attr_get(struct net_device *dev, struct switchdev_attr *attr)
{ {
struct mlx5e_priv *priv = netdev_priv(dev); struct mlx5e_priv *priv = netdev_priv(dev);
struct mlx5_eswitch_rep *rep = priv->ppriv;
struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; struct mlx5_eswitch *esw = priv->mdev->priv.eswitch;
u8 mac[ETH_ALEN];
if (esw->mode == SRIOV_NONE) if (esw->mode == SRIOV_NONE)
return -EOPNOTSUPP; return -EOPNOTSUPP;
switch (attr->id) { switch (attr->id) {
case SWITCHDEV_ATTR_ID_PORT_PARENT_ID: case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
mlx5_query_nic_vport_mac_address(priv->mdev, 0, mac);
attr->u.ppid.id_len = ETH_ALEN; attr->u.ppid.id_len = ETH_ALEN;
memcpy(&attr->u.ppid.id, &mac, ETH_ALEN); ether_addr_copy(attr->u.ppid.id, rep->hw_id);
break; break;
default: default:
return -EOPNOTSUPP; return -EOPNOTSUPP;

2
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c
View File

@ -170,7 +170,7 @@ static int parse_cls_flower(struct mlx5e_priv *priv, struct mlx5_flow_spec *spec
if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_CONTROL)) { if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_CONTROL)) {
struct flow_dissector_key_control *key = struct flow_dissector_key_control *key =
skb_flow_dissector_target(f->dissector, skb_flow_dissector_target(f->dissector,
FLOW_DISSECTOR_KEY_BASIC, FLOW_DISSECTOR_KEY_CONTROL,
f->key); f->key);
addr_type = key->addr_type; addr_type = key->addr_type;
} }

16
drivers/net/ethernet/mellanox/mlx5/core/eswitch.c
View File

@ -1451,7 +1451,8 @@ static void esw_enable_vport(struct mlx5_eswitch *esw, int vport_num,
esw_debug(esw->dev, "Enabling VPORT(%d)\n", vport_num); esw_debug(esw->dev, "Enabling VPORT(%d)\n", vport_num);
if (vport_num) { /* Only VFs need ACLs for VST and spoofchk filtering */ /* Only VFs need ACLs for VST and spoofchk filtering */
if (vport_num && esw->mode == SRIOV_LEGACY) {
esw_vport_ingress_config(esw, vport); esw_vport_ingress_config(esw, vport);
esw_vport_egress_config(esw, vport); esw_vport_egress_config(esw, vport);
} }
@ -1502,7 +1503,7 @@ static void esw_disable_vport(struct mlx5_eswitch *esw, int vport_num)
*/ */
esw_vport_change_handle_locked(vport); esw_vport_change_handle_locked(vport);
vport->enabled_events = 0; vport->enabled_events = 0;
if (vport_num) { if (vport_num && esw->mode == SRIOV_LEGACY) {
esw_vport_disable_egress_acl(esw, vport); esw_vport_disable_egress_acl(esw, vport);
esw_vport_disable_ingress_acl(esw, vport); esw_vport_disable_ingress_acl(esw, vport);
} }
@ -1767,7 +1768,7 @@ int mlx5_eswitch_set_vport_mac(struct mlx5_eswitch *esw,
vport, err); vport, err);
mutex_lock(&esw->state_lock); mutex_lock(&esw->state_lock);
if (evport->enabled) if (evport->enabled && esw->mode == SRIOV_LEGACY)
err = esw_vport_ingress_config(esw, evport); err = esw_vport_ingress_config(esw, evport);
mutex_unlock(&esw->state_lock); mutex_unlock(&esw->state_lock);
return err; return err;
@ -1839,7 +1840,7 @@ int mlx5_eswitch_set_vport_vlan(struct mlx5_eswitch *esw,
mutex_lock(&esw->state_lock); mutex_lock(&esw->state_lock);
evport->vlan = vlan; evport->vlan = vlan;
evport->qos = qos; evport->qos = qos;
if (evport->enabled) { if (evport->enabled && esw->mode == SRIOV_LEGACY) {
err = esw_vport_ingress_config(esw, evport); err = esw_vport_ingress_config(esw, evport);
if (err) if (err)
goto out; goto out;
@ -1868,10 +1869,11 @@ int mlx5_eswitch_set_vport_spoofchk(struct mlx5_eswitch *esw,
mutex_lock(&esw->state_lock); mutex_lock(&esw->state_lock);
pschk = evport->spoofchk; pschk = evport->spoofchk;
evport->spoofchk = spoofchk; evport->spoofchk = spoofchk;
if (evport->enabled) if (evport->enabled && esw->mode == SRIOV_LEGACY) {
err = esw_vport_ingress_config(esw, evport); err = esw_vport_ingress_config(esw, evport);
if (err) if (err)
evport->spoofchk = pschk; evport->spoofchk = pschk;
}
mutex_unlock(&esw->state_lock); mutex_unlock(&esw->state_lock);
return err; return err;

1
drivers/net/ethernet/mellanox/mlx5/core/eswitch.h
View File

@ -174,6 +174,7 @@ struct mlx5_eswitch_rep {
void *priv_data; void *priv_data;
struct list_head vport_sqs_list; struct list_head vport_sqs_list;
bool valid; bool valid;
u8 hw_id[ETH_ALEN];
}; };
struct mlx5_esw_offload { struct mlx5_esw_offload {

26
drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c
View File

@ -113,7 +113,7 @@ mlx5_eswitch_add_send_to_vport_rule(struct mlx5_eswitch *esw, int vport, u32 sqn
dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT; dest.type = MLX5_FLOW_DESTINATION_TYPE_VPORT;
dest.vport_num = vport; dest.vport_num = vport;
flow_rule = mlx5_add_flow_rule(esw->fdb_table.fdb, spec, flow_rule = mlx5_add_flow_rule(esw->fdb_table.offloads.fdb, spec,
MLX5_FLOW_CONTEXT_ACTION_FWD_DEST, MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,
0, &dest); 0, &dest);
if (IS_ERR(flow_rule)) if (IS_ERR(flow_rule))
@ -535,7 +535,7 @@ void esw_offloads_cleanup(struct mlx5_eswitch *esw, int nvports)
esw_destroy_offloads_fdb_table(esw); esw_destroy_offloads_fdb_table(esw);
} }
static int mlx5_esw_mode_from_devlink(u16 mode, u16 *mlx5_mode) static int esw_mode_from_devlink(u16 mode, u16 *mlx5_mode)
{ {
switch (mode) { switch (mode) {
case DEVLINK_ESWITCH_MODE_LEGACY: case DEVLINK_ESWITCH_MODE_LEGACY:
@ -551,6 +551,22 @@ static int mlx5_esw_mode_from_devlink(u16 mode, u16 *mlx5_mode)
return 0; return 0;
} }
static int esw_mode_to_devlink(u16 mlx5_mode, u16 *mode)
{
switch (mlx5_mode) {
case SRIOV_LEGACY:
*mode = DEVLINK_ESWITCH_MODE_LEGACY;
break;
case SRIOV_OFFLOADS:
*mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
break;
default:
return -EINVAL;
}
return 0;
}
int mlx5_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode) int mlx5_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode)
{ {
struct mlx5_core_dev *dev; struct mlx5_core_dev *dev;
@ -566,7 +582,7 @@ int mlx5_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode)
if (cur_mlx5_mode == SRIOV_NONE) if (cur_mlx5_mode == SRIOV_NONE)
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (mlx5_esw_mode_from_devlink(mode, &mlx5_mode)) if (esw_mode_from_devlink(mode, &mlx5_mode))
return -EINVAL; return -EINVAL;
if (cur_mlx5_mode == mlx5_mode) if (cur_mlx5_mode == mlx5_mode)
@ -592,9 +608,7 @@ int mlx5_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
if (dev->priv.eswitch->mode == SRIOV_NONE) if (dev->priv.eswitch->mode == SRIOV_NONE)
return -EOPNOTSUPP; return -EOPNOTSUPP;
*mode = dev->priv.eswitch->mode; return esw_mode_to_devlink(dev->priv.eswitch->mode, mode);
return 0;
} }
void mlx5_eswitch_register_vport_rep(struct mlx5_eswitch *esw, void mlx5_eswitch_register_vport_rep(struct mlx5_eswitch *esw,

11
drivers/net/ethernet/mellanox/mlx5/core/fs_counters.c
View File

@ -126,12 +126,21 @@ static struct rb_node *mlx5_fc_stats_query(struct mlx5_core_dev *dev,
for (node = &first->node; node; node = rb_next(node)) { for (node = &first->node; node; node = rb_next(node)) {
struct mlx5_fc *counter = rb_entry(node, struct mlx5_fc, node); struct mlx5_fc *counter = rb_entry(node, struct mlx5_fc, node);
struct mlx5_fc_cache *c = &counter->cache; struct mlx5_fc_cache *c = &counter->cache;
u64 packets;
u64 bytes;
if (counter->id > last_id) if (counter->id > last_id)
break; break;
mlx5_cmd_fc_bulk_get(dev, b, mlx5_cmd_fc_bulk_get(dev, b,
counter->id, &c->packets, &c->bytes); counter->id, &packets, &bytes);
if (c->packets == packets)
continue;
c->packets = packets;
c->bytes = bytes;
c->lastuse = jiffies;
} }
out: out:

63
drivers/net/ethernet/mellanox/mlx5/core/main.c
View File

@ -1420,36 +1420,12 @@ static pci_ers_result_t mlx5_pci_err_detected(struct pci_dev *pdev,
dev_info(&pdev->dev, "%s was called\n", __func__); dev_info(&pdev->dev, "%s was called\n", __func__);
mlx5_enter_error_state(dev); mlx5_enter_error_state(dev);
mlx5_unload_one(dev, priv); mlx5_unload_one(dev, priv);
pci_save_state(pdev);
mlx5_pci_disable_device(dev); mlx5_pci_disable_device(dev);
return state == pci_channel_io_perm_failure ? return state == pci_channel_io_perm_failure ?
PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_NEED_RESET; PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_NEED_RESET;
} }
static pci_ers_result_t mlx5_pci_slot_reset(struct pci_dev *pdev)
{
struct mlx5_core_dev *dev = pci_get_drvdata(pdev);
int err = 0;
dev_info(&pdev->dev, "%s was called\n", __func__);
err = mlx5_pci_enable_device(dev);
if (err) {
dev_err(&pdev->dev, "%s: mlx5_pci_enable_device failed with error code: %d\n"
, __func__, err);
return PCI_ERS_RESULT_DISCONNECT;
}
pci_set_master(pdev);
pci_set_power_state(pdev, PCI_D0);
pci_restore_state(pdev);
return err ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
}
void mlx5_disable_device(struct mlx5_core_dev *dev)
{
mlx5_pci_err_detected(dev->pdev, 0);
}
/* wait for the device to show vital signs by waiting /* wait for the device to show vital signs by waiting
* for the health counter to start counting. * for the health counter to start counting.
*/ */
@ -1477,6 +1453,36 @@ static int wait_vital(struct pci_dev *pdev)
return -ETIMEDOUT; return -ETIMEDOUT;
} }
static pci_ers_result_t mlx5_pci_slot_reset(struct pci_dev *pdev)
{
struct mlx5_core_dev *dev = pci_get_drvdata(pdev);
int err;
dev_info(&pdev->dev, "%s was called\n", __func__);
err = mlx5_pci_enable_device(dev);
if (err) {
dev_err(&pdev->dev, "%s: mlx5_pci_enable_device failed with error code: %d\n"
, __func__, err);
return PCI_ERS_RESULT_DISCONNECT;
}
pci_set_master(pdev);
pci_restore_state(pdev);
if (wait_vital(pdev)) {
dev_err(&pdev->dev, "%s: wait_vital timed out\n", __func__);
return PCI_ERS_RESULT_DISCONNECT;
}
return PCI_ERS_RESULT_RECOVERED;
}
void mlx5_disable_device(struct mlx5_core_dev *dev)
{
mlx5_pci_err_detected(dev->pdev, 0);
}
static void mlx5_pci_resume(struct pci_dev *pdev) static void mlx5_pci_resume(struct pci_dev *pdev)
{ {
struct mlx5_core_dev *dev = pci_get_drvdata(pdev); struct mlx5_core_dev *dev = pci_get_drvdata(pdev);
@ -1485,13 +1491,6 @@ static void mlx5_pci_resume(struct pci_dev *pdev)
dev_info(&pdev->dev, "%s was called\n", __func__); dev_info(&pdev->dev, "%s was called\n", __func__);
pci_save_state(pdev);
err = wait_vital(pdev);
if (err) {
dev_err(&pdev->dev, "%s: wait_vital timed out\n", __func__);
return;
}
err = mlx5_load_one(dev, priv); err = mlx5_load_one(dev, priv);
if (err) if (err)
dev_err(&pdev->dev, "%s: mlx5_load_one failed with error code: %d\n" dev_err(&pdev->dev, "%s: mlx5_load_one failed with error code: %d\n"