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)
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 {
128 	struct nfp_pf *pf = devlink_priv(devlink);
129 	struct nfp_eth_table_port eth_port;
130 	int ret;
131 
132 	mutex_lock(&pf->lock);
133 
134 	rtnl_lock();
135 	ret = nfp_devlink_fill_eth_port_from_id(pf, port_index, &eth_port);
136 	rtnl_unlock();
137 	if (ret)
138 		goto out;
139 
140 	if (!eth_port.is_split) {
141 		ret = -EINVAL;
142 		goto out;
143 	}
144 
145 	ret = nfp_devlink_set_lanes(pf, eth_port.index, eth_port.port_lanes);
146 out:
147 	mutex_unlock(&pf->lock);
148 
149 	return ret;
150 }
151 
152 static int nfp_devlink_eswitch_mode_get(struct devlink *devlink, u16 *mode)
153 {
154 	struct nfp_pf *pf = devlink_priv(devlink);
155 	int ret;
156 
157 	mutex_lock(&pf->lock);
158 	if (!pf->app) {
159 		ret = -EBUSY;
160 		goto out;
161 	}
162 	ret = nfp_app_eswitch_mode_get(pf->app, mode);
163 out:
164 	mutex_unlock(&pf->lock);
165 
166 	return ret;
167 }
168 
169 const struct devlink_ops nfp_devlink_ops = {
170 	.port_split		= nfp_devlink_port_split,
171 	.port_unsplit		= nfp_devlink_port_unsplit,
172 	.eswitch_mode_get	= nfp_devlink_eswitch_mode_get,
173 };
174 
175 int nfp_devlink_port_register(struct nfp_app *app, struct nfp_port *port)
176 {
177 	struct nfp_eth_table_port eth_port;
178 	struct devlink *devlink;
179 	int ret;
180 
181 	rtnl_lock();
182 	ret = nfp_devlink_fill_eth_port(port, &eth_port);
183 	rtnl_unlock();
184 	if (ret)
185 		return ret;
186 
187 	devlink_port_type_eth_set(&port->dl_port, port->netdev);
188 	if (eth_port.is_split)
189 		devlink_port_split_set(&port->dl_port, eth_port.label_port);
190 
191 	devlink = priv_to_devlink(app->pf);
192 
193 	return devlink_port_register(devlink, &port->dl_port, port->eth_id);
194 }
195 
196 void nfp_devlink_port_unregister(struct nfp_port *port)
197 {
198 	devlink_port_unregister(&port->dl_port);
199 }
200