drivers/platform/mellanox/mlxreg-lc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Nvidia line card driver
   4  *
   5  * Copyright (C) 2020 Nvidia Technologies Ltd.
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/i2c.h>
  10 #include <linux/module.h>
  11 #include <linux/platform_data/mlxcpld.h>
  12 #include <linux/platform_data/mlxreg.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/regmap.h>
  15
  16 /* I2C bus IO offsets */
  17 #define MLXREG_LC_REG_CPLD1_VER_OFFSET          0x2500
  18 #define MLXREG_LC_REG_FPGA1_VER_OFFSET          0x2501
  19 #define MLXREG_LC_REG_CPLD1_PN_OFFSET           0x2504
  20 #define MLXREG_LC_REG_FPGA1_PN_OFFSET           0x2506
  21 #define MLXREG_LC_REG_RESET_CAUSE_OFFSET        0x251d
  22 #define MLXREG_LC_REG_LED1_OFFSET               0x2520
  23 #define MLXREG_LC_REG_GP0_OFFSET                0x252e
  24 #define MLXREG_LC_REG_FIELD_UPGRADE             0x2534
  25 #define MLXREG_LC_CHANNEL_I2C_REG               0x25dc
  26 #define MLXREG_LC_REG_CPLD1_MVER_OFFSET         0x25de
  27 #define MLXREG_LC_REG_FPGA1_MVER_OFFSET         0x25df
  28 #define MLXREG_LC_REG_MAX_POWER_OFFSET          0x25f1
  29 #define MLXREG_LC_REG_CONFIG_OFFSET             0x25fb
  30 #define MLXREG_LC_REG_MAX                       0x3fff
  31
  32 /**
  33  * enum mlxreg_lc_type - line cards types
  34  *
  35  * @MLXREG_LC_SN4800_C16: 100GbE line card with 16 QSFP28 ports;
  36  */
  37 enum mlxreg_lc_type {
  38         MLXREG_LC_SN4800_C16 = 0x0000,
  39 };
  40
  41 /**
  42  * enum mlxreg_lc_state - line cards state
  43  *
  44  * @MLXREG_LC_INITIALIZED: line card is initialized;
  45  * @MLXREG_LC_POWERED: line card is powered;
  46  * @MLXREG_LC_SYNCED: line card is synchronized between hardware and firmware;
  47  */
  48 enum mlxreg_lc_state {
  49         MLXREG_LC_INITIALIZED = BIT(0),
  50         MLXREG_LC_POWERED = BIT(1),
  51         MLXREG_LC_SYNCED = BIT(2),
  52 };
  53
  54 #define MLXREG_LC_CONFIGURED    (MLXREG_LC_INITIALIZED | MLXREG_LC_POWERED | MLXREG_LC_SYNCED)
  55
  56 /* mlxreg_lc - device private data
  57  * @dev: platform device;
  58  * @lock: line card lock;
  59  * @par_regmap: parent device regmap handle;
  60  * @data: pltaform core data;
  61  * @io_data: register access platform data;
  62  * @led_data: LED platform data ;
  63  * @mux_data: MUX platform data;
  64  * @led: LED device;
  65  * @io_regs: register access device;
  66  * @mux_brdinfo: mux configuration;
  67  * @mux: mux devices;
  68  * @aux_devs: I2C devices feeding by auxiliary power;
  69  * @aux_devs_num: number of I2C devices feeding by auxiliary power;
  70  * @main_devs: I2C devices feeding by main power;
  71  * @main_devs_num: number of I2C devices feeding by main power;
  72  * @state: line card state;
  73  */
  74 struct mlxreg_lc {
  75         struct device *dev;
  76         struct mutex lock; /* line card access lock */
  77         void *par_regmap;
  78         struct mlxreg_core_data *data;
  79         struct mlxreg_core_platform_data *io_data;
  80         struct mlxreg_core_platform_data *led_data;
  81         struct mlxcpld_mux_plat_data *mux_data;
  82         struct platform_device *led;
  83         struct platform_device *io_regs;
  84         struct i2c_board_info *mux_brdinfo;
  85         struct platform_device *mux;
  86         struct mlxreg_hotplug_device *aux_devs;
  87         int aux_devs_num;
  88         struct mlxreg_hotplug_device *main_devs;
  89         int main_devs_num;
  90         enum mlxreg_lc_state state;
  91 };
  92
  93 static bool mlxreg_lc_writeable_reg(struct device *dev, unsigned int reg)
  94 {
  95         switch (reg) {
  96         case MLXREG_LC_REG_LED1_OFFSET:
  97         case MLXREG_LC_REG_GP0_OFFSET:
  98         case MLXREG_LC_REG_FIELD_UPGRADE:
  99         case MLXREG_LC_CHANNEL_I2C_REG:
 100                 return true;
 101         }
 102         return false;
 103 }
 104
 105 static bool mlxreg_lc_readable_reg(struct device *dev, unsigned int reg)
 106 {
 107         switch (reg) {
 108         case MLXREG_LC_REG_CPLD1_VER_OFFSET:
 109         case MLXREG_LC_REG_FPGA1_VER_OFFSET:
 110         case MLXREG_LC_REG_CPLD1_PN_OFFSET:
 111         case MLXREG_LC_REG_FPGA1_PN_OFFSET:
 112         case MLXREG_LC_REG_RESET_CAUSE_OFFSET:
 113         case MLXREG_LC_REG_LED1_OFFSET:
 114         case MLXREG_LC_REG_GP0_OFFSET:
 115         case MLXREG_LC_REG_FIELD_UPGRADE:
 116         case MLXREG_LC_CHANNEL_I2C_REG:
 117         case MLXREG_LC_REG_CPLD1_MVER_OFFSET:
 118         case MLXREG_LC_REG_FPGA1_MVER_OFFSET:
 119         case MLXREG_LC_REG_MAX_POWER_OFFSET:
 120         case MLXREG_LC_REG_CONFIG_OFFSET:
 121                 return true;
 122         }
 123         return false;
 124 }
 125
 126 static bool mlxreg_lc_volatile_reg(struct device *dev, unsigned int reg)
 127 {
 128         switch (reg) {
 129         case MLXREG_LC_REG_CPLD1_VER_OFFSET:
 130         case MLXREG_LC_REG_FPGA1_VER_OFFSET:
 131         case MLXREG_LC_REG_CPLD1_PN_OFFSET:
 132         case MLXREG_LC_REG_FPGA1_PN_OFFSET:
 133         case MLXREG_LC_REG_RESET_CAUSE_OFFSET:
 134         case MLXREG_LC_REG_LED1_OFFSET:
 135         case MLXREG_LC_REG_GP0_OFFSET:
 136         case MLXREG_LC_REG_FIELD_UPGRADE:
 137         case MLXREG_LC_CHANNEL_I2C_REG:
 138         case MLXREG_LC_REG_CPLD1_MVER_OFFSET:
 139         case MLXREG_LC_REG_FPGA1_MVER_OFFSET:
 140         case MLXREG_LC_REG_MAX_POWER_OFFSET:
 141         case MLXREG_LC_REG_CONFIG_OFFSET:
 142                 return true;
 143         }
 144         return false;
 145 }
 146
 147 static const struct reg_default mlxreg_lc_regmap_default[] = {
 148         { MLXREG_LC_CHANNEL_I2C_REG, 0x00 },
 149 };
 150
 151 /* Configuration for the register map of a device with 2 bytes address space. */
 152 static const struct regmap_config mlxreg_lc_regmap_conf = {
 153         .reg_bits = 16,
 154         .val_bits = 8,
 155         .max_register = MLXREG_LC_REG_MAX,
 156         .cache_type = REGCACHE_FLAT,
 157         .writeable_reg = mlxreg_lc_writeable_reg,
 158         .readable_reg = mlxreg_lc_readable_reg,
 159         .volatile_reg = mlxreg_lc_volatile_reg,
 160         .reg_defaults = mlxreg_lc_regmap_default,
 161         .num_reg_defaults = ARRAY_SIZE(mlxreg_lc_regmap_default),
 162 };
 163
 164 /* Default channels vector.
 165  * It contains only the channels, which physically connected to the devices,
 166  * empty channels are skipped.
 167  */
 168 static int mlxreg_lc_chan[] = {
 169         0x04, 0x05, 0x06, 0x07, 0x08, 0x10, 0x20, 0x21, 0x22, 0x23, 0x40, 0x41,
 170         0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
 171         0x4e, 0x4f
 172 };
 173
 174 /* Defaul mux configuration. */
 175 static struct mlxcpld_mux_plat_data mlxreg_lc_mux_data[] = {
 176         {
 177                 .chan_ids = mlxreg_lc_chan,
 178                 .num_adaps = ARRAY_SIZE(mlxreg_lc_chan),
 179                 .sel_reg_addr = MLXREG_LC_CHANNEL_I2C_REG,
 180                 .reg_size = 2,
 181         },
 182 };
 183
 184 /* Defaul mux board info. */
 185 static struct i2c_board_info mlxreg_lc_mux_brdinfo = {
 186         I2C_BOARD_INFO("i2c-mux-mlxcpld", 0x32),
 187 };
 188
 189 /* Line card default auxiliary power static devices. */
 190 static struct i2c_board_info mlxreg_lc_aux_pwr_devices[] = {
 191         {
 192                 I2C_BOARD_INFO("24c32", 0x51),
 193         },
 194         {
 195                 I2C_BOARD_INFO("24c32", 0x51),
 196         },
 197 };
 198
 199 /* Line card default auxiliary power board info. */
 200 static struct mlxreg_hotplug_device mlxreg_lc_aux_pwr_brdinfo[] = {
 201         {
 202                 .brdinfo = &mlxreg_lc_aux_pwr_devices[0],
 203                 .nr = 3,
 204         },
 205         {
 206                 .brdinfo = &mlxreg_lc_aux_pwr_devices[1],
 207                 .nr = 4,
 208         },
 209 };
 210
 211 /* Line card default main power static devices. */
 212 static struct i2c_board_info mlxreg_lc_main_pwr_devices[] = {
 213         {
 214                 I2C_BOARD_INFO("mp2975", 0x62),
 215         },
 216         {
 217                 I2C_BOARD_INFO("mp2975", 0x64),
 218         },
 219         {
 220                 I2C_BOARD_INFO("max11603", 0x6d),
 221         },
 222         {
 223                 I2C_BOARD_INFO("lm25066", 0x15),
 224         },
 225 };
 226
 227 /* Line card default main power board info. */
 228 static struct mlxreg_hotplug_device mlxreg_lc_main_pwr_brdinfo[] = {
 229         {
 230                 .brdinfo = &mlxreg_lc_main_pwr_devices[0],
 231                 .nr = 0,
 232         },
 233         {
 234                 .brdinfo = &mlxreg_lc_main_pwr_devices[1],
 235                 .nr = 0,
 236         },
 237         {
 238                 .brdinfo = &mlxreg_lc_main_pwr_devices[2],
 239                 .nr = 1,
 240         },
 241         {
 242                 .brdinfo = &mlxreg_lc_main_pwr_devices[3],
 243                 .nr = 2,
 244         },
 245 };
 246
 247 /* LED default data. */
 248 static struct mlxreg_core_data mlxreg_lc_led_data[] = {
 249         {
 250                 .label = "status:green",
 251                 .reg = MLXREG_LC_REG_LED1_OFFSET,
 252                 .mask = GENMASK(7, 4),
 253         },
 254         {
 255                 .label = "status:orange",
 256                 .reg = MLXREG_LC_REG_LED1_OFFSET,
 257                 .mask = GENMASK(7, 4),
 258         },
 259 };
 260
 261 static struct mlxreg_core_platform_data mlxreg_lc_led = {
 262         .identity = "pci",
 263         .data = mlxreg_lc_led_data,
 264         .counter = ARRAY_SIZE(mlxreg_lc_led_data),
 265 };
 266
 267 /* Default register access data. */
 268 static struct mlxreg_core_data mlxreg_lc_io_data[] = {
 269         {
 270                 .label = "cpld1_version",
 271                 .reg = MLXREG_LC_REG_CPLD1_VER_OFFSET,
 272                 .bit = GENMASK(7, 0),
 273                 .mode = 0444,
 274         },
 275         {
 276                 .label = "fpga1_version",
 277                 .reg = MLXREG_LC_REG_FPGA1_VER_OFFSET,
 278                 .bit = GENMASK(7, 0),
 279                 .mode = 0444,
 280         },
 281         {
 282                 .label = "cpld1_pn",
 283                 .reg = MLXREG_LC_REG_CPLD1_PN_OFFSET,
 284                 .bit = GENMASK(15, 0),
 285                 .mode = 0444,
 286                 .regnum = 2,
 287         },
 288         {
 289                 .label = "fpga1_pn",
 290                 .reg = MLXREG_LC_REG_FPGA1_PN_OFFSET,
 291                 .bit = GENMASK(15, 0),
 292                 .mode = 0444,
 293                 .regnum = 2,
 294         },
 295         {
 296                 .label = "cpld1_version_min",
 297                 .reg = MLXREG_LC_REG_CPLD1_MVER_OFFSET,
 298                 .bit = GENMASK(7, 0),
 299                 .mode = 0444,
 300         },
 301         {
 302                 .label = "fpga1_version_min",
 303                 .reg = MLXREG_LC_REG_FPGA1_MVER_OFFSET,
 304                 .bit = GENMASK(7, 0),
 305                 .mode = 0444,
 306         },
 307         {
 308                 .label = "reset_fpga_not_done",
 309                 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET,
 310                 .mask = GENMASK(7, 0) & ~BIT(1),
 311                 .mode = 0444,
 312         },
 313         {
 314                 .label = "reset_aux_pwr_or_ref",
 315                 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET,
 316                 .mask = GENMASK(7, 0) & ~BIT(2),
 317                 .mode = 0444,
 318         },
 319         {
 320                 .label = "reset_dc_dc_pwr_fail",
 321                 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET,
 322                 .mask = GENMASK(7, 0) & ~BIT(3),
 323                 .mode = 0444,
 324         },
 325         {
 326                 .label = "reset_from_chassis",
 327                 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET,
 328                 .mask = GENMASK(7, 0) & ~BIT(4),
 329                 .mode = 0444,
 330         },
 331         {
 332                 .label = "reset_pwr_off_from_chassis",
 333                 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET,
 334                 .mask = GENMASK(7, 0) & ~BIT(5),
 335                 .mode = 0444,
 336         },
 337         {
 338                 .label = "reset_line_card",
 339                 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET,
 340                 .mask = GENMASK(7, 0) & ~BIT(6),
 341                 .mode = 0444,
 342         },
 343         {
 344                 .label = "reset_line_card_pwr_en",
 345                 .reg = MLXREG_LC_REG_RESET_CAUSE_OFFSET,
 346                 .mask = GENMASK(7, 0) & ~BIT(7),
 347                 .mode = 0444,
 348         },
 349         {
 350                 .label = "cpld_upgrade_en",
 351                 .reg = MLXREG_LC_REG_FIELD_UPGRADE,
 352                 .mask = GENMASK(7, 0) & ~BIT(0),
 353                 .mode = 0644,
 354                 .secured = 1,
 355         },
 356         {
 357                 .label = "fpga_upgrade_en",
 358                 .reg = MLXREG_LC_REG_FIELD_UPGRADE,
 359                 .mask = GENMASK(7, 0) & ~BIT(1),
 360                 .mode = 0644,
 361                 .secured = 1,
 362         },
 363         {
 364                 .label = "qsfp_pwr_en",
 365                 .reg = MLXREG_LC_REG_GP0_OFFSET,
 366                 .mask = GENMASK(7, 0) & ~BIT(0),
 367                 .mode = 0644,
 368         },
 369         {
 370                 .label = "vpd_wp",
 371                 .reg = MLXREG_LC_REG_GP0_OFFSET,
 372                 .mask = GENMASK(7, 0) & ~BIT(3),
 373                 .mode = 0644,
 374                 .secured = 1,
 375         },
 376         {
 377                 .label = "agb_spi_burn_en",
 378                 .reg = MLXREG_LC_REG_GP0_OFFSET,
 379                 .mask = GENMASK(7, 0) & ~BIT(5),
 380                 .mode = 0644,
 381                 .secured = 1,
 382         },
 383         {
 384                 .label = "fpga_spi_burn_en",
 385                 .reg = MLXREG_LC_REG_GP0_OFFSET,
 386                 .mask = GENMASK(7, 0) & ~BIT(6),
 387                 .mode = 0644,
 388                 .secured = 1,
 389         },
 390         {
 391                 .label = "max_power",
 392                 .reg = MLXREG_LC_REG_MAX_POWER_OFFSET,
 393                 .bit = GENMASK(15, 0),
 394                 .mode = 0444,
 395                 .regnum = 2,
 396         },
 397         {
 398                 .label = "config",
 399                 .reg = MLXREG_LC_REG_CONFIG_OFFSET,
 400                 .bit = GENMASK(15, 0),
 401                 .mode = 0444,
 402                 .regnum = 2,
 403         },
 404 };
 405
 406 static struct mlxreg_core_platform_data mlxreg_lc_regs_io = {
 407         .data = mlxreg_lc_io_data,
 408         .counter = ARRAY_SIZE(mlxreg_lc_io_data),
 409 };
 410
 411 static int
 412 mlxreg_lc_create_static_devices(struct mlxreg_lc *mlxreg_lc, struct mlxreg_hotplug_device *devs,
 413                                 int size)
 414 {
 415         struct mlxreg_hotplug_device *dev = devs;
 416         int i, ret;
 417
 418         /* Create static I2C device feeding by auxiliary or main power. */
 419         for (i = 0; i < size; i++, dev++) {
 420                 dev->client = i2c_new_client_device(dev->adapter, dev->brdinfo);
 421                 if (IS_ERR(dev->client)) {
 422                         dev_err(mlxreg_lc->dev, "Failed to create client %s at bus %d at addr 0x%02x\n",
 423                                 dev->brdinfo->type, dev->nr, dev->brdinfo->addr);
 424
 425                         dev->adapter = NULL;
 426                         ret = PTR_ERR(dev->client);
 427                         goto fail_create_static_devices;
 428                 }
 429         }
 430
 431         return 0;
 432
 433 fail_create_static_devices:
 434         while (--i >= 0) {
 435                 dev = devs + i;
 436                 i2c_unregister_device(dev->client);
 437                 dev->client = NULL;
 438         }
 439         return ret;
 440 }
 441
 442 static void
 443 mlxreg_lc_destroy_static_devices(struct mlxreg_lc *mlxreg_lc, struct mlxreg_hotplug_device *devs,
 444                                  int size)
 445 {
 446         struct mlxreg_hotplug_device *dev = devs;
 447         int i;
 448
 449         /* Destroy static I2C device feeding by auxiliary or main power. */
 450         for (i = 0; i < size; i++, dev++) {
 451                 if (dev->client) {
 452                         i2c_unregister_device(dev->client);
 453                         dev->client = NULL;
 454                 }
 455         }
 456 }
 457
 458 static int mlxreg_lc_power_on_off(struct mlxreg_lc *mlxreg_lc, u8 action)
 459 {
 460         u32 regval;
 461         int err;
 462
 463         mutex_lock(&mlxreg_lc->lock);
 464
 465         err = regmap_read(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_pwr, &regval);
 466         if (err)
 467                 goto regmap_read_fail;
 468
 469         if (action)
 470                 regval |= BIT(mlxreg_lc->data->slot - 1);
 471         else
 472                 regval &= ~BIT(mlxreg_lc->data->slot - 1);
 473
 474         err = regmap_write(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_pwr, regval);
 475
 476 regmap_read_fail:
 477         mutex_unlock(&mlxreg_lc->lock);
 478         return err;
 479 }
 480
 481 static int mlxreg_lc_enable_disable(struct mlxreg_lc *mlxreg_lc, bool action)
 482 {
 483         u32 regval;
 484         int err;
 485
 486         /*
 487          * Hardware holds the line card after powering on in the disabled state. Holding line card
 488          * in disabled state protects access to the line components, like FPGA and gearboxes.
 489          * Line card should be enabled in order to get it in operational state. Line card could be
 490          * disabled for moving it to non-operational state. Enabling line card does not affect the
 491          * line card which is already has been enabled. Disabling does not affect the disabled line
 492          * card.
 493          */
 494         mutex_lock(&mlxreg_lc->lock);
 495
 496         err = regmap_read(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_ena, &regval);
 497         if (err)
 498                 goto regmap_read_fail;
 499
 500         if (action)
 501                 regval |= BIT(mlxreg_lc->data->slot - 1);
 502         else
 503                 regval &= ~BIT(mlxreg_lc->data->slot - 1);
 504
 505         err = regmap_write(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_ena, regval);
 506
 507 regmap_read_fail:
 508         mutex_unlock(&mlxreg_lc->lock);
 509         return err;
 510 }
 511
 512 static int
 513 mlxreg_lc_sn4800_c16_config_init(struct mlxreg_lc *mlxreg_lc, void *regmap,
 514                                  struct mlxreg_core_data *data)
 515 {
 516         struct device *dev = &data->hpdev.client->dev;
 517
 518         /* Set line card configuration according to the type. */
 519         mlxreg_lc->mux_data = mlxreg_lc_mux_data;
 520         mlxreg_lc->io_data = &mlxreg_lc_regs_io;
 521         mlxreg_lc->led_data = &mlxreg_lc_led;
 522         mlxreg_lc->mux_brdinfo = &mlxreg_lc_mux_brdinfo;
 523
 524         mlxreg_lc->aux_devs = devm_kmemdup(dev, mlxreg_lc_aux_pwr_brdinfo,
 525                                            sizeof(mlxreg_lc_aux_pwr_brdinfo), GFP_KERNEL);
 526         if (!mlxreg_lc->aux_devs)
 527                 return -ENOMEM;
 528         mlxreg_lc->aux_devs_num = ARRAY_SIZE(mlxreg_lc_aux_pwr_brdinfo);
 529         mlxreg_lc->main_devs = devm_kmemdup(dev, mlxreg_lc_main_pwr_brdinfo,
 530                                             sizeof(mlxreg_lc_main_pwr_brdinfo), GFP_KERNEL);
 531         if (!mlxreg_lc->main_devs)
 532                 return -ENOMEM;
 533         mlxreg_lc->main_devs_num = ARRAY_SIZE(mlxreg_lc_main_pwr_brdinfo);
 534
 535         return 0;
 536 }
 537
 538 static void
 539 mlxreg_lc_state_update(struct mlxreg_lc *mlxreg_lc, enum mlxreg_lc_state state, u8 action)
 540 {
 541         mutex_lock(&mlxreg_lc->lock);
 542
 543         if (action)
 544                 mlxreg_lc->state |= state;
 545         else
 546                 mlxreg_lc->state &= ~state;
 547
 548         mutex_unlock(&mlxreg_lc->lock);
 549 }
 550
 551 /*
 552  * Callback is to be called from mlxreg-hotplug driver to notify about line card about received
 553  * event.
 554  */
 555 static int mlxreg_lc_event_handler(void *handle, enum mlxreg_hotplug_kind kind, u8 action)
 556 {
 557         struct mlxreg_lc *mlxreg_lc = handle;
 558         int err = 0;
 559
 560         dev_info(mlxreg_lc->dev, "linecard#%d state %d event kind %d action %d\n",
 561                  mlxreg_lc->data->slot, mlxreg_lc->state, kind, action);
 562
 563         if (!(mlxreg_lc->state & MLXREG_LC_INITIALIZED))
 564                 return 0;
 565
 566         switch (kind) {
 567         case MLXREG_HOTPLUG_LC_SYNCED:
 568                 /*
 569                  * Synchronization event - hardware and firmware are synchronized. Power on/off
 570                  * line card - to allow/disallow main power source.
 571                  */
 572                 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_SYNCED, action);
 573                 /* Power line card if it is not powered yet. */
 574                 if (!(mlxreg_lc->state & MLXREG_LC_POWERED) && action) {
 575                         err = mlxreg_lc_power_on_off(mlxreg_lc, 1);
 576                         if (err)
 577                                 return err;
 578                 }
 579                 /* In case line card is configured - enable it. */
 580                 if (mlxreg_lc->state & MLXREG_LC_CONFIGURED && action)
 581                         err = mlxreg_lc_enable_disable(mlxreg_lc, 1);
 582                 break;
 583         case MLXREG_HOTPLUG_LC_POWERED:
 584                 /* Power event - attach or de-attach line card device feeding by the main power. */
 585                 if (action) {
 586                         /* Do not create devices, if line card is already powered. */
 587                         if (mlxreg_lc->state & MLXREG_LC_POWERED) {
 588                                 /* In case line card is configured - enable it. */
 589                                 if (mlxreg_lc->state & MLXREG_LC_CONFIGURED)
 590                                         err = mlxreg_lc_enable_disable(mlxreg_lc, 1);
 591                                 return err;
 592                         }
 593                         err = mlxreg_lc_create_static_devices(mlxreg_lc, mlxreg_lc->main_devs,
 594                                                               mlxreg_lc->main_devs_num);
 595                         if (err)
 596                                 return err;
 597
 598                         /* In case line card is already in ready state - enable it. */
 599                         if (mlxreg_lc->state & MLXREG_LC_CONFIGURED)
 600                                 err = mlxreg_lc_enable_disable(mlxreg_lc, 1);
 601                 } else {
 602                         mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->main_devs,
 603                                                          mlxreg_lc->main_devs_num);
 604                 }
 605                 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_POWERED, action);
 606                 break;
 607         case MLXREG_HOTPLUG_LC_READY:
 608                 /*
 609                  * Ready event – enable line card by releasing it from reset or disable it by put
 610                  * to reset state.
 611                  */
 612                 err = mlxreg_lc_enable_disable(mlxreg_lc, !!action);
 613                 break;
 614         case MLXREG_HOTPLUG_LC_THERMAL:
 615                 /* Thermal shutdown event – power off line card. */
 616                 if (action)
 617                         err = mlxreg_lc_power_on_off(mlxreg_lc, 0);
 618                 break;
 619         default:
 620                 break;
 621         }
 622
 623         return err;
 624 }
 625
 626 /*
 627  * Callback is to be called from i2c-mux-mlxcpld driver to indicate that all adapter devices has
 628  * been created.
 629  */
 630 static int mlxreg_lc_completion_notify(void *handle, struct i2c_adapter *parent,
 631                                        struct i2c_adapter *adapters[])
 632 {
 633         struct mlxreg_hotplug_device *main_dev, *aux_dev;
 634         struct mlxreg_lc *mlxreg_lc = handle;
 635         u32 regval;
 636         int i, err;
 637
 638         /* Update I2C devices feeding by auxiliary power. */
 639         aux_dev = mlxreg_lc->aux_devs;
 640         for (i = 0; i < mlxreg_lc->aux_devs_num; i++, aux_dev++) {
 641                 aux_dev->adapter = adapters[aux_dev->nr];
 642                 aux_dev->nr = adapters[aux_dev->nr]->nr;
 643         }
 644
 645         err = mlxreg_lc_create_static_devices(mlxreg_lc, mlxreg_lc->aux_devs,
 646                                               mlxreg_lc->aux_devs_num);
 647         if (err)
 648                 return err;
 649
 650         /* Update I2C devices feeding by main power. */
 651         main_dev = mlxreg_lc->main_devs;
 652         for (i = 0; i < mlxreg_lc->main_devs_num; i++, main_dev++) {
 653                 main_dev->adapter = adapters[main_dev->nr];
 654                 main_dev->nr = adapters[main_dev->nr]->nr;
 655         }
 656
 657         /* Verify if line card is powered. */
 658         err = regmap_read(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_pwr, &regval);
 659         if (err)
 660                 goto mlxreg_lc_regmap_read_power_fail;
 661
 662         if (regval & mlxreg_lc->data->mask) {
 663                 err = mlxreg_lc_create_static_devices(mlxreg_lc, mlxreg_lc->main_devs,
 664                                                       mlxreg_lc->main_devs_num);
 665                 if (err)
 666                         goto mlxreg_lc_create_static_devices_failed;
 667
 668                 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_POWERED, 1);
 669         }
 670
 671         /* Verify if line card is synchronized. */
 672         err = regmap_read(mlxreg_lc->par_regmap, mlxreg_lc->data->reg_sync, &regval);
 673         if (err)
 674                 goto mlxreg_lc_regmap_read_sync_fail;
 675
 676         /* Power on line card if necessary. */
 677         if (regval & mlxreg_lc->data->mask) {
 678                 mlxreg_lc->state |= MLXREG_LC_SYNCED;
 679                 mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_SYNCED, 1);
 680                 if (mlxreg_lc->state & ~MLXREG_LC_POWERED) {
 681                         err = mlxreg_lc_power_on_off(mlxreg_lc, 1);
 682                         if (err)
 683                                 goto mlxreg_lc_regmap_power_on_off_fail;
 684                 }
 685         }
 686
 687         mlxreg_lc_state_update(mlxreg_lc, MLXREG_LC_INITIALIZED, 1);
 688
 689         return 0;
 690
 691 mlxreg_lc_regmap_power_on_off_fail:
 692 mlxreg_lc_regmap_read_sync_fail:
 693         if (mlxreg_lc->state & MLXREG_LC_POWERED)
 694                 mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->main_devs,
 695                                                  mlxreg_lc->main_devs_num);
 696 mlxreg_lc_create_static_devices_failed:
 697         mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->aux_devs, mlxreg_lc->aux_devs_num);
 698 mlxreg_lc_regmap_read_power_fail:
 699         return err;
 700 }
 701
 702 static int
 703 mlxreg_lc_config_init(struct mlxreg_lc *mlxreg_lc, void *regmap,
 704                       struct mlxreg_core_data *data)
 705 {
 706         struct device *dev = &data->hpdev.client->dev;
 707         int lsb, err;
 708         u32 regval;
 709
 710         /* Validate line card type. */
 711         err = regmap_read(regmap, MLXREG_LC_REG_CONFIG_OFFSET, &lsb);
 712         err = (!err) ? regmap_read(regmap, MLXREG_LC_REG_CONFIG_OFFSET, &regval) : err;
 713         if (err)
 714                 return err;
 715         regval = (regval & GENMASK(7, 0)) << 8 | (lsb & GENMASK(7, 0));
 716         switch (regval) {
 717         case MLXREG_LC_SN4800_C16:
 718                 err = mlxreg_lc_sn4800_c16_config_init(mlxreg_lc, regmap, data);
 719                 if (err) {
 720                         dev_err(dev, "Failed to config client %s at bus %d at addr 0x%02x\n",
 721                                 data->hpdev.brdinfo->type, data->hpdev.nr,
 722                                 data->hpdev.brdinfo->addr);
 723                         return err;
 724                 }
 725                 break;
 726         default:
 727                 return -ENODEV;
 728         }
 729
 730         /* Create mux infrastructure. */
 731         mlxreg_lc->mux_data->handle = mlxreg_lc;
 732         mlxreg_lc->mux_data->completion_notify = mlxreg_lc_completion_notify;
 733         mlxreg_lc->mux_brdinfo->platform_data = mlxreg_lc->mux_data;
 734         mlxreg_lc->mux = platform_device_register_resndata(dev, "i2c-mux-mlxcpld", data->hpdev.nr,
 735                                                            NULL, 0, mlxreg_lc->mux_data,
 736                                                            sizeof(*mlxreg_lc->mux_data));
 737         if (IS_ERR(mlxreg_lc->mux)) {
 738                 dev_err(dev, "Failed to create mux infra for client %s at bus %d at addr 0x%02x\n",
 739                         data->hpdev.brdinfo->type, data->hpdev.nr, data->hpdev.brdinfo->addr);
 740                 return PTR_ERR(mlxreg_lc->mux);
 741         }
 742
 743         /* Register IO access driver. */
 744         if (mlxreg_lc->io_data) {
 745                 mlxreg_lc->io_data->regmap = regmap;
 746                 mlxreg_lc->io_regs =
 747                 platform_device_register_resndata(dev, "mlxreg-io", data->hpdev.nr, NULL, 0,
 748                                                   mlxreg_lc->io_data, sizeof(*mlxreg_lc->io_data));
 749                 if (IS_ERR(mlxreg_lc->io_regs)) {
 750                         dev_err(dev, "Failed to create regio for client %s at bus %d at addr 0x%02x\n",
 751                                 data->hpdev.brdinfo->type, data->hpdev.nr,
 752                                 data->hpdev.brdinfo->addr);
 753                         err = PTR_ERR(mlxreg_lc->io_regs);
 754                         goto fail_register_io;
 755                 }
 756         }
 757
 758         /* Register LED driver. */
 759         if (mlxreg_lc->led_data) {
 760                 mlxreg_lc->led_data->regmap = regmap;
 761                 mlxreg_lc->led =
 762                 platform_device_register_resndata(dev, "leds-mlxreg", data->hpdev.nr, NULL, 0,
 763                                                   mlxreg_lc->led_data,
 764                                                   sizeof(*mlxreg_lc->led_data));
 765                 if (IS_ERR(mlxreg_lc->led)) {
 766                         dev_err(dev, "Failed to create LED objects for client %s at bus %d at addr 0x%02x\n",
 767                                 data->hpdev.brdinfo->type, data->hpdev.nr,
 768                                 data->hpdev.brdinfo->addr);
 769                         err = PTR_ERR(mlxreg_lc->led);
 770                         goto fail_register_led;
 771                 }
 772         }
 773
 774         return 0;
 775
 776 fail_register_led:
 777         if (mlxreg_lc->io_regs)
 778                 platform_device_unregister(mlxreg_lc->io_regs);
 779 fail_register_io:
 780         if (mlxreg_lc->mux)
 781                 platform_device_unregister(mlxreg_lc->mux);
 782
 783         return err;
 784 }
 785
 786 static void mlxreg_lc_config_exit(struct mlxreg_lc *mlxreg_lc)
 787 {
 788         /* Unregister LED driver. */
 789         if (mlxreg_lc->led)
 790                 platform_device_unregister(mlxreg_lc->led);
 791         /* Unregister IO access driver. */
 792         if (mlxreg_lc->io_regs)
 793                 platform_device_unregister(mlxreg_lc->io_regs);
 794         /* Remove mux infrastructure. */
 795         if (mlxreg_lc->mux)
 796                 platform_device_unregister(mlxreg_lc->mux);
 797 }
 798
 799 static int mlxreg_lc_probe(struct platform_device *pdev)
 800 {
 801         struct mlxreg_core_hotplug_platform_data *par_pdata;
 802         struct mlxreg_core_data *data;
 803         struct mlxreg_lc *mlxreg_lc;
 804         void *regmap;
 805         int i, err;
 806
 807         data = dev_get_platdata(&pdev->dev);
 808         if (!data)
 809                 return -EINVAL;
 810
 811         mlxreg_lc = devm_kzalloc(&pdev->dev, sizeof(*mlxreg_lc), GFP_KERNEL);
 812         if (!mlxreg_lc)
 813                 return -ENOMEM;
 814
 815         mutex_init(&mlxreg_lc->lock);
 816         /* Set event notification callback. */
 817         if (data->notifier) {
 818                 data->notifier->user_handler = mlxreg_lc_event_handler;
 819                 data->notifier->handle = mlxreg_lc;
 820         }
 821         data->hpdev.adapter = i2c_get_adapter(data->hpdev.nr);
 822         if (!data->hpdev.adapter) {
 823                 dev_err(&pdev->dev, "Failed to get adapter for bus %d\n",
 824                         data->hpdev.nr);
 825                 err = -EFAULT;
 826                 goto i2c_get_adapter_fail;
 827         }
 828
 829         /* Create device at the top of line card I2C tree.*/
 830         data->hpdev.client = i2c_new_client_device(data->hpdev.adapter,
 831                                                    data->hpdev.brdinfo);
 832         if (IS_ERR(data->hpdev.client)) {
 833                 dev_err(&pdev->dev, "Failed to create client %s at bus %d at addr 0x%02x\n",
 834                         data->hpdev.brdinfo->type, data->hpdev.nr, data->hpdev.brdinfo->addr);
 835                 err = PTR_ERR(data->hpdev.client);
 836                 goto i2c_new_device_fail;
 837         }
 838
 839         regmap = devm_regmap_init_i2c(data->hpdev.client,
 840                                       &mlxreg_lc_regmap_conf);
 841         if (IS_ERR(regmap)) {
 842                 dev_err(&pdev->dev, "Failed to create regmap for client %s at bus %d at addr 0x%02x\n",
 843                         data->hpdev.brdinfo->type, data->hpdev.nr, data->hpdev.brdinfo->addr);
 844                 err = PTR_ERR(regmap);
 845                 goto devm_regmap_init_i2c_fail;
 846         }
 847
 848         /* Set default registers. */
 849         for (i = 0; i < mlxreg_lc_regmap_conf.num_reg_defaults; i++) {
 850                 err = regmap_write(regmap, mlxreg_lc_regmap_default[i].reg,
 851                                    mlxreg_lc_regmap_default[i].def);
 852                 if (err) {
 853                         dev_err(&pdev->dev, "Failed to set default regmap %d for client %s at bus %d at addr 0x%02x\n",
 854                                 i, data->hpdev.brdinfo->type, data->hpdev.nr,
 855                                 data->hpdev.brdinfo->addr);
 856                         goto regmap_write_fail;
 857                 }
 858         }
 859
 860         /* Sync registers with hardware. */
 861         regcache_mark_dirty(regmap);
 862         err = regcache_sync(regmap);
 863         if (err) {
 864                 dev_err(&pdev->dev, "Failed to sync regmap for client %s at bus %d at addr 0x%02x\n",
 865                         data->hpdev.brdinfo->type, data->hpdev.nr, data->hpdev.brdinfo->addr);
 866                 err = PTR_ERR(regmap);
 867                 goto regcache_sync_fail;
 868         }
 869
 870         par_pdata = data->hpdev.brdinfo->platform_data;
 871         mlxreg_lc->par_regmap = par_pdata->regmap;
 872         mlxreg_lc->data = data;
 873         mlxreg_lc->dev = &pdev->dev;
 874         platform_set_drvdata(pdev, mlxreg_lc);
 875
 876         /* Configure line card. */
 877         err = mlxreg_lc_config_init(mlxreg_lc, regmap, data);
 878         if (err)
 879                 goto mlxreg_lc_config_init_fail;
 880
 881         return err;
 882
 883 mlxreg_lc_config_init_fail:
 884 regcache_sync_fail:
 885 regmap_write_fail:
 886 devm_regmap_init_i2c_fail:
 887         if (data->hpdev.client) {
 888                 i2c_unregister_device(data->hpdev.client);
 889                 data->hpdev.client = NULL;
 890         }
 891 i2c_new_device_fail:
 892         i2c_put_adapter(data->hpdev.adapter);
 893         data->hpdev.adapter = NULL;
 894 i2c_get_adapter_fail:
 895         /* Clear event notification callback and handle. */
 896         if (data->notifier) {
 897                 data->notifier->user_handler = NULL;
 898                 data->notifier->handle = NULL;
 899         }
 900         return err;
 901 }
 902
 903 static int mlxreg_lc_remove(struct platform_device *pdev)
 904 {
 905         struct mlxreg_core_data *data = dev_get_platdata(&pdev->dev);
 906         struct mlxreg_lc *mlxreg_lc = platform_get_drvdata(pdev);
 907
 908         /*
 909          * Probing and removing are invoked by hotplug events raised upon line card insertion and
 910          * removing. If probing procedure fails all data is cleared. However, hotplug event still
 911          * will be raised on line card removing and activate removing procedure. In this case there
 912          * is nothing to remove.
 913          */
 914         if (!data->notifier || !data->notifier->handle)
 915                 return 0;
 916
 917         /* Clear event notification callback and handle. */
 918         data->notifier->user_handler = NULL;
 919         data->notifier->handle = NULL;
 920
 921         /* Destroy static I2C device feeding by main power. */
 922         mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->main_devs,
 923                                          mlxreg_lc->main_devs_num);
 924         /* Destroy static I2C device feeding by auxiliary power. */
 925         mlxreg_lc_destroy_static_devices(mlxreg_lc, mlxreg_lc->aux_devs, mlxreg_lc->aux_devs_num);
 926         /* Unregister underlying drivers. */
 927         mlxreg_lc_config_exit(mlxreg_lc);
 928         if (data->hpdev.client) {
 929                 i2c_unregister_device(data->hpdev.client);
 930                 data->hpdev.client = NULL;
 931                 i2c_put_adapter(data->hpdev.adapter);
 932                 data->hpdev.adapter = NULL;
 933         }
 934
 935         return 0;
 936 }
 937
 938 static struct platform_driver mlxreg_lc_driver = {
 939         .probe = mlxreg_lc_probe,
 940         .remove = mlxreg_lc_remove,
 941         .driver = {
 942                 .name = "mlxreg-lc",
 943         },
 944 };
 945
 946 module_platform_driver(mlxreg_lc_driver);
 947
 948 MODULE_AUTHOR("Vadim Pasternak <vadimp@nvidia.com>");
 949 MODULE_DESCRIPTION("Nvidia line card platform driver");
 950 MODULE_LICENSE("Dual BSD/GPL");
 951 MODULE_ALIAS("platform:mlxreg-lc");