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