GNU Linux-libre 4.9.304-gnu1
[releases.git] / drivers / infiniband / hw / mlx5 / ib_virt.c
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 }