Quelle  mlx-platform.c   Sprache: C

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/*
 * Mellanox platform driver
 *
 * Copyright (C) 2016-2018 Mellanox Technologies
 * Copyright (C) 2016-2018 Vadim Pasternak <vadimp@mellanox.com>
 */

#include <linux/device.h>
#include <linux/dmi.h>
#include <linux/i2c.h>
#include <linux/i2c-mux.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/platform_device.h>
#include <linux/platform_data/i2c-mux-reg.h>
#include <linux/platform_data/mlxreg.h>
#include <linux/reboot.h>
#include <linux/regmap.h>

#define MLX_PLAT_DEVICE_NAME  "mlxplat"

/* LPC bus IO offsets */
#define MLXPLAT_CPLD_LPC_I2C_BASE_ADRR  0x2000
#define MLXPLAT_CPLD_LPC_REG_BASE_ADRR  0x2500
#define MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET 0x00
#define MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET 0x01
#define MLXPLAT_CPLD_LPC_REG_CPLD3_VER_OFFSET 0x02
#define MLXPLAT_CPLD_LPC_REG_CPLD4_VER_OFFSET 0x03
#define MLXPLAT_CPLD_LPC_REG_CPLD1_PN_OFFSET 0x04
#define MLXPLAT_CPLD_LPC_REG_CPLD1_PN1_OFFSET 0x05
#define MLXPLAT_CPLD_LPC_REG_CPLD2_PN_OFFSET 0x06
#define MLXPLAT_CPLD_LPC_REG_CPLD2_PN1_OFFSET 0x07
#define MLXPLAT_CPLD_LPC_REG_CPLD3_PN_OFFSET 0x08
#define MLXPLAT_CPLD_LPC_REG_CPLD3_PN1_OFFSET 0x09
#define MLXPLAT_CPLD_LPC_REG_CPLD4_PN_OFFSET 0x0a
#define MLXPLAT_CPLD_LPC_REG_CPLD4_PN1_OFFSET 0x0b
#define MLXPLAT_CPLD_LPC_REG_RESET_GP1_OFFSET 0x17
#define MLXPLAT_CPLD_LPC_REG_RESET_GP2_OFFSET 0x19
#define MLXPLAT_CPLD_LPC_REG_RESET_GP3_OFFSET 0x1b
#define MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET 0x1c
#define MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET 0x1d
#define MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET 0x1e
#define MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET 0x1f
#define MLXPLAT_CPLD_LPC_REG_LED1_OFFSET 0x20
#define MLXPLAT_CPLD_LPC_REG_LED2_OFFSET 0x21
#define MLXPLAT_CPLD_LPC_REG_LED3_OFFSET 0x22
#define MLXPLAT_CPLD_LPC_REG_LED4_OFFSET 0x23
#define MLXPLAT_CPLD_LPC_REG_LED5_OFFSET 0x24
#define MLXPLAT_CPLD_LPC_REG_LED6_OFFSET 0x25
#define MLXPLAT_CPLD_LPC_REG_LED7_OFFSET 0x26
#define MLXPLAT_CPLD_LPC_REG_LED8_OFFSET 0x27
#define MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION 0x2a
#define MLXPLAT_CPLD_LPC_REG_GP0_RO_OFFSET 0x2b
#define MLXPLAT_CPLD_LPC_REG_GPCOM0_OFFSET 0x2d
#define MLXPLAT_CPLD_LPC_REG_GP1_RO_OFFSET 0x2c
#define MLXPLAT_CPLD_LPC_REG_GP0_OFFSET  0x2e
#define MLXPLAT_CPLD_LPC_REG_GP_RST_OFFSET 0x2f
#define MLXPLAT_CPLD_LPC_REG_GP1_OFFSET  0x30
#define MLXPLAT_CPLD_LPC_REG_WP1_OFFSET  0x31
#define MLXPLAT_CPLD_LPC_REG_GP2_OFFSET  0x32
#define MLXPLAT_CPLD_LPC_REG_WP2_OFFSET  0x33
#define MLXPLAT_CPLD_LPC_REG_FIELD_UPGRADE 0x34
#define MLXPLAT_CPLD_LPC_SAFE_BIOS_OFFSET 0x35
#define MLXPLAT_CPLD_LPC_SAFE_BIOS_WP_OFFSET 0x36
#define MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET 0x37
#define MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET 0x3a
#define MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET 0x3b
#define MLXPLAT_CPLD_LPC_REG_FU_CAP_OFFSET 0x3c
#define MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET 0x40
#define MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET 0x41
#define MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET 0x42
#define MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET 0x43
#define MLXPLAT_CPLD_LPC_REG_AGGRCX_OFFSET 0x44
#define MLXPLAT_CPLD_LPC_REG_AGGRCX_MASK_OFFSET 0x45
#define MLXPLAT_CPLD_LPC_REG_GP3_OFFSET  0x46
#define MLXPLAT_CPLD_LPC_REG_BRD_OFFSET  0x47
#define MLXPLAT_CPLD_LPC_REG_BRD_EVENT_OFFSET 0x48
#define MLXPLAT_CPLD_LPC_REG_BRD_MASK_OFFSET 0x49
#define MLXPLAT_CPLD_LPC_REG_GWP_OFFSET  0x4a
#define MLXPLAT_CPLD_LPC_REG_GWP_EVENT_OFFSET 0x4b
#define MLXPLAT_CPLD_LPC_REG_GWP_MASK_OFFSET 0x4c
#define MLXPLAT_CPLD_LPC_REG_GPI_MASK_OFFSET 0x4e
#define MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET 0x50
#define MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET 0x51
#define MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET 0x52
#define MLXPLAT_CPLD_LPC_REG_ASIC2_HEALTH_OFFSET 0x53
#define MLXPLAT_CPLD_LPC_REG_ASIC2_EVENT_OFFSET 0x54
#define MLXPLAT_CPLD_LPC_REG_ASIC2_MASK_OFFSET 0x55
#define MLXPLAT_CPLD_LPC_REG_AGGRLC_OFFSET 0x56
#define MLXPLAT_CPLD_LPC_REG_AGGRLC_MASK_OFFSET 0x57
#define MLXPLAT_CPLD_LPC_REG_PSU_OFFSET  0x58
#define MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET 0x59
#define MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET 0x5a
#define MLXPLAT_CPLD_LPC_REG_PSU_AC_OFFSET 0x5e
#define MLXPLAT_CPLD_LPC_REG_PWR_OFFSET  0x64
#define MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET 0x65
#define MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET 0x66
#define MLXPLAT_CPLD_LPC_REG_PSU_ALERT_OFFSET 0x6a
#define MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET 0x70
#define MLXPLAT_CPLD_LPC_REG_LC_IN_EVENT_OFFSET 0x71
#define MLXPLAT_CPLD_LPC_REG_LC_IN_MASK_OFFSET 0x72
#define MLXPLAT_CPLD_LPC_REG_FAN_OFFSET  0x88
#define MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET 0x89
#define MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET 0x8a
#define MLXPLAT_CPLD_LPC_REG_FAN2_OFFSET 0x8b
#define MLXPLAT_CPLD_LPC_REG_FAN2_EVENT_OFFSET 0x8c
#define MLXPLAT_CPLD_LPC_REG_FAN2_MASK_OFFSET 0x8d
#define MLXPLAT_CPLD_LPC_REG_CPLD5_VER_OFFSET 0x8e
#define MLXPLAT_CPLD_LPC_REG_CPLD5_PN_OFFSET 0x8f
#define MLXPLAT_CPLD_LPC_REG_CPLD5_PN1_OFFSET 0x90
#define MLXPLAT_CPLD_LPC_REG_EROT_OFFSET 0x91
#define MLXPLAT_CPLD_LPC_REG_EROT_EVENT_OFFSET 0x92
#define MLXPLAT_CPLD_LPC_REG_EROT_MASK_OFFSET 0x93
#define MLXPLAT_CPLD_LPC_REG_EROTE_OFFSET 0x94
#define MLXPLAT_CPLD_LPC_REG_EROTE_EVENT_OFFSET 0x95
#define MLXPLAT_CPLD_LPC_REG_EROTE_MASK_OFFSET 0x96
#define MLXPLAT_CPLD_LPC_REG_PWRB_OFFSET 0x97
#define MLXPLAT_CPLD_LPC_REG_PWRB_EVENT_OFFSET 0x98
#define MLXPLAT_CPLD_LPC_REG_PWRB_MASK_OFFSET 0x99
#define MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET 0x9a
#define MLXPLAT_CPLD_LPC_REG_LC_VR_EVENT_OFFSET 0x9b
#define MLXPLAT_CPLD_LPC_REG_LC_VR_MASK_OFFSET 0x9c
#define MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET 0x9d
#define MLXPLAT_CPLD_LPC_REG_LC_PG_EVENT_OFFSET 0x9e
#define MLXPLAT_CPLD_LPC_REG_LC_PG_MASK_OFFSET 0x9f
#define MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET 0xa0
#define MLXPLAT_CPLD_LPC_REG_LC_RD_EVENT_OFFSET 0xa1
#define MLXPLAT_CPLD_LPC_REG_LC_RD_MASK_OFFSET 0xa2
#define MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET 0xa3
#define MLXPLAT_CPLD_LPC_REG_LC_SN_EVENT_OFFSET 0xa4
#define MLXPLAT_CPLD_LPC_REG_LC_SN_MASK_OFFSET 0xa5
#define MLXPLAT_CPLD_LPC_REG_LC_OK_OFFSET 0xa6
#define MLXPLAT_CPLD_LPC_REG_LC_OK_EVENT_OFFSET 0xa7
#define MLXPLAT_CPLD_LPC_REG_LC_OK_MASK_OFFSET 0xa8
#define MLXPLAT_CPLD_LPC_REG_LC_SD_OFFSET 0xa9
#define MLXPLAT_CPLD_LPC_REG_LC_SD_EVENT_OFFSET 0xaa
#define MLXPLAT_CPLD_LPC_REG_LC_SD_MASK_OFFSET 0xab
#define MLXPLAT_CPLD_LPC_REG_LC_PWR_ON  0xb2
#define MLXPLAT_CPLD_LPC_REG_TACHO19_OFFSET 0xb4
#define MLXPLAT_CPLD_LPC_REG_TACHO20_OFFSET 0xb5
#define MLXPLAT_CPLD_LPC_REG_DBG1_OFFSET 0xb6
#define MLXPLAT_CPLD_LPC_REG_DBG2_OFFSET 0xb7
#define MLXPLAT_CPLD_LPC_REG_DBG3_OFFSET 0xb8
#define MLXPLAT_CPLD_LPC_REG_DBG4_OFFSET 0xb9
#define MLXPLAT_CPLD_LPC_REG_TACHO17_OFFSET 0xba
#define MLXPLAT_CPLD_LPC_REG_TACHO18_OFFSET 0xbb
#define MLXPLAT_CPLD_LPC_REG_ASIC_CAP_OFFSET 0xc1
#define MLXPLAT_CPLD_LPC_REG_GP4_RO_OFFSET 0xc2
#define MLXPLAT_CPLD_LPC_REG_SPI_CHNL_SELECT 0xc3
#define MLXPLAT_CPLD_LPC_REG_CPLD5_MVER_OFFSET 0xc4
#define MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET 0xc7
#define MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET 0xc8
#define MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET 0xc9
#define MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET 0xcb
#define MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET 0xcd
#define MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET 0xce
#define MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET 0xcf
#define MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET 0xd1
#define MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET 0xd2
#define MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET 0xd3
#define MLXPLAT_CPLD_LPC_REG_CPLD6_MVER_OFFSET 0xd9
#define MLXPLAT_CPLD_LPC_REG_I2C_CH1_OFFSET 0xdb
#define MLXPLAT_CPLD_LPC_REG_I2C_CH2_OFFSET 0xda
#define MLXPLAT_CPLD_LPC_REG_I2C_CH3_OFFSET 0xdc
#define MLXPLAT_CPLD_LPC_REG_I2C_CH4_OFFSET 0xdd
#define MLXPLAT_CPLD_LPC_REG_CPLD1_MVER_OFFSET 0xde
#define MLXPLAT_CPLD_LPC_REG_CPLD2_MVER_OFFSET 0xdf
#define MLXPLAT_CPLD_LPC_REG_CPLD3_MVER_OFFSET 0xe0
#define MLXPLAT_CPLD_LPC_REG_CPLD4_MVER_OFFSET 0xe1
#define MLXPLAT_CPLD_LPC_REG_UFM_VERSION_OFFSET 0xe2
#define MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET 0xe3
#define MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET 0xe4
#define MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET 0xe5
#define MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET 0xe6
#define MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET 0xe7
#define MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET 0xe8
#define MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET 0xe9
#define MLXPLAT_CPLD_LPC_REG_PWM2_OFFSET 0xea
#define MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET 0xeb
#define MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET 0xec
#define MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET 0xed
#define MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET 0xee
#define MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET 0xef
#define MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET 0xf0
#define MLXPLAT_CPLD_LPC_REG_TACHO13_OFFSET 0xf1
#define MLXPLAT_CPLD_LPC_REG_TACHO14_OFFSET 0xf2
#define MLXPLAT_CPLD_LPC_REG_PWM3_OFFSET 0xf3
#define MLXPLAT_CPLD_LPC_REG_PWM4_OFFSET 0xf4
#define MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET 0xf5
#define MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET 0xf6
#define MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET 0xf7
#define MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET 0xf8
#define MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET 0xf9
#define MLXPLAT_CPLD_LPC_REG_SLOT_QTY_OFFSET 0xfa
#define MLXPLAT_CPLD_LPC_REG_CONFIG1_OFFSET 0xfb
#define MLXPLAT_CPLD_LPC_REG_CONFIG2_OFFSET 0xfc
#define MLXPLAT_CPLD_LPC_REG_CONFIG3_OFFSET 0xfd
#define MLXPLAT_CPLD_LPC_REG_TACHO15_OFFSET 0xfe
#define MLXPLAT_CPLD_LPC_REG_TACHO16_OFFSET 0xff

