devlink: Add extack for eswitch operations
[sfrench/cifs-2.6.git] / drivers / net / ethernet / netronome / nfp / nfp_devlink.c
1 /*
2  * Copyright (C) 2017 Netronome Systems, Inc.
3  *
4  * This software is dual licensed under the GNU General License Version 2,
5  * June 1991 as shown in the file COPYING in the top-level directory of this
6  * source tree or the BSD 2-Clause License provided below.  You have the
7  * option to license this software under the complete terms of either license.
8  *
9  * The BSD 2-Clause License:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      1. Redistributions of source code must retain the above
16  *         copyright notice, this list of conditions and the following
17  *         disclaimer.
18  *
19  *      2. Redistributions in binary form must reproduce the above
20  *         copyright notice, this list of conditions and the following
21  *         disclaimer in the documentation and/or other materials
22  *         provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #include <linux/rtnetlink.h>
35 #include <net/devlink.h>
36
37 #include "nfpcore/nfp_nsp.h"
38 #include "nfp_app.h"
39 #include "nfp_main.h"
40 #include "nfp_port.h"
41
42 static int
43 nfp_devlink_fill_eth_port(struct nfp_port *port,
44                           struct nfp_eth_table_port *copy)
45 {
46         struct nfp_eth_table_port *eth_port;
47
48         eth_port = __nfp_port_get_eth_port(port);
49         if (!eth_port)
50                 return -EINVAL;
51
52         memcpy(copy, eth_port, sizeof(*eth_port));
53
54         return 0;
55 }
56
57 static int
58 nfp_devlink_fill_eth_port_from_id(struct nfp_pf *pf, unsigned int port_index,
59                                   struct nfp_eth_table_port *copy)
60 {
61         struct nfp_port *port;
62
63         port = nfp_port_from_id(pf, NFP_PORT_PHYS_PORT, port_index);
64
65         return nfp_devlink_fill_eth_port(port, copy);
66 }
67
68 static int
69 nfp_devlink_set_lanes(struct nfp_pf *pf, unsigned int idx, unsigned int lanes)
70 {
71         struct nfp_nsp *nsp;
72         int ret;
73
74         nsp = nfp_eth_config_start(pf->cpp, idx);
75         if (IS_ERR(nsp))
76                 return PTR_ERR(nsp);
77
78         ret = __nfp_eth_set_split(nsp, lanes);
79         if (ret) {
80                 nfp_eth_config_cleanup_end(nsp);
81                 return ret;
82         }
83
84         ret = nfp_eth_config_commit_end(nsp);
85         if (ret < 0)
86                 return ret;
87         if (ret) /* no change */
88                 return 0;
89
90         return nfp_net_refresh_port_table_sync(pf);
91 }
92
93 static int
94 nfp_devlink_port_split(struct devlink *devlink, unsigned int port_index,
95                        unsigned int count, struct netlink_ext_ack *extack)
96 {
97         struct nfp_pf *pf = devlink_priv(devlink);
98         struct nfp_eth_table_port eth_port;
99         int ret;
100
101         if (count < 2)
102                 return -EINVAL;
103
104         mutex_lock(&pf->lock);
105
106         rtnl_lock();
107         ret = nfp_devlink_fill_eth_port_from_id(pf, port_index, &eth_port);
108         rtnl_unlock();
109         if (ret)
110                 goto out;
111
112         if (eth_port.is_split || eth_port.port_lanes % count) {
113                 ret = -EINVAL;
114                 goto out;
115         }
116
117         ret = nfp_devlink_set_lanes(pf, eth_port.index,
118                                     eth_port.port_lanes / count);
119 out:
120         mutex_unlock(&pf->lock);
121
122         return ret;
123 }
124
125 static int
126 nfp_devlink_port_unsplit(struct devlink *devlink, unsigned int port_index,
127                          struct netlink_ext_ack *extack)
128 {
129         struct nfp_pf *pf = devlink_priv(devlink);
130         struct nfp_eth_table_port eth_port;
131         int ret;
132
133         mutex_lock(&pf->lock);
134
135         rtnl_lock();
136         ret = nfp_devlink_fill_eth_port_from_id(pf, port_index, &eth_port);
137         rtnl_unlock();
138         if (ret)
139                 goto out;
140
141         if (!eth_port.is_split) {
142                 ret = -EINVAL;
143                 goto out;
144         }
145
146         ret = nfp_devlink_set_lanes(pf, eth_port.index, eth_port.port_lanes);
147 out:
148         mutex_unlock(&pf->lock);
149
150         return ret;
151 }
152
153 static int
154 nfp_devlink_sb_pool_get(struct devlink *devlink, unsigned int sb_index,
155                         u16 pool_index, struct devlink_sb_pool_info *pool_info)
156 {
157         struct nfp_pf *pf = devlink_priv(devlink);
158
159         return nfp_shared_buf_pool_get(pf, sb_index, pool_index, pool_info);
160 }
161
162 static int
163 nfp_devlink_sb_pool_set(struct devlink *devlink, unsigned int sb_index,
164                         u16 pool_index,
165                         u32 size, enum devlink_sb_threshold_type threshold_type)
166 {
167         struct nfp_pf *pf = devlink_priv(devlink);
168
169         return nfp_shared_buf_pool_set(pf, sb_index, pool_index,
170                                        size, threshold_type);
171 }
172
173 static int nfp_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
174 {
175         struct nfp_pf *pf = devlink_priv(devlink);
176
177         return nfp_app_eswitch_mode_get(pf->app, mode);
178 }
179
180 static int nfp_devlink_eswitch_mode_set(struct devlink *devlink, u16 mode,
181                                         struct netlink_ext_ack *extack)
182 {
183         struct nfp_pf *pf = devlink_priv(devlink);
184         int ret;
185
186         mutex_lock(&pf->lock);
187         ret = nfp_app_eswitch_mode_set(pf->app, mode);
188         mutex_unlock(&pf->lock);
189
190         return ret;
191 }
192
193 const struct devlink_ops nfp_devlink_ops = {
194         .port_split             = nfp_devlink_port_split,
195         .port_unsplit           = nfp_devlink_port_unsplit,
196         .sb_pool_get            = nfp_devlink_sb_pool_get,
197         .sb_pool_set            = nfp_devlink_sb_pool_set,
198         .eswitch_mode_get       = nfp_devlink_eswitch_mode_get,
199         .eswitch_mode_set       = nfp_devlink_eswitch_mode_set,
200 };
201
202 int nfp_devlink_port_register(struct nfp_app *app, struct nfp_port *port)
203 {
204         struct nfp_eth_table_port eth_port;
205         struct devlink *devlink;
206         int ret;
207
208         rtnl_lock();
209         ret = nfp_devlink_fill_eth_port(port, &eth_port);
210         rtnl_unlock();
211         if (ret)
212                 return ret;
213
214         devlink_port_type_eth_set(&port->dl_port, port->netdev);
215         devlink_port_attrs_set(&port->dl_port, DEVLINK_PORT_FLAVOUR_PHYSICAL,
216                                eth_port.label_port, eth_port.is_split,
217                                eth_port.label_subport);
218
219         devlink = priv_to_devlink(app->pf);
220
221         return devlink_port_register(devlink, &port->dl_port, port->eth_id);
222 }
223
224 void nfp_devlink_port_unregister(struct nfp_port *port)
225 {
226         devlink_port_unregister(&port->dl_port);
227 }