1 /* 2 * Copyright (c) 2016, Mellanox Technologies. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 */ 32 33 #include <linux/module.h> 34 #include <linux/mlx5/vport.h> 35 #include "mlx5_ib.h" 36 37 static inline u32 mlx_to_net_policy(enum port_state_policy mlx_policy) 38 { 39 switch (mlx_policy) { 40 case MLX5_POLICY_DOWN: 41 return IFLA_VF_LINK_STATE_DISABLE; 42 case MLX5_POLICY_UP: 43 return IFLA_VF_LINK_STATE_ENABLE; 44 case MLX5_POLICY_FOLLOW: 45 return IFLA_VF_LINK_STATE_AUTO; 46 default: 47 return __IFLA_VF_LINK_STATE_MAX; 48 } 49 } 50 51 int mlx5_ib_get_vf_config(struct ib_device *device, int vf, u8 port, 52 struct ifla_vf_info *info) 53 { 54 struct mlx5_ib_dev *dev = to_mdev(device); 55 struct mlx5_core_dev *mdev = dev->mdev; 56 struct mlx5_hca_vport_context *rep; 57 int err; 58 59 rep = kzalloc(sizeof(*rep), GFP_KERNEL); 60 if (!rep) 61 return -ENOMEM; 62 63 err = mlx5_query_hca_vport_context(mdev, 1, 1, vf + 1, rep); 64 if (err) { 65 mlx5_ib_warn(dev, "failed to query port policy for vf %d (%d)\n", 66 vf, err); 67 goto free; 68 } 69 memset(info, 0, sizeof(*info)); 70 info->linkstate = mlx_to_net_policy(rep->policy); 71 if (info->linkstate == __IFLA_VF_LINK_STATE_MAX) 72 err = -EINVAL; 73 74 free: 75 kfree(rep); 76 return err; 77 } 78 79 static inline enum port_state_policy net_to_mlx_policy(int policy) 80 { 81 switch (policy) { 82 case IFLA_VF_LINK_STATE_DISABLE: 83 return MLX5_POLICY_DOWN; 84 case IFLA_VF_LINK_STATE_ENABLE: 85 return MLX5_POLICY_UP; 86 case IFLA_VF_LINK_STATE_AUTO: 87 return MLX5_POLICY_FOLLOW; 88 default: 89 return MLX5_POLICY_INVALID; 90 } 91 } 92 93 int mlx5_ib_set_vf_link_state(struct ib_device *device, int vf, 94 u8 port, int state) 95 { 96 struct mlx5_ib_dev *dev = to_mdev(device); 97 struct mlx5_core_dev *mdev = dev->mdev; 98 struct mlx5_hca_vport_context *in; 99 int err; 100 101 in = kzalloc(sizeof(*in), GFP_KERNEL); 102 if (!in) 103 return -ENOMEM; 104 105 in->policy = net_to_mlx_policy(state); 106 if (in->policy == MLX5_POLICY_INVALID) { 107 err = -EINVAL; 108 goto out; 109 } 110 in->field_select = MLX5_HCA_VPORT_SEL_STATE_POLICY; 111 err = mlx5_core_modify_hca_vport_context(mdev, 1, 1, vf + 1, in); 112 113 out: 114 kfree(in); 115 return err; 116 } 117 118 int mlx5_ib_get_vf_stats(struct ib_device *device, int vf, 119 u8 port, struct ifla_vf_stats *stats) 120 { 121 int out_sz = MLX5_ST_SZ_BYTES(query_vport_counter_out); 122 struct mlx5_core_dev *mdev; 123 struct mlx5_ib_dev *dev; 124 void *out; 125 int err; 126 127 dev = to_mdev(device); 128 mdev = dev->mdev; 129 130 out = kzalloc(out_sz, GFP_KERNEL); 131 if (!out) 132 return -ENOMEM; 133 134 err = mlx5_core_query_vport_counter(mdev, true, vf, port, out, out_sz); 135 if (err) 136 goto ex; 137 138 stats->rx_packets = MLX5_GET64_PR(query_vport_counter_out, out, received_ib_unicast.packets); 139 stats->tx_packets = MLX5_GET64_PR(query_vport_counter_out, out, transmitted_ib_unicast.packets); 140 stats->rx_bytes = MLX5_GET64_PR(query_vport_counter_out, out, received_ib_unicast.octets); 141 stats->tx_bytes = MLX5_GET64_PR(query_vport_counter_out, out, transmitted_ib_unicast.octets); 142 stats->multicast = MLX5_GET64_PR(query_vport_counter_out, out, received_ib_multicast.packets); 143 144 ex: 145 kfree(out); 146 return err; 147 } 148 149 static int set_vf_node_guid(struct ib_device *device, int vf, u8 port, u64 guid) 150 { 151 struct mlx5_ib_dev *dev = to_mdev(device); 152 struct mlx5_core_dev *mdev = dev->mdev; 153 struct mlx5_hca_vport_context *in; 154 int err; 155 156 in = kzalloc(sizeof(*in), GFP_KERNEL); 157 if (!in) 158 return -ENOMEM; 159 160 in->field_select = MLX5_HCA_VPORT_SEL_NODE_GUID; 161 in->node_guid = guid; 162 err = mlx5_core_modify_hca_vport_context(mdev, 1, 1, vf + 1, in); 163 kfree(in); 164 return err; 165 } 166 167 static int set_vf_port_guid(struct ib_device *device, int vf, u8 port, u64 guid) 168 { 169 struct mlx5_ib_dev *dev = to_mdev(device); 170 struct mlx5_core_dev *mdev = dev->mdev; 171 struct mlx5_hca_vport_context *in; 172 int err; 173 174 in = kzalloc(sizeof(*in), GFP_KERNEL); 175 if (!in) 176 return -ENOMEM; 177 178 in->field_select = MLX5_HCA_VPORT_SEL_PORT_GUID; 179 in->port_guid = guid; 180 err = mlx5_core_modify_hca_vport_context(mdev, 1, 1, vf + 1, in); 181 kfree(in); 182 return err; 183 } 184 185 int mlx5_ib_set_vf_guid(struct ib_device *device, int vf, u8 port, 186 u64 guid, int type) 187 { 188 if (type == IFLA_VF_IB_NODE_GUID) 189 return set_vf_node_guid(device, vf, port, guid); 190 else if (type == IFLA_VF_IB_PORT_GUID) 191 return set_vf_port_guid(device, vf, port, guid); 192 193 return -EINVAL; 194 } 195