#define MLXPLAT_CPLD_LPC_IO_RANGE  0x100

#define MLXPLAT_CPLD_LPC_PIO_OFFSET  0x10000UL
#define MLXPLAT_CPLD_LPC_REG1 ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
      MLXPLAT_CPLD_LPC_REG_I2C_CH1_OFFSET) | \
      MLXPLAT_CPLD_LPC_PIO_OFFSET)
#define MLXPLAT_CPLD_LPC_REG2 ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
      MLXPLAT_CPLD_LPC_REG_I2C_CH2_OFFSET) | \
      MLXPLAT_CPLD_LPC_PIO_OFFSET)
#define MLXPLAT_CPLD_LPC_REG3 ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
      MLXPLAT_CPLD_LPC_REG_I2C_CH3_OFFSET) | \
      MLXPLAT_CPLD_LPC_PIO_OFFSET)
#define MLXPLAT_CPLD_LPC_REG4 ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
      MLXPLAT_CPLD_LPC_REG_I2C_CH4_OFFSET) | \
      MLXPLAT_CPLD_LPC_PIO_OFFSET)

/* Masks for aggregation, psu, pwr and fan event in CPLD related registers. */
#define MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF 0x04
#define MLXPLAT_CPLD_AGGR_PSU_MASK_DEF 0x08
#define MLXPLAT_CPLD_AGGR_PWR_MASK_DEF 0x08
#define MLXPLAT_CPLD_AGGR_FAN_MASK_DEF 0x40
#define MLXPLAT_CPLD_AGGR_MASK_DEF (MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF | \
      MLXPLAT_CPLD_AGGR_PSU_MASK_DEF | \
      MLXPLAT_CPLD_AGGR_FAN_MASK_DEF)
