drivers/platform/x86/mlx-platform.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /*
   3  * Mellanox platform driver
   4  *
   5  * Copyright (C) 2016-2018 Mellanox Technologies
   6  * Copyright (C) 2016-2018 Vadim Pasternak <vadimp@mellanox.com>
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/dmi.h>
  11 #include <linux/i2c.h>
  12 #include <linux/i2c-mux.h>
  13 #include <linux/io.h>
  14 #include <linux/module.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/platform_data/i2c-mux-reg.h>
  17 #include <linux/platform_data/mlxreg.h>
  18 #include <linux/regmap.h>
  19
  20 #define MLX_PLAT_DEVICE_NAME            "mlxplat"
  21
  22 /* LPC bus IO offsets */
  23 #define MLXPLAT_CPLD_LPC_I2C_BASE_ADRR          0x2000
  24 #define MLXPLAT_CPLD_LPC_REG_BASE_ADRR          0x2500
  25 #define MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET   0x00
  26 #define MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET   0x01
  27 #define MLXPLAT_CPLD_LPC_REG_CPLD3_VER_OFFSET   0x02
  28 #define MLXPLAT_CPLD_LPC_REG_CPLD4_VER_OFFSET   0x03
  29 #define MLXPLAT_CPLD_LPC_REG_CPLD1_PN_OFFSET    0x04
  30 #define MLXPLAT_CPLD_LPC_REG_CPLD2_PN_OFFSET    0x06
  31 #define MLXPLAT_CPLD_LPC_REG_CPLD3_PN_OFFSET    0x08
  32 #define MLXPLAT_CPLD_LPC_REG_CPLD4_PN_OFFSET    0x0a
  33 #define MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET 0x1d
  34 #define MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET  0x1e
  35 #define MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET  0x1f
  36 #define MLXPLAT_CPLD_LPC_REG_LED1_OFFSET        0x20
  37 #define MLXPLAT_CPLD_LPC_REG_LED2_OFFSET        0x21
  38 #define MLXPLAT_CPLD_LPC_REG_LED3_OFFSET        0x22
  39 #define MLXPLAT_CPLD_LPC_REG_LED4_OFFSET        0x23
  40 #define MLXPLAT_CPLD_LPC_REG_LED5_OFFSET        0x24
  41 #define MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION      0x2a
  42 #define MLXPLAT_CPLD_LPC_REG_GP0_RO_OFFSET      0x2b
  43 #define MLXPLAT_CPLD_LPC_REG_GP0_OFFSET         0x2e
  44 #define MLXPLAT_CPLD_LPC_REG_GP1_OFFSET         0x30
  45 #define MLXPLAT_CPLD_LPC_REG_WP1_OFFSET         0x31
  46 #define MLXPLAT_CPLD_LPC_REG_GP2_OFFSET         0x32
  47 #define MLXPLAT_CPLD_LPC_REG_WP2_OFFSET         0x33
  48 #define MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET 0x37
  49 #define MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET        0x3a
  50 #define MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET   0x3b
  51 #define MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET      0x40
  52 #define MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET 0x41
  53 #define MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET      0x42
  54 #define MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET 0x43
  55 #define MLXPLAT_CPLD_LPC_REG_AGGRCX_OFFSET      0x44
  56 #define MLXPLAT_CPLD_LPC_REG_AGGRCX_MASK_OFFSET 0x45
  57 #define MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET 0x50
  58 #define MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET  0x51
  59 #define MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET   0x52
  60 #define MLXPLAT_CPLD_LPC_REG_PSU_OFFSET         0x58
  61 #define MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET   0x59
  62 #define MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET    0x5a
  63 #define MLXPLAT_CPLD_LPC_REG_PWR_OFFSET         0x64
  64 #define MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET   0x65
  65 #define MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET    0x66
  66 #define MLXPLAT_CPLD_LPC_REG_FAN_OFFSET         0x88
  67 #define MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET   0x89
  68 #define MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET    0x8a
  69 #define MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET    0xc7
  70 #define MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET 0xc8
  71 #define MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET     0xc9
  72 #define MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET     0xcb
  73 #define MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET     0xcd
  74 #define MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET   0xce
  75 #define MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET     0xcf
  76 #define MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET     0xd1
  77 #define MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET   0xd2
  78 #define MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET     0xd3
  79 #define MLXPLAT_CPLD_LPC_REG_CPLD1_MVER_OFFSET  0xde
  80 #define MLXPLAT_CPLD_LPC_REG_CPLD2_MVER_OFFSET  0xdf
  81 #define MLXPLAT_CPLD_LPC_REG_CPLD3_MVER_OFFSET  0xe0
  82 #define MLXPLAT_CPLD_LPC_REG_CPLD4_MVER_OFFSET  0xe1
  83 #define MLXPLAT_CPLD_LPC_REG_UFM_VERSION_OFFSET 0xe2
  84 #define MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET        0xe3
  85 #define MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET      0xe4
  86 #define MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET      0xe5
  87 #define MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET      0xe6
  88 #define MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET      0xe7
  89 #define MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET      0xe8
  90 #define MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET      0xe9
  91 #define MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET      0xeb
  92 #define MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET      0xec
  93 #define MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET      0xed
  94 #define MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET     0xee
  95 #define MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET     0xef
  96 #define MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET     0xf0
  97 #define MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET    0xf5
  98 #define MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET    0xf6
  99 #define MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET 0xf7
 100 #define MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET 0xf8
 101 #define MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET 0xf9
 102 #define MLXPLAT_CPLD_LPC_REG_CONFIG1_OFFSET     0xfb
 103 #define MLXPLAT_CPLD_LPC_REG_CONFIG2_OFFSET     0xfc
 104 #define MLXPLAT_CPLD_LPC_IO_RANGE               0x100
 105 #define MLXPLAT_CPLD_LPC_I2C_CH1_OFF            0xdb
 106 #define MLXPLAT_CPLD_LPC_I2C_CH2_OFF            0xda
 107 #define MLXPLAT_CPLD_LPC_I2C_CH3_OFF            0xdc
 108
 109 #define MLXPLAT_CPLD_LPC_PIO_OFFSET             0x10000UL
 110 #define MLXPLAT_CPLD_LPC_REG1   ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
 111                                   MLXPLAT_CPLD_LPC_I2C_CH1_OFF) | \
 112                                   MLXPLAT_CPLD_LPC_PIO_OFFSET)
 113 #define MLXPLAT_CPLD_LPC_REG2   ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
 114                                   MLXPLAT_CPLD_LPC_I2C_CH2_OFF) | \
 115                                   MLXPLAT_CPLD_LPC_PIO_OFFSET)
 116 #define MLXPLAT_CPLD_LPC_REG3   ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
 117                                   MLXPLAT_CPLD_LPC_I2C_CH3_OFF) | \
 118                                   MLXPLAT_CPLD_LPC_PIO_OFFSET)
 119
 120 /* Masks for aggregation, psu, pwr and fan event in CPLD related registers. */
 121 #define MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF 0x04
 122 #define MLXPLAT_CPLD_AGGR_PSU_MASK_DEF  0x08
 123 #define MLXPLAT_CPLD_AGGR_PWR_MASK_DEF  0x08
 124 #define MLXPLAT_CPLD_AGGR_FAN_MASK_DEF  0x40
 125 #define MLXPLAT_CPLD_AGGR_MASK_DEF      (MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF | \
 126                                          MLXPLAT_CPLD_AGGR_PSU_MASK_DEF | \
 127                                          MLXPLAT_CPLD_AGGR_FAN_MASK_DEF)
 128 #define MLXPLAT_CPLD_AGGR_ASIC_MASK_NG  0x01
 129 #define MLXPLAT_CPLD_AGGR_MASK_NG_DEF   0x04
 130 #define MLXPLAT_CPLD_AGGR_MASK_COMEX    BIT(0)
 131 #define MLXPLAT_CPLD_LOW_AGGR_MASK_LOW  0xc1
 132 #define MLXPLAT_CPLD_LOW_AGGR_MASK_I2C  BIT(6)
 133 #define MLXPLAT_CPLD_PSU_MASK           GENMASK(1, 0)
 134 #define MLXPLAT_CPLD_PWR_MASK           GENMASK(1, 0)
 135 #define MLXPLAT_CPLD_PSU_EXT_MASK       GENMASK(3, 0)
 136 #define MLXPLAT_CPLD_PWR_EXT_MASK       GENMASK(3, 0)
 137 #define MLXPLAT_CPLD_FAN_MASK           GENMASK(3, 0)
 138 #define MLXPLAT_CPLD_ASIC_MASK          GENMASK(1, 0)
 139 #define MLXPLAT_CPLD_FAN_NG_MASK        GENMASK(5, 0)
 140 #define MLXPLAT_CPLD_LED_LO_NIBBLE_MASK GENMASK(7, 4)
 141 #define MLXPLAT_CPLD_LED_HI_NIBBLE_MASK GENMASK(3, 0)
 142 #define MLXPLAT_CPLD_VOLTREG_UPD_MASK   GENMASK(5, 4)
 143 #define MLXPLAT_CPLD_I2C_CAP_BIT        0x04
 144 #define MLXPLAT_CPLD_I2C_CAP_MASK       GENMASK(5, MLXPLAT_CPLD_I2C_CAP_BIT)
 145
 146 /* Masks for aggregation for comex carriers */
 147 #define MLXPLAT_CPLD_AGGR_MASK_CARRIER  BIT(1)
 148 #define MLXPLAT_CPLD_AGGR_MASK_CARR_DEF (MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF | \
 149                                          MLXPLAT_CPLD_AGGR_MASK_CARRIER)
 150 #define MLXPLAT_CPLD_LOW_AGGRCX_MASK    0xc1
 151
 152 /* Default I2C parent bus number */
 153 #define MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR        1
 154
 155 /* Maximum number of possible physical buses equipped on system */
 156 #define MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM       16
 157 #define MLXPLAT_CPLD_MAX_PHYS_EXT_ADAPTER_NUM   24
 158
 159 /* Number of channels in group */
 160 #define MLXPLAT_CPLD_GRP_CHNL_NUM               8
 161
 162 /* Start channel numbers */
 163 #define MLXPLAT_CPLD_CH1                        2
 164 #define MLXPLAT_CPLD_CH2                        10
 165 #define MLXPLAT_CPLD_CH3                        18
 166
 167 /* Number of LPC attached MUX platform devices */
 168 #define MLXPLAT_CPLD_LPC_MUX_DEVS               3
 169
 170 /* Hotplug devices adapter numbers */
 171 #define MLXPLAT_CPLD_NR_NONE                    -1
 172 #define MLXPLAT_CPLD_PSU_DEFAULT_NR             10
 173 #define MLXPLAT_CPLD_PSU_MSNXXXX_NR             4
 174 #define MLXPLAT_CPLD_FAN1_DEFAULT_NR            11
 175 #define MLXPLAT_CPLD_FAN2_DEFAULT_NR            12
 176 #define MLXPLAT_CPLD_FAN3_DEFAULT_NR            13
 177 #define MLXPLAT_CPLD_FAN4_DEFAULT_NR            14
 178
 179 /* Masks and default values for watchdogs */
 180 #define MLXPLAT_CPLD_WD1_CLEAR_MASK     GENMASK(7, 1)
 181 #define MLXPLAT_CPLD_WD2_CLEAR_MASK     (GENMASK(7, 0) & ~BIT(1))
 182
 183 #define MLXPLAT_CPLD_WD_TYPE1_TO_MASK   GENMASK(7, 4)
 184 #define MLXPLAT_CPLD_WD_TYPE2_TO_MASK   0
 185 #define MLXPLAT_CPLD_WD_RESET_ACT_MASK  GENMASK(7, 1)
 186 #define MLXPLAT_CPLD_WD_FAN_ACT_MASK    (GENMASK(7, 0) & ~BIT(4))
 187 #define MLXPLAT_CPLD_WD_COUNT_ACT_MASK  (GENMASK(7, 0) & ~BIT(7))
 188 #define MLXPLAT_CPLD_WD_CPBLTY_MASK     (GENMASK(7, 0) & ~BIT(6))
 189 #define MLXPLAT_CPLD_WD_DFLT_TIMEOUT    30
 190 #define MLXPLAT_CPLD_WD3_DFLT_TIMEOUT   600
 191 #define MLXPLAT_CPLD_WD_MAX_DEVS        2
 192
 193 /* mlxplat_priv - platform private data
 194  * @pdev_i2c - i2c controller platform device
 195  * @pdev_mux - array of mux platform devices
 196  * @pdev_hotplug - hotplug platform devices
 197  * @pdev_led - led platform devices
 198  * @pdev_io_regs - register access platform devices
 199  * @pdev_fan - FAN platform devices
 200  * @pdev_wd - array of watchdog platform devices
 201  * @regmap: device register map
 202  */
 203 struct mlxplat_priv {
 204         struct platform_device *pdev_i2c;
 205         struct platform_device *pdev_mux[MLXPLAT_CPLD_LPC_MUX_DEVS];
 206         struct platform_device *pdev_hotplug;
 207         struct platform_device *pdev_led;
 208         struct platform_device *pdev_io_regs;
 209         struct platform_device *pdev_fan;
 210         struct platform_device *pdev_wd[MLXPLAT_CPLD_WD_MAX_DEVS];
 211         void *regmap;
 212 };
 213
 214 /* Regions for LPC I2C controller and LPC base register space */
 215 static const struct resource mlxplat_lpc_resources[] = {
 216         [0] = DEFINE_RES_NAMED(MLXPLAT_CPLD_LPC_I2C_BASE_ADRR,
 217                                MLXPLAT_CPLD_LPC_IO_RANGE,
 218                                "mlxplat_cpld_lpc_i2c_ctrl", IORESOURCE_IO),
 219         [1] = DEFINE_RES_NAMED(MLXPLAT_CPLD_LPC_REG_BASE_ADRR,
 220                                MLXPLAT_CPLD_LPC_IO_RANGE,
 221                                "mlxplat_cpld_lpc_regs",
 222                                IORESOURCE_IO),
 223 };
 224
 225 /* Platform i2c next generation systems data */
 226 static struct mlxreg_core_data mlxplat_mlxcpld_i2c_ng_items_data[] = {
 227         {
 228                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
 229                 .mask = MLXPLAT_CPLD_I2C_CAP_MASK,
 230                 .bit = MLXPLAT_CPLD_I2C_CAP_BIT,
 231         },
 232 };
 233
 234 static struct mlxreg_core_item mlxplat_mlxcpld_i2c_ng_items[] = {
 235         {
 236                 .data = mlxplat_mlxcpld_i2c_ng_items_data,
 237         },
 238 };
 239
 240 /* Platform next generation systems i2c data */
 241 static struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_i2c_ng_data = {
 242         .items = mlxplat_mlxcpld_i2c_ng_items,
 243         .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 244         .mask = MLXPLAT_CPLD_AGGR_MASK_COMEX,
 245         .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET,
 246         .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_I2C,
 247 };
 248
 249 /* Platform default channels */
 250 static const int mlxplat_default_channels[][MLXPLAT_CPLD_GRP_CHNL_NUM] = {
 251         {
 252                 MLXPLAT_CPLD_CH1, MLXPLAT_CPLD_CH1 + 1, MLXPLAT_CPLD_CH1 + 2,
 253                 MLXPLAT_CPLD_CH1 + 3, MLXPLAT_CPLD_CH1 + 4, MLXPLAT_CPLD_CH1 +
 254                 5, MLXPLAT_CPLD_CH1 + 6, MLXPLAT_CPLD_CH1 + 7
 255         },
 256         {
 257                 MLXPLAT_CPLD_CH2, MLXPLAT_CPLD_CH2 + 1, MLXPLAT_CPLD_CH2 + 2,
 258                 MLXPLAT_CPLD_CH2 + 3, MLXPLAT_CPLD_CH2 + 4, MLXPLAT_CPLD_CH2 +
 259                 5, MLXPLAT_CPLD_CH2 + 6, MLXPLAT_CPLD_CH2 + 7
 260         },
 261 };
 262
 263 /* Platform channels for MSN21xx system family */
 264 static const int mlxplat_msn21xx_channels[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 265
 266 /* Platform mux data */
 267 static struct i2c_mux_reg_platform_data mlxplat_default_mux_data[] = {
 268         {
 269                 .parent = 1,
 270                 .base_nr = MLXPLAT_CPLD_CH1,
 271                 .write_only = 1,
 272                 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
 273                 .reg_size = 1,
 274                 .idle_in_use = 1,
 275         },
 276         {
 277                 .parent = 1,
 278                 .base_nr = MLXPLAT_CPLD_CH2,
 279                 .write_only = 1,
 280                 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
 281                 .reg_size = 1,
 282                 .idle_in_use = 1,
 283         },
 284
 285 };
 286
 287 /* Platform mux configuration variables */
 288 static int mlxplat_max_adap_num;
 289 static int mlxplat_mux_num;
 290 static struct i2c_mux_reg_platform_data *mlxplat_mux_data;
 291
 292 /* Platform extended mux data */
 293 static struct i2c_mux_reg_platform_data mlxplat_extended_mux_data[] = {
 294         {
 295                 .parent = 1,
 296                 .base_nr = MLXPLAT_CPLD_CH1,
 297                 .write_only = 1,
 298                 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
 299                 .reg_size = 1,
 300                 .idle_in_use = 1,
 301         },
 302         {
 303                 .parent = 1,
 304                 .base_nr = MLXPLAT_CPLD_CH2,
 305                 .write_only = 1,
 306                 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG3,
 307                 .reg_size = 1,
 308                 .idle_in_use = 1,
 309         },
 310         {
 311                 .parent = 1,
 312                 .base_nr = MLXPLAT_CPLD_CH3,
 313                 .write_only = 1,
 314                 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
 315                 .reg_size = 1,
 316                 .idle_in_use = 1,
 317         },
 318
 319 };
 320
 321 /* Platform hotplug devices */
 322 static struct i2c_board_info mlxplat_mlxcpld_pwr[] = {
 323         {
 324                 I2C_BOARD_INFO("dps460", 0x59),
 325         },
 326         {
 327                 I2C_BOARD_INFO("dps460", 0x58),
 328         },
 329 };
 330
 331 static struct i2c_board_info mlxplat_mlxcpld_ext_pwr[] = {
 332         {
 333                 I2C_BOARD_INFO("dps460", 0x5b),
 334         },
 335         {
 336                 I2C_BOARD_INFO("dps460", 0x5a),
 337         },
 338 };
 339
 340 static struct i2c_board_info mlxplat_mlxcpld_fan[] = {
 341         {
 342                 I2C_BOARD_INFO("24c32", 0x50),
 343         },
 344         {
 345                 I2C_BOARD_INFO("24c32", 0x50),
 346         },
 347         {
 348                 I2C_BOARD_INFO("24c32", 0x50),
 349         },
 350         {
 351                 I2C_BOARD_INFO("24c32", 0x50),
 352         },
 353 };
 354
 355 /* Platform hotplug comex carrier system family data */
 356 static struct mlxreg_core_data mlxplat_mlxcpld_comex_psu_items_data[] = {
 357         {
 358                 .label = "psu1",
 359                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 360                 .mask = BIT(0),
 361                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 362         },
 363         {
 364                 .label = "psu2",
 365                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 366                 .mask = BIT(1),
 367                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 368         },
 369 };
 370
 371 /* Platform hotplug default data */
 372 static struct mlxreg_core_data mlxplat_mlxcpld_default_psu_items_data[] = {
 373         {
 374                 .label = "psu1",
 375                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 376                 .mask = BIT(0),
 377                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 378         },
 379         {
 380                 .label = "psu2",
 381                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 382                 .mask = BIT(1),
 383                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 384         },
 385 };
 386
 387 static struct mlxreg_core_data mlxplat_mlxcpld_default_pwr_items_data[] = {
 388         {
 389                 .label = "pwr1",
 390                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 391                 .mask = BIT(0),
 392                 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
 393                 .hpdev.nr = MLXPLAT_CPLD_PSU_DEFAULT_NR,
 394         },
 395         {
 396                 .label = "pwr2",
 397                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 398                 .mask = BIT(1),
 399                 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
 400                 .hpdev.nr = MLXPLAT_CPLD_PSU_DEFAULT_NR,
 401         },
 402 };
 403
 404 static struct mlxreg_core_data mlxplat_mlxcpld_default_fan_items_data[] = {
 405         {
 406                 .label = "fan1",
 407                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 408                 .mask = BIT(0),
 409                 .hpdev.brdinfo = &mlxplat_mlxcpld_fan[0],
 410                 .hpdev.nr = MLXPLAT_CPLD_FAN1_DEFAULT_NR,
 411         },
 412         {
 413                 .label = "fan2",
 414                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 415                 .mask = BIT(1),
 416                 .hpdev.brdinfo = &mlxplat_mlxcpld_fan[1],
 417                 .hpdev.nr = MLXPLAT_CPLD_FAN2_DEFAULT_NR,
 418         },
 419         {
 420                 .label = "fan3",
 421                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 422                 .mask = BIT(2),
 423                 .hpdev.brdinfo = &mlxplat_mlxcpld_fan[2],
 424                 .hpdev.nr = MLXPLAT_CPLD_FAN3_DEFAULT_NR,
 425         },
 426         {
 427                 .label = "fan4",
 428                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 429                 .mask = BIT(3),
 430                 .hpdev.brdinfo = &mlxplat_mlxcpld_fan[3],
 431                 .hpdev.nr = MLXPLAT_CPLD_FAN4_DEFAULT_NR,
 432         },
 433 };
 434
 435 static struct mlxreg_core_data mlxplat_mlxcpld_default_asic_items_data[] = {
 436         {
 437                 .label = "asic1",
 438                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
 439                 .mask = MLXPLAT_CPLD_ASIC_MASK,
 440                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 441         },
 442 };
 443
 444 static struct mlxreg_core_item mlxplat_mlxcpld_default_items[] = {
 445         {
 446                 .data = mlxplat_mlxcpld_default_psu_items_data,
 447                 .aggr_mask = MLXPLAT_CPLD_AGGR_PSU_MASK_DEF,
 448                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 449                 .mask = MLXPLAT_CPLD_PSU_MASK,
 450                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_psu_items_data),
 451                 .inversed = 1,
 452                 .health = false,
 453         },
 454         {
 455                 .data = mlxplat_mlxcpld_default_pwr_items_data,
 456                 .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
 457                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 458                 .mask = MLXPLAT_CPLD_PWR_MASK,
 459                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_pwr_items_data),
 460                 .inversed = 0,
 461                 .health = false,
 462         },
 463         {
 464                 .data = mlxplat_mlxcpld_default_fan_items_data,
 465                 .aggr_mask = MLXPLAT_CPLD_AGGR_FAN_MASK_DEF,
 466                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 467                 .mask = MLXPLAT_CPLD_FAN_MASK,
 468                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_fan_items_data),
 469                 .inversed = 1,
 470                 .health = false,
 471         },
 472         {
 473                 .data = mlxplat_mlxcpld_default_asic_items_data,
 474                 .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
 475                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
 476                 .mask = MLXPLAT_CPLD_ASIC_MASK,
 477                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
 478                 .inversed = 0,
 479                 .health = true,
 480         },
 481 };
 482
 483 static struct mlxreg_core_item mlxplat_mlxcpld_comex_items[] = {
 484         {
 485                 .data = mlxplat_mlxcpld_comex_psu_items_data,
 486                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_CARRIER,
 487                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 488                 .mask = MLXPLAT_CPLD_PSU_MASK,
 489                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_psu_items_data),
 490                 .inversed = 1,
 491                 .health = false,
 492         },
 493         {
 494                 .data = mlxplat_mlxcpld_default_pwr_items_data,
 495                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_CARRIER,
 496                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 497                 .mask = MLXPLAT_CPLD_PWR_MASK,
 498                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_pwr_items_data),
 499                 .inversed = 0,
 500                 .health = false,
 501         },
 502         {
 503                 .data = mlxplat_mlxcpld_default_fan_items_data,
 504                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_CARRIER,
 505                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 506                 .mask = MLXPLAT_CPLD_FAN_MASK,
 507                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_fan_items_data),
 508                 .inversed = 1,
 509                 .health = false,
 510         },
 511         {
 512                 .data = mlxplat_mlxcpld_default_asic_items_data,
 513                 .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
 514                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
 515                 .mask = MLXPLAT_CPLD_ASIC_MASK,
 516                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
 517                 .inversed = 0,
 518                 .health = true,
 519         },
 520 };
 521
 522 static
 523 struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_default_data = {
 524         .items = mlxplat_mlxcpld_default_items,
 525         .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_items),
 526         .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 527         .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
 528         .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 529         .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
 530 };
 531
 532 static
 533 struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_comex_data = {
 534         .items = mlxplat_mlxcpld_comex_items,
 535         .counter = ARRAY_SIZE(mlxplat_mlxcpld_comex_items),
 536         .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 537         .mask = MLXPLAT_CPLD_AGGR_MASK_CARR_DEF,
 538         .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRCX_OFFSET,
 539         .mask_low = MLXPLAT_CPLD_LOW_AGGRCX_MASK,
 540 };
 541
 542 static struct mlxreg_core_data mlxplat_mlxcpld_msn21xx_pwr_items_data[] = {
 543         {
 544                 .label = "pwr1",
 545                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 546                 .mask = BIT(0),
 547                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 548         },
 549         {
 550                 .label = "pwr2",
 551                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 552                 .mask = BIT(1),
 553                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 554         },
 555 };
 556
 557 /* Platform hotplug MSN21xx system family data */
 558 static struct mlxreg_core_item mlxplat_mlxcpld_msn21xx_items[] = {
 559         {
 560                 .data = mlxplat_mlxcpld_msn21xx_pwr_items_data,
 561                 .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
 562                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 563                 .mask = MLXPLAT_CPLD_PWR_MASK,
 564                 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_pwr_items_data),
 565                 .inversed = 0,
 566                 .health = false,
 567         },
 568         {
 569                 .data = mlxplat_mlxcpld_default_asic_items_data,
 570                 .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
 571                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
 572                 .mask = MLXPLAT_CPLD_ASIC_MASK,
 573                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
 574                 .inversed = 0,
 575                 .health = true,
 576         },
 577 };
 578
 579 static
 580 struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn21xx_data = {
 581         .items = mlxplat_mlxcpld_msn21xx_items,
 582         .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_items),
 583         .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 584         .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
 585         .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 586         .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
 587 };
 588
 589 /* Platform hotplug msn274x system family data */
 590 static struct mlxreg_core_data mlxplat_mlxcpld_msn274x_psu_items_data[] = {
 591         {
 592                 .label = "psu1",
 593                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 594                 .mask = BIT(0),
 595                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 596         },
 597         {
 598                 .label = "psu2",
 599                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 600                 .mask = BIT(1),
 601                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 602         },
 603 };
 604
 605 static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_pwr_items_data[] = {
 606         {
 607                 .label = "pwr1",
 608                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 609                 .mask = BIT(0),
 610                 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
 611                 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 612         },
 613         {
 614                 .label = "pwr2",
 615                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 616                 .mask = BIT(1),
 617                 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
 618                 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 619         },
 620 };
 621
 622 static struct mlxreg_core_data mlxplat_mlxcpld_msn274x_fan_items_data[] = {
 623         {
 624                 .label = "fan1",
 625                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 626                 .mask = BIT(0),
 627                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 628         },
 629         {
 630                 .label = "fan2",
 631                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 632                 .mask = BIT(1),
 633                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 634         },
 635         {
 636                 .label = "fan3",
 637                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 638                 .mask = BIT(2),
 639                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 640         },
 641         {
 642                 .label = "fan4",
 643                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 644                 .mask = BIT(3),
 645                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 646         },
 647 };
 648
 649 static struct mlxreg_core_item mlxplat_mlxcpld_msn274x_items[] = {
 650         {
 651                 .data = mlxplat_mlxcpld_msn274x_psu_items_data,
 652                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 653                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 654                 .mask = MLXPLAT_CPLD_PSU_MASK,
 655                 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_psu_items_data),
 656                 .inversed = 1,
 657                 .health = false,
 658         },
 659         {
 660                 .data = mlxplat_mlxcpld_default_ng_pwr_items_data,
 661                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 662                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 663                 .mask = MLXPLAT_CPLD_PWR_MASK,
 664                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_pwr_items_data),
 665                 .inversed = 0,
 666                 .health = false,
 667         },
 668         {
 669                 .data = mlxplat_mlxcpld_msn274x_fan_items_data,
 670                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 671                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 672                 .mask = MLXPLAT_CPLD_FAN_MASK,
 673                 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_fan_items_data),
 674                 .inversed = 1,
 675                 .health = false,
 676         },
 677         {
 678                 .data = mlxplat_mlxcpld_default_asic_items_data,
 679                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 680                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
 681                 .mask = MLXPLAT_CPLD_ASIC_MASK,
 682                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
 683                 .inversed = 0,
 684                 .health = true,
 685         },
 686 };
 687
 688 static
 689 struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn274x_data = {
 690         .items = mlxplat_mlxcpld_msn274x_items,
 691         .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_items),
 692         .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 693         .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 694         .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 695         .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
 696 };
 697
 698 /* Platform hotplug MSN201x system family data */
 699 static struct mlxreg_core_data mlxplat_mlxcpld_msn201x_pwr_items_data[] = {
 700         {
 701                 .label = "pwr1",
 702                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 703                 .mask = BIT(0),
 704                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 705         },
 706         {
 707                 .label = "pwr2",
 708                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 709                 .mask = BIT(1),
 710                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 711         },
 712 };
 713
 714 static struct mlxreg_core_item mlxplat_mlxcpld_msn201x_items[] = {
 715         {
 716                 .data = mlxplat_mlxcpld_msn201x_pwr_items_data,
 717                 .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
 718                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 719                 .mask = MLXPLAT_CPLD_PWR_MASK,
 720                 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn201x_pwr_items_data),
 721                 .inversed = 0,
 722                 .health = false,
 723         },
 724         {
 725                 .data = mlxplat_mlxcpld_default_asic_items_data,
 726                 .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
 727                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
 728                 .mask = MLXPLAT_CPLD_ASIC_MASK,
 729                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
 730                 .inversed = 0,
 731                 .health = true,
 732         },
 733 };
 734
 735 static
 736 struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn201x_data = {
 737         .items = mlxplat_mlxcpld_msn201x_items,
 738         .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn201x_items),
 739         .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 740         .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
 741         .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 742         .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
 743 };
 744
 745 /* Platform hotplug next generation system family data */
 746 static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_psu_items_data[] = {
 747         {
 748                 .label = "psu1",
 749                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 750                 .mask = BIT(0),
 751                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 752         },
 753         {
 754                 .label = "psu2",
 755                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 756                 .mask = BIT(1),
 757                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 758         },
 759 };
 760
 761 static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_fan_items_data[] = {
 762         {
 763                 .label = "fan1",
 764                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 765                 .mask = BIT(0),
 766                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
 767                 .bit = BIT(0),
 768                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 769         },
 770         {
 771                 .label = "fan2",
 772                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 773                 .mask = BIT(1),
 774                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
 775                 .bit = BIT(1),
 776                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 777         },
 778         {
 779                 .label = "fan3",
 780                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 781                 .mask = BIT(2),
 782                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
 783                 .bit = BIT(2),
 784                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 785         },
 786         {
 787                 .label = "fan4",
 788                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 789                 .mask = BIT(3),
 790                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
 791                 .bit = BIT(3),
 792                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 793         },
 794         {
 795                 .label = "fan5",
 796                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 797                 .mask = BIT(4),
 798                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
 799                 .bit = BIT(4),
 800                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 801         },
 802         {
 803                 .label = "fan6",
 804                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 805                 .mask = BIT(5),
 806                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
 807                 .bit = BIT(5),
 808                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 809         },
 810 };
 811
 812 static struct mlxreg_core_item mlxplat_mlxcpld_default_ng_items[] = {
 813         {
 814                 .data = mlxplat_mlxcpld_default_ng_psu_items_data,
 815                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 816                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 817                 .mask = MLXPLAT_CPLD_PSU_MASK,
 818                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_psu_items_data),
 819                 .inversed = 1,
 820                 .health = false,
 821         },
 822         {
 823                 .data = mlxplat_mlxcpld_default_ng_pwr_items_data,
 824                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 825                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 826                 .mask = MLXPLAT_CPLD_PWR_MASK,
 827                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_pwr_items_data),
 828                 .inversed = 0,
 829                 .health = false,
 830         },
 831         {
 832                 .data = mlxplat_mlxcpld_default_ng_fan_items_data,
 833                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 834                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 835                 .mask = MLXPLAT_CPLD_FAN_NG_MASK,
 836                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_fan_items_data),
 837                 .inversed = 1,
 838                 .health = false,
 839         },
 840         {
 841                 .data = mlxplat_mlxcpld_default_asic_items_data,
 842                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 843                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
 844                 .mask = MLXPLAT_CPLD_ASIC_MASK,
 845                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
 846                 .inversed = 0,
 847                 .health = true,
 848         },
 849 };
 850
 851 static
 852 struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_default_ng_data = {
 853         .items = mlxplat_mlxcpld_default_ng_items,
 854         .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_items),
 855         .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 856         .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF | MLXPLAT_CPLD_AGGR_MASK_COMEX,
 857         .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 858         .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
 859 };
 860
 861 /* Platform hotplug extended system family data */
 862 static struct mlxreg_core_data mlxplat_mlxcpld_ext_psu_items_data[] = {
 863         {
 864                 .label = "psu1",
 865                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 866                 .mask = BIT(0),
 867                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 868         },
 869         {
 870                 .label = "psu2",
 871                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 872                 .mask = BIT(1),
 873                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 874         },
 875         {
 876                 .label = "psu3",
 877                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 878                 .mask = BIT(2),
 879                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 880         },
 881         {
 882                 .label = "psu4",
 883                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 884                 .mask = BIT(3),
 885                 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 886         },
 887 };
 888
 889 static struct mlxreg_core_data mlxplat_mlxcpld_ext_pwr_items_data[] = {
 890         {
 891                 .label = "pwr1",
 892                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 893                 .mask = BIT(0),
 894                 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
 895                 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 896         },
 897         {
 898                 .label = "pwr2",
 899                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 900                 .mask = BIT(1),
 901                 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
 902                 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 903         },
 904         {
 905                 .label = "pwr3",
 906                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 907                 .mask = BIT(2),
 908                 .hpdev.brdinfo = &mlxplat_mlxcpld_ext_pwr[0],
 909                 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 910         },
 911         {
 912                 .label = "pwr4",
 913                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 914                 .mask = BIT(3),
 915                 .hpdev.brdinfo = &mlxplat_mlxcpld_ext_pwr[1],
 916                 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 917         },
 918 };
 919
 920 static struct mlxreg_core_item mlxplat_mlxcpld_ext_items[] = {
 921         {
 922                 .data = mlxplat_mlxcpld_ext_psu_items_data,
 923                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 924                 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
 925                 .mask = MLXPLAT_CPLD_PSU_EXT_MASK,
 926                 .capability = MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
 927                 .count = ARRAY_SIZE(mlxplat_mlxcpld_ext_psu_items_data),
 928                 .inversed = 1,
 929                 .health = false,
 930         },
 931         {
 932                 .data = mlxplat_mlxcpld_ext_pwr_items_data,
 933                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 934                 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
 935                 .mask = MLXPLAT_CPLD_PWR_EXT_MASK,
 936                 .capability = MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
 937                 .count = ARRAY_SIZE(mlxplat_mlxcpld_ext_pwr_items_data),
 938                 .inversed = 0,
 939                 .health = false,
 940         },
 941         {
 942                 .data = mlxplat_mlxcpld_default_ng_fan_items_data,
 943                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 944                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
 945                 .mask = MLXPLAT_CPLD_FAN_NG_MASK,
 946                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_fan_items_data),
 947                 .inversed = 1,
 948                 .health = false,
 949         },
 950         {
 951                 .data = mlxplat_mlxcpld_default_asic_items_data,
 952                 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 953                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
 954                 .mask = MLXPLAT_CPLD_ASIC_MASK,
 955                 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
 956                 .inversed = 0,
 957                 .health = true,
 958         },
 959 };
 960
 961 static
 962 struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_ext_data = {
 963         .items = mlxplat_mlxcpld_ext_items,
 964         .counter = ARRAY_SIZE(mlxplat_mlxcpld_ext_items),
 965         .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 966         .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF | MLXPLAT_CPLD_AGGR_MASK_COMEX,
 967         .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 968         .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
 969 };
 970
 971 /* Platform led default data */
 972 static struct mlxreg_core_data mlxplat_mlxcpld_default_led_data[] = {
 973         {
 974                 .label = "status:green",
 975                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
 976                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
 977         },
 978         {
 979                 .label = "status:red",
 980                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
 981                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK
 982         },
 983         {
 984                 .label = "psu:green",
 985                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
 986                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
 987         },
 988         {
 989                 .label = "psu:red",
 990                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
 991                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
 992         },
 993         {
 994                 .label = "fan1:green",
 995                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
 996                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
 997         },
 998         {
 999                 .label = "fan1:red",
1000                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1001                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1002         },
1003         {
1004                 .label = "fan2:green",
1005                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1006                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1007         },
1008         {
1009                 .label = "fan2:red",
1010                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1011                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1012         },
1013         {
1014                 .label = "fan3:green",
1015                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1016                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1017         },
1018         {
1019                 .label = "fan3:red",
1020                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1021                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1022         },
1023         {
1024                 .label = "fan4:green",
1025                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1026                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1027         },
1028         {
1029                 .label = "fan4:red",
1030                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1031                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1032         },
1033 };
1034
1035 static struct mlxreg_core_platform_data mlxplat_default_led_data = {
1036                 .data = mlxplat_mlxcpld_default_led_data,
1037                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_led_data),
1038 };
1039
1040 /* Platform led MSN21xx system family data */
1041 static struct mlxreg_core_data mlxplat_mlxcpld_msn21xx_led_data[] = {
1042         {
1043                 .label = "status:green",
1044                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1045                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1046         },
1047         {
1048                 .label = "status:red",
1049                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1050                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK
1051         },
1052         {
1053                 .label = "fan:green",
1054                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1055                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1056         },
1057         {
1058                 .label = "fan:red",
1059                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1060                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1061         },
1062         {
1063                 .label = "psu1:green",
1064                 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
1065                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1066         },
1067         {
1068                 .label = "psu1:red",
1069                 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
1070                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1071         },
1072         {
1073                 .label = "psu2:green",
1074                 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
1075                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1076         },
1077         {
1078                 .label = "psu2:red",
1079                 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
1080                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1081         },
1082         {
1083                 .label = "uid:blue",
1084                 .reg = MLXPLAT_CPLD_LPC_REG_LED5_OFFSET,
1085                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1086         },
1087 };
1088
1089 static struct mlxreg_core_platform_data mlxplat_msn21xx_led_data = {
1090                 .data = mlxplat_mlxcpld_msn21xx_led_data,
1091                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_led_data),
1092 };
1093
1094 /* Platform led for default data for 200GbE systems */
1095 static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_led_data[] = {
1096         {
1097                 .label = "status:green",
1098                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1099                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1100         },
1101         {
1102                 .label = "status:orange",
1103                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1104                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK
1105         },
1106         {
1107                 .label = "psu:green",
1108                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1109                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1110         },
1111         {
1112                 .label = "psu:orange",
1113                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1114                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1115         },
1116         {
1117                 .label = "fan1:green",
1118                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1119                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1120                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1121                 .bit = BIT(0),
1122         },
1123         {
1124                 .label = "fan1:orange",
1125                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1126                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1127                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1128                 .bit = BIT(0),
1129         },
1130         {
1131                 .label = "fan2:green",
1132                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1133                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1134                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1135                 .bit = BIT(1),
1136         },
1137         {
1138                 .label = "fan2:orange",
1139                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1140                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1141                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1142                 .bit = BIT(1),
1143         },
1144         {
1145                 .label = "fan3:green",
1146                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1147                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1148                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1149                 .bit = BIT(2),
1150         },
1151         {
1152                 .label = "fan3:orange",
1153                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1154                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1155                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1156                 .bit = BIT(2),
1157         },
1158         {
1159                 .label = "fan4:green",
1160                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1161                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1162                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1163                 .bit = BIT(3),
1164         },
1165         {
1166                 .label = "fan4:orange",
1167                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1168                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1169                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1170                 .bit = BIT(3),
1171         },
1172         {
1173                 .label = "fan5:green",
1174                 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
1175                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1176                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1177                 .bit = BIT(4),
1178         },
1179         {
1180                 .label = "fan5:orange",
1181                 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
1182                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1183                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1184                 .bit = BIT(4),
1185         },
1186         {
1187                 .label = "fan6:green",
1188                 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
1189                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1190                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1191                 .bit = BIT(5),
1192         },
1193         {
1194                 .label = "fan6:orange",
1195                 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
1196                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1197                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1198                 .bit = BIT(5),
1199         },
1200         {
1201                 .label = "uid:blue",
1202                 .reg = MLXPLAT_CPLD_LPC_REG_LED5_OFFSET,
1203                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1204         },
1205 };
1206
1207 static struct mlxreg_core_platform_data mlxplat_default_ng_led_data = {
1208                 .data = mlxplat_mlxcpld_default_ng_led_data,
1209                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_led_data),
1210 };
1211
1212 /* Platform led for Comex based 100GbE systems */
1213 static struct mlxreg_core_data mlxplat_mlxcpld_comex_100G_led_data[] = {
1214         {
1215                 .label = "status:green",
1216                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1217                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1218         },
1219         {
1220                 .label = "status:red",
1221                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1222                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK
1223         },
1224         {
1225                 .label = "psu:green",
1226                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1227                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1228         },
1229         {
1230                 .label = "psu:red",
1231                 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
1232                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1233         },
1234         {
1235                 .label = "fan1:green",
1236                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1237                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1238         },
1239         {
1240                 .label = "fan1:red",
1241                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1242                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1243         },
1244         {
1245                 .label = "fan2:green",
1246                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1247                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1248         },
1249         {
1250                 .label = "fan2:red",
1251                 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
1252                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1253         },
1254         {
1255                 .label = "fan3:green",
1256                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1257                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1258         },
1259         {
1260                 .label = "fan3:red",
1261                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1262                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1263         },
1264         {
1265                 .label = "fan4:green",
1266                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1267                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1268         },
1269         {
1270                 .label = "fan4:red",
1271                 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
1272                 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
1273         },
1274         {
1275                 .label = "uid:blue",
1276                 .reg = MLXPLAT_CPLD_LPC_REG_LED5_OFFSET,
1277                 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
1278         },
1279 };
1280
1281 static struct mlxreg_core_platform_data mlxplat_comex_100G_led_data = {
1282                 .data = mlxplat_mlxcpld_comex_100G_led_data,
1283                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_comex_100G_led_data),
1284 };
1285
1286 /* Platform register access default */
1287 static struct mlxreg_core_data mlxplat_mlxcpld_default_regs_io_data[] = {
1288         {
1289                 .label = "cpld1_version",
1290                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET,
1291                 .bit = GENMASK(7, 0),
1292                 .mode = 0444,
1293         },
1294         {
1295                 .label = "cpld2_version",
1296                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET,
1297                 .bit = GENMASK(7, 0),
1298                 .mode = 0444,
1299         },
1300         {
1301                 .label = "cpld1_pn",
1302                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_PN_OFFSET,
1303                 .bit = GENMASK(15, 0),
1304                 .mode = 0444,
1305                 .regnum = 2,
1306         },
1307         {
1308                 .label = "cpld2_pn",
1309                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_PN_OFFSET,
1310                 .bit = GENMASK(15, 0),
1311                 .mode = 0444,
1312                 .regnum = 2,
1313         },
1314         {
1315                 .label = "cpld1_version_min",
1316                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_MVER_OFFSET,
1317                 .bit = GENMASK(7, 0),
1318                 .mode = 0444,
1319         },
1320         {
1321                 .label = "cpld2_version_min",
1322                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_MVER_OFFSET,
1323                 .bit = GENMASK(7, 0),
1324                 .mode = 0444,
1325         },
1326         {
1327                 .label = "reset_long_pb",
1328                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1329                 .mask = GENMASK(7, 0) & ~BIT(0),
1330                 .mode = 0444,
1331         },
1332         {
1333                 .label = "reset_short_pb",
1334                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1335                 .mask = GENMASK(7, 0) & ~BIT(1),
1336                 .mode = 0444,
1337         },
1338         {
1339                 .label = "reset_aux_pwr_or_ref",
1340                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1341                 .mask = GENMASK(7, 0) & ~BIT(2),
1342                 .mode = 0444,
1343         },
1344         {
1345                 .label = "reset_main_pwr_fail",
1346                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1347                 .mask = GENMASK(7, 0) & ~BIT(3),
1348                 .mode = 0444,
1349         },
1350         {
1351                 .label = "reset_sw_reset",
1352                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1353                 .mask = GENMASK(7, 0) & ~BIT(4),
1354                 .mode = 0444,
1355         },
1356         {
1357                 .label = "reset_fw_reset",
1358                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1359                 .mask = GENMASK(7, 0) & ~BIT(5),
1360                 .mode = 0444,
1361         },
1362         {
1363                 .label = "reset_hotswap_or_wd",
1364                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1365                 .mask = GENMASK(7, 0) & ~BIT(6),
1366                 .mode = 0444,
1367         },
1368         {
1369                 .label = "reset_asic_thermal",
1370                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1371                 .mask = GENMASK(7, 0) & ~BIT(7),
1372                 .mode = 0444,
1373         },
1374         {
1375                 .label = "psu1_on",
1376                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1377                 .mask = GENMASK(7, 0) & ~BIT(0),
1378                 .mode = 0200,
1379         },
1380         {
1381                 .label = "psu2_on",
1382                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1383                 .mask = GENMASK(7, 0) & ~BIT(1),
1384                 .mode = 0200,
1385         },
1386         {
1387                 .label = "pwr_cycle",
1388                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1389                 .mask = GENMASK(7, 0) & ~BIT(2),
1390                 .mode = 0200,
1391         },
1392         {
1393                 .label = "pwr_down",
1394                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1395                 .mask = GENMASK(7, 0) & ~BIT(3),
1396                 .mode = 0200,
1397         },
1398         {
1399                 .label = "select_iio",
1400                 .reg = MLXPLAT_CPLD_LPC_REG_GP2_OFFSET,
1401                 .mask = GENMASK(7, 0) & ~BIT(6),
1402                 .mode = 0644,
1403         },
1404         {
1405                 .label = "asic_health",
1406                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
1407                 .mask = MLXPLAT_CPLD_ASIC_MASK,
1408                 .bit = 1,
1409                 .mode = 0444,
1410         },
1411 };
1412
1413 static struct mlxreg_core_platform_data mlxplat_default_regs_io_data = {
1414                 .data = mlxplat_mlxcpld_default_regs_io_data,
1415                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_regs_io_data),
1416 };
1417
1418 /* Platform register access MSN21xx, MSN201x, MSN274x systems families data */
1419 static struct mlxreg_core_data mlxplat_mlxcpld_msn21xx_regs_io_data[] = {
1420         {
1421                 .label = "cpld1_version",
1422                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET,
1423                 .bit = GENMASK(7, 0),
1424                 .mode = 0444,
1425         },
1426         {
1427                 .label = "cpld2_version",
1428                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET,
1429                 .bit = GENMASK(7, 0),
1430                 .mode = 0444,
1431         },
1432         {
1433                 .label = "cpld1_pn",
1434                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_PN_OFFSET,
1435                 .bit = GENMASK(15, 0),
1436                 .mode = 0444,
1437                 .regnum = 2,
1438         },
1439         {
1440                 .label = "cpld2_pn",
1441                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_PN_OFFSET,
1442                 .bit = GENMASK(15, 0),
1443                 .mode = 0444,
1444                 .regnum = 2,
1445         },
1446         {
1447                 .label = "cpld1_version_min",
1448                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_MVER_OFFSET,
1449                 .bit = GENMASK(7, 0),
1450                 .mode = 0444,
1451         },
1452         {
1453                 .label = "cpld2_version_min",
1454                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_MVER_OFFSET,
1455                 .bit = GENMASK(7, 0),
1456                 .mode = 0444,
1457         },
1458         {
1459                 .label = "reset_long_pb",
1460                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1461                 .mask = GENMASK(7, 0) & ~BIT(0),
1462                 .mode = 0444,
1463         },
1464         {
1465                 .label = "reset_short_pb",
1466                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1467                 .mask = GENMASK(7, 0) & ~BIT(1),
1468                 .mode = 0444,
1469         },
1470         {
1471                 .label = "reset_aux_pwr_or_ref",
1472                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1473                 .mask = GENMASK(7, 0) & ~BIT(2),
1474                 .mode = 0444,
1475         },
1476         {
1477                 .label = "reset_sw_reset",
1478                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1479                 .mask = GENMASK(7, 0) & ~BIT(3),
1480                 .mode = 0444,
1481         },
1482         {
1483                 .label = "reset_main_pwr_fail",
1484                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1485                 .mask = GENMASK(7, 0) & ~BIT(4),
1486                 .mode = 0444,
1487         },
1488         {
1489                 .label = "reset_asic_thermal",
1490                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1491                 .mask = GENMASK(7, 0) & ~BIT(5),
1492                 .mode = 0444,
1493         },
1494         {
1495                 .label = "reset_hotswap_or_halt",
1496                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1497                 .mask = GENMASK(7, 0) & ~BIT(6),
1498                 .mode = 0444,
1499         },
1500         {
1501                 .label = "reset_sff_wd",
1502                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET,
1503                 .mask = GENMASK(7, 0) & ~BIT(6),
1504                 .mode = 0444,
1505         },
1506         {
1507                 .label = "psu1_on",
1508                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1509                 .mask = GENMASK(7, 0) & ~BIT(0),
1510                 .mode = 0200,
1511         },
1512         {
1513                 .label = "psu2_on",
1514                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1515                 .mask = GENMASK(7, 0) & ~BIT(1),
1516                 .mode = 0200,
1517         },
1518         {
1519                 .label = "pwr_cycle",
1520                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1521                 .mask = GENMASK(7, 0) & ~BIT(2),
1522                 .mode = 0200,
1523         },
1524         {
1525                 .label = "pwr_down",
1526                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1527                 .mask = GENMASK(7, 0) & ~BIT(3),
1528                 .mode = 0200,
1529         },
1530         {
1531                 .label = "select_iio",
1532                 .reg = MLXPLAT_CPLD_LPC_REG_GP2_OFFSET,
1533                 .mask = GENMASK(7, 0) & ~BIT(6),
1534                 .mode = 0644,
1535         },
1536         {
1537                 .label = "asic_health",
1538                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
1539                 .mask = MLXPLAT_CPLD_ASIC_MASK,
1540                 .bit = 1,
1541                 .mode = 0444,
1542         },
1543 };
1544
1545 static struct mlxreg_core_platform_data mlxplat_msn21xx_regs_io_data = {
1546                 .data = mlxplat_mlxcpld_msn21xx_regs_io_data,
1547                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_regs_io_data),
1548 };
1549
1550 /* Platform register access for next generation systems families data */
1551 static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_regs_io_data[] = {
1552         {
1553                 .label = "cpld1_version",
1554                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET,
1555                 .bit = GENMASK(7, 0),
1556                 .mode = 0444,
1557         },
1558         {
1559                 .label = "cpld2_version",
1560                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET,
1561                 .bit = GENMASK(7, 0),
1562                 .mode = 0444,
1563         },
1564         {
1565                 .label = "cpld3_version",
1566                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD3_VER_OFFSET,
1567                 .bit = GENMASK(7, 0),
1568                 .mode = 0444,
1569         },
1570         {
1571                 .label = "cpld4_version",
1572                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD4_VER_OFFSET,
1573                 .bit = GENMASK(7, 0),
1574                 .mode = 0444,
1575         },
1576         {
1577                 .label = "cpld1_pn",
1578                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_PN_OFFSET,
1579                 .bit = GENMASK(15, 0),
1580                 .mode = 0444,
1581                 .regnum = 2,
1582         },
1583         {
1584                 .label = "cpld2_pn",
1585                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_PN_OFFSET,
1586                 .bit = GENMASK(15, 0),
1587                 .mode = 0444,
1588                 .regnum = 2,
1589         },
1590         {
1591                 .label = "cpld3_pn",
1592                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD3_PN_OFFSET,
1593                 .bit = GENMASK(15, 0),
1594                 .mode = 0444,
1595                 .regnum = 2,
1596         },
1597         {
1598                 .label = "cpld4_pn",
1599                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD4_PN_OFFSET,
1600                 .bit = GENMASK(15, 0),
1601                 .mode = 0444,
1602                 .regnum = 2,
1603         },
1604         {
1605                 .label = "cpld1_version_min",
1606                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_MVER_OFFSET,
1607                 .bit = GENMASK(7, 0),
1608                 .mode = 0444,
1609         },
1610         {
1611                 .label = "cpld2_version_min",
1612                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_MVER_OFFSET,
1613                 .bit = GENMASK(7, 0),
1614                 .mode = 0444,
1615         },
1616         {
1617                 .label = "cpld3_version_min",
1618                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD3_MVER_OFFSET,
1619                 .bit = GENMASK(7, 0),
1620                 .mode = 0444,
1621         },
1622         {
1623                 .label = "cpld4_version_min",
1624                 .reg = MLXPLAT_CPLD_LPC_REG_CPLD4_MVER_OFFSET,
1625                 .bit = GENMASK(7, 0),
1626                 .mode = 0444,
1627         },
1628         {
1629                 .label = "reset_long_pb",
1630                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1631                 .mask = GENMASK(7, 0) & ~BIT(0),
1632                 .mode = 0444,
1633         },
1634         {
1635                 .label = "reset_short_pb",
1636                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1637                 .mask = GENMASK(7, 0) & ~BIT(1),
1638                 .mode = 0444,
1639         },
1640         {
1641                 .label = "reset_aux_pwr_or_ref",
1642                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1643                 .mask = GENMASK(7, 0) & ~BIT(2),
1644                 .mode = 0444,
1645         },
1646         {
1647                 .label = "reset_from_comex",
1648                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1649                 .mask = GENMASK(7, 0) & ~BIT(4),
1650                 .mode = 0444,
1651         },
1652         {
1653                 .label = "reset_from_asic",
1654                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1655                 .mask = GENMASK(7, 0) & ~BIT(5),
1656                 .mode = 0444,
1657         },
1658         {
1659                 .label = "reset_swb_wd",
1660                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1661                 .mask = GENMASK(7, 0) & ~BIT(6),
1662                 .mode = 0444,
1663         },
1664         {
1665                 .label = "reset_asic_thermal",
1666                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1667                 .mask = GENMASK(7, 0) & ~BIT(7),
1668                 .mode = 0444,
1669         },
1670         {
1671                 .label = "reset_comex_pwr_fail",
1672                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET,
1673                 .mask = GENMASK(7, 0) & ~BIT(3),
1674                 .mode = 0444,
1675         },
1676         {
1677                 .label = "reset_platform",
1678                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET,
1679                 .mask = GENMASK(7, 0) & ~BIT(4),
1680                 .mode = 0444,
1681         },
1682         {
1683                 .label = "reset_soc",
1684                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET,
1685                 .mask = GENMASK(7, 0) & ~BIT(5),
1686                 .mode = 0444,
1687         },
1688         {
1689                 .label = "reset_comex_wd",
1690                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET,
1691                 .mask = GENMASK(7, 0) & ~BIT(6),
1692                 .mode = 0444,
1693         },
1694         {
1695                 .label = "reset_voltmon_upgrade_fail",
1696                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1697                 .mask = GENMASK(7, 0) & ~BIT(0),
1698                 .mode = 0444,
1699         },
1700         {
1701                 .label = "reset_system",
1702                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1703                 .mask = GENMASK(7, 0) & ~BIT(1),
1704                 .mode = 0444,
1705         },
1706         {
1707                 .label = "reset_sw_pwr_off",
1708                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1709                 .mask = GENMASK(7, 0) & ~BIT(2),
1710                 .mode = 0444,
1711         },
1712         {
1713                 .label = "reset_comex_thermal",
1714                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1715                 .mask = GENMASK(7, 0) & ~BIT(3),
1716                 .mode = 0444,
1717         },
1718         {
1719                 .label = "reset_reload_bios",
1720                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1721                 .mask = GENMASK(7, 0) & ~BIT(5),
1722                 .mode = 0444,
1723         },
1724         {
1725                 .label = "reset_ac_pwr_fail",
1726                 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1727                 .mask = GENMASK(7, 0) & ~BIT(6),
1728                 .mode = 0444,
1729         },
1730         {
1731                 .label = "psu1_on",
1732                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1733                 .mask = GENMASK(7, 0) & ~BIT(0),
1734                 .mode = 0200,
1735         },
1736         {
1737                 .label = "psu2_on",
1738                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1739                 .mask = GENMASK(7, 0) & ~BIT(1),
1740                 .mode = 0200,
1741         },
1742         {
1743                 .label = "pwr_cycle",
1744                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1745                 .mask = GENMASK(7, 0) & ~BIT(2),
1746                 .mode = 0200,
1747         },
1748         {
1749                 .label = "pwr_down",
1750                 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1751                 .mask = GENMASK(7, 0) & ~BIT(3),
1752                 .mode = 0200,
1753         },
1754         {
1755                 .label = "jtag_enable",
1756                 .reg = MLXPLAT_CPLD_LPC_REG_GP2_OFFSET,
1757                 .mask = GENMASK(7, 0) & ~BIT(4),
1758                 .mode = 0644,
1759         },
1760         {
1761                 .label = "asic_health",
1762                 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
1763                 .mask = MLXPLAT_CPLD_ASIC_MASK,
1764                 .bit = 1,
1765                 .mode = 0444,
1766         },
1767         {
1768                 .label = "fan_dir",
1769                 .reg = MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION,
1770                 .bit = GENMASK(7, 0),
1771                 .mode = 0444,
1772         },
1773         {
1774                 .label = "voltreg_update_status",
1775                 .reg = MLXPLAT_CPLD_LPC_REG_GP0_RO_OFFSET,
1776                 .mask = MLXPLAT_CPLD_VOLTREG_UPD_MASK,
1777                 .bit = 5,
1778                 .mode = 0444,
1779         },
1780         {
1781                 .label = "vpd_wp",
1782                 .reg = MLXPLAT_CPLD_LPC_REG_GP0_OFFSET,
1783                 .mask = GENMASK(7, 0) & ~BIT(3),
1784                 .mode = 0644,
1785         },
1786         {
1787                 .label = "pcie_asic_reset_dis",
1788                 .reg = MLXPLAT_CPLD_LPC_REG_GP0_OFFSET,
1789                 .mask = GENMASK(7, 0) & ~BIT(4),
1790                 .mode = 0644,
1791         },
1792         {
1793                 .label = "config1",
1794                 .reg = MLXPLAT_CPLD_LPC_REG_CONFIG1_OFFSET,
1795                 .bit = GENMASK(7, 0),
1796                 .mode = 0444,
1797         },
1798         {
1799                 .label = "config2",
1800                 .reg = MLXPLAT_CPLD_LPC_REG_CONFIG2_OFFSET,
1801                 .bit = GENMASK(7, 0),
1802                 .mode = 0444,
1803         },
1804         {
1805                 .label = "ufm_version",
1806                 .reg = MLXPLAT_CPLD_LPC_REG_UFM_VERSION_OFFSET,
1807                 .bit = GENMASK(7, 0),
1808                 .mode = 0444,
1809         },
1810 };
1811
1812 static struct mlxreg_core_platform_data mlxplat_default_ng_regs_io_data = {
1813                 .data = mlxplat_mlxcpld_default_ng_regs_io_data,
1814                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_regs_io_data),
1815 };
1816
1817 /* Platform FAN default */
1818 static struct mlxreg_core_data mlxplat_mlxcpld_default_fan_data[] = {
1819         {
1820                 .label = "pwm1",
1821                 .reg = MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET,
1822         },
1823         {
1824                 .label = "tacho1",
1825                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET,
1826                 .mask = GENMASK(7, 0),
1827                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1828                 .bit = BIT(0),
1829                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1830
1831         },
1832         {
1833                 .label = "tacho2",
1834                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET,
1835                 .mask = GENMASK(7, 0),
1836                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1837                 .bit = BIT(1),
1838                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1839         },
1840         {
1841                 .label = "tacho3",
1842                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET,
1843                 .mask = GENMASK(7, 0),
1844                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1845                 .bit = BIT(2),
1846                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1847         },
1848         {
1849                 .label = "tacho4",
1850                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET,
1851                 .mask = GENMASK(7, 0),
1852                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1853                 .bit = BIT(3),
1854                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1855         },
1856         {
1857                 .label = "tacho5",
1858                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET,
1859                 .mask = GENMASK(7, 0),
1860                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1861                 .bit = BIT(4),
1862                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1863         },
1864         {
1865                 .label = "tacho6",
1866                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET,
1867                 .mask = GENMASK(7, 0),
1868                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1869                 .bit = BIT(5),
1870                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1871         },
1872         {
1873                 .label = "tacho7",
1874                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET,
1875                 .mask = GENMASK(7, 0),
1876                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1877                 .bit = BIT(6),
1878                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1879         },
1880         {
1881                 .label = "tacho8",
1882                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET,
1883                 .mask = GENMASK(7, 0),
1884                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1885                 .bit = BIT(7),
1886                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1887         },
1888         {
1889                 .label = "tacho9",
1890                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET,
1891                 .mask = GENMASK(7, 0),
1892                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET,
1893                 .bit = BIT(0),
1894                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1895         },
1896         {
1897                 .label = "tacho10",
1898                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET,
1899                 .mask = GENMASK(7, 0),
1900                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET,
1901                 .bit = BIT(1),
1902                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1903         },
1904         {
1905                 .label = "tacho11",
1906                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET,
1907                 .mask = GENMASK(7, 0),
1908                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET,
1909                 .bit = BIT(2),
1910                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1911         },
1912         {
1913                 .label = "tacho12",
1914                 .reg = MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET,
1915                 .mask = GENMASK(7, 0),
1916                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET,
1917                 .bit = BIT(3),
1918                 .reg_prsnt = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
1919         },
1920         {
1921                 .label = "conf",
1922                 .capability = MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET,
1923         },
1924 };
1925
1926 static struct mlxreg_core_platform_data mlxplat_default_fan_data = {
1927                 .data = mlxplat_mlxcpld_default_fan_data,
1928                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_fan_data),
1929                 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
1930 };
1931
1932 /* Watchdog type1: hardware implementation version1
1933  * (MSN2700, MSN2410, MSN2740, MSN2100 and MSN2140 systems).
1934  */
1935 static struct mlxreg_core_data mlxplat_mlxcpld_wd_main_regs_type1[] = {
1936         {
1937                 .label = "action",
1938                 .reg = MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET,
1939                 .mask = MLXPLAT_CPLD_WD_RESET_ACT_MASK,
1940                 .bit = 0,
1941         },
1942         {
1943                 .label = "timeout",
1944                 .reg = MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET,
1945                 .mask = MLXPLAT_CPLD_WD_TYPE1_TO_MASK,
1946                 .health_cntr = MLXPLAT_CPLD_WD_DFLT_TIMEOUT,
1947         },
1948         {
1949                 .label = "ping",
1950                 .reg = MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET,
1951                 .mask = MLXPLAT_CPLD_WD1_CLEAR_MASK,
1952                 .bit = 0,
1953         },
1954         {
1955                 .label = "reset",
1956                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1957                 .mask = GENMASK(7, 0) & ~BIT(6),
1958                 .bit = 6,
1959         },
1960 };
1961
1962 static struct mlxreg_core_data mlxplat_mlxcpld_wd_aux_regs_type1[] = {
1963         {
1964                 .label = "action",
1965                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET,
1966                 .mask = MLXPLAT_CPLD_WD_FAN_ACT_MASK,
1967                 .bit = 4,
1968         },
1969         {
1970                 .label = "timeout",
1971                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET,
1972                 .mask = MLXPLAT_CPLD_WD_TYPE1_TO_MASK,
1973                 .health_cntr = MLXPLAT_CPLD_WD_DFLT_TIMEOUT,
1974         },
1975         {
1976                 .label = "ping",
1977                 .reg = MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET,
1978                 .mask = MLXPLAT_CPLD_WD1_CLEAR_MASK,
1979                 .bit = 1,
1980         },
1981 };
1982
1983 static struct mlxreg_core_platform_data mlxplat_mlxcpld_wd_set_type1[] = {
1984         {
1985                 .data = mlxplat_mlxcpld_wd_main_regs_type1,
1986                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_main_regs_type1),
1987                 .version = MLX_WDT_TYPE1,
1988                 .identity = "mlx-wdt-main",
1989         },
1990         {
1991                 .data = mlxplat_mlxcpld_wd_aux_regs_type1,
1992                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_aux_regs_type1),
1993                 .version = MLX_WDT_TYPE1,
1994                 .identity = "mlx-wdt-aux",
1995         },
1996 };
1997
1998 /* Watchdog type2: hardware implementation version 2
1999  * (all systems except (MSN2700, MSN2410, MSN2740, MSN2100 and MSN2140).
2000  */
2001 static struct mlxreg_core_data mlxplat_mlxcpld_wd_main_regs_type2[] = {
2002         {
2003                 .label = "action",
2004                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET,
2005                 .mask = MLXPLAT_CPLD_WD_RESET_ACT_MASK,
2006                 .bit = 0,
2007         },
2008         {
2009                 .label = "timeout",
2010                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET,
2011                 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
2012                 .health_cntr = MLXPLAT_CPLD_WD_DFLT_TIMEOUT,
2013         },
2014         {
2015                 .label = "timeleft",
2016                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET,
2017                 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
2018         },
2019         {
2020                 .label = "ping",
2021                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET,
2022                 .mask = MLXPLAT_CPLD_WD_RESET_ACT_MASK,
2023                 .bit = 0,
2024         },
2025         {
2026                 .label = "reset",
2027                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
2028                 .mask = GENMASK(7, 0) & ~BIT(6),
2029                 .bit = 6,
2030         },
2031 };
2032
2033 static struct mlxreg_core_data mlxplat_mlxcpld_wd_aux_regs_type2[] = {
2034         {
2035                 .label = "action",
2036                 .reg = MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET,
2037                 .mask = MLXPLAT_CPLD_WD_FAN_ACT_MASK,
2038                 .bit = 4,
2039         },
2040         {
2041                 .label = "timeout",
2042                 .reg = MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET,
2043                 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
2044                 .health_cntr = MLXPLAT_CPLD_WD_DFLT_TIMEOUT,
2045         },
2046         {
2047                 .label = "timeleft",
2048                 .reg = MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET,
2049                 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
2050         },
2051         {
2052                 .label = "ping",
2053                 .reg = MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET,
2054                 .mask = MLXPLAT_CPLD_WD_FAN_ACT_MASK,
2055                 .bit = 4,
2056         },
2057 };
2058
2059 static struct mlxreg_core_platform_data mlxplat_mlxcpld_wd_set_type2[] = {
2060         {
2061                 .data = mlxplat_mlxcpld_wd_main_regs_type2,
2062                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_main_regs_type2),
2063                 .version = MLX_WDT_TYPE2,
2064                 .identity = "mlx-wdt-main",
2065         },
2066         {
2067                 .data = mlxplat_mlxcpld_wd_aux_regs_type2,
2068                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_aux_regs_type2),
2069                 .version = MLX_WDT_TYPE2,
2070                 .identity = "mlx-wdt-aux",
2071         },
2072 };
2073
2074 /* Watchdog type3: hardware implementation version 3
2075  * Can be on all systems. It's differentiated by WD capability bit.
2076  * Old systems (MSN2700, MSN2410, MSN2740, MSN2100 and MSN2140)
2077  * still have only one main watchdog.
2078  */
2079 static struct mlxreg_core_data mlxplat_mlxcpld_wd_main_regs_type3[] = {
2080         {
2081                 .label = "action",
2082                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET,
2083                 .mask = MLXPLAT_CPLD_WD_RESET_ACT_MASK,
2084                 .bit = 0,
2085         },
2086         {
2087                 .label = "timeout",
2088                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET,
2089                 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
2090                 .health_cntr = MLXPLAT_CPLD_WD3_DFLT_TIMEOUT,
2091         },
2092         {
2093                 .label = "timeleft",
2094                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET,
2095                 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
2096         },
2097         {
2098                 .label = "ping",
2099                 .reg = MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET,
2100                 .mask = MLXPLAT_CPLD_WD_RESET_ACT_MASK,
2101                 .bit = 0,
2102         },
2103         {
2104                 .label = "reset",
2105                 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
2106                 .mask = GENMASK(7, 0) & ~BIT(6),
2107                 .bit = 6,
2108         },
2109 };
2110
2111 static struct mlxreg_core_data mlxplat_mlxcpld_wd_aux_regs_type3[] = {
2112         {
2113                 .label = "action",
2114                 .reg = MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET,
2115                 .mask = MLXPLAT_CPLD_WD_FAN_ACT_MASK,
2116                 .bit = 4,
2117         },
2118         {
2119                 .label = "timeout",
2120                 .reg = MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET,
2121                 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
2122                 .health_cntr = MLXPLAT_CPLD_WD3_DFLT_TIMEOUT,
2123         },
2124         {
2125                 .label = "timeleft",
2126                 .reg = MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET,
2127                 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
2128         },
2129         {
2130                 .label = "ping",
2131                 .reg = MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET,
2132                 .mask = MLXPLAT_CPLD_WD_FAN_ACT_MASK,
2133                 .bit = 4,
2134         },
2135 };
2136
2137 static struct mlxreg_core_platform_data mlxplat_mlxcpld_wd_set_type3[] = {
2138         {
2139                 .data = mlxplat_mlxcpld_wd_main_regs_type3,
2140                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_main_regs_type3),
2141                 .version = MLX_WDT_TYPE3,
2142                 .identity = "mlx-wdt-main",
2143         },
2144         {
2145                 .data = mlxplat_mlxcpld_wd_aux_regs_type3,
2146                 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_aux_regs_type3),
2147                 .version = MLX_WDT_TYPE3,
2148                 .identity = "mlx-wdt-aux",
2149         },
2150 };
2151
2152 static bool mlxplat_mlxcpld_writeable_reg(struct device *dev, unsigned int reg)
2153 {
2154         switch (reg) {
2155         case MLXPLAT_CPLD_LPC_REG_LED1_OFFSET:
2156         case MLXPLAT_CPLD_LPC_REG_LED2_OFFSET:
2157         case MLXPLAT_CPLD_LPC_REG_LED3_OFFSET:
2158         case MLXPLAT_CPLD_LPC_REG_LED4_OFFSET:
2159         case MLXPLAT_CPLD_LPC_REG_LED5_OFFSET:
2160         case MLXPLAT_CPLD_LPC_REG_GP0_OFFSET:
2161         case MLXPLAT_CPLD_LPC_REG_GP1_OFFSET:
2162         case MLXPLAT_CPLD_LPC_REG_WP1_OFFSET:
2163         case MLXPLAT_CPLD_LPC_REG_GP2_OFFSET:
2164         case MLXPLAT_CPLD_LPC_REG_WP2_OFFSET:
2165         case MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET:
2166         case MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET:
2167         case MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET:
2168         case MLXPLAT_CPLD_LPC_REG_AGGRCX_MASK_OFFSET:
2169         case MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET:
2170         case MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET:
2171         case MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET:
2172         case MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET:
2173         case MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET:
2174         case MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET:
2175         case MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET:
2176         case MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET:
2177         case MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET:
2178         case MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET:
2179         case MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET:
2180         case MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET:
2181         case MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET:
2182         case MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET:
2183         case MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET:
2184         case MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET:
2185         case MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET:
2186         case MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET:
2187         case MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET:
2188         case MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET:
2189                 return true;
2190         }
2191         return false;
2192 }
2193
2194 static bool mlxplat_mlxcpld_readable_reg(struct device *dev, unsigned int reg)
2195 {
2196         switch (reg) {
2197         case MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET:
2198         case MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET:
2199         case MLXPLAT_CPLD_LPC_REG_CPLD3_VER_OFFSET:
2200         case MLXPLAT_CPLD_LPC_REG_CPLD4_VER_OFFSET:
2201         case MLXPLAT_CPLD_LPC_REG_CPLD1_PN_OFFSET:
2202         case MLXPLAT_CPLD_LPC_REG_CPLD2_PN_OFFSET:
2203         case MLXPLAT_CPLD_LPC_REG_CPLD3_PN_OFFSET:
2204         case MLXPLAT_CPLD_LPC_REG_CPLD4_PN_OFFSET:
2205         case MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET:
2206         case MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET:
2207         case MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET:
2208         case MLXPLAT_CPLD_LPC_REG_LED1_OFFSET:
2209         case MLXPLAT_CPLD_LPC_REG_LED2_OFFSET:
2210         case MLXPLAT_CPLD_LPC_REG_LED3_OFFSET:
2211         case MLXPLAT_CPLD_LPC_REG_LED4_OFFSET:
2212         case MLXPLAT_CPLD_LPC_REG_LED5_OFFSET:
2213         case MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION:
2214         case MLXPLAT_CPLD_LPC_REG_GP0_RO_OFFSET:
2215         case MLXPLAT_CPLD_LPC_REG_GP0_OFFSET:
2216         case MLXPLAT_CPLD_LPC_REG_GP1_OFFSET:
2217         case MLXPLAT_CPLD_LPC_REG_WP1_OFFSET:
2218         case MLXPLAT_CPLD_LPC_REG_GP2_OFFSET:
2219         case MLXPLAT_CPLD_LPC_REG_WP2_OFFSET:
2220         case MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET:
2221         case MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET:
2222         case MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET:
2223         case MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET:
2224         case MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET:
2225         case MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET:
2226         case MLXPLAT_CPLD_LPC_REG_AGGRCX_OFFSET:
2227         case MLXPLAT_CPLD_LPC_REG_AGGRCX_MASK_OFFSET:
2228         case MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET:
2229         case MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET:
2230         case MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET:
2231         case MLXPLAT_CPLD_LPC_REG_PSU_OFFSET:
2232         case MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET:
2233         case MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET:
2234         case MLXPLAT_CPLD_LPC_REG_PWR_OFFSET:
2235         case MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET:
2236         case MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET:
2237         case MLXPLAT_CPLD_LPC_REG_FAN_OFFSET:
2238         case MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET:
2239         case MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET:
2240         case MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET:
2241         case MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET:
2242         case MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET:
2243         case MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET:
2244         case MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET:
2245         case MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET:
2246         case MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET:
2247         case MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET:
2248         case MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET:
2249         case MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET:
2250         case MLXPLAT_CPLD_LPC_REG_CPLD1_MVER_OFFSET:
2251         case MLXPLAT_CPLD_LPC_REG_CPLD2_MVER_OFFSET:
2252         case MLXPLAT_CPLD_LPC_REG_CPLD3_MVER_OFFSET:
2253         case MLXPLAT_CPLD_LPC_REG_CPLD4_MVER_OFFSET:
2254         case MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET:
2255         case MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET:
2256         case MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET:
2257         case MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET:
2258         case MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET:
2259         case MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET:
2260         case MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET:
2261         case MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET:
2262         case MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET:
2263         case MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET:
2264         case MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET:
2265         case MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET:
2266         case MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET:
2267         case MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET:
2268         case MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET:
2269         case MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET:
2270         case MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET:
2271         case MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET:
2272         case MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET:
2273         case MLXPLAT_CPLD_LPC_REG_CONFIG1_OFFSET:
2274         case MLXPLAT_CPLD_LPC_REG_CONFIG2_OFFSET:
2275         case MLXPLAT_CPLD_LPC_REG_UFM_VERSION_OFFSET:
2276                 return true;
2277         }
2278         return false;
2279 }
2280
2281 static bool mlxplat_mlxcpld_volatile_reg(struct device *dev, unsigned int reg)
2282 {
2283         switch (reg) {
2284         case MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET:
2285         case MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET:
2286         case MLXPLAT_CPLD_LPC_REG_CPLD3_VER_OFFSET:
2287         case MLXPLAT_CPLD_LPC_REG_CPLD4_VER_OFFSET:
2288         case MLXPLAT_CPLD_LPC_REG_CPLD1_PN_OFFSET:
2289         case MLXPLAT_CPLD_LPC_REG_CPLD2_PN_OFFSET:
2290         case MLXPLAT_CPLD_LPC_REG_CPLD3_PN_OFFSET:
2291         case MLXPLAT_CPLD_LPC_REG_CPLD4_PN_OFFSET:
2292         case MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET:
2293         case MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET:
2294         case MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET:
2295         case MLXPLAT_CPLD_LPC_REG_LED1_OFFSET:
2296         case MLXPLAT_CPLD_LPC_REG_LED2_OFFSET:
2297         case MLXPLAT_CPLD_LPC_REG_LED3_OFFSET:
2298         case MLXPLAT_CPLD_LPC_REG_LED4_OFFSET:
2299         case MLXPLAT_CPLD_LPC_REG_LED5_OFFSET:
2300         case MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION:
2301         case MLXPLAT_CPLD_LPC_REG_GP0_RO_OFFSET:
2302         case MLXPLAT_CPLD_LPC_REG_GP0_OFFSET:
2303         case MLXPLAT_CPLD_LPC_REG_GP1_OFFSET:
2304         case MLXPLAT_CPLD_LPC_REG_GP2_OFFSET:
2305         case MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET:
2306         case MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET:
2307         case MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET:
2308         case MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET:
2309         case MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET:
2310         case MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET:
2311         case MLXPLAT_CPLD_LPC_REG_AGGRCX_OFFSET:
2312         case MLXPLAT_CPLD_LPC_REG_AGGRCX_MASK_OFFSET:
2313         case MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET:
2314         case MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET:
2315         case MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET:
2316         case MLXPLAT_CPLD_LPC_REG_PSU_OFFSET:
2317         case MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET:
2318         case MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET:
2319         case MLXPLAT_CPLD_LPC_REG_PWR_OFFSET:
2320         case MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET:
2321         case MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET:
2322         case MLXPLAT_CPLD_LPC_REG_FAN_OFFSET:
2323         case MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET:
2324         case MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET:
2325         case MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET:
2326         case MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET:
2327         case MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET:
2328         case MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET:
2329         case MLXPLAT_CPLD_LPC_REG_CPLD1_MVER_OFFSET:
2330         case MLXPLAT_CPLD_LPC_REG_CPLD2_MVER_OFFSET:
2331         case MLXPLAT_CPLD_LPC_REG_CPLD3_MVER_OFFSET:
2332         case MLXPLAT_CPLD_LPC_REG_CPLD4_MVER_OFFSET:
2333         case MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET:
2334         case MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET:
2335         case MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET:
2336         case MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET:
2337         case MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET:
2338         case MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET:
2339         case MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET:
2340         case MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET:
2341         case MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET:
2342         case MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET:
2343         case MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET:
2344         case MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET:
2345         case MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET:
2346         case MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET:
2347         case MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET:
2348         case MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET:
2349         case MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET:
2350         case MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET:
2351         case MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET:
2352         case MLXPLAT_CPLD_LPC_REG_CONFIG1_OFFSET:
2353         case MLXPLAT_CPLD_LPC_REG_CONFIG2_OFFSET:
2354         case MLXPLAT_CPLD_LPC_REG_UFM_VERSION_OFFSET:
2355                 return true;
2356         }
2357         return false;
2358 }
2359
2360 static const struct reg_default mlxplat_mlxcpld_regmap_default[] = {
2361         { MLXPLAT_CPLD_LPC_REG_WP1_OFFSET, 0x00 },
2362         { MLXPLAT_CPLD_LPC_REG_WP2_OFFSET, 0x00 },
2363         { MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET, 0x00 },
2364         { MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET, 0x00 },
2365 };
2366
2367 static const struct reg_default mlxplat_mlxcpld_regmap_ng[] = {
2368         { MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET, 0x00 },
2369         { MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET, 0x00 },
2370 };
2371
2372 static const struct reg_default mlxplat_mlxcpld_regmap_comex_default[] = {
2373         { MLXPLAT_CPLD_LPC_REG_AGGRCX_MASK_OFFSET,
2374           MLXPLAT_CPLD_LOW_AGGRCX_MASK },
2375         { MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET, 0x00 },
2376 };
2377
2378 static const struct reg_default mlxplat_mlxcpld_regmap_ng400[] = {
2379         { MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET, 0x00 },
2380         { MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET, 0x00 },
2381         { MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET, 0x00 },
2382         { MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET, 0x00 },
2383 };
2384
2385 struct mlxplat_mlxcpld_regmap_context {
2386         void __iomem *base;
2387 };
2388
2389 static struct mlxplat_mlxcpld_regmap_context mlxplat_mlxcpld_regmap_ctx;
2390
2391 static int
2392 mlxplat_mlxcpld_reg_read(void *context, unsigned int reg, unsigned int *val)
2393 {
2394         struct mlxplat_mlxcpld_regmap_context *ctx = context;
2395
2396         *val = ioread8(ctx->base + reg);
2397         return 0;
2398 }
2399
2400 static int
2401 mlxplat_mlxcpld_reg_write(void *context, unsigned int reg, unsigned int val)
2402 {
2403         struct mlxplat_mlxcpld_regmap_context *ctx = context;
2404
2405         iowrite8(val, ctx->base + reg);
2406         return 0;
2407 }
2408
2409 static const struct regmap_config mlxplat_mlxcpld_regmap_config = {
2410         .reg_bits = 8,
2411         .val_bits = 8,
2412         .max_register = 255,
2413         .cache_type = REGCACHE_FLAT,
2414         .writeable_reg = mlxplat_mlxcpld_writeable_reg,
2415         .readable_reg = mlxplat_mlxcpld_readable_reg,
2416         .volatile_reg = mlxplat_mlxcpld_volatile_reg,
2417         .reg_defaults = mlxplat_mlxcpld_regmap_default,
2418         .num_reg_defaults = ARRAY_SIZE(mlxplat_mlxcpld_regmap_default),
2419         .reg_read = mlxplat_mlxcpld_reg_read,
2420         .reg_write = mlxplat_mlxcpld_reg_write,
2421 };
2422
2423 static const struct regmap_config mlxplat_mlxcpld_regmap_config_ng = {
2424         .reg_bits = 8,
2425         .val_bits = 8,
2426         .max_register = 255,
2427         .cache_type = REGCACHE_FLAT,
2428         .writeable_reg = mlxplat_mlxcpld_writeable_reg,
2429         .readable_reg = mlxplat_mlxcpld_readable_reg,
2430         .volatile_reg = mlxplat_mlxcpld_volatile_reg,
2431         .reg_defaults = mlxplat_mlxcpld_regmap_ng,
2432         .num_reg_defaults = ARRAY_SIZE(mlxplat_mlxcpld_regmap_ng),
2433         .reg_read = mlxplat_mlxcpld_reg_read,
2434         .reg_write = mlxplat_mlxcpld_reg_write,
2435 };
2436
2437 static const struct regmap_config mlxplat_mlxcpld_regmap_config_comex = {
2438         .reg_bits = 8,
2439         .val_bits = 8,
2440         .max_register = 255,
2441         .cache_type = REGCACHE_FLAT,
2442         .writeable_reg = mlxplat_mlxcpld_writeable_reg,
2443         .readable_reg = mlxplat_mlxcpld_readable_reg,
2444         .volatile_reg = mlxplat_mlxcpld_volatile_reg,
2445         .reg_defaults = mlxplat_mlxcpld_regmap_comex_default,
2446         .num_reg_defaults = ARRAY_SIZE(mlxplat_mlxcpld_regmap_comex_default),
2447         .reg_read = mlxplat_mlxcpld_reg_read,
2448         .reg_write = mlxplat_mlxcpld_reg_write,
2449 };
2450
2451 static const struct regmap_config mlxplat_mlxcpld_regmap_config_ng400 = {
2452         .reg_bits = 8,
2453         .val_bits = 8,
2454         .max_register = 255,
2455         .cache_type = REGCACHE_FLAT,
2456         .writeable_reg = mlxplat_mlxcpld_writeable_reg,
2457         .readable_reg = mlxplat_mlxcpld_readable_reg,
2458         .volatile_reg = mlxplat_mlxcpld_volatile_reg,
2459         .reg_defaults = mlxplat_mlxcpld_regmap_ng400,
2460         .num_reg_defaults = ARRAY_SIZE(mlxplat_mlxcpld_regmap_ng400),
2461         .reg_read = mlxplat_mlxcpld_reg_read,
2462         .reg_write = mlxplat_mlxcpld_reg_write,
2463 };
2464
2465 static struct resource mlxplat_mlxcpld_resources[] = {
2466         [0] = DEFINE_RES_IRQ_NAMED(17, "mlxreg-hotplug"),
2467 };
2468
2469 static struct platform_device *mlxplat_dev;
2470 static struct mlxreg_core_hotplug_platform_data *mlxplat_i2c;
2471 static struct mlxreg_core_hotplug_platform_data *mlxplat_hotplug;
2472 static struct mlxreg_core_platform_data *mlxplat_led;
2473 static struct mlxreg_core_platform_data *mlxplat_regs_io;
2474 static struct mlxreg_core_platform_data *mlxplat_fan;
2475 static struct mlxreg_core_platform_data
2476         *mlxplat_wd_data[MLXPLAT_CPLD_WD_MAX_DEVS];
2477 static const struct regmap_config *mlxplat_regmap_config;
2478
2479 static int __init mlxplat_dmi_default_matched(const struct dmi_system_id *dmi)
2480 {
2481         int i;
2482
2483         mlxplat_max_adap_num = MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM;
2484         mlxplat_mux_num = ARRAY_SIZE(mlxplat_default_mux_data);
2485         mlxplat_mux_data = mlxplat_default_mux_data;
2486         for (i = 0; i < mlxplat_mux_num; i++) {
2487                 mlxplat_mux_data[i].values = mlxplat_default_channels[i];
2488                 mlxplat_mux_data[i].n_values =
2489                                 ARRAY_SIZE(mlxplat_default_channels[i]);
2490         }
2491         mlxplat_hotplug = &mlxplat_mlxcpld_default_data;
2492         mlxplat_hotplug->deferred_nr =
2493                 mlxplat_default_channels[i - 1][MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
2494         mlxplat_led = &mlxplat_default_led_data;
2495         mlxplat_regs_io = &mlxplat_default_regs_io_data;
2496         mlxplat_wd_data[0] = &mlxplat_mlxcpld_wd_set_type1[0];
2497
2498         return 1;
2499 }
2500
2501 static int __init mlxplat_dmi_msn21xx_matched(const struct dmi_system_id *dmi)
2502 {
2503         int i;
2504
2505         mlxplat_max_adap_num = MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM;
2506         mlxplat_mux_num = ARRAY_SIZE(mlxplat_default_mux_data);
2507         mlxplat_mux_data = mlxplat_default_mux_data;
2508         for (i = 0; i < mlxplat_mux_num; i++) {
2509                 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
2510                 mlxplat_mux_data[i].n_values =
2511                                 ARRAY_SIZE(mlxplat_msn21xx_channels);
2512         }
2513         mlxplat_hotplug = &mlxplat_mlxcpld_msn21xx_data;
2514         mlxplat_hotplug->deferred_nr =
2515                 mlxplat_msn21xx_channels[MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
2516         mlxplat_led = &mlxplat_msn21xx_led_data;
2517         mlxplat_regs_io = &mlxplat_msn21xx_regs_io_data;
2518         mlxplat_wd_data[0] = &mlxplat_mlxcpld_wd_set_type1[0];
2519
2520         return 1;
2521 }
2522
2523 static int __init mlxplat_dmi_msn274x_matched(const struct dmi_system_id *dmi)
2524 {
2525         int i;
2526
2527         mlxplat_max_adap_num = MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM;
2528         mlxplat_mux_num = ARRAY_SIZE(mlxplat_default_mux_data);
2529         mlxplat_mux_data = mlxplat_default_mux_data;
2530         for (i = 0; i < mlxplat_mux_num; i++) {
2531                 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
2532                 mlxplat_mux_data[i].n_values =
2533                                 ARRAY_SIZE(mlxplat_msn21xx_channels);
2534         }
2535         mlxplat_hotplug = &mlxplat_mlxcpld_msn274x_data;
2536         mlxplat_hotplug->deferred_nr =
2537                 mlxplat_msn21xx_channels[MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
2538         mlxplat_led = &mlxplat_default_led_data;
2539         mlxplat_regs_io = &mlxplat_msn21xx_regs_io_data;
2540         mlxplat_wd_data[0] = &mlxplat_mlxcpld_wd_set_type1[0];
2541
2542         return 1;
2543 }
2544
2545 static int __init mlxplat_dmi_msn201x_matched(const struct dmi_system_id *dmi)
2546 {
2547         int i;
2548
2549         mlxplat_max_adap_num = MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM;
2550         mlxplat_mux_num = ARRAY_SIZE(mlxplat_default_mux_data);
2551         mlxplat_mux_data = mlxplat_default_mux_data;
2552         for (i = 0; i < mlxplat_mux_num; i++) {
2553                 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
2554                 mlxplat_mux_data[i].n_values =
2555                                 ARRAY_SIZE(mlxplat_msn21xx_channels);
2556         }
2557         mlxplat_hotplug = &mlxplat_mlxcpld_msn201x_data;
2558         mlxplat_hotplug->deferred_nr =
2559                 mlxplat_default_channels[i - 1][MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
2560         mlxplat_led = &mlxplat_msn21xx_led_data;
2561         mlxplat_regs_io = &mlxplat_msn21xx_regs_io_data;
2562         mlxplat_wd_data[0] = &mlxplat_mlxcpld_wd_set_type1[0];
2563
2564         return 1;
2565 }
2566
2567 static int __init mlxplat_dmi_qmb7xx_matched(const struct dmi_system_id *dmi)
2568 {
2569         int i;
2570
2571         mlxplat_max_adap_num = MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM;
2572         mlxplat_mux_num = ARRAY_SIZE(mlxplat_default_mux_data);
2573         mlxplat_mux_data = mlxplat_default_mux_data;
2574         for (i = 0; i < mlxplat_mux_num; i++) {
2575                 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
2576                 mlxplat_mux_data[i].n_values =
2577                                 ARRAY_SIZE(mlxplat_msn21xx_channels);
2578         }
2579         mlxplat_hotplug = &mlxplat_mlxcpld_default_ng_data;
2580         mlxplat_hotplug->deferred_nr =
2581                 mlxplat_msn21xx_channels[MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
2582         mlxplat_led = &mlxplat_default_ng_led_data;
2583         mlxplat_regs_io = &mlxplat_default_ng_regs_io_data;
2584         mlxplat_fan = &mlxplat_default_fan_data;
2585         for (i = 0; i < ARRAY_SIZE(mlxplat_mlxcpld_wd_set_type2); i++)
2586                 mlxplat_wd_data[i] = &mlxplat_mlxcpld_wd_set_type2[i];
2587         mlxplat_i2c = &mlxplat_mlxcpld_i2c_ng_data;
2588         mlxplat_regmap_config = &mlxplat_mlxcpld_regmap_config_ng;
2589
2590         return 1;
2591 }
2592
2593 static int __init mlxplat_dmi_comex_matched(const struct dmi_system_id *dmi)
2594 {
2595         int i;
2596
2597         mlxplat_max_adap_num = MLXPLAT_CPLD_MAX_PHYS_EXT_ADAPTER_NUM;
2598         mlxplat_mux_num = ARRAY_SIZE(mlxplat_extended_mux_data);
2599         mlxplat_mux_data = mlxplat_extended_mux_data;
2600         for (i = 0; i < mlxplat_mux_num; i++) {
2601                 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
2602                 mlxplat_mux_data[i].n_values =
2603                                 ARRAY_SIZE(mlxplat_msn21xx_channels);
2604         }
2605         mlxplat_hotplug = &mlxplat_mlxcpld_comex_data;
2606         mlxplat_hotplug->deferred_nr = MLXPLAT_CPLD_MAX_PHYS_EXT_ADAPTER_NUM;
2607         mlxplat_led = &mlxplat_comex_100G_led_data;
2608         mlxplat_regs_io = &mlxplat_default_ng_regs_io_data;
2609         mlxplat_fan = &mlxplat_default_fan_data;
2610         for (i = 0; i < ARRAY_SIZE(mlxplat_mlxcpld_wd_set_type2); i++)
2611                 mlxplat_wd_data[i] = &mlxplat_mlxcpld_wd_set_type2[i];
2612         mlxplat_regmap_config = &mlxplat_mlxcpld_regmap_config_comex;
2613
2614         return 1;
2615 }
2616
2617 static int __init mlxplat_dmi_ng400_matched(const struct dmi_system_id *dmi)
2618 {
2619         int i;
2620
2621         mlxplat_max_adap_num = MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM;
2622         mlxplat_mux_num = ARRAY_SIZE(mlxplat_default_mux_data);
2623         mlxplat_mux_data = mlxplat_default_mux_data;
2624         for (i = 0; i < mlxplat_mux_num; i++) {
2625                 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
2626                 mlxplat_mux_data[i].n_values =
2627                                 ARRAY_SIZE(mlxplat_msn21xx_channels);
2628         }
2629         mlxplat_hotplug = &mlxplat_mlxcpld_ext_data;
2630         mlxplat_hotplug->deferred_nr =
2631                 mlxplat_msn21xx_channels[MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
2632         mlxplat_led = &mlxplat_default_ng_led_data;
2633         mlxplat_regs_io = &mlxplat_default_ng_regs_io_data;
2634         mlxplat_fan = &mlxplat_default_fan_data;
2635         for (i = 0; i < ARRAY_SIZE(mlxplat_mlxcpld_wd_set_type2); i++)
2636                 mlxplat_wd_data[i] = &mlxplat_mlxcpld_wd_set_type2[i];
2637         mlxplat_i2c = &mlxplat_mlxcpld_i2c_ng_data;
2638         mlxplat_regmap_config = &mlxplat_mlxcpld_regmap_config_ng400;
2639
2640         return 1;
2641 }
2642
2643 static const struct dmi_system_id mlxplat_dmi_table[] __initconst = {
2644         {
2645                 .callback = mlxplat_dmi_default_matched,
2646                 .matches = {
2647                         DMI_MATCH(DMI_BOARD_NAME, "VMOD0001"),
2648                 },
2649         },
2650         {
2651                 .callback = mlxplat_dmi_msn21xx_matched,
2652                 .matches = {
2653                         DMI_MATCH(DMI_BOARD_NAME, "VMOD0002"),
2654                 },
2655         },
2656         {
2657                 .callback = mlxplat_dmi_msn274x_matched,
2658                 .matches = {
2659                         DMI_MATCH(DMI_BOARD_NAME, "VMOD0003"),
2660                 },
2661         },
2662         {
2663                 .callback = mlxplat_dmi_msn201x_matched,
2664                 .matches = {
2665                         DMI_MATCH(DMI_BOARD_NAME, "VMOD0004"),
2666                 },
2667         },
2668         {
2669                 .callback = mlxplat_dmi_qmb7xx_matched,
2670                 .matches = {
2671                         DMI_MATCH(DMI_BOARD_NAME, "VMOD0005"),
2672                 },
2673         },
2674         {
2675                 .callback = mlxplat_dmi_qmb7xx_matched,
2676                 .matches = {
2677                         DMI_MATCH(DMI_BOARD_NAME, "VMOD0007"),
2678                 },
2679         },
2680         {
2681                 .callback = mlxplat_dmi_comex_matched,
2682                 .matches = {
2683                         DMI_MATCH(DMI_BOARD_NAME, "VMOD0009"),
2684                 },
2685         },
2686         {
2687                 .callback = mlxplat_dmi_ng400_matched,
2688                 .matches = {
2689                         DMI_MATCH(DMI_BOARD_NAME, "VMOD0010"),
2690                 },
2691         },
2692         {
2693                 .callback = mlxplat_dmi_msn274x_matched,
2694                 .matches = {
2695                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2696                         DMI_MATCH(DMI_PRODUCT_NAME, "MSN274"),
2697                 },
2698         },
2699         {
2700                 .callback = mlxplat_dmi_default_matched,
2701                 .matches = {
2702                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2703                         DMI_MATCH(DMI_PRODUCT_NAME, "MSN24"),
2704                 },
2705         },
2706         {
2707                 .callback = mlxplat_dmi_default_matched,
2708                 .matches = {
2709                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2710                         DMI_MATCH(DMI_PRODUCT_NAME, "MSN27"),
2711                 },
2712         },
2713         {
2714                 .callback = mlxplat_dmi_default_matched,
2715                 .matches = {
2716                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2717                         DMI_MATCH(DMI_PRODUCT_NAME, "MSB"),
2718                 },
2719         },
2720         {
2721                 .callback = mlxplat_dmi_default_matched,
2722                 .matches = {
2723                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2724                         DMI_MATCH(DMI_PRODUCT_NAME, "MSX"),
2725                 },
2726         },
2727         {
2728                 .callback = mlxplat_dmi_msn21xx_matched,
2729                 .matches = {
2730                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2731                         DMI_MATCH(DMI_PRODUCT_NAME, "MSN21"),
2732                 },
2733         },
2734         {
2735                 .callback = mlxplat_dmi_msn201x_matched,
2736                 .matches = {
2737                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2738                         DMI_MATCH(DMI_PRODUCT_NAME, "MSN201"),
2739                 },
2740         },
2741         {
2742                 .callback = mlxplat_dmi_qmb7xx_matched,
2743                 .matches = {
2744                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2745                         DMI_MATCH(DMI_PRODUCT_NAME, "MQM87"),
2746                 },
2747         },
2748         {
2749                 .callback = mlxplat_dmi_qmb7xx_matched,
2750                 .matches = {
2751                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2752                         DMI_MATCH(DMI_PRODUCT_NAME, "MSN37"),
2753                 },
2754         },
2755         {
2756                 .callback = mlxplat_dmi_qmb7xx_matched,
2757                 .matches = {
2758                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2759                         DMI_MATCH(DMI_PRODUCT_NAME, "MSN34"),
2760                 },
2761         },
2762         {
2763                 .callback = mlxplat_dmi_qmb7xx_matched,
2764                 .matches = {
2765                         DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2766                         DMI_MATCH(DMI_PRODUCT_NAME, "MSN38"),
2767                 },
2768         },
2769         { }
2770 };
2771
2772 MODULE_DEVICE_TABLE(dmi, mlxplat_dmi_table);
2773
2774 static int mlxplat_mlxcpld_verify_bus_topology(int *nr)
2775 {
2776         struct i2c_adapter *search_adap;
2777         int shift, i;
2778
2779         /* Scan adapters from expected id to verify it is free. */
2780         *nr = MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR;
2781         for (i = MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR; i <
2782              mlxplat_max_adap_num; i++) {
2783                 search_adap = i2c_get_adapter(i);
2784                 if (search_adap) {
2785                         i2c_put_adapter(search_adap);
2786                         continue;
2787                 }
2788
2789                 /* Return if expected parent adapter is free. */
2790                 if (i == MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR)
2791                         return 0;
2792                 break;
2793         }
2794
2795         /* Return with error if free id for adapter is not found. */
2796         if (i == mlxplat_max_adap_num)
2797                 return -ENODEV;
2798
2799         /* Shift adapter ids, since expected parent adapter is not free. */
2800         *nr = i;
2801         for (i = 0; i < mlxplat_mux_num; i++) {
2802                 shift = *nr - mlxplat_mux_data[i].parent;
2803                 mlxplat_mux_data[i].parent = *nr;
2804                 mlxplat_mux_data[i].base_nr += shift;
2805                 if (shift > 0)
2806                         mlxplat_hotplug->shift_nr = shift;
2807         }
2808
2809         return 0;
2810 }
2811
2812 static int mlxplat_mlxcpld_check_wd_capability(void *regmap)
2813 {
2814         u32 regval;
2815         int i, rc;
2816
2817         rc = regmap_read(regmap, MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
2818                          &regval);
2819         if (rc)
2820                 return rc;
2821
2822         if (!(regval & ~MLXPLAT_CPLD_WD_CPBLTY_MASK)) {
2823                 for (i = 0; i < ARRAY_SIZE(mlxplat_mlxcpld_wd_set_type3); i++) {
2824                         if (mlxplat_wd_data[i])
2825                                 mlxplat_wd_data[i] =
2826                                         &mlxplat_mlxcpld_wd_set_type3[i];
2827                 }
2828         }
2829
2830         return 0;
2831 }
2832
2833 static int __init mlxplat_init(void)
2834 {
2835         struct mlxplat_priv *priv;
2836         int i, j, nr, err;
2837
2838         if (!dmi_check_system(mlxplat_dmi_table))
2839                 return -ENODEV;
2840
2841         mlxplat_dev = platform_device_register_simple(MLX_PLAT_DEVICE_NAME, -1,
2842                                         mlxplat_lpc_resources,
2843                                         ARRAY_SIZE(mlxplat_lpc_resources));
2844
2845         if (IS_ERR(mlxplat_dev))
2846                 return PTR_ERR(mlxplat_dev);
2847
2848         priv = devm_kzalloc(&mlxplat_dev->dev, sizeof(struct mlxplat_priv),
2849                             GFP_KERNEL);
2850         if (!priv) {
2851                 err = -ENOMEM;
2852                 goto fail_alloc;
2853         }
2854         platform_set_drvdata(mlxplat_dev, priv);
2855
2856         mlxplat_mlxcpld_regmap_ctx.base = devm_ioport_map(&mlxplat_dev->dev,
2857                                mlxplat_lpc_resources[1].start, 1);
2858         if (!mlxplat_mlxcpld_regmap_ctx.base) {
2859                 err = -ENOMEM;
2860                 goto fail_alloc;
2861         }
2862
2863         if (!mlxplat_regmap_config)
2864                 mlxplat_regmap_config = &mlxplat_mlxcpld_regmap_config;
2865
2866         priv->regmap = devm_regmap_init(&mlxplat_dev->dev, NULL,
2867                                         &mlxplat_mlxcpld_regmap_ctx,
2868                                         mlxplat_regmap_config);
2869         if (IS_ERR(priv->regmap)) {
2870                 err = PTR_ERR(priv->regmap);
2871                 goto fail_alloc;
2872         }
2873
2874         err = mlxplat_mlxcpld_verify_bus_topology(&nr);
2875         if (nr < 0)
2876                 goto fail_alloc;
2877
2878         nr = (nr == mlxplat_max_adap_num) ? -1 : nr;
2879         if (mlxplat_i2c)
2880                 mlxplat_i2c->regmap = priv->regmap;
2881         priv->pdev_i2c = platform_device_register_resndata(
2882                                         &mlxplat_dev->dev, "i2c_mlxcpld",
2883                                         nr, mlxplat_mlxcpld_resources,
2884                                         ARRAY_SIZE(mlxplat_mlxcpld_resources),
2885                                         mlxplat_i2c, sizeof(*mlxplat_i2c));
2886         if (IS_ERR(priv->pdev_i2c)) {
2887                 err = PTR_ERR(priv->pdev_i2c);
2888                 goto fail_alloc;
2889         }
2890
2891         for (i = 0; i < mlxplat_mux_num; i++) {
2892                 priv->pdev_mux[i] = platform_device_register_resndata(
2893                                                 &priv->pdev_i2c->dev,
2894                                                 "i2c-mux-reg", i, NULL,
2895                                                 0, &mlxplat_mux_data[i],
2896                                                 sizeof(mlxplat_mux_data[i]));
2897                 if (IS_ERR(priv->pdev_mux[i])) {
2898                         err = PTR_ERR(priv->pdev_mux[i]);
2899                         goto fail_platform_mux_register;
2900                 }
2901         }
2902
2903         /* Add hotplug driver */
2904         mlxplat_hotplug->regmap = priv->regmap;
2905         priv->pdev_hotplug = platform_device_register_resndata(
2906                                 &mlxplat_dev->dev, "mlxreg-hotplug",
2907                                 PLATFORM_DEVID_NONE,
2908                                 mlxplat_mlxcpld_resources,
2909                                 ARRAY_SIZE(mlxplat_mlxcpld_resources),
2910                                 mlxplat_hotplug, sizeof(*mlxplat_hotplug));
2911         if (IS_ERR(priv->pdev_hotplug)) {
2912                 err = PTR_ERR(priv->pdev_hotplug);
2913                 goto fail_platform_mux_register;
2914         }
2915
2916         /* Set default registers. */
2917         for (j = 0; j <  mlxplat_regmap_config->num_reg_defaults; j++) {
2918                 err = regmap_write(priv->regmap,
2919                                    mlxplat_regmap_config->reg_defaults[j].reg,
2920                                    mlxplat_regmap_config->reg_defaults[j].def);
2921                 if (err)
2922                         goto fail_platform_mux_register;
2923         }
2924
2925         /* Add LED driver. */
2926         mlxplat_led->regmap = priv->regmap;
2927         priv->pdev_led = platform_device_register_resndata(
2928                                 &mlxplat_dev->dev, "leds-mlxreg",
2929                                 PLATFORM_DEVID_NONE, NULL, 0,
2930                                 mlxplat_led, sizeof(*mlxplat_led));
2931         if (IS_ERR(priv->pdev_led)) {
2932                 err = PTR_ERR(priv->pdev_led);
2933                 goto fail_platform_hotplug_register;
2934         }
2935
2936         /* Add registers io access driver. */
2937         if (mlxplat_regs_io) {
2938                 mlxplat_regs_io->regmap = priv->regmap;
2939                 priv->pdev_io_regs = platform_device_register_resndata(
2940                                         &mlxplat_dev->dev, "mlxreg-io",
2941                                         PLATFORM_DEVID_NONE, NULL, 0,
2942                                         mlxplat_regs_io,
2943                                         sizeof(*mlxplat_regs_io));
2944                 if (IS_ERR(priv->pdev_io_regs)) {
2945                         err = PTR_ERR(priv->pdev_io_regs);
2946                         goto fail_platform_led_register;
2947                 }
2948         }
2949
2950         /* Add FAN driver. */
2951         if (mlxplat_fan) {
2952                 mlxplat_fan->regmap = priv->regmap;
2953                 priv->pdev_fan = platform_device_register_resndata(
2954                                         &mlxplat_dev->dev, "mlxreg-fan",
2955                                         PLATFORM_DEVID_NONE, NULL, 0,
2956                                         mlxplat_fan,
2957                                         sizeof(*mlxplat_fan));
2958                 if (IS_ERR(priv->pdev_fan)) {
2959                         err = PTR_ERR(priv->pdev_fan);
2960                         goto fail_platform_io_regs_register;
2961                 }
2962         }
2963
2964         /* Add WD drivers. */
2965         err = mlxplat_mlxcpld_check_wd_capability(priv->regmap);
2966         if (err)
2967                 goto fail_platform_wd_register;
2968         for (j = 0; j < MLXPLAT_CPLD_WD_MAX_DEVS; j++) {
2969                 if (mlxplat_wd_data[j]) {
2970                         mlxplat_wd_data[j]->regmap = priv->regmap;
2971                         priv->pdev_wd[j] = platform_device_register_resndata(
2972                                                 &mlxplat_dev->dev, "mlx-wdt",
2973                                                 j, NULL, 0,
2974                                                 mlxplat_wd_data[j],
2975                                                 sizeof(*mlxplat_wd_data[j]));
2976                         if (IS_ERR(priv->pdev_wd[j])) {
2977                                 err = PTR_ERR(priv->pdev_wd[j]);
2978                                 goto fail_platform_wd_register;
2979                         }
2980                 }
2981         }
2982
2983         /* Sync registers with hardware. */
2984         regcache_mark_dirty(priv->regmap);
2985         err = regcache_sync(priv->regmap);
2986         if (err)
2987                 goto fail_platform_wd_register;
2988
2989         return 0;
2990
2991 fail_platform_wd_register:
2992         while (--j >= 0)
2993                 platform_device_unregister(priv->pdev_wd[j]);
2994         if (mlxplat_fan)
2995                 platform_device_unregister(priv->pdev_fan);
2996 fail_platform_io_regs_register:
2997         if (mlxplat_regs_io)
2998                 platform_device_unregister(priv->pdev_io_regs);
2999 fail_platform_led_register:
3000         platform_device_unregister(priv->pdev_led);
3001 fail_platform_hotplug_register:
3002         platform_device_unregister(priv->pdev_hotplug);
3003 fail_platform_mux_register:
3004         while (--i >= 0)
3005                 platform_device_unregister(priv->pdev_mux[i]);
3006         platform_device_unregister(priv->pdev_i2c);
3007 fail_alloc:
3008         platform_device_unregister(mlxplat_dev);
3009
3010         return err;
3011 }
3012 module_init(mlxplat_init);
3013
3014 static void __exit mlxplat_exit(void)
3015 {
3016         struct mlxplat_priv *priv = platform_get_drvdata(mlxplat_dev);
3017         int i;
3018
3019         for (i = MLXPLAT_CPLD_WD_MAX_DEVS - 1; i >= 0 ; i--)
3020                 platform_device_unregister(priv->pdev_wd[i]);
3021         if (priv->pdev_fan)
3022                 platform_device_unregister(priv->pdev_fan);
3023         if (priv->pdev_io_regs)
3024                 platform_device_unregister(priv->pdev_io_regs);
3025         platform_device_unregister(priv->pdev_led);
3026         platform_device_unregister(priv->pdev_hotplug);
3027
3028         for (i = mlxplat_mux_num - 1; i >= 0 ; i--)
3029                 platform_device_unregister(priv->pdev_mux[i]);
3030
3031         platform_device_unregister(priv->pdev_i2c);
3032         platform_device_unregister(mlxplat_dev);
3033 }
3034 module_exit(mlxplat_exit);
3035
3036 MODULE_AUTHOR("Vadim Pasternak (vadimp@mellanox.com)");
3037 MODULE_DESCRIPTION("Mellanox platform driver");
3038 MODULE_LICENSE("Dual BSD/GPL");