drivers/net/ethernet/mellanox/mlxsw/minimal.c

   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_line_card {
  30         bool active;
  31         int module_to_port[];
  32 };
  33
  34 struct mlxsw_m {
  35         struct mlxsw_m_port **ports;
  36         struct mlxsw_core *core;
  37         const struct mlxsw_bus_info *bus_info;
  38         u8 base_mac[ETH_ALEN];
  39         u8 max_ports;
  40         u8 max_modules_per_slot; /* Maximum number of modules per-slot. */
  41         u8 num_of_slots; /* Including the main board. */
  42         struct mlxsw_m_line_card **line_cards;
  43 };
  44
  45 struct mlxsw_m_port {
  46         struct net_device *dev;
  47         struct mlxsw_m *mlxsw_m;
  48         u16 local_port;
  49         u8 slot_index;
  50         u8 module;
  51         u8 module_offset;
  52 };
  53
  54 static int mlxsw_m_base_mac_get(struct mlxsw_m *mlxsw_m)
  55 {
  56         char spad_pl[MLXSW_REG_SPAD_LEN] = {0};
  57         int err;
  58
  59         err = mlxsw_reg_query(mlxsw_m->core, MLXSW_REG(spad), spad_pl);
  60         if (err)
  61                 return err;
  62         mlxsw_reg_spad_base_mac_memcpy_from(spad_pl, mlxsw_m->base_mac);
  63         return 0;
  64 }
  65
  66 static int mlxsw_m_port_open(struct net_device *dev)
  67 {
  68         struct mlxsw_m_port *mlxsw_m_port = netdev_priv(dev);
  69         struct mlxsw_m *mlxsw_m = mlxsw_m_port->mlxsw_m;
  70
  71         return mlxsw_env_module_port_up(mlxsw_m->core, 0,
  72                                         mlxsw_m_port->module);
  73 }
  74
  75 static int mlxsw_m_port_stop(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         mlxsw_env_module_port_down(mlxsw_m->core, 0, mlxsw_m_port->module);
  81         return 0;
  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 };
  88
  89 static void mlxsw_m_module_get_drvinfo(struct net_device *dev,
  90                                        struct ethtool_drvinfo *drvinfo)
  91 {
  92         struct mlxsw_m_port *mlxsw_m_port = netdev_priv(dev);
  93         struct mlxsw_m *mlxsw_m = mlxsw_m_port->mlxsw_m;
  94
  95         strscpy(drvinfo->driver, mlxsw_m->bus_info->device_kind,
  96                 sizeof(drvinfo->driver));
  97         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
  98                  "%d.%d.%d",
  99                  mlxsw_m->bus_info->fw_rev.major,
 100                  mlxsw_m->bus_info->fw_rev.minor,
 101                  mlxsw_m->bus_info->fw_rev.subminor);
 102         strscpy(drvinfo->bus_info, mlxsw_m->bus_info->device_name,
 103                 sizeof(drvinfo->bus_info));
 104 }
 105
 106 static int mlxsw_m_get_module_info(struct net_device *netdev,
 107                                    struct ethtool_modinfo *modinfo)
 108 {
 109         struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
 110         struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
 111
 112         return mlxsw_env_get_module_info(netdev, core,
 113                                          mlxsw_m_port->slot_index,
 114                                          mlxsw_m_port->module, modinfo);
 115 }
 116
 117 static int
 118 mlxsw_m_get_module_eeprom(struct net_device *netdev, struct ethtool_eeprom *ee,
 119                           u8 *data)
 120 {
 121         struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
 122         struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
 123
 124         return mlxsw_env_get_module_eeprom(netdev, core,
 125                                            mlxsw_m_port->slot_index,
 126                                            mlxsw_m_port->module, ee, data);
 127 }
 128
 129 static int
 130 mlxsw_m_get_module_eeprom_by_page(struct net_device *netdev,
 131                                   const struct ethtool_module_eeprom *page,
 132                                   struct netlink_ext_ack *extack)
 133 {
 134         struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
 135         struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
 136
 137         return mlxsw_env_get_module_eeprom_by_page(core,
 138                                                    mlxsw_m_port->slot_index,
 139                                                    mlxsw_m_port->module,
 140                                                    page, extack);
 141 }
 142
 143 static int mlxsw_m_reset(struct net_device *netdev, u32 *flags)
 144 {
 145         struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
 146         struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
 147
 148         return mlxsw_env_reset_module(netdev, core, mlxsw_m_port->slot_index,
 149                                       mlxsw_m_port->module,
 150                                       flags);
 151 }
 152
 153 static int
 154 mlxsw_m_get_module_power_mode(struct net_device *netdev,
 155                               struct ethtool_module_power_mode_params *params,
 156                               struct netlink_ext_ack *extack)
 157 {
 158         struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
 159         struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
 160
 161         return mlxsw_env_get_module_power_mode(core, mlxsw_m_port->slot_index,
 162                                                mlxsw_m_port->module,
 163                                                params, extack);
 164 }
 165
 166 static int
 167 mlxsw_m_set_module_power_mode(struct net_device *netdev,
 168                               const struct ethtool_module_power_mode_params *params,
 169                               struct netlink_ext_ack *extack)
 170 {
 171         struct mlxsw_m_port *mlxsw_m_port = netdev_priv(netdev);
 172         struct mlxsw_core *core = mlxsw_m_port->mlxsw_m->core;
 173
 174         return mlxsw_env_set_module_power_mode(core, mlxsw_m_port->slot_index,
 175                                                mlxsw_m_port->module,
 176                                                params->policy, extack);
 177 }
 178
 179 static const struct ethtool_ops mlxsw_m_port_ethtool_ops = {
 180         .get_drvinfo            = mlxsw_m_module_get_drvinfo,
 181         .get_module_info        = mlxsw_m_get_module_info,
 182         .get_module_eeprom      = mlxsw_m_get_module_eeprom,
 183         .get_module_eeprom_by_page = mlxsw_m_get_module_eeprom_by_page,
 184         .reset                  = mlxsw_m_reset,
 185         .get_module_power_mode  = mlxsw_m_get_module_power_mode,
 186         .set_module_power_mode  = mlxsw_m_set_module_power_mode,
 187 };
 188
 189 static int
 190 mlxsw_m_port_module_info_get(struct mlxsw_m *mlxsw_m, u16 local_port,
 191                              u8 *p_module, u8 *p_width, u8 *p_slot_index)
 192 {
 193         char pmlp_pl[MLXSW_REG_PMLP_LEN];
 194         int err;
 195
 196         mlxsw_reg_pmlp_pack(pmlp_pl, local_port);
 197         err = mlxsw_reg_query(mlxsw_m->core, MLXSW_REG(pmlp), pmlp_pl);
 198         if (err)
 199                 return err;
 200         *p_module = mlxsw_reg_pmlp_module_get(pmlp_pl, 0);
 201         *p_width = mlxsw_reg_pmlp_width_get(pmlp_pl);
 202         *p_slot_index = mlxsw_reg_pmlp_slot_index_get(pmlp_pl, 0);
 203
 204         return 0;
 205 }
 206
 207 static int
 208 mlxsw_m_port_dev_addr_get(struct mlxsw_m_port *mlxsw_m_port)
 209 {
 210         struct mlxsw_m *mlxsw_m = mlxsw_m_port->mlxsw_m;
 211         char ppad_pl[MLXSW_REG_PPAD_LEN];
 212         u8 addr[ETH_ALEN];
 213         int err;
 214
 215         mlxsw_reg_ppad_pack(ppad_pl, false, 0);
 216         err = mlxsw_reg_query(mlxsw_m->core, MLXSW_REG(ppad), ppad_pl);
 217         if (err)
 218                 return err;
 219         mlxsw_reg_ppad_mac_memcpy_from(ppad_pl, addr);
 220         eth_hw_addr_gen(mlxsw_m_port->dev, addr, mlxsw_m_port->module + 1 +
 221                         mlxsw_m_port->module_offset);
 222         return 0;
 223 }
 224
 225 static bool mlxsw_m_port_created(struct mlxsw_m *mlxsw_m, u16 local_port)
 226 {
 227         return mlxsw_m->ports[local_port];
 228 }
 229
 230 static int
 231 mlxsw_m_port_create(struct mlxsw_m *mlxsw_m, u16 local_port, u8 slot_index,
 232                     u8 module)
 233 {
 234         struct mlxsw_m_port *mlxsw_m_port;
 235         struct net_device *dev;
 236         int err;
 237
 238         err = mlxsw_core_port_init(mlxsw_m->core, local_port, slot_index,
 239                                    module + 1, false, 0, false,
 240                                    0, mlxsw_m->base_mac,
 241                                    sizeof(mlxsw_m->base_mac));
 242         if (err) {
 243                 dev_err(mlxsw_m->bus_info->dev, "Port %d: Failed to init core port\n",
 244                         local_port);
 245                 return err;
 246         }
 247
 248         dev = alloc_etherdev(sizeof(struct mlxsw_m_port));
 249         if (!dev) {
 250                 err = -ENOMEM;
 251                 goto err_alloc_etherdev;
 252         }
 253
 254         SET_NETDEV_DEV(dev, mlxsw_m->bus_info->dev);
 255         dev_net_set(dev, mlxsw_core_net(mlxsw_m->core));
 256         mlxsw_m_port = netdev_priv(dev);
 257         mlxsw_core_port_netdev_link(mlxsw_m->core, local_port,
 258                                     mlxsw_m_port, dev);
 259         mlxsw_m_port->dev = dev;
 260         mlxsw_m_port->mlxsw_m = mlxsw_m;
 261         mlxsw_m_port->local_port = local_port;
 262         mlxsw_m_port->module = module;
 263         mlxsw_m_port->slot_index = slot_index;
 264         /* Add module offset for line card. Offset for main board iz zero.
 265          * For line card in slot #n offset is calculated as (#n - 1)
 266          * multiplied by maximum modules number, which could be found on a line
 267          * card.
 268          */
 269         mlxsw_m_port->module_offset = mlxsw_m_port->slot_index ?
 270                                       (mlxsw_m_port->slot_index - 1) *
 271                                       mlxsw_m->max_modules_per_slot : 0;
 272
 273         dev->netdev_ops = &mlxsw_m_port_netdev_ops;
 274         dev->ethtool_ops = &mlxsw_m_port_ethtool_ops;
 275
 276         err = mlxsw_m_port_dev_addr_get(mlxsw_m_port);
 277         if (err) {
 278                 dev_err(mlxsw_m->bus_info->dev, "Port %d: Unable to get port mac address\n",
 279                         mlxsw_m_port->local_port);
 280                 goto err_dev_addr_get;
 281         }
 282
 283         netif_carrier_off(dev);
 284         mlxsw_m->ports[local_port] = mlxsw_m_port;
 285         err = register_netdev(dev);
 286         if (err) {
 287                 dev_err(mlxsw_m->bus_info->dev, "Port %d: Failed to register netdev\n",
 288                         mlxsw_m_port->local_port);
 289                 goto err_register_netdev;
 290         }
 291
 292         return 0;
 293
 294 err_register_netdev:
 295         mlxsw_m->ports[local_port] = NULL;
 296 err_dev_addr_get:
 297         free_netdev(dev);
 298 err_alloc_etherdev:
 299         mlxsw_core_port_fini(mlxsw_m->core, local_port);
 300         return err;
 301 }
 302
 303 static void mlxsw_m_port_remove(struct mlxsw_m *mlxsw_m, u16 local_port)
 304 {
 305         struct mlxsw_m_port *mlxsw_m_port = mlxsw_m->ports[local_port];
 306
 307         unregister_netdev(mlxsw_m_port->dev); /* This calls ndo_stop */
 308         mlxsw_m->ports[local_port] = NULL;
 309         free_netdev(mlxsw_m_port->dev);
 310         mlxsw_core_port_fini(mlxsw_m->core, local_port);
 311 }
 312
 313 static int*
 314 mlxsw_m_port_mapping_get(struct mlxsw_m *mlxsw_m, u8 slot_index, u8 module)
 315 {
 316         return &mlxsw_m->line_cards[slot_index]->module_to_port[module];
 317 }
 318
 319 static int mlxsw_m_port_module_map(struct mlxsw_m *mlxsw_m, u16 local_port,
 320                                    u8 *last_module)
 321 {
 322         unsigned int max_ports = mlxsw_core_max_ports(mlxsw_m->core);
 323         u8 module, width, slot_index;
 324         int *module_to_port;
 325         int err;
 326
 327         /* Fill out to local port mapping array */
 328         err = mlxsw_m_port_module_info_get(mlxsw_m, local_port, &module,
 329                                            &width, &slot_index);
 330         if (err)
 331                 return err;
 332
 333         /* Skip if line card has been already configured */
 334         if (mlxsw_m->line_cards[slot_index]->active)
 335                 return 0;
 336         if (!width)
 337                 return 0;
 338         /* Skip, if port belongs to the cluster */
 339         if (module == *last_module)
 340                 return 0;
 341         *last_module = module;
 342
 343         if (WARN_ON_ONCE(module >= max_ports))
 344                 return -EINVAL;
 345         mlxsw_env_module_port_map(mlxsw_m->core, slot_index, module);
 346         module_to_port = mlxsw_m_port_mapping_get(mlxsw_m, slot_index, module);
 347         *module_to_port = local_port;
 348
 349         return 0;
 350 }
 351
 352 static void
 353 mlxsw_m_port_module_unmap(struct mlxsw_m *mlxsw_m, u8 slot_index, u8 module)
 354 {
 355         int *module_to_port = mlxsw_m_port_mapping_get(mlxsw_m, slot_index,
 356                                                        module);
 357         *module_to_port = -1;
 358         mlxsw_env_module_port_unmap(mlxsw_m->core, slot_index, module);
 359 }
 360
 361 static int mlxsw_m_linecards_init(struct mlxsw_m *mlxsw_m)
 362 {
 363         unsigned int max_ports = mlxsw_core_max_ports(mlxsw_m->core);
 364         char mgpir_pl[MLXSW_REG_MGPIR_LEN];
 365         u8 num_of_modules;
 366         int i, j, err;
 367
 368         mlxsw_reg_mgpir_pack(mgpir_pl, 0);
 369         err = mlxsw_reg_query(mlxsw_m->core, MLXSW_REG(mgpir), mgpir_pl);
 370         if (err)
 371                 return err;
 372
 373         mlxsw_reg_mgpir_unpack(mgpir_pl, NULL, NULL, NULL, &num_of_modules,
 374                                &mlxsw_m->num_of_slots);
 375         /* If the system is modular, get the maximum number of modules per-slot.
 376          * Otherwise, get the maximum number of modules on the main board.
 377          */
 378         if (mlxsw_m->num_of_slots)
 379                 mlxsw_m->max_modules_per_slot =
 380                         mlxsw_reg_mgpir_max_modules_per_slot_get(mgpir_pl);
 381         else
 382                 mlxsw_m->max_modules_per_slot = num_of_modules;
 383         /* Add slot for main board. */
 384         mlxsw_m->num_of_slots += 1;
 385
 386         mlxsw_m->ports = kcalloc(max_ports, sizeof(*mlxsw_m->ports),
 387                                  GFP_KERNEL);
 388         if (!mlxsw_m->ports)
 389                 return -ENOMEM;
 390
 391         mlxsw_m->line_cards = kcalloc(mlxsw_m->num_of_slots,
 392                                       sizeof(*mlxsw_m->line_cards),
 393                                       GFP_KERNEL);
 394         if (!mlxsw_m->line_cards) {
 395                 err = -ENOMEM;
 396                 goto err_kcalloc;
 397         }
 398
 399         for (i = 0; i < mlxsw_m->num_of_slots; i++) {
 400                 mlxsw_m->line_cards[i] =
 401                         kzalloc(struct_size(mlxsw_m->line_cards[i],
 402                                             module_to_port,
 403                                             mlxsw_m->max_modules_per_slot),
 404                                 GFP_KERNEL);
 405                 if (!mlxsw_m->line_cards[i]) {
 406                         err = -ENOMEM;
 407                         goto err_kmalloc_array;
 408                 }
 409
 410                 /* Invalidate the entries of module to local port mapping array. */
 411                 for (j = 0; j < mlxsw_m->max_modules_per_slot; j++)
 412                         mlxsw_m->line_cards[i]->module_to_port[j] = -1;
 413         }
 414
 415         return 0;
 416
 417 err_kmalloc_array:
 418         for (i--; i >= 0; i--)
 419                 kfree(mlxsw_m->line_cards[i]);
 420         kfree(mlxsw_m->line_cards);
 421 err_kcalloc:
 422         kfree(mlxsw_m->ports);
 423         return err;
 424 }
 425
 426 static void mlxsw_m_linecards_fini(struct mlxsw_m *mlxsw_m)
 427 {
 428         int i = mlxsw_m->num_of_slots;
 429
 430         for (i--; i >= 0; i--)
 431                 kfree(mlxsw_m->line_cards[i]);
 432         kfree(mlxsw_m->line_cards);
 433         kfree(mlxsw_m->ports);
 434 }
 435
 436 static void
 437 mlxsw_m_linecard_port_module_unmap(struct mlxsw_m *mlxsw_m, u8 slot_index)
 438 {
 439         int i;
 440
 441         for (i = mlxsw_m->max_modules_per_slot - 1; i >= 0; i--) {
 442                 int *module_to_port;
 443
 444                 module_to_port = mlxsw_m_port_mapping_get(mlxsw_m, slot_index, i);
 445                 if (*module_to_port > 0)
 446                         mlxsw_m_port_module_unmap(mlxsw_m, slot_index, i);
 447         }
 448 }
 449
 450 static int
 451 mlxsw_m_linecard_ports_create(struct mlxsw_m *mlxsw_m, u8 slot_index)
 452 {
 453         int *module_to_port;
 454         int i, err;
 455
 456         for (i = 0; i < mlxsw_m->max_modules_per_slot; i++) {
 457                 module_to_port = mlxsw_m_port_mapping_get(mlxsw_m, slot_index, i);
 458                 if (*module_to_port > 0) {
 459                         err = mlxsw_m_port_create(mlxsw_m, *module_to_port,
 460                                                   slot_index, i);
 461                         if (err)
 462                                 goto err_port_create;
 463                         /* Mark slot as active */
 464                         if (!mlxsw_m->line_cards[slot_index]->active)
 465                                 mlxsw_m->line_cards[slot_index]->active = true;
 466                 }
 467         }
 468         return 0;
 469
 470 err_port_create:
 471         for (i--; i >= 0; i--) {
 472                 module_to_port = mlxsw_m_port_mapping_get(mlxsw_m, slot_index, i);
 473                 if (*module_to_port > 0 &&
 474                     mlxsw_m_port_created(mlxsw_m, *module_to_port)) {
 475                         mlxsw_m_port_remove(mlxsw_m, *module_to_port);
 476                         /* Mark slot as inactive */
 477                         if (mlxsw_m->line_cards[slot_index]->active)
 478                                 mlxsw_m->line_cards[slot_index]->active = false;
 479                 }
 480         }
 481         return err;
 482 }
 483
 484 static void
 485 mlxsw_m_linecard_ports_remove(struct mlxsw_m *mlxsw_m, u8 slot_index)
 486 {
 487         int i;
 488
 489         for (i = 0; i < mlxsw_m->max_modules_per_slot; i++) {
 490                 int *module_to_port = mlxsw_m_port_mapping_get(mlxsw_m,
 491                                                                slot_index, i);
 492
 493                 if (*module_to_port > 0 &&
 494                     mlxsw_m_port_created(mlxsw_m, *module_to_port)) {
 495                         mlxsw_m_port_remove(mlxsw_m, *module_to_port);
 496                         mlxsw_m_port_module_unmap(mlxsw_m, slot_index, i);
 497                 }
 498         }
 499 }
 500
 501 static int mlxsw_m_ports_module_map(struct mlxsw_m *mlxsw_m)
 502 {
 503         unsigned int max_ports = mlxsw_core_max_ports(mlxsw_m->core);
 504         u8 last_module = max_ports;
 505         int i, err;
 506
 507         for (i = 1; i < max_ports; i++) {
 508                 err = mlxsw_m_port_module_map(mlxsw_m, i, &last_module);
 509                 if (err)
 510                         return err;
 511         }
 512
 513         return 0;
 514 }
 515
 516 static int mlxsw_m_ports_create(struct mlxsw_m *mlxsw_m)
 517 {
 518         int err;
 519
 520         /* Fill out module to local port mapping array */
 521         err = mlxsw_m_ports_module_map(mlxsw_m);
 522         if (err)
 523                 goto err_ports_module_map;
 524
 525         /* Create port objects for each valid entry */
 526         err = mlxsw_m_linecard_ports_create(mlxsw_m, 0);
 527         if (err)
 528                 goto err_linecard_ports_create;
 529
 530         return 0;
 531
 532 err_linecard_ports_create:
 533 err_ports_module_map:
 534         mlxsw_m_linecard_port_module_unmap(mlxsw_m, 0);
 535
 536         return err;
 537 }
 538
 539 static void mlxsw_m_ports_remove(struct mlxsw_m *mlxsw_m)
 540 {
 541         mlxsw_m_linecard_ports_remove(mlxsw_m, 0);
 542 }
 543
 544 static void
 545 mlxsw_m_ports_remove_selected(struct mlxsw_core *mlxsw_core,
 546                               bool (*selector)(void *priv, u16 local_port),
 547                               void *priv)
 548 {
 549         struct mlxsw_m *mlxsw_m = mlxsw_core_driver_priv(mlxsw_core);
 550         struct mlxsw_linecard *linecard_priv = priv;
 551         struct mlxsw_m_line_card *linecard;
 552
 553         linecard = mlxsw_m->line_cards[linecard_priv->slot_index];
 554
 555         if (WARN_ON(!linecard->active))
 556                 return;
 557
 558         mlxsw_m_linecard_ports_remove(mlxsw_m, linecard_priv->slot_index);
 559         linecard->active = false;
 560 }
 561
 562 static int mlxsw_m_fw_rev_validate(struct mlxsw_m *mlxsw_m)
 563 {
 564         const struct mlxsw_fw_rev *rev = &mlxsw_m->bus_info->fw_rev;
 565
 566         /* Validate driver and FW are compatible.
 567          * Do not check major version, since it defines chip type, while
 568          * driver is supposed to support any type.
 569          */
 570         if (mlxsw_core_fw_rev_minor_subminor_validate(rev, &mlxsw_m_fw_rev))
 571                 return 0;
 572
 573         dev_err(mlxsw_m->bus_info->dev, "The firmware version %d.%d.%d is incompatible with the driver (required >= %d.%d.%d)\n",
 574                 rev->major, rev->minor, rev->subminor, rev->major,
 575                 mlxsw_m_fw_rev.minor, mlxsw_m_fw_rev.subminor);
 576
 577         return -EINVAL;
 578 }
 579
 580 static void
 581 mlxsw_m_got_active(struct mlxsw_core *mlxsw_core, u8 slot_index, void *priv)
 582 {
 583         struct mlxsw_m_line_card *linecard;
 584         struct mlxsw_m *mlxsw_m = priv;
 585         int err;
 586
 587         linecard = mlxsw_m->line_cards[slot_index];
 588         /* Skip if line card has been already configured during init */
 589         if (linecard->active)
 590                 return;
 591
 592         /* Fill out module to local port mapping array */
 593         err = mlxsw_m_ports_module_map(mlxsw_m);
 594         if (err)
 595                 goto err_ports_module_map;
 596
 597         /* Create port objects for each valid entry */
 598         err = mlxsw_m_linecard_ports_create(mlxsw_m, slot_index);
 599         if (err) {
 600                 dev_err(mlxsw_m->bus_info->dev, "Failed to create port for line card at slot %d\n",
 601                         slot_index);
 602                 goto err_linecard_ports_create;
 603         }
 604
 605         linecard->active = true;
 606
 607         return;
 608
 609 err_linecard_ports_create:
 610 err_ports_module_map:
 611         mlxsw_m_linecard_port_module_unmap(mlxsw_m, slot_index);
 612 }
 613
 614 static void
 615 mlxsw_m_got_inactive(struct mlxsw_core *mlxsw_core, u8 slot_index, void *priv)
 616 {
 617         struct mlxsw_m_line_card *linecard;
 618         struct mlxsw_m *mlxsw_m = priv;
 619
 620         linecard = mlxsw_m->line_cards[slot_index];
 621
 622         if (WARN_ON(!linecard->active))
 623                 return;
 624
 625         mlxsw_m_linecard_ports_remove(mlxsw_m, slot_index);
 626         linecard->active = false;
 627 }
 628
 629 static struct mlxsw_linecards_event_ops mlxsw_m_event_ops = {
 630         .got_active = mlxsw_m_got_active,
 631         .got_inactive = mlxsw_m_got_inactive,
 632 };
 633
 634 static int mlxsw_m_init(struct mlxsw_core *mlxsw_core,
 635                         const struct mlxsw_bus_info *mlxsw_bus_info,
 636                         struct netlink_ext_ack *extack)
 637 {
 638         struct mlxsw_m *mlxsw_m = mlxsw_core_driver_priv(mlxsw_core);
 639         int err;
 640
 641         mlxsw_m->core = mlxsw_core;
 642         mlxsw_m->bus_info = mlxsw_bus_info;
 643
 644         err = mlxsw_m_fw_rev_validate(mlxsw_m);
 645         if (err)
 646                 return err;
 647
 648         err = mlxsw_m_base_mac_get(mlxsw_m);
 649         if (err) {
 650                 dev_err(mlxsw_m->bus_info->dev, "Failed to get base mac\n");
 651                 return err;
 652         }
 653
 654         err = mlxsw_m_linecards_init(mlxsw_m);
 655         if (err) {
 656                 dev_err(mlxsw_m->bus_info->dev, "Failed to create line cards\n");
 657                 return err;
 658         }
 659
 660         err = mlxsw_linecards_event_ops_register(mlxsw_core,
 661                                                  &mlxsw_m_event_ops, mlxsw_m);
 662         if (err) {
 663                 dev_err(mlxsw_m->bus_info->dev, "Failed to register line cards operations\n");
 664                 goto linecards_event_ops_register;
 665         }
 666
 667         err = mlxsw_m_ports_create(mlxsw_m);
 668         if (err) {
 669                 dev_err(mlxsw_m->bus_info->dev, "Failed to create ports\n");
 670                 goto err_ports_create;
 671         }
 672
 673         return 0;
 674
 675 err_ports_create:
 676         mlxsw_linecards_event_ops_unregister(mlxsw_core,
 677                                              &mlxsw_m_event_ops, mlxsw_m);
 678 linecards_event_ops_register:
 679         mlxsw_m_linecards_fini(mlxsw_m);
 680         return err;
 681 }
 682
 683 static void mlxsw_m_fini(struct mlxsw_core *mlxsw_core)
 684 {
 685         struct mlxsw_m *mlxsw_m = mlxsw_core_driver_priv(mlxsw_core);
 686
 687         mlxsw_m_ports_remove(mlxsw_m);
 688         mlxsw_linecards_event_ops_unregister(mlxsw_core,
 689                                              &mlxsw_m_event_ops, mlxsw_m);
 690         mlxsw_m_linecards_fini(mlxsw_m);
 691 }
 692
 693 static const struct mlxsw_config_profile mlxsw_m_config_profile;
 694
 695 static struct mlxsw_driver mlxsw_m_driver = {
 696         .kind                   = mlxsw_m_driver_name,
 697         .priv_size              = sizeof(struct mlxsw_m),
 698         .init                   = mlxsw_m_init,
 699         .fini                   = mlxsw_m_fini,
 700         .ports_remove_selected  = mlxsw_m_ports_remove_selected,
 701         .profile                = &mlxsw_m_config_profile,
 702 };
 703
 704 static const struct i2c_device_id mlxsw_m_i2c_id[] = {
 705         { "mlxsw_minimal", 0},
 706         { },
 707 };
 708
 709 static struct i2c_driver mlxsw_m_i2c_driver = {
 710         .driver.name = "mlxsw_minimal",
 711         .class = I2C_CLASS_HWMON,
 712         .id_table = mlxsw_m_i2c_id,
 713 };
 714
 715 static int __init mlxsw_m_module_init(void)
 716 {
 717         int err;
 718
 719         err = mlxsw_core_driver_register(&mlxsw_m_driver);
 720         if (err)
 721                 return err;
 722
 723         err = mlxsw_i2c_driver_register(&mlxsw_m_i2c_driver);
 724         if (err)
 725                 goto err_i2c_driver_register;
 726
 727         return 0;
 728
 729 err_i2c_driver_register:
 730         mlxsw_core_driver_unregister(&mlxsw_m_driver);
 731
 732         return err;
 733 }
 734
 735 static void __exit mlxsw_m_module_exit(void)
 736 {
 737         mlxsw_i2c_driver_unregister(&mlxsw_m_i2c_driver);
 738         mlxsw_core_driver_unregister(&mlxsw_m_driver);
 739 }
 740
 741 module_init(mlxsw_m_module_init);
 742 module_exit(mlxsw_m_module_exit);
 743
 744 MODULE_LICENSE("Dual BSD/GPL");
 745 MODULE_AUTHOR("Vadim Pasternak <vadimp@mellanox.com>");
 746 MODULE_DESCRIPTION("Mellanox minimal driver");
 747 MODULE_DEVICE_TABLE(i2c, mlxsw_m_i2c_id);