#define MLXPLAT_CPLD_AGGR_ASIC_MASK_NG 0x01
#define MLXPLAT_CPLD_AGGR_MASK_NG_DEF 0x04
#define MLXPLAT_CPLD_AGGR_MASK_COMEX BIT(0)
#define MLXPLAT_CPLD_AGGR_MASK_LC BIT(3)
#define MLXPLAT_CPLD_AGGR_MASK_DPU_BRD BIT(4)
#define MLXPLAT_CPLD_AGGR_MASK_DPU_CORE BIT(5)
#define MLXPLAT_CPLD_AGGR_MASK_MODULAR (MLXPLAT_CPLD_AGGR_MASK_NG_DEF | \
      MLXPLAT_CPLD_AGGR_MASK_COMEX | \
      MLXPLAT_CPLD_AGGR_MASK_LC)
#define MLXPLAT_CPLD_AGGR_MASK_SMART_SW (MLXPLAT_CPLD_AGGR_MASK_COMEX | \
      MLXPLAT_CPLD_AGGR_MASK_NG_DEF | \
      MLXPLAT_CPLD_AGGR_MASK_DPU_BRD | \
      MLXPLAT_CPLD_AGGR_MASK_DPU_CORE)
#define MLXPLAT_CPLD_AGGR_MASK_LC_PRSNT BIT(0)
#define MLXPLAT_CPLD_AGGR_MASK_LC_RDY BIT(1)
#define MLXPLAT_CPLD_AGGR_MASK_LC_PG BIT(2)
#define MLXPLAT_CPLD_AGGR_MASK_LC_SCRD BIT(3)
#define MLXPLAT_CPLD_AGGR_MASK_LC_SYNC BIT(4)
#define MLXPLAT_CPLD_AGGR_MASK_LC_ACT BIT(5)
#define MLXPLAT_CPLD_AGGR_MASK_LC_SDWN BIT(6)
#define MLXPLAT_CPLD_AGGR_MASK_LC_LOW (MLXPLAT_CPLD_AGGR_MASK_LC_PRSNT | \
      MLXPLAT_CPLD_AGGR_MASK_LC_RDY | \
      MLXPLAT_CPLD_AGGR_MASK_LC_PG | \
      MLXPLAT_CPLD_AGGR_MASK_LC_SCRD | \
      MLXPLAT_CPLD_AGGR_MASK_LC_SYNC | \
      MLXPLAT_CPLD_AGGR_MASK_LC_ACT | \
      MLXPLAT_CPLD_AGGR_MASK_LC_SDWN)
#define MLXPLAT_CPLD_LOW_AGGR_MASK_LOW 0xc1
#define MLXPLAT_CPLD_LOW_AGGR_MASK_ASIC2 BIT(2)
#define MLXPLAT_CPLD_LOW_AGGR_MASK_PWR_BUT GENMASK(5, 4)
#define MLXPLAT_CPLD_LOW_AGGR_MASK_I2C BIT(6)
#define MLXPLAT_CPLD_PSU_MASK  GENMASK(1, 0)
#define MLXPLAT_CPLD_PWR_MASK  GENMASK(1, 0)
#define MLXPLAT_CPLD_PSU_EXT_MASK GENMASK(3, 0)
#define MLXPLAT_CPLD_PWR_EXT_MASK GENMASK(3, 0)
#define MLXPLAT_CPLD_PSU_XDR_MASK GENMASK(7, 0)
#define MLXPLAT_CPLD_PWR_XDR_MASK GENMASK(7, 0)
#define MLXPLAT_CPLD_FAN_MASK  GENMASK(3, 0)
#define MLXPLAT_CPLD_ASIC_MASK  GENMASK(1, 0)
#define MLXPLAT_CPLD_ASIC_XDR_MASK GENMASK(3, 0)
#define MLXPLAT_CPLD_FAN_NG_MASK GENMASK(6, 0)
#define MLXPLAT_CPLD_FAN_XDR_MASK GENMASK(7, 0)
#define MLXPLAT_CPLD_LED_LO_NIBBLE_MASK GENMASK(7, 4)
#define MLXPLAT_CPLD_LED_HI_NIBBLE_MASK GENMASK(3, 0)
#define MLXPLAT_CPLD_VOLTREG_UPD_MASK GENMASK(5, 4)
#define MLXPLAT_CPLD_GWP_MASK  GENMASK(0, 0)
#define MLXPLAT_CPLD_EROT_MASK  GENMASK(1, 0)
#define MLXPLAT_CPLD_FU_CAP_MASK GENMASK(1, 0)
#define MLXPLAT_CPLD_BIOS_STATUS_MASK GENMASK(3, 1)
#define MLXPLAT_CPLD_DPU_MASK  GENMASK(3, 0)
#define MLXPLAT_CPLD_PWR_BUTTON_MASK BIT(0)
#define MLXPLAT_CPLD_LATCH_RST_MASK BIT(6)
#define MLXPLAT_CPLD_THERMAL1_PDB_MASK BIT(3)
#define MLXPLAT_CPLD_THERMAL2_PDB_MASK BIT(4)
#define MLXPLAT_CPLD_INTRUSION_MASK BIT(6)
#define MLXPLAT_CPLD_PWM_PG_MASK BIT(7)
#define MLXPLAT_CPLD_L1_CHA_HEALTH_MASK (MLXPLAT_CPLD_THERMAL1_PDB_MASK | \
      MLXPLAT_CPLD_THERMAL2_PDB_MASK | \
      MLXPLAT_CPLD_INTRUSION_MASK |\
      MLXPLAT_CPLD_PWM_PG_MASK)
