1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2016-2019 Mellanox Technologies. All rights reserved */
3
4 #include <linux/netdevice.h>
5 #include <linux/etherdevice.h>
6 #include <linux/ethtool.h>
7 #include <linux/i2c.h>
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/mod_devicetable.h>
11 #include <linux/types.h>
12
13 #include "core.h"
14 #include "core_env.h"
15 #include "i2c.h"
16
17 static const char mlxsw_m_driver_name[] = "mlxsw_minimal";
18
19 #define MLXSW_M_FWREV_MINOR 2000
20 #define MLXSW_M_FWREV_SUBMINOR 1886
21
22 static const struct mlxsw_fw_rev mlxsw_m_fw_rev = {
23 .minor = MLXSW_M_FWREV_MINOR,
24 .subminor = MLXSW_M_FWREV_SUBMINOR,
25 };
26
27 struct mlxsw_m_port;
28
29 struct mlxsw_m {
30 struct mlxsw_m_port **ports;
31 int *module_to_port;
32 struct mlxsw_core *core;
33 const struct mlxsw_bus_info *bus_info;
34 u8 base_mac[ETH_ALEN];
35 u8 max_ports;
36 };
37
38 struct mlxsw_m_port {
39 struct net_device *dev;
40 struct mlxsw_m *mlxsw_m;
41 u8 local_port;
42 u8 module;
43 };
44
mlxsw_m_base_mac_get(struct mlxsw_m * mlxsw_m)45 static int mlxsw_m_base_mac_get(struct mlxsw_m *mlxsw_m)
46 {
47 char spad_pl[MLXSW_REG_SPAD_LEN] = {0};
48 int err;
49
50 err = mlxsw_reg_query(mlxsw_m->core, MLXSW_REG(spad), spad_pl);
51 if (err)
52 return err;
53 mlxsw_reg_spad_base_mac_memcpy_from(spad_pl, mlxsw_m->base_mac);
54 return 0;
55 }
56
mlxsw_m_port_dummy_open_stop(struct net_device * dev)57 static int mlxsw_m_port_dummy_open_stop(struct net_device *dev)
58 {
59 return 0;
60 }
61
62 static struct devlink_port *
mlxsw_m_port_get_devlink_port(struct net_device * dev)63 mlxsw_m_port_get_devlink_port(struct net_device *dev)
64 {
65 struct mlxsw_m_port *mlxsw_m_port = netdev_priv(dev);
66 struct mlxsw_m *mlxsw_m = mlxsw_m_port->mlxsw_m;
67
68 return mlxsw_core_port_devlink_port_get(mlxsw_m->core,
69 mlxsw_m_port->local_port);
70 }
71
72 static const struct net_device_ops mlxsw_m_port_netdev_ops = {
73 .ndo_open = mlxsw_m_port_dummy_open_stop,
74 .ndo_stop = mlxsw_m_port_dummy_open_stop,
75 .ndo_get_devlink_port = mlxsw_m_port_get_devlink_port,
76 };
77
mlxsw_m_module_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * drvinfo)78 static void mlxsw_m_module_get_drvinfo(struct net_device *dev,
79 struct ethtool_drvinfo *drvinfo)
80 {
81 struct mlxsw_m_port *mlxsw_m_port = netdev_priv(dev);
82 struct mlxsw_m *mlxsw_m = mlxsw_m_port->mlxsw_m;
83
84 strlcpy(drvinfo->driver, mlxsw_m->bus_info->device_kind,
85 sizeof(drvinfo->driver));
86 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
87 "%d.%d.%d",
88 mlxsw_m->bus_info->fw_rev.major,
89 mlxsw_m->bus_info->fw_rev.minor,
90 mlxsw_m->bus_info->fw_rev.subminor);
91 strlcpy(drvinfo->bus_info, mlxsw_m->bus_info->device_name,
92 sizeof(drvinfo->bus_info));
93 }
94
mlxsw_m_get_module_info(struct net_device * netdev,struct ethtool_modinfo * modinfo)95 static int mlxsw_m_get_module_info(struct net_device *netdev,
96 struct ethtool_modinfo *modinfo)
97 {
98 struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
99 struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
100
101 return mlxsw_env_get_module_info(core, mlxsw_m_port->module, modinfo);
102 }
103
104 static int
mlxsw_m_get_module_eeprom(struct net_device * netdev,struct ethtool_eeprom * ee,u8 * data)105 mlxsw_m_get_module_eeprom(struct net_device *netdev, struct ethtool_eeprom *ee,
106 u8 *data)
107 {
108 struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
109 struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
110
111 return mlxsw_env_get_module_eeprom(netdev, core, mlxsw_m_port->module,
112 ee, data);
113 }
114
115 static const struct ethtool_ops mlxsw_m_port_ethtool_ops = {
116 .get_drvinfo = mlxsw_m_module_get_drvinfo,
117 .get_module_info = mlxsw_m_get_module_info,
118 .get_module_eeprom = mlxsw_m_get_module_eeprom,
119 };
120
121 static int
mlxsw_m_port_module_info_get(struct mlxsw_m * mlxsw_m,u8 local_port,u8 * p_module,u8 * p_width)122 mlxsw_m_port_module_info_get(struct mlxsw_m *mlxsw_m, u8 local_port,
123 u8 *p_module, u8 *p_width)
124 {
125 char pmlp_pl[MLXSW_REG_PMLP_LEN];
126 int err;
127
128 mlxsw_reg_pmlp_pack(pmlp_pl, local_port);
129 err = mlxsw_reg_query(mlxsw_m->core, MLXSW_REG(pmlp), pmlp_pl);
130 if (err)
131 return err;
132 *p_module = mlxsw_reg_pmlp_module_get(pmlp_pl, 0);
133 *p_width = mlxsw_reg_pmlp_width_get(pmlp_pl);
134
135 return 0;
136 }
137
138 static int
mlxsw_m_port_dev_addr_get(struct mlxsw_m_port * mlxsw_m_port)139 mlxsw_m_port_dev_addr_get(struct mlxsw_m_port *mlxsw_m_port)
140 {
141 struct mlxsw_m *mlxsw_m = mlxsw_m_port->mlxsw_m;
142 struct net_device *dev = mlxsw_m_port->dev;
143 char ppad_pl[MLXSW_REG_PPAD_LEN];
144 int err;
145
146 mlxsw_reg_ppad_pack(ppad_pl, false, 0);
147 err = mlxsw_reg_query(mlxsw_m->core, MLXSW_REG(ppad), ppad_pl);
148 if (err)
149 return err;
150 mlxsw_reg_ppad_mac_memcpy_from(ppad_pl, dev->dev_addr);
151 /* The last byte value in base mac address is guaranteed
152 * to be such it does not overflow when adding local_port
153 * value.
154 */
155 dev->dev_addr[ETH_ALEN - 1] += mlxsw_m_port->module + 1;
156 return 0;
157 }
158
159 static int
mlxsw_m_port_create(struct mlxsw_m * mlxsw_m,u8 local_port,u8 module)160 mlxsw_m_port_create(struct mlxsw_m *mlxsw_m, u8 local_port, u8 module)
161 {
162 struct mlxsw_m_port *mlxsw_m_port;
163 struct net_device *dev;
164 int err;
165
166 err = mlxsw_core_port_init(mlxsw_m->core, local_port,
167 module + 1, false, 0, false,
168 0, mlxsw_m->base_mac,
169 sizeof(mlxsw_m->base_mac));
170 if (err) {
171 dev_err(mlxsw_m->bus_info->dev, "Port %d: Failed to init core port\n",
172 local_port);
173 return err;
174 }
175
176 dev = alloc_etherdev(sizeof(struct mlxsw_m_port));
177 if (!dev) {
178 err = -ENOMEM;
179 goto err_alloc_etherdev;
180 }
181
182 SET_NETDEV_DEV(dev, mlxsw_m->bus_info->dev);
183 dev_net_set(dev, mlxsw_core_net(mlxsw_m->core));
184 mlxsw_m_port = netdev_priv(dev);
185 mlxsw_m_port->dev = dev;
186 mlxsw_m_port->mlxsw_m = mlxsw_m;
187 mlxsw_m_port->local_port = local_port;
188 mlxsw_m_port->module = module;
189
190 dev->netdev_ops = &mlxsw_m_port_netdev_ops;
191 dev->ethtool_ops = &mlxsw_m_port_ethtool_ops;
192
193 err = mlxsw_m_port_dev_addr_get(mlxsw_m_port);
194 if (err) {
195 dev_err(mlxsw_m->bus_info->dev, "Port %d: Unable to get port mac address\n",
196 mlxsw_m_port->local_port);
197 goto err_dev_addr_get;
198 }
199
200 netif_carrier_off(dev);
201 mlxsw_m->ports[local_port] = mlxsw_m_port;
202 err = register_netdev(dev);
203 if (err) {
204 dev_err(mlxsw_m->bus_info->dev, "Port %d: Failed to register netdev\n",
205 mlxsw_m_port->local_port);
206 goto err_register_netdev;
207 }
208
209 mlxsw_core_port_eth_set(mlxsw_m->core, mlxsw_m_port->local_port,
210 mlxsw_m_port, dev);
211
212 return 0;
213
214 err_register_netdev:
215 mlxsw_m->ports[local_port] = NULL;
216 err_dev_addr_get:
217 free_netdev(dev);
218 err_alloc_etherdev:
219 mlxsw_core_port_fini(mlxsw_m->core, local_port);
220 return err;
221 }
222
mlxsw_m_port_remove(struct mlxsw_m * mlxsw_m,u8 local_port)223 static void mlxsw_m_port_remove(struct mlxsw_m *mlxsw_m, u8 local_port)
224 {
225 struct mlxsw_m_port *mlxsw_m_port = mlxsw_m->ports[local_port];
226
227 mlxsw_core_port_clear(mlxsw_m->core, local_port, mlxsw_m);
228 unregister_netdev(mlxsw_m_port->dev); /* This calls ndo_stop */
229 mlxsw_m->ports[local_port] = NULL;
230 free_netdev(mlxsw_m_port->dev);
231 mlxsw_core_port_fini(mlxsw_m->core, local_port);
232 }
233
mlxsw_m_port_module_map(struct mlxsw_m * mlxsw_m,u8 local_port,u8 * last_module)234 static int mlxsw_m_port_module_map(struct mlxsw_m *mlxsw_m, u8 local_port,
235 u8 *last_module)
236 {
237 u8 module, width;
238 int err;
239
240 /* Fill out to local port mapping array */
241 err = mlxsw_m_port_module_info_get(mlxsw_m, local_port, &module,
242 &width);
243 if (err)
244 return err;
245
246 if (!width)
247 return 0;
248 /* Skip, if port belongs to the cluster */
249 if (module == *last_module)
250 return 0;
251 *last_module = module;
252 mlxsw_m->module_to_port[module] = ++mlxsw_m->max_ports;
253
254 return 0;
255 }
256
mlxsw_m_port_module_unmap(struct mlxsw_m * mlxsw_m,u8 module)257 static void mlxsw_m_port_module_unmap(struct mlxsw_m *mlxsw_m, u8 module)
258 {
259 mlxsw_m->module_to_port[module] = -1;
260 }
261
mlxsw_m_ports_create(struct mlxsw_m * mlxsw_m)262 static int mlxsw_m_ports_create(struct mlxsw_m *mlxsw_m)
263 {
264 unsigned int max_ports = mlxsw_core_max_ports(mlxsw_m->core);
265 u8 last_module = max_ports;
266 int i;
267 int err;
268
269 mlxsw_m->ports = kcalloc(max_ports, sizeof(*mlxsw_m->ports),
270 GFP_KERNEL);
271 if (!mlxsw_m->ports)
272 return -ENOMEM;
273
274 mlxsw_m->module_to_port = kmalloc_array(max_ports, sizeof(int),
275 GFP_KERNEL);
276 if (!mlxsw_m->module_to_port) {
277 err = -ENOMEM;
278 goto err_module_to_port_alloc;
279 }
280
281 /* Invalidate the entries of module to local port mapping array */
282 for (i = 0; i < max_ports; i++)
283 mlxsw_m->module_to_port[i] = -1;
284
285 /* Fill out module to local port mapping array */
286 for (i = 1; i < max_ports; i++) {
287 err = mlxsw_m_port_module_map(mlxsw_m, i, &last_module);
288 if (err)
289 goto err_module_to_port_map;
290 }
291
292 /* Create port objects for each valid entry */
293 for (i = 0; i < mlxsw_m->max_ports; i++) {
294 if (mlxsw_m->module_to_port[i] > 0 &&
295 !mlxsw_core_port_is_xm(mlxsw_m->core, i)) {
296 err = mlxsw_m_port_create(mlxsw_m,
297 mlxsw_m->module_to_port[i],
298 i);
299 if (err)
300 goto err_module_to_port_create;
301 }
302 }
303
304 return 0;
305
306 err_module_to_port_create:
307 for (i--; i >= 0; i--) {
308 if (mlxsw_m->module_to_port[i] > 0)
309 mlxsw_m_port_remove(mlxsw_m,
310 mlxsw_m->module_to_port[i]);
311 }
312 i = max_ports;
313 err_module_to_port_map:
314 for (i--; i > 0; i--)
315 mlxsw_m_port_module_unmap(mlxsw_m, i);
316 kfree(mlxsw_m->module_to_port);
317 err_module_to_port_alloc:
318 kfree(mlxsw_m->ports);
319 return err;
320 }
321
mlxsw_m_ports_remove(struct mlxsw_m * mlxsw_m)322 static void mlxsw_m_ports_remove(struct mlxsw_m *mlxsw_m)
323 {
324 int i;
325
326 for (i = 0; i < mlxsw_m->max_ports; i++) {
327 if (mlxsw_m->module_to_port[i] > 0) {
328 mlxsw_m_port_remove(mlxsw_m,
329 mlxsw_m->module_to_port[i]);
330 mlxsw_m_port_module_unmap(mlxsw_m, i);
331 }
332 }
333
334 kfree(mlxsw_m->module_to_port);
335 kfree(mlxsw_m->ports);
336 }
337
mlxsw_m_fw_rev_validate(struct mlxsw_m * mlxsw_m)338 static int mlxsw_m_fw_rev_validate(struct mlxsw_m *mlxsw_m)
339 {
340 const struct mlxsw_fw_rev *rev = &mlxsw_m->bus_info->fw_rev;
341
342 /* Validate driver and FW are compatible.
343 * Do not check major version, since it defines chip type, while
344 * driver is supposed to support any type.
345 */
346 if (mlxsw_core_fw_rev_minor_subminor_validate(rev, &mlxsw_m_fw_rev))
347 return 0;
348
349 dev_err(mlxsw_m->bus_info->dev, "The firmware version %d.%d.%d is incompatible with the driver (required >= %d.%d.%d)\n",
350 rev->major, rev->minor, rev->subminor, rev->major,
351 mlxsw_m_fw_rev.minor, mlxsw_m_fw_rev.subminor);
352
353 return -EINVAL;
354 }
355
mlxsw_m_init(struct mlxsw_core * mlxsw_core,const struct mlxsw_bus_info * mlxsw_bus_info,struct netlink_ext_ack * extack)356 static int mlxsw_m_init(struct mlxsw_core *mlxsw_core,
357 const struct mlxsw_bus_info *mlxsw_bus_info,
358 struct netlink_ext_ack *extack)
359 {
360 struct mlxsw_m *mlxsw_m = mlxsw_core_driver_priv(mlxsw_core);
361 int err;
362
363 mlxsw_m->core = mlxsw_core;
364 mlxsw_m->bus_info = mlxsw_bus_info;
365
366 err = mlxsw_m_fw_rev_validate(mlxsw_m);
367 if (err)
368 return err;
369
370 err = mlxsw_m_base_mac_get(mlxsw_m);
371 if (err) {
372 dev_err(mlxsw_m->bus_info->dev, "Failed to get base mac\n");
373 return err;
374 }
375
376 err = mlxsw_m_ports_create(mlxsw_m);
377 if (err) {
378 dev_err(mlxsw_m->bus_info->dev, "Failed to create ports\n");
379 return err;
380 }
381
382 return 0;
383 }
384
mlxsw_m_fini(struct mlxsw_core * mlxsw_core)385 static void mlxsw_m_fini(struct mlxsw_core *mlxsw_core)
386 {
387 struct mlxsw_m *mlxsw_m = mlxsw_core_driver_priv(mlxsw_core);
388
389 mlxsw_m_ports_remove(mlxsw_m);
390 }
391
392 static const struct mlxsw_config_profile mlxsw_m_config_profile;
393
394 static struct mlxsw_driver mlxsw_m_driver = {
395 .kind = mlxsw_m_driver_name,
396 .priv_size = sizeof(struct mlxsw_m),
397 .init = mlxsw_m_init,
398 .fini = mlxsw_m_fini,
399 .profile = &mlxsw_m_config_profile,
400 .res_query_enabled = true,
401 };
402
403 static const struct i2c_device_id mlxsw_m_i2c_id[] = {
404 { "mlxsw_minimal", 0},
405 { },
406 };
407
408 static struct i2c_driver mlxsw_m_i2c_driver = {
409 .driver.name = "mlxsw_minimal",
410 .class = I2C_CLASS_HWMON,
411 .id_table = mlxsw_m_i2c_id,
412 };
413
mlxsw_m_module_init(void)414 static int __init mlxsw_m_module_init(void)
415 {
416 int err;
417
418 err = mlxsw_core_driver_register(&mlxsw_m_driver);
419 if (err)
420 return err;
421
422 err = mlxsw_i2c_driver_register(&mlxsw_m_i2c_driver);
423 if (err)
424 goto err_i2c_driver_register;
425
426 return 0;
427
428 err_i2c_driver_register:
429 mlxsw_core_driver_unregister(&mlxsw_m_driver);
430
431 return err;
432 }
433
mlxsw_m_module_exit(void)434 static void __exit mlxsw_m_module_exit(void)
435 {
436 mlxsw_i2c_driver_unregister(&mlxsw_m_i2c_driver);
437 mlxsw_core_driver_unregister(&mlxsw_m_driver);
438 }
439
440 module_init(mlxsw_m_module_init);
441 module_exit(mlxsw_m_module_exit);
442
443 MODULE_LICENSE("Dual BSD/GPL");
444 MODULE_AUTHOR("Vadim Pasternak <vadimp@mellanox.com>");
445 MODULE_DESCRIPTION("Mellanox minimal driver");
446 MODULE_DEVICE_TABLE(i2c, mlxsw_m_i2c_id);
447