#define MLXPLAT_CPLD_I2C_CAP_BIT 0x04
#define MLXPLAT_CPLD_I2C_CAP_MASK GENMASK(5, MLXPLAT_CPLD_I2C_CAP_BIT)
#define MLXPLAT_CPLD_SYS_RESET_MASK BIT(0)

/* Masks for aggregation for comex carriers */
#define MLXPLAT_CPLD_AGGR_MASK_CARRIER BIT(1)
#define MLXPLAT_CPLD_AGGR_MASK_CARR_DEF (MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF | \
      MLXPLAT_CPLD_AGGR_MASK_CARRIER)
#define MLXPLAT_CPLD_LOW_AGGRCX_MASK 0xc1

/* Masks for aggregation for modular systems */
#define MLXPLAT_CPLD_LPC_LC_MASK GENMASK(7, 0)

/* Masks for aggregation for smart switch systems */
#define MLXPLAT_CPLD_LPC_SM_SW_MASK GENMASK(7, 0)

#define MLXPLAT_CPLD_HALT_MASK  BIT(3)
#define MLXPLAT_CPLD_RESET_MASK  GENMASK(7, 1)

/* Default I2C parent bus number */
#define MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR 1

/* Maximum number of possible physical buses equipped on system */
#define MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM 16
#define MLXPLAT_CPLD_MAX_PHYS_EXT_ADAPTER_NUM 24

/* Number of channels in group */
#define MLXPLAT_CPLD_GRP_CHNL_NUM  8

/* Start channel numbers */
#define MLXPLAT_CPLD_CH1   2
#define MLXPLAT_CPLD_CH2   10
#define MLXPLAT_CPLD_CH3   18
#define MLXPLAT_CPLD_CH2_ETH_MODULAR  3
#define MLXPLAT_CPLD_CH3_ETH_MODULAR  43
#define MLXPLAT_CPLD_CH4_ETH_MODULAR  51
#define MLXPLAT_CPLD_CH2_RACK_SWITCH  18
#define MLXPLAT_CPLD_CH2_NG800   34

/* Number of LPC attached MUX platform devices */
#define MLXPLAT_CPLD_LPC_MUX_DEVS  4

/* Hotplug devices adapter numbers */
#define MLXPLAT_CPLD_NR_NONE   -1
#define MLXPLAT_CPLD_PSU_DEFAULT_NR  10
#define MLXPLAT_CPLD_PSU_MSNXXXX_NR  4
#define MLXPLAT_CPLD_PSU_XDR_NR   3
#define MLXPLAT_CPLD_FAN1_DEFAULT_NR  11
#define MLXPLAT_CPLD_FAN2_DEFAULT_NR  12
#define MLXPLAT_CPLD_FAN3_DEFAULT_NR  13
#define MLXPLAT_CPLD_FAN4_DEFAULT_NR  14
#define MLXPLAT_CPLD_NR_ASIC   3
#define MLXPLAT_CPLD_NR_LC_BASE   34
#define MLXPLAT_CPLD_NR_DPU_BASE  18

#define MLXPLAT_CPLD_NR_LC_SET(nr) (MLXPLAT_CPLD_NR_LC_BASE + (nr))
#define MLXPLAT_CPLD_LC_ADDR  0x32
#define MLXPLAT_CPLD_DPU_ADDR  0x68

/* Masks and default values for watchdogs */
#define MLXPLAT_CPLD_WD1_CLEAR_MASK GENMASK(7, 1)
#define MLXPLAT_CPLD_WD2_CLEAR_MASK (GENMASK(7, 0) & ~BIT(1))

#define MLXPLAT_CPLD_WD_TYPE1_TO_MASK GENMASK(7, 4)
#define MLXPLAT_CPLD_WD_TYPE2_TO_MASK 0
#define MLXPLAT_CPLD_WD_RESET_ACT_MASK GENMASK(7, 1)
#define MLXPLAT_CPLD_WD_FAN_ACT_MASK (GENMASK(7, 0) & ~BIT(4))
#define MLXPLAT_CPLD_WD_COUNT_ACT_MASK (GENMASK(7, 0) & ~BIT(7))
#define MLXPLAT_CPLD_WD_CPBLTY_MASK (GENMASK(7, 0) & ~BIT(6))
#define MLXPLAT_CPLD_WD_DFLT_TIMEOUT 30
#define MLXPLAT_CPLD_WD3_DFLT_TIMEOUT 600
#define MLXPLAT_CPLD_WD_MAX_DEVS 2
#define MLXPLAT_CPLD_DPU_MAX_DEVS 4

#define MLXPLAT_CPLD_LPC_SYSIRQ  17

/* Minimum power required for turning on Ethernet modular system (WATT) */
#define MLXPLAT_CPLD_ETH_MODULAR_PWR_MIN 50

/* Default value for PWM control register for rack switch system */
#define MLXPLAT_REGMAP_NVSWITCH_PWM_DEFAULT 0xf4

#define MLXPLAT_I2C_MAIN_BUS_NOTIFIED  0x01
#define MLXPLAT_I2C_MAIN_BUS_HANDLE_CREATED 0x02

/* Lattice FPGA PCI configuration */
#define PCI_VENDOR_ID_LATTICE   0x1204
#define PCI_DEVICE_ID_LATTICE_I2C_BRIDGE 0x9c2f
#define PCI_DEVICE_ID_LATTICE_JTAG_BRIDGE 0x9c30
#define PCI_DEVICE_ID_LATTICE_LPC_BRIDGE 0x9c32

/* mlxplat_priv - platform private data
 * @pdev_i2c - i2c controller platform device
 * @pdev_mux - array of mux platform devices
 * @pdev_hotplug - hotplug platform devices
 * @pdev_led - led platform devices
 * @pdev_io_regs - register access platform devices
 * @pdev_fan - FAN platform devices
 * @pdev_wd - array of watchdog platform devices
 * pdev_dpu - array of Data Processor Unit platform devices
 * @regmap: device register map
 * @hotplug_resources: system hotplug resources
 * @hotplug_resources_size: size of system hotplug resources
 * @hi2c_main_init_status: init status of I2C main bus
 * @irq_fpga: FPGA IRQ number
 */
struct mlxplat_priv {
 struct platform_device *pdev_i2c;
 struct platform_device *pdev_mux[MLXPLAT_CPLD_LPC_MUX_DEVS];
 struct platform_device *pdev_hotplug;
 struct platform_device *pdev_led;
 struct platform_device *pdev_io_regs;
 struct platform_device *pdev_fan;
 struct platform_device *pdev_wd[MLXPLAT_CPLD_WD_MAX_DEVS];
 struct platform_device *pdev_dpu[MLXPLAT_CPLD_DPU_MAX_DEVS];
 void *regmap;
 struct resource *hotplug_resources;
 unsigned int hotplug_resources_size;
 u8 i2c_main_init_status;
 int irq_fpga;
};

static struct platform_device *mlxplat_dev;
static int mlxplat_i2c_main_completion_notify(void *handle, int id);
static void __iomem *i2c_bridge_addr, *jtag_bridge_addr;

/* Regions for LPC I2C controller and LPC base register space */
static const struct resource mlxplat_lpc_resources[] = {
 [0] = DEFINE_RES_NAMED(MLXPLAT_CPLD_LPC_I2C_BASE_ADRR,
          MLXPLAT_CPLD_LPC_IO_RANGE,
          "mlxplat_cpld_lpc_i2c_ctrl", IORESOURCE_IO),
 [1] = DEFINE_RES_NAMED(MLXPLAT_CPLD_LPC_REG_BASE_ADRR,
          MLXPLAT_CPLD_LPC_IO_RANGE,
          "mlxplat_cpld_lpc_regs",
          IORESOURCE_IO),
};

/* Platform systems default i2c data */
static struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_i2c_default_data = {
 .completion_notify = mlxplat_i2c_main_completion_notify,
};

/* Platform i2c next generation systems data */
static struct mlxreg_core_data mlxplat_mlxcpld_i2c_ng_items_data[] = {
 {
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
  .mask = MLXPLAT_CPLD_I2C_CAP_MASK,
  .bit = MLXPLAT_CPLD_I2C_CAP_BIT,
 },
};

static struct mlxreg_core_item mlxplat_mlxcpld_i2c_ng_items[] = {
 {
  .data = mlxplat_mlxcpld_i2c_ng_items_data,
 },
};

/* Platform next generation systems i2c data */
static struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_i2c_ng_data = {
 .items = mlxplat_mlxcpld_i2c_ng_items,
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_COMEX,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_I2C,
 .completion_notify = mlxplat_i2c_main_completion_notify,
};

/* Platform default channels */
static const int mlxplat_default_channels[][MLXPLAT_CPLD_GRP_CHNL_NUM] = {
 {
  MLXPLAT_CPLD_CH1, MLXPLAT_CPLD_CH1 + 1, MLXPLAT_CPLD_CH1 + 2,
  MLXPLAT_CPLD_CH1 + 3, MLXPLAT_CPLD_CH1 + 4, MLXPLAT_CPLD_CH1 +
  5, MLXPLAT_CPLD_CH1 + 6, MLXPLAT_CPLD_CH1 + 7
 },
 {
  MLXPLAT_CPLD_CH2, MLXPLAT_CPLD_CH2 + 1, MLXPLAT_CPLD_CH2 + 2,
  MLXPLAT_CPLD_CH2 + 3, MLXPLAT_CPLD_CH2 + 4, MLXPLAT_CPLD_CH2 +
  5, MLXPLAT_CPLD_CH2 + 6, MLXPLAT_CPLD_CH2 + 7
 },
};

/* Platform channels for MSN21xx system family */
static const int mlxplat_msn21xx_channels[] = { 1, 2, 3, 4, 5, 6, 7, 8 };

/* Platform mux data */
static struct i2c_mux_reg_platform_data mlxplat_default_mux_data[] = {
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH1,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
  .reg_size = 1,
  .idle_in_use = 1,
 },
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH2,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
  .reg_size = 1,
  .idle_in_use = 1,
 },

};

/* Platform mux configuration variables */
static int mlxplat_max_adap_num;
static int mlxplat_mux_num;
static struct i2c_mux_reg_platform_data *mlxplat_mux_data;
static struct notifier_block *mlxplat_reboot_nb;

/* Platform extended mux data */
static struct i2c_mux_reg_platform_data mlxplat_extended_mux_data[] = {
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH1,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
  .reg_size = 1,
  .idle_in_use = 1,
 },
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH2,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG3,
  .reg_size = 1,
  .idle_in_use = 1,
 },
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH3,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
  .reg_size = 1,
  .idle_in_use = 1,
 },

};

/* Platform channels for modular system family */
static const int mlxplat_modular_upper_channel[] = { 1 };
static const int mlxplat_modular_channels[] = {
 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
 38, 39, 40
};

/* Platform modular mux data */
static struct i2c_mux_reg_platform_data mlxplat_modular_mux_data[] = {
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH1,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG4,
  .reg_size = 1,
  .idle_in_use = 1,
  .values = mlxplat_modular_upper_channel,
  .n_values = ARRAY_SIZE(mlxplat_modular_upper_channel),
 },
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH2_ETH_MODULAR,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
  .reg_size = 1,
  .idle_in_use = 1,
  .values = mlxplat_modular_channels,
  .n_values = ARRAY_SIZE(mlxplat_modular_channels),
 },
 {
  .parent = MLXPLAT_CPLD_CH1,
  .base_nr = MLXPLAT_CPLD_CH3_ETH_MODULAR,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG3,
  .reg_size = 1,
  .idle_in_use = 1,
  .values = mlxplat_msn21xx_channels,
  .n_values = ARRAY_SIZE(mlxplat_msn21xx_channels),
 },
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH4_ETH_MODULAR,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
  .reg_size = 1,
  .idle_in_use = 1,
  .values = mlxplat_msn21xx_channels,
  .n_values = ARRAY_SIZE(mlxplat_msn21xx_channels),
 },
};

/* Platform channels for rack switch system family */
static const int mlxplat_rack_switch_channels[] = {
 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
};

/* Platform rack switch mux data */
static struct i2c_mux_reg_platform_data mlxplat_rack_switch_mux_data[] = {
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH1,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
  .reg_size = 1,
  .idle_in_use = 1,
  .values = mlxplat_rack_switch_channels,
  .n_values = ARRAY_SIZE(mlxplat_rack_switch_channels),
 },
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH2_RACK_SWITCH,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
  .reg_size = 1,
  .idle_in_use = 1,
  .values = mlxplat_msn21xx_channels,
  .n_values = ARRAY_SIZE(mlxplat_msn21xx_channels),
 },

};

/* Platform channels for ng800 system family */
static const int mlxplat_ng800_channels[] = {
 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32
};

/* Platform ng800 mux data */
static struct i2c_mux_reg_platform_data mlxplat_ng800_mux_data[] = {
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH1,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
  .reg_size = 1,
  .idle_in_use = 1,
  .values = mlxplat_ng800_channels,
  .n_values = ARRAY_SIZE(mlxplat_ng800_channels),
 },
 {
  .parent = 1,
  .base_nr = MLXPLAT_CPLD_CH2_NG800,
  .write_only = 1,
  .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
  .reg_size = 1,
  .idle_in_use = 1,
  .values = mlxplat_msn21xx_channels,
  .n_values = ARRAY_SIZE(mlxplat_msn21xx_channels),
 },

};

/* Platform hotplug devices */
static struct i2c_board_info mlxplat_mlxcpld_pwr[] = {
 {
  I2C_BOARD_INFO("dps460", 0x59),
 },
 {
  I2C_BOARD_INFO("dps460", 0x58),
 },
};

static struct i2c_board_info mlxplat_mlxcpld_ext_pwr[] = {
 {
  I2C_BOARD_INFO("dps460", 0x5b),
 },
 {
  I2C_BOARD_INFO("dps460", 0x5a),
 },
};

static struct i2c_board_info mlxplat_mlxcpld_pwr_ng800[] = {
 {
  I2C_BOARD_INFO("dps460", 0x59),
 },
 {
  I2C_BOARD_INFO("dps460", 0x5a),
 },
};

static struct i2c_board_info mlxplat_mlxcpld_xdr_pwr[] = {
 {
  I2C_BOARD_INFO("dps460", 0x5d),
 },
 {
  I2C_BOARD_INFO("dps460", 0x5c),
 },
 {
  I2C_BOARD_INFO("dps460", 0x5e),
 },
 {
  I2C_BOARD_INFO("dps460", 0x5f),
 },
};

static struct i2c_board_info mlxplat_mlxcpld_fan[] = {
 {
  I2C_BOARD_INFO("24c32", 0x50),
 },
 {
  I2C_BOARD_INFO("24c32", 0x50),
 },
 {
  I2C_BOARD_INFO("24c32", 0x50),
 },
 {
  I2C_BOARD_INFO("24c32", 0x50),
 },
};

/* Platform hotplug comex carrier system family data */
static struct mlxreg_core_data mlxplat_mlxcpld_comex_psu_items_data[] = {
 {
  .label = "psu1",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "psu2",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

/* Platform hotplug default data */
static struct mlxreg_core_data mlxplat_mlxcpld_default_psu_items_data[] = {
 {
  .label = "psu1",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "psu2",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_default_pwr_items_data[] = {
 {
  .label = "pwr1",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
  .hpdev.nr = MLXPLAT_CPLD_PSU_DEFAULT_NR,
 },
 {
  .label = "pwr2",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
  .hpdev.nr = MLXPLAT_CPLD_PSU_DEFAULT_NR,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_default_pwr_wc_items_data[] = {
 {
  .label = "pwr1",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "pwr2",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_default_pwr_ng800_items_data[] = {
 {
  .label = "pwr1",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr_ng800[0],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
 {
  .label = "pwr2",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr_ng800[1],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_default_fan_items_data[] = {
 {
  .label = "fan1",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_fan[0],
  .hpdev.nr = MLXPLAT_CPLD_FAN1_DEFAULT_NR,
 },
 {
  .label = "fan2",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_fan[1],
  .hpdev.nr = MLXPLAT_CPLD_FAN2_DEFAULT_NR,
 },
 {
  .label = "fan3",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(2),
  .hpdev.brdinfo = &mlxplat_mlxcpld_fan[2],
  .hpdev.nr = MLXPLAT_CPLD_FAN3_DEFAULT_NR,
 },
 {
  .label = "fan4",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(3),
  .hpdev.brdinfo = &mlxplat_mlxcpld_fan[3],
  .hpdev.nr = MLXPLAT_CPLD_FAN4_DEFAULT_NR,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_default_asic_items_data[] = {
 {
  .label = "asic1",
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_default_asic2_items_data[] = {
 {
  .label = "asic2",
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC2_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_item mlxplat_mlxcpld_default_items[] = {
 {
  .data = mlxplat_mlxcpld_default_psu_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_PSU_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = MLXPLAT_CPLD_PSU_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_psu_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_pwr_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_pwr_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_fan_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_FAN_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = MLXPLAT_CPLD_FAN_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_fan_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
};

static struct mlxreg_core_item mlxplat_mlxcpld_comex_items[] = {
 {
  .data = mlxplat_mlxcpld_comex_psu_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_CARRIER,
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = MLXPLAT_CPLD_PSU_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_psu_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_pwr_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_CARRIER,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_pwr_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_fan_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_CARRIER,
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = MLXPLAT_CPLD_FAN_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_fan_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_default_data = {
 .items = mlxplat_mlxcpld_default_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
};

static struct mlxreg_core_item mlxplat_mlxcpld_default_wc_items[] = {
 {
  .data = mlxplat_mlxcpld_comex_psu_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_CARRIER,
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = MLXPLAT_CPLD_PSU_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_psu_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_pwr_wc_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_CARRIER,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_pwr_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_default_wc_data = {
 .items = mlxplat_mlxcpld_default_wc_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_wc_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_comex_data = {
 .items = mlxplat_mlxcpld_comex_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_comex_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_CARR_DEF,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRCX_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGRCX_MASK,
};

static struct mlxreg_core_data mlxplat_mlxcpld_msn21xx_pwr_items_data[] = {
 {
  .label = "pwr1",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "pwr2",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

/* Platform hotplug MSN21xx system family data */
static struct mlxreg_core_item mlxplat_mlxcpld_msn21xx_items[] = {
 {
  .data = mlxplat_mlxcpld_msn21xx_pwr_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_pwr_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn21xx_data = {
 .items = mlxplat_mlxcpld_msn21xx_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
};

/* Platform hotplug msn274x system family data */
static struct mlxreg_core_data mlxplat_mlxcpld_msn274x_psu_items_data[] = {
 {
  .label = "psu1",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "psu2",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_pwr_items_data[] = {
 {
  .label = "pwr1",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
 {
  .label = "pwr2",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_msn274x_fan_items_data[] = {
 {
  .label = "fan1",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan2",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan3",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(2),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan4",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(3),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_item mlxplat_mlxcpld_msn274x_items[] = {
 {
  .data = mlxplat_mlxcpld_msn274x_psu_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = MLXPLAT_CPLD_PSU_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_psu_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_ng_pwr_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_pwr_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_msn274x_fan_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = MLXPLAT_CPLD_FAN_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_fan_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn274x_data = {
 .items = mlxplat_mlxcpld_msn274x_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
};

/* Platform hotplug MSN201x system family data */
static struct mlxreg_core_data mlxplat_mlxcpld_msn201x_pwr_items_data[] = {
 {
  .label = "pwr1",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "pwr2",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_item mlxplat_mlxcpld_msn201x_items[] = {
 {
  .data = mlxplat_mlxcpld_msn201x_pwr_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_msn201x_pwr_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn201x_data = {
 .items = mlxplat_mlxcpld_msn201x_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn201x_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
};

/* Platform hotplug next generation system family data */
static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_psu_items_data[] = {
 {
  .label = "psu1",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "psu2",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_fan_items_data[] = {
 {
  .label = "fan1",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(0),
  .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
  .bit = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan2",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(1),
  .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
  .bit = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan3",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(2),
  .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
  .bit = BIT(2),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan4",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(3),
  .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
  .bit = BIT(3),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan5",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(4),
  .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
  .bit = BIT(4),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan6",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(5),
  .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
  .bit = BIT(5),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "fan7",
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = BIT(6),
  .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
  .bit = BIT(6),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_item mlxplat_mlxcpld_default_ng_items[] = {
 {
  .data = mlxplat_mlxcpld_default_ng_psu_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = MLXPLAT_CPLD_PSU_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_psu_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_ng_pwr_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_pwr_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_ng_fan_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = MLXPLAT_CPLD_FAN_NG_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_fan_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_default_ng_data = {
 .items = mlxplat_mlxcpld_default_ng_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF | MLXPLAT_CPLD_AGGR_MASK_COMEX,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
};

/* Platform hotplug extended system family data */
static struct mlxreg_core_data mlxplat_mlxcpld_ext_psu_items_data[] = {
 {
  .label = "psu1",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(0),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "psu2",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(1),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "psu3",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(2),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
 {
  .label = "psu4",
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = BIT(3),
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_ext_pwr_items_data[] = {
 {
  .label = "pwr1",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
 {
  .label = "pwr2",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
 {
  .label = "pwr3",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(2),
  .hpdev.brdinfo = &mlxplat_mlxcpld_ext_pwr[0],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
 {
  .label = "pwr4",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(3),
  .hpdev.brdinfo = &mlxplat_mlxcpld_ext_pwr[1],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
};

static struct mlxreg_core_item mlxplat_mlxcpld_ext_items[] = {
 {
  .data = mlxplat_mlxcpld_ext_psu_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = MLXPLAT_CPLD_PSU_EXT_MASK,
  .capability = MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_ext_psu_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_ext_pwr_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_EXT_MASK,
  .capability = MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_ext_pwr_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_ng_fan_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = MLXPLAT_CPLD_FAN_NG_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_fan_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
 {
  .data = mlxplat_mlxcpld_default_asic2_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC2_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic2_items_data),
  .inversed = 0,
  .health = true,
 }
};

static struct mlxreg_core_item mlxplat_mlxcpld_ng800_items[] = {
 {
  .data = mlxplat_mlxcpld_default_ng_psu_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
  .mask = MLXPLAT_CPLD_PSU_EXT_MASK,
  .capability = MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_psu_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_pwr_ng800_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = MLXPLAT_CPLD_PWR_EXT_MASK,
  .capability = MLXPLAT_CPLD_LPC_REG_PSU_I2C_CAP_OFFSET,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_pwr_ng800_items_data),
  .inversed = 0,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_ng_fan_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
  .mask = MLXPLAT_CPLD_FAN_NG_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_fan_items_data),
  .inversed = 1,
  .health = false,
 },
 {
  .data = mlxplat_mlxcpld_default_asic_items_data,
  .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
  .inversed = 0,
  .health = true,
 },
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_ext_data = {
 .items = mlxplat_mlxcpld_ext_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_ext_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF | MLXPLAT_CPLD_AGGR_MASK_COMEX,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW | MLXPLAT_CPLD_LOW_AGGR_MASK_ASIC2,
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_ng800_data = {
 .items = mlxplat_mlxcpld_ng800_items,
 .count = ARRAY_SIZE(mlxplat_mlxcpld_ng800_items),
 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
 .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF | MLXPLAT_CPLD_AGGR_MASK_COMEX,
 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW | MLXPLAT_CPLD_LOW_AGGR_MASK_ASIC2,
};

static struct mlxreg_core_data mlxplat_mlxcpld_modular_pwr_items_data[] = {
 {
  .label = "pwr1",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
 {
  .label = "pwr2",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
 {
  .label = "pwr3",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(2),
  .hpdev.brdinfo = &mlxplat_mlxcpld_ext_pwr[0],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
 {
  .label = "pwr4",
  .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
  .mask = BIT(3),
  .hpdev.brdinfo = &mlxplat_mlxcpld_ext_pwr[1],
  .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
 },
};

static
struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_lc_act = {
 .irq = MLXPLAT_CPLD_LPC_SYSIRQ,
};

static struct mlxreg_core_data mlxplat_mlxcpld_modular_asic_items_data[] = {
 {
  .label = "asic1",
  .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
  .mask = MLXPLAT_CPLD_ASIC_MASK,
  .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
 },
};

static struct i2c_board_info mlxplat_mlxcpld_lc_i2c_dev[] = {
 {
  I2C_BOARD_INFO("mlxreg-lc", MLXPLAT_CPLD_LC_ADDR),
  .platform_data = &mlxplat_mlxcpld_lc_act,
 },
 {
  I2C_BOARD_INFO("mlxreg-lc", MLXPLAT_CPLD_LC_ADDR),
  .platform_data = &mlxplat_mlxcpld_lc_act,
 },
 {
  I2C_BOARD_INFO("mlxreg-lc", MLXPLAT_CPLD_LC_ADDR),
  .platform_data = &mlxplat_mlxcpld_lc_act,
 },
 {
  I2C_BOARD_INFO("mlxreg-lc", MLXPLAT_CPLD_LC_ADDR),
  .platform_data = &mlxplat_mlxcpld_lc_act,
 },
 {
  I2C_BOARD_INFO("mlxreg-lc", MLXPLAT_CPLD_LC_ADDR),
  .platform_data = &mlxplat_mlxcpld_lc_act,
 },
 {
  I2C_BOARD_INFO("mlxreg-lc", MLXPLAT_CPLD_LC_ADDR),
  .platform_data = &mlxplat_mlxcpld_lc_act,
 },
 {
  I2C_BOARD_INFO("mlxreg-lc", MLXPLAT_CPLD_LC_ADDR),
  .platform_data = &mlxplat_mlxcpld_lc_act,
 },
 {
  I2C_BOARD_INFO("mlxreg-lc", MLXPLAT_CPLD_LC_ADDR),
  .platform_data = &mlxplat_mlxcpld_lc_act,
 },
};

static struct mlxreg_core_hotplug_notifier mlxplat_mlxcpld_modular_lc_notifier[] = {
 {
  .identity = "lc1",
 },
 {
  .identity = "lc2",
 },
 {
  .identity = "lc3",
 },
 {
  .identity = "lc4",
 },
 {
  .identity = "lc5",
 },
 {
  .identity = "lc6",
 },
 {
  .identity = "lc7",
 },
 {
  .identity = "lc8",
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_modular_lc_pr_items_data[] = {
 {
  .label = "lc1_present",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[0],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(0),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[0],
  .slot = 1,
 },
 {
  .label = "lc2_present",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[1],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(1),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[1],
  .slot = 2,
 },
 {
  .label = "lc3_present",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET,
  .mask = BIT(2),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[2],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(2),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[2],
  .slot = 3,
 },
 {
  .label = "lc4_present",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET,
  .mask = BIT(3),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[3],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(3),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[3],
  .slot = 4,
 },
 {
  .label = "lc5_present",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET,
  .mask = BIT(4),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[4],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(4),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[4],
  .slot = 5,
 },
 {
  .label = "lc6_present",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET,
  .mask = BIT(5),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[5],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(5),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[5],
  .slot = 6,
 },
 {
  .label = "lc7_present",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET,
  .mask = BIT(6),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[6],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(6),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[6],
  .slot = 7,
 },
 {
  .label = "lc8_present",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_IN_OFFSET,
  .mask = BIT(7),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[7],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(7),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[7],
  .slot = 8,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_modular_lc_ver_items_data[] = {
 {
  .label = "lc1_verified",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET,
  .mask = BIT(0),
  .reg_prsnt = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .reg_sync = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .reg_pwr = MLXPLAT_CPLD_LPC_REG_LC_PWR_ON,
  .reg_ena = MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET,
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[0],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(0),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[0],
  .slot = 1,
 },
 {
  .label = "lc2_verified",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET,
  .mask = BIT(1),
  .reg_prsnt = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .reg_sync = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .reg_pwr = MLXPLAT_CPLD_LPC_REG_LC_PWR_ON,
  .reg_ena = MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET,
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[1],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(1),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[1],
  .slot = 2,
 },
 {
  .label = "lc3_verified",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET,
  .mask = BIT(2),
  .reg_prsnt = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .reg_sync = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .reg_pwr = MLXPLAT_CPLD_LPC_REG_LC_PWR_ON,
  .reg_ena = MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET,
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[2],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(2),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[2],
  .slot = 3,
 },
 {
  .label = "lc4_verified",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET,
  .mask = BIT(3),
  .reg_prsnt = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .reg_sync = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .reg_pwr = MLXPLAT_CPLD_LPC_REG_LC_PWR_ON,
  .reg_ena = MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET,
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[3],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(3),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[3],
  .slot = 4,
 },
 {
  .label = "lc5_verified",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET,
  .mask = BIT(4),
  .reg_prsnt = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .reg_sync = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .reg_pwr = MLXPLAT_CPLD_LPC_REG_LC_PWR_ON,
  .reg_ena = MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET,
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[4],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(4),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[4],
  .slot = 5,
 },
 {
  .label = "lc6_verified",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET,
  .mask = BIT(5),
  .reg_prsnt = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .reg_sync = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .reg_pwr = MLXPLAT_CPLD_LPC_REG_LC_PWR_ON,
  .reg_ena = MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET,
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[5],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(5),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[5],
  .slot = 6,
 },
 {
  .label = "lc7_verified",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET,
  .mask = BIT(6),
  .reg_prsnt = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .reg_sync = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .reg_pwr = MLXPLAT_CPLD_LPC_REG_LC_PWR_ON,
  .reg_ena = MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET,
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[6],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(6),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[6],
  .slot = 7,
 },
 {
  .label = "lc8_verified",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_VR_OFFSET,
  .mask = BIT(7),
  .reg_prsnt = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .reg_sync = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .reg_pwr = MLXPLAT_CPLD_LPC_REG_LC_PWR_ON,
  .reg_ena = MLXPLAT_CPLD_LPC_REG_RESET_GP4_OFFSET,
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[7],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(7),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[7],
  .slot = 8,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_modular_lc_pg_data[] = {
 {
  .label = "lc1_powered",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[0],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(0),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[0],
  .slot = 1,
 },
 {
  .label = "lc2_powered",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[1],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(1),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[1],
  .slot = 2,
 },
 {
  .label = "lc3_powered",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .mask = BIT(2),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[2],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(2),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[2],
  .slot = 3,
 },
 {
  .label = "lc4_powered",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .mask = BIT(3),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[3],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(3),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[3],
  .slot = 4,
 },
 {
  .label = "lc5_powered",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .mask = BIT(4),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[4],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(4),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[4],
  .slot = 5,
 },
 {
  .label = "lc6_powered",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .mask = BIT(5),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[5],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(5),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[5],
  .slot = 6,
 },
 {
  .label = "lc7_powered",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .mask = BIT(6),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[6],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(6),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[6],
  .slot = 7,
 },
 {
  .label = "lc8_powered",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_PG_OFFSET,
  .mask = BIT(7),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[7],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(7),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[7],
  .slot = 8,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_modular_lc_ready_data[] = {
 {
  .label = "lc1_ready",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[0],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(0),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[0],
  .slot = 1,
 },
 {
  .label = "lc2_ready",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[1],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(1),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[1],
  .slot = 2,
 },
 {
  .label = "lc3_ready",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET,
  .mask = BIT(2),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[2],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(2),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[2],
  .slot = 3,
 },
 {
  .label = "lc4_ready",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET,
  .mask = BIT(3),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[3],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(3),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[3],
  .slot = 4,
 },
 {
  .label = "lc5_ready",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET,
  .mask = BIT(4),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[4],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(4),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[4],
  .slot = 5,
 },
 {
  .label = "lc6_ready",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET,
  .mask = BIT(5),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[5],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(5),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[5],
  .slot = 6,
 },
 {
  .label = "lc7_ready",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET,
  .mask = BIT(6),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[6],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(6),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[6],
  .slot = 7,
 },
 {
  .label = "lc8_ready",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_RD_OFFSET,
  .mask = BIT(7),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[7],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(7),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[7],
  .slot = 8,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_modular_lc_synced_data[] = {
 {
  .label = "lc1_synced",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[0],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(0),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[0],
  .slot = 1,
 },
 {
  .label = "lc2_synced",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[1],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(1),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[1],
  .slot = 2,
 },
 {
  .label = "lc3_synced",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .mask = BIT(2),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[2],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(2),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[2],
  .slot = 3,
 },
 {
  .label = "lc4_synced",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .mask = BIT(3),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[3],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(3),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[3],
  .slot = 4,
 },
 {
  .label = "lc5_synced",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .mask = BIT(4),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[4],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(4),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[4],
  .slot = 5,
 },
 {
  .label = "lc6_synced",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .mask = BIT(5),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[5],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(5),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[5],
  .slot = 6,
 },
 {
  .label = "lc7_synced",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .mask = BIT(6),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[6],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(6),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[6],
  .slot = 7,
 },
 {
  .label = "lc8_synced",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_SN_OFFSET,
  .mask = BIT(7),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[7],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(7),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[7],
  .slot = 8,
 },
};

static struct mlxreg_core_data mlxplat_mlxcpld_modular_lc_act_data[] = {
 {
  .label = "lc1_active",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_OK_OFFSET,
  .mask = BIT(0),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[0],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(0),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[0],
  .slot = 1,
 },
 {
  .label = "lc2_active",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_OK_OFFSET,
  .mask = BIT(1),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[1],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(1),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[1],
  .slot = 2,
 },
 {
  .label = "lc3_active",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_OK_OFFSET,
  .mask = BIT(2),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[2],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(2),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[2],
  .slot = 3,
 },
 {
  .label = "lc4_active",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_OK_OFFSET,
  .mask = BIT(3),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[3],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(3),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[3],
  .slot = 4,
 },
 {
  .label = "lc5_active",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_OK_OFFSET,
  .mask = BIT(4),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[4],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(4),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
  .hpdev.notifier = &mlxplat_mlxcpld_modular_lc_notifier[4],
  .slot = 5,
 },
 {
  .label = "lc6_active",
  .reg = MLXPLAT_CPLD_LPC_REG_LC_OK_OFFSET,
  .mask = BIT(5),
  .hpdev.brdinfo = &mlxplat_mlxcpld_lc_i2c_dev[5],
  .hpdev.nr = MLXPLAT_CPLD_NR_LC_SET(5),
  .hpdev.action = MLXREG_HOTPLUG_DEVICE_NO_ACTION,
--> --------------------

--> maximum size reached

--> --------------------