Loading...
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 */
203struct 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 */
215static 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 */
226static 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
234static 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 */
241static 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 */
250static 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 */
264static const int mlxplat_msn21xx_channels[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
265
266/* Platform mux data */
267static 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 */
288static int mlxplat_max_adap_num;
289static int mlxplat_mux_num;
290static struct i2c_mux_reg_platform_data *mlxplat_mux_data;
291
292/* Platform extended mux data */
293static 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 */
322static 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
331static 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
340static 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 */
356static 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 */
372static 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
387static 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
404static 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
435static 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
444static 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
483static 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
522static
523struct 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
532static
533struct 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
542static 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 */
558static 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
579static
580struct 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 */
590static 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
605static 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
622static 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
649static 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
688static
689struct 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 */
699static 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
714static 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
735static
736struct 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 */
746static 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
761static 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
812static 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
851static
852struct 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 */
862static 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
889static 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
920static 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
961static
962struct 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 */
972static 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
1035static 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 */
1041static 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
1089static 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 */
1095static 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
1207static 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 */
1213static 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
1281static 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 */
1287static 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
1413static 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 */
1419static 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
1545static 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 */
1551static 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
1812static 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 */
1818static 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
1926static 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 */
1935static 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
1962static 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
1983static 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 */
2001static 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
2033static 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
2059static 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 */
2079static 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
2111static 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
2137static 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
2152static 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
2194static 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
2281static 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
2360static 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
2367static 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
2372static 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
2378static 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
2385struct mlxplat_mlxcpld_regmap_context {
2386 void __iomem *base;
2387};
2388
2389static struct mlxplat_mlxcpld_regmap_context mlxplat_mlxcpld_regmap_ctx;
2390
2391static int
2392mlxplat_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
2400static int
2401mlxplat_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
2409static 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
2423static 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
2437static 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
2451static 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
2465static struct resource mlxplat_mlxcpld_resources[] = {
2466 [0] = DEFINE_RES_IRQ_NAMED(17, "mlxreg-hotplug"),
2467};
2468
2469static struct platform_device *mlxplat_dev;
2470static struct mlxreg_core_hotplug_platform_data *mlxplat_i2c;
2471static struct mlxreg_core_hotplug_platform_data *mlxplat_hotplug;
2472static struct mlxreg_core_platform_data *mlxplat_led;
2473static struct mlxreg_core_platform_data *mlxplat_regs_io;
2474static struct mlxreg_core_platform_data *mlxplat_fan;
2475static struct mlxreg_core_platform_data
2476 *mlxplat_wd_data[MLXPLAT_CPLD_WD_MAX_DEVS];
2477static const struct regmap_config *mlxplat_regmap_config;
2478
2479static 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
2501static 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
2523static 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
2545static 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
2567static 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
2593static 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
2617static 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
2643static 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
2772MODULE_DEVICE_TABLE(dmi, mlxplat_dmi_table);
2773
2774static 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
2812static 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 ®val);
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
2833static 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
2991fail_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);
2996fail_platform_io_regs_register:
2997 if (mlxplat_regs_io)
2998 platform_device_unregister(priv->pdev_io_regs);
2999fail_platform_led_register:
3000 platform_device_unregister(priv->pdev_led);
3001fail_platform_hotplug_register:
3002 platform_device_unregister(priv->pdev_hotplug);
3003fail_platform_mux_register:
3004 while (--i >= 0)
3005 platform_device_unregister(priv->pdev_mux[i]);
3006 platform_device_unregister(priv->pdev_i2c);
3007fail_alloc:
3008 platform_device_unregister(mlxplat_dev);
3009
3010 return err;
3011}
3012module_init(mlxplat_init);
3013
3014static 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}
3034module_exit(mlxplat_exit);
3035
3036MODULE_AUTHOR("Vadim Pasternak (vadimp@mellanox.com)");
3037MODULE_DESCRIPTION("Mellanox platform driver");
3038MODULE_LICENSE("Dual BSD/GPL");
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_RESET_CAUSE_OFFSET 0x1d
30#define MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET 0x1e
31#define MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET 0x1f
32#define MLXPLAT_CPLD_LPC_REG_LED1_OFFSET 0x20
33#define MLXPLAT_CPLD_LPC_REG_LED2_OFFSET 0x21
34#define MLXPLAT_CPLD_LPC_REG_LED3_OFFSET 0x22
35#define MLXPLAT_CPLD_LPC_REG_LED4_OFFSET 0x23
36#define MLXPLAT_CPLD_LPC_REG_LED5_OFFSET 0x24
37#define MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION 0x2a
38#define MLXPLAT_CPLD_LPC_REG_GP1_OFFSET 0x30
39#define MLXPLAT_CPLD_LPC_REG_WP1_OFFSET 0x31
40#define MLXPLAT_CPLD_LPC_REG_GP2_OFFSET 0x32
41#define MLXPLAT_CPLD_LPC_REG_WP2_OFFSET 0x33
42#define MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET 0x37
43#define MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET 0x3a
44#define MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET 0x3b
45#define MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET 0x40
46#define MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET 0x41
47#define MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET 0x42
48#define MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET 0x43
49#define MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET 0x50
50#define MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET 0x51
51#define MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET 0x52
52#define MLXPLAT_CPLD_LPC_REG_PSU_OFFSET 0x58
53#define MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET 0x59
54#define MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET 0x5a
55#define MLXPLAT_CPLD_LPC_REG_PWR_OFFSET 0x64
56#define MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET 0x65
57#define MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET 0x66
58#define MLXPLAT_CPLD_LPC_REG_FAN_OFFSET 0x88
59#define MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET 0x89
60#define MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET 0x8a
61#define MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET 0xc7
62#define MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET 0xc8
63#define MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET 0xc9
64#define MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET 0xcb
65#define MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET 0xcd
66#define MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET 0xce
67#define MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET 0xcf
68#define MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET 0xd1
69#define MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET 0xd2
70#define MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET 0xd3
71#define MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET 0xe3
72#define MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET 0xe4
73#define MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET 0xe5
74#define MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET 0xe6
75#define MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET 0xe7
76#define MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET 0xe8
77#define MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET 0xe9
78#define MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET 0xeb
79#define MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET 0xec
80#define MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET 0xed
81#define MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET 0xee
82#define MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET 0xef
83#define MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET 0xf0
84#define MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET 0xf5
85#define MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET 0xf6
86#define MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET 0xf7
87#define MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET 0xf8
88#define MLXPLAT_CPLD_LPC_IO_RANGE 0x100
89#define MLXPLAT_CPLD_LPC_I2C_CH1_OFF 0xdb
90#define MLXPLAT_CPLD_LPC_I2C_CH2_OFF 0xda
91
92#define MLXPLAT_CPLD_LPC_PIO_OFFSET 0x10000UL
93#define MLXPLAT_CPLD_LPC_REG1 ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
94 MLXPLAT_CPLD_LPC_I2C_CH1_OFF) | \
95 MLXPLAT_CPLD_LPC_PIO_OFFSET)
96#define MLXPLAT_CPLD_LPC_REG2 ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
97 MLXPLAT_CPLD_LPC_I2C_CH2_OFF) | \
98 MLXPLAT_CPLD_LPC_PIO_OFFSET)
99
100/* Masks for aggregation, psu, pwr and fan event in CPLD related registers. */
101#define MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF 0x04
102#define MLXPLAT_CPLD_AGGR_PSU_MASK_DEF 0x08
103#define MLXPLAT_CPLD_AGGR_PWR_MASK_DEF 0x08
104#define MLXPLAT_CPLD_AGGR_FAN_MASK_DEF 0x40
105#define MLXPLAT_CPLD_AGGR_MASK_DEF (MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF | \
106 MLXPLAT_CPLD_AGGR_PSU_MASK_DEF | \
107 MLXPLAT_CPLD_AGGR_FAN_MASK_DEF)
108#define MLXPLAT_CPLD_AGGR_ASIC_MASK_NG 0x01
109#define MLXPLAT_CPLD_AGGR_MASK_NG_DEF 0x04
110#define MLXPLAT_CPLD_AGGR_MASK_COMEX BIT(0)
111#define MLXPLAT_CPLD_LOW_AGGR_MASK_LOW 0xc1
112#define MLXPLAT_CPLD_LOW_AGGR_MASK_I2C BIT(6)
113#define MLXPLAT_CPLD_PSU_MASK GENMASK(1, 0)
114#define MLXPLAT_CPLD_PWR_MASK GENMASK(1, 0)
115#define MLXPLAT_CPLD_FAN_MASK GENMASK(3, 0)
116#define MLXPLAT_CPLD_ASIC_MASK GENMASK(1, 0)
117#define MLXPLAT_CPLD_FAN_NG_MASK GENMASK(5, 0)
118#define MLXPLAT_CPLD_LED_LO_NIBBLE_MASK GENMASK(7, 4)
119#define MLXPLAT_CPLD_LED_HI_NIBBLE_MASK GENMASK(3, 0)
120
121/* Default I2C parent bus number */
122#define MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR 1
123
124/* Maximum number of possible physical buses equipped on system */
125#define MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM 16
126
127/* Number of channels in group */
128#define MLXPLAT_CPLD_GRP_CHNL_NUM 8
129
130/* Start channel numbers */
131#define MLXPLAT_CPLD_CH1 2
132#define MLXPLAT_CPLD_CH2 10
133
134/* Number of LPC attached MUX platform devices */
135#define MLXPLAT_CPLD_LPC_MUX_DEVS 2
136
137/* Hotplug devices adapter numbers */
138#define MLXPLAT_CPLD_NR_NONE -1
139#define MLXPLAT_CPLD_PSU_DEFAULT_NR 10
140#define MLXPLAT_CPLD_PSU_MSNXXXX_NR 4
141#define MLXPLAT_CPLD_FAN1_DEFAULT_NR 11
142#define MLXPLAT_CPLD_FAN2_DEFAULT_NR 12
143#define MLXPLAT_CPLD_FAN3_DEFAULT_NR 13
144#define MLXPLAT_CPLD_FAN4_DEFAULT_NR 14
145
146/* Masks and default values for watchdogs */
147#define MLXPLAT_CPLD_WD1_CLEAR_MASK GENMASK(7, 1)
148#define MLXPLAT_CPLD_WD2_CLEAR_MASK (GENMASK(7, 0) & ~BIT(1))
149
150#define MLXPLAT_CPLD_WD_TYPE1_TO_MASK GENMASK(7, 4)
151#define MLXPLAT_CPLD_WD_TYPE2_TO_MASK 0
152#define MLXPLAT_CPLD_WD_RESET_ACT_MASK GENMASK(7, 1)
153#define MLXPLAT_CPLD_WD_FAN_ACT_MASK (GENMASK(7, 0) & ~BIT(4))
154#define MLXPLAT_CPLD_WD_COUNT_ACT_MASK (GENMASK(7, 0) & ~BIT(7))
155#define MLXPLAT_CPLD_WD_DFLT_TIMEOUT 30
156#define MLXPLAT_CPLD_WD_MAX_DEVS 2
157
158/* mlxplat_priv - platform private data
159 * @pdev_i2c - i2c controller platform device
160 * @pdev_mux - array of mux platform devices
161 * @pdev_hotplug - hotplug platform devices
162 * @pdev_led - led platform devices
163 * @pdev_io_regs - register access platform devices
164 * @pdev_fan - FAN platform devices
165 * @pdev_wd - array of watchdog platform devices
166 * @regmap: device register map
167 */
168struct mlxplat_priv {
169 struct platform_device *pdev_i2c;
170 struct platform_device *pdev_mux[MLXPLAT_CPLD_LPC_MUX_DEVS];
171 struct platform_device *pdev_hotplug;
172 struct platform_device *pdev_led;
173 struct platform_device *pdev_io_regs;
174 struct platform_device *pdev_fan;
175 struct platform_device *pdev_wd[MLXPLAT_CPLD_WD_MAX_DEVS];
176 void *regmap;
177};
178
179/* Regions for LPC I2C controller and LPC base register space */
180static const struct resource mlxplat_lpc_resources[] = {
181 [0] = DEFINE_RES_NAMED(MLXPLAT_CPLD_LPC_I2C_BASE_ADRR,
182 MLXPLAT_CPLD_LPC_IO_RANGE,
183 "mlxplat_cpld_lpc_i2c_ctrl", IORESOURCE_IO),
184 [1] = DEFINE_RES_NAMED(MLXPLAT_CPLD_LPC_REG_BASE_ADRR,
185 MLXPLAT_CPLD_LPC_IO_RANGE,
186 "mlxplat_cpld_lpc_regs",
187 IORESOURCE_IO),
188};
189
190/* Platform next generation systems i2c data */
191static struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_i2c_ng_data = {
192 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
193 .mask = MLXPLAT_CPLD_AGGR_MASK_COMEX,
194 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET,
195 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_I2C,
196};
197
198/* Platform default channels */
199static const int mlxplat_default_channels[][MLXPLAT_CPLD_GRP_CHNL_NUM] = {
200 {
201 MLXPLAT_CPLD_CH1, MLXPLAT_CPLD_CH1 + 1, MLXPLAT_CPLD_CH1 + 2,
202 MLXPLAT_CPLD_CH1 + 3, MLXPLAT_CPLD_CH1 + 4, MLXPLAT_CPLD_CH1 +
203 5, MLXPLAT_CPLD_CH1 + 6, MLXPLAT_CPLD_CH1 + 7
204 },
205 {
206 MLXPLAT_CPLD_CH2, MLXPLAT_CPLD_CH2 + 1, MLXPLAT_CPLD_CH2 + 2,
207 MLXPLAT_CPLD_CH2 + 3, MLXPLAT_CPLD_CH2 + 4, MLXPLAT_CPLD_CH2 +
208 5, MLXPLAT_CPLD_CH2 + 6, MLXPLAT_CPLD_CH2 + 7
209 },
210};
211
212/* Platform channels for MSN21xx system family */
213static const int mlxplat_msn21xx_channels[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
214
215/* Platform mux data */
216static struct i2c_mux_reg_platform_data mlxplat_mux_data[] = {
217 {
218 .parent = 1,
219 .base_nr = MLXPLAT_CPLD_CH1,
220 .write_only = 1,
221 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
222 .reg_size = 1,
223 .idle_in_use = 1,
224 },
225 {
226 .parent = 1,
227 .base_nr = MLXPLAT_CPLD_CH2,
228 .write_only = 1,
229 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
230 .reg_size = 1,
231 .idle_in_use = 1,
232 },
233
234};
235
236/* Platform hotplug devices */
237static struct i2c_board_info mlxplat_mlxcpld_psu[] = {
238 {
239 I2C_BOARD_INFO("24c02", 0x51),
240 },
241 {
242 I2C_BOARD_INFO("24c02", 0x50),
243 },
244};
245
246static struct i2c_board_info mlxplat_mlxcpld_ng_psu[] = {
247 {
248 I2C_BOARD_INFO("24c32", 0x51),
249 },
250 {
251 I2C_BOARD_INFO("24c32", 0x50),
252 },
253};
254
255static struct i2c_board_info mlxplat_mlxcpld_pwr[] = {
256 {
257 I2C_BOARD_INFO("dps460", 0x59),
258 },
259 {
260 I2C_BOARD_INFO("dps460", 0x58),
261 },
262};
263
264static struct i2c_board_info mlxplat_mlxcpld_fan[] = {
265 {
266 I2C_BOARD_INFO("24c32", 0x50),
267 },
268 {
269 I2C_BOARD_INFO("24c32", 0x50),
270 },
271 {
272 I2C_BOARD_INFO("24c32", 0x50),
273 },
274 {
275 I2C_BOARD_INFO("24c32", 0x50),
276 },
277};
278
279/* Platform hotplug default data */
280static struct mlxreg_core_data mlxplat_mlxcpld_default_psu_items_data[] = {
281 {
282 .label = "psu1",
283 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
284 .mask = BIT(0),
285 .hpdev.brdinfo = &mlxplat_mlxcpld_psu[0],
286 .hpdev.nr = MLXPLAT_CPLD_PSU_DEFAULT_NR,
287 },
288 {
289 .label = "psu2",
290 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
291 .mask = BIT(1),
292 .hpdev.brdinfo = &mlxplat_mlxcpld_psu[1],
293 .hpdev.nr = MLXPLAT_CPLD_PSU_DEFAULT_NR,
294 },
295};
296
297static struct mlxreg_core_data mlxplat_mlxcpld_default_pwr_items_data[] = {
298 {
299 .label = "pwr1",
300 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
301 .mask = BIT(0),
302 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
303 .hpdev.nr = MLXPLAT_CPLD_PSU_DEFAULT_NR,
304 },
305 {
306 .label = "pwr2",
307 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
308 .mask = BIT(1),
309 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
310 .hpdev.nr = MLXPLAT_CPLD_PSU_DEFAULT_NR,
311 },
312};
313
314static struct mlxreg_core_data mlxplat_mlxcpld_default_fan_items_data[] = {
315 {
316 .label = "fan1",
317 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
318 .mask = BIT(0),
319 .hpdev.brdinfo = &mlxplat_mlxcpld_fan[0],
320 .hpdev.nr = MLXPLAT_CPLD_FAN1_DEFAULT_NR,
321 },
322 {
323 .label = "fan2",
324 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
325 .mask = BIT(1),
326 .hpdev.brdinfo = &mlxplat_mlxcpld_fan[1],
327 .hpdev.nr = MLXPLAT_CPLD_FAN2_DEFAULT_NR,
328 },
329 {
330 .label = "fan3",
331 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
332 .mask = BIT(2),
333 .hpdev.brdinfo = &mlxplat_mlxcpld_fan[2],
334 .hpdev.nr = MLXPLAT_CPLD_FAN3_DEFAULT_NR,
335 },
336 {
337 .label = "fan4",
338 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
339 .mask = BIT(3),
340 .hpdev.brdinfo = &mlxplat_mlxcpld_fan[3],
341 .hpdev.nr = MLXPLAT_CPLD_FAN4_DEFAULT_NR,
342 },
343};
344
345static struct mlxreg_core_data mlxplat_mlxcpld_default_asic_items_data[] = {
346 {
347 .label = "asic1",
348 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
349 .mask = MLXPLAT_CPLD_ASIC_MASK,
350 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
351 },
352};
353
354static struct mlxreg_core_item mlxplat_mlxcpld_default_items[] = {
355 {
356 .data = mlxplat_mlxcpld_default_psu_items_data,
357 .aggr_mask = MLXPLAT_CPLD_AGGR_PSU_MASK_DEF,
358 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
359 .mask = MLXPLAT_CPLD_PSU_MASK,
360 .count = ARRAY_SIZE(mlxplat_mlxcpld_psu),
361 .inversed = 1,
362 .health = false,
363 },
364 {
365 .data = mlxplat_mlxcpld_default_pwr_items_data,
366 .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
367 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
368 .mask = MLXPLAT_CPLD_PWR_MASK,
369 .count = ARRAY_SIZE(mlxplat_mlxcpld_pwr),
370 .inversed = 0,
371 .health = false,
372 },
373 {
374 .data = mlxplat_mlxcpld_default_fan_items_data,
375 .aggr_mask = MLXPLAT_CPLD_AGGR_FAN_MASK_DEF,
376 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
377 .mask = MLXPLAT_CPLD_FAN_MASK,
378 .count = ARRAY_SIZE(mlxplat_mlxcpld_fan),
379 .inversed = 1,
380 .health = false,
381 },
382 {
383 .data = mlxplat_mlxcpld_default_asic_items_data,
384 .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
385 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
386 .mask = MLXPLAT_CPLD_ASIC_MASK,
387 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
388 .inversed = 0,
389 .health = true,
390 },
391};
392
393static
394struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_default_data = {
395 .items = mlxplat_mlxcpld_default_items,
396 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_items),
397 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
398 .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
399 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
400 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
401};
402
403static struct mlxreg_core_data mlxplat_mlxcpld_msn21xx_pwr_items_data[] = {
404 {
405 .label = "pwr1",
406 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
407 .mask = BIT(0),
408 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
409 },
410 {
411 .label = "pwr2",
412 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
413 .mask = BIT(1),
414 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
415 },
416};
417
418/* Platform hotplug MSN21xx system family data */
419static struct mlxreg_core_item mlxplat_mlxcpld_msn21xx_items[] = {
420 {
421 .data = mlxplat_mlxcpld_msn21xx_pwr_items_data,
422 .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
423 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
424 .mask = MLXPLAT_CPLD_PWR_MASK,
425 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_pwr_items_data),
426 .inversed = 0,
427 .health = false,
428 },
429 {
430 .data = mlxplat_mlxcpld_default_asic_items_data,
431 .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
432 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
433 .mask = MLXPLAT_CPLD_ASIC_MASK,
434 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
435 .inversed = 0,
436 .health = true,
437 },
438};
439
440static
441struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn21xx_data = {
442 .items = mlxplat_mlxcpld_msn21xx_items,
443 .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_items),
444 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
445 .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
446 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
447 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
448};
449
450/* Platform hotplug msn274x system family data */
451static struct mlxreg_core_data mlxplat_mlxcpld_msn274x_psu_items_data[] = {
452 {
453 .label = "psu1",
454 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
455 .mask = BIT(0),
456 .hpdev.brdinfo = &mlxplat_mlxcpld_psu[0],
457 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
458 },
459 {
460 .label = "psu2",
461 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
462 .mask = BIT(1),
463 .hpdev.brdinfo = &mlxplat_mlxcpld_psu[1],
464 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
465 },
466};
467
468static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_pwr_items_data[] = {
469 {
470 .label = "pwr1",
471 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
472 .mask = BIT(0),
473 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[0],
474 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
475 },
476 {
477 .label = "pwr2",
478 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
479 .mask = BIT(1),
480 .hpdev.brdinfo = &mlxplat_mlxcpld_pwr[1],
481 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
482 },
483};
484
485static struct mlxreg_core_data mlxplat_mlxcpld_msn274x_fan_items_data[] = {
486 {
487 .label = "fan1",
488 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
489 .mask = BIT(0),
490 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
491 },
492 {
493 .label = "fan2",
494 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
495 .mask = BIT(1),
496 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
497 },
498 {
499 .label = "fan3",
500 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
501 .mask = BIT(2),
502 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
503 },
504 {
505 .label = "fan4",
506 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
507 .mask = BIT(3),
508 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
509 },
510};
511
512static struct mlxreg_core_item mlxplat_mlxcpld_msn274x_items[] = {
513 {
514 .data = mlxplat_mlxcpld_msn274x_psu_items_data,
515 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
516 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
517 .mask = MLXPLAT_CPLD_PSU_MASK,
518 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_psu_items_data),
519 .inversed = 1,
520 .health = false,
521 },
522 {
523 .data = mlxplat_mlxcpld_default_ng_pwr_items_data,
524 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
525 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
526 .mask = MLXPLAT_CPLD_PWR_MASK,
527 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_pwr_items_data),
528 .inversed = 0,
529 .health = false,
530 },
531 {
532 .data = mlxplat_mlxcpld_msn274x_fan_items_data,
533 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
534 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
535 .mask = MLXPLAT_CPLD_FAN_MASK,
536 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_fan_items_data),
537 .inversed = 1,
538 .health = false,
539 },
540 {
541 .data = mlxplat_mlxcpld_default_asic_items_data,
542 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
543 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
544 .mask = MLXPLAT_CPLD_ASIC_MASK,
545 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
546 .inversed = 0,
547 .health = true,
548 },
549};
550
551static
552struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn274x_data = {
553 .items = mlxplat_mlxcpld_msn274x_items,
554 .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn274x_items),
555 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
556 .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
557 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
558 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
559};
560
561/* Platform hotplug MSN201x system family data */
562static struct mlxreg_core_data mlxplat_mlxcpld_msn201x_pwr_items_data[] = {
563 {
564 .label = "pwr1",
565 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
566 .mask = BIT(0),
567 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
568 },
569 {
570 .label = "pwr2",
571 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
572 .mask = BIT(1),
573 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
574 },
575};
576
577static struct mlxreg_core_item mlxplat_mlxcpld_msn201x_items[] = {
578 {
579 .data = mlxplat_mlxcpld_msn201x_pwr_items_data,
580 .aggr_mask = MLXPLAT_CPLD_AGGR_PWR_MASK_DEF,
581 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
582 .mask = MLXPLAT_CPLD_PWR_MASK,
583 .count = ARRAY_SIZE(mlxplat_mlxcpld_msn201x_pwr_items_data),
584 .inversed = 0,
585 .health = false,
586 },
587 {
588 .data = mlxplat_mlxcpld_default_asic_items_data,
589 .aggr_mask = MLXPLAT_CPLD_AGGR_ASIC_MASK_DEF,
590 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
591 .mask = MLXPLAT_CPLD_ASIC_MASK,
592 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
593 .inversed = 0,
594 .health = true,
595 },
596};
597
598static
599struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_msn201x_data = {
600 .items = mlxplat_mlxcpld_msn201x_items,
601 .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn201x_items),
602 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
603 .mask = MLXPLAT_CPLD_AGGR_MASK_DEF,
604 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
605 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
606};
607
608/* Platform hotplug next generation system family data */
609static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_psu_items_data[] = {
610 {
611 .label = "psu1",
612 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
613 .mask = BIT(0),
614 .hpdev.brdinfo = &mlxplat_mlxcpld_ng_psu[0],
615 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
616 },
617 {
618 .label = "psu2",
619 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
620 .mask = BIT(1),
621 .hpdev.brdinfo = &mlxplat_mlxcpld_ng_psu[1],
622 .hpdev.nr = MLXPLAT_CPLD_PSU_MSNXXXX_NR,
623 },
624};
625
626static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_fan_items_data[] = {
627 {
628 .label = "fan1",
629 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
630 .mask = BIT(0),
631 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
632 .bit = BIT(0),
633 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
634 },
635 {
636 .label = "fan2",
637 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
638 .mask = BIT(1),
639 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
640 .bit = BIT(1),
641 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
642 },
643 {
644 .label = "fan3",
645 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
646 .mask = BIT(2),
647 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
648 .bit = BIT(2),
649 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
650 },
651 {
652 .label = "fan4",
653 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
654 .mask = BIT(3),
655 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
656 .bit = BIT(3),
657 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
658 },
659 {
660 .label = "fan5",
661 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
662 .mask = BIT(4),
663 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
664 .bit = BIT(4),
665 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
666 },
667 {
668 .label = "fan6",
669 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
670 .mask = BIT(5),
671 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
672 .bit = BIT(5),
673 .hpdev.nr = MLXPLAT_CPLD_NR_NONE,
674 },
675};
676
677static struct mlxreg_core_item mlxplat_mlxcpld_default_ng_items[] = {
678 {
679 .data = mlxplat_mlxcpld_default_ng_psu_items_data,
680 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
681 .reg = MLXPLAT_CPLD_LPC_REG_PSU_OFFSET,
682 .mask = MLXPLAT_CPLD_PSU_MASK,
683 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_psu_items_data),
684 .inversed = 1,
685 .health = false,
686 },
687 {
688 .data = mlxplat_mlxcpld_default_ng_pwr_items_data,
689 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
690 .reg = MLXPLAT_CPLD_LPC_REG_PWR_OFFSET,
691 .mask = MLXPLAT_CPLD_PWR_MASK,
692 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_pwr_items_data),
693 .inversed = 0,
694 .health = false,
695 },
696 {
697 .data = mlxplat_mlxcpld_default_ng_fan_items_data,
698 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
699 .reg = MLXPLAT_CPLD_LPC_REG_FAN_OFFSET,
700 .mask = MLXPLAT_CPLD_FAN_NG_MASK,
701 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_fan_items_data),
702 .inversed = 1,
703 .health = false,
704 },
705 {
706 .data = mlxplat_mlxcpld_default_asic_items_data,
707 .aggr_mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF,
708 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
709 .mask = MLXPLAT_CPLD_ASIC_MASK,
710 .count = ARRAY_SIZE(mlxplat_mlxcpld_default_asic_items_data),
711 .inversed = 0,
712 .health = true,
713 },
714};
715
716static
717struct mlxreg_core_hotplug_platform_data mlxplat_mlxcpld_default_ng_data = {
718 .items = mlxplat_mlxcpld_default_ng_items,
719 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_items),
720 .cell = MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET,
721 .mask = MLXPLAT_CPLD_AGGR_MASK_NG_DEF | MLXPLAT_CPLD_AGGR_MASK_COMEX,
722 .cell_low = MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET,
723 .mask_low = MLXPLAT_CPLD_LOW_AGGR_MASK_LOW,
724};
725
726/* Platform led default data */
727static struct mlxreg_core_data mlxplat_mlxcpld_default_led_data[] = {
728 {
729 .label = "status:green",
730 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
731 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
732 },
733 {
734 .label = "status:red",
735 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
736 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK
737 },
738 {
739 .label = "psu:green",
740 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
741 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
742 },
743 {
744 .label = "psu:red",
745 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
746 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
747 },
748 {
749 .label = "fan1:green",
750 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
751 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
752 },
753 {
754 .label = "fan1:red",
755 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
756 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
757 },
758 {
759 .label = "fan2:green",
760 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
761 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
762 },
763 {
764 .label = "fan2:red",
765 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
766 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
767 },
768 {
769 .label = "fan3:green",
770 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
771 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
772 },
773 {
774 .label = "fan3:red",
775 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
776 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
777 },
778 {
779 .label = "fan4:green",
780 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
781 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
782 },
783 {
784 .label = "fan4:red",
785 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
786 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
787 },
788};
789
790static struct mlxreg_core_platform_data mlxplat_default_led_data = {
791 .data = mlxplat_mlxcpld_default_led_data,
792 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_led_data),
793};
794
795/* Platform led MSN21xx system family data */
796static struct mlxreg_core_data mlxplat_mlxcpld_msn21xx_led_data[] = {
797 {
798 .label = "status:green",
799 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
800 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
801 },
802 {
803 .label = "status:red",
804 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
805 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK
806 },
807 {
808 .label = "fan:green",
809 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
810 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
811 },
812 {
813 .label = "fan:red",
814 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
815 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
816 },
817 {
818 .label = "psu1:green",
819 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
820 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
821 },
822 {
823 .label = "psu1:red",
824 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
825 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
826 },
827 {
828 .label = "psu2:green",
829 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
830 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
831 },
832 {
833 .label = "psu2:red",
834 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
835 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
836 },
837 {
838 .label = "uid:blue",
839 .reg = MLXPLAT_CPLD_LPC_REG_LED5_OFFSET,
840 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
841 },
842};
843
844static struct mlxreg_core_platform_data mlxplat_msn21xx_led_data = {
845 .data = mlxplat_mlxcpld_msn21xx_led_data,
846 .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_led_data),
847};
848
849/* Platform led for default data for 200GbE systems */
850static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_led_data[] = {
851 {
852 .label = "status:green",
853 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
854 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
855 },
856 {
857 .label = "status:orange",
858 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
859 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK
860 },
861 {
862 .label = "psu:green",
863 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
864 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
865 },
866 {
867 .label = "psu:orange",
868 .reg = MLXPLAT_CPLD_LPC_REG_LED1_OFFSET,
869 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
870 },
871 {
872 .label = "fan1:green",
873 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
874 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
875 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
876 .bit = BIT(0),
877 },
878 {
879 .label = "fan1:orange",
880 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
881 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
882 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
883 .bit = BIT(0),
884 },
885 {
886 .label = "fan2:green",
887 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
888 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
889 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
890 .bit = BIT(1),
891 },
892 {
893 .label = "fan2:orange",
894 .reg = MLXPLAT_CPLD_LPC_REG_LED2_OFFSET,
895 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
896 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
897 .bit = BIT(1),
898 },
899 {
900 .label = "fan3:green",
901 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
902 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
903 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
904 .bit = BIT(2),
905 },
906 {
907 .label = "fan3:orange",
908 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
909 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
910 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
911 .bit = BIT(2),
912 },
913 {
914 .label = "fan4:green",
915 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
916 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
917 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
918 .bit = BIT(3),
919 },
920 {
921 .label = "fan4:orange",
922 .reg = MLXPLAT_CPLD_LPC_REG_LED3_OFFSET,
923 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
924 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
925 .bit = BIT(3),
926 },
927 {
928 .label = "fan5:green",
929 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
930 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
931 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
932 .bit = BIT(4),
933 },
934 {
935 .label = "fan5:orange",
936 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
937 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
938 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
939 .bit = BIT(4),
940 },
941 {
942 .label = "fan6:green",
943 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
944 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
945 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
946 .bit = BIT(5),
947 },
948 {
949 .label = "fan6:orange",
950 .reg = MLXPLAT_CPLD_LPC_REG_LED4_OFFSET,
951 .mask = MLXPLAT_CPLD_LED_HI_NIBBLE_MASK,
952 .capability = MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET,
953 .bit = BIT(5),
954 },
955 {
956 .label = "uid:blue",
957 .reg = MLXPLAT_CPLD_LPC_REG_LED5_OFFSET,
958 .mask = MLXPLAT_CPLD_LED_LO_NIBBLE_MASK,
959 },
960};
961
962static struct mlxreg_core_platform_data mlxplat_default_ng_led_data = {
963 .data = mlxplat_mlxcpld_default_ng_led_data,
964 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_led_data),
965};
966
967/* Platform register access default */
968static struct mlxreg_core_data mlxplat_mlxcpld_default_regs_io_data[] = {
969 {
970 .label = "cpld1_version",
971 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET,
972 .bit = GENMASK(7, 0),
973 .mode = 0444,
974 },
975 {
976 .label = "cpld2_version",
977 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET,
978 .bit = GENMASK(7, 0),
979 .mode = 0444,
980 },
981 {
982 .label = "reset_long_pb",
983 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
984 .mask = GENMASK(7, 0) & ~BIT(0),
985 .mode = 0444,
986 },
987 {
988 .label = "reset_short_pb",
989 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
990 .mask = GENMASK(7, 0) & ~BIT(1),
991 .mode = 0444,
992 },
993 {
994 .label = "reset_aux_pwr_or_ref",
995 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
996 .mask = GENMASK(7, 0) & ~BIT(2),
997 .mode = 0444,
998 },
999 {
1000 .label = "reset_main_pwr_fail",
1001 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1002 .mask = GENMASK(7, 0) & ~BIT(3),
1003 .mode = 0444,
1004 },
1005 {
1006 .label = "reset_sw_reset",
1007 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1008 .mask = GENMASK(7, 0) & ~BIT(4),
1009 .mode = 0444,
1010 },
1011 {
1012 .label = "reset_fw_reset",
1013 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1014 .mask = GENMASK(7, 0) & ~BIT(5),
1015 .mode = 0444,
1016 },
1017 {
1018 .label = "reset_hotswap_or_wd",
1019 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1020 .mask = GENMASK(7, 0) & ~BIT(6),
1021 .mode = 0444,
1022 },
1023 {
1024 .label = "reset_asic_thermal",
1025 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1026 .mask = GENMASK(7, 0) & ~BIT(7),
1027 .mode = 0444,
1028 },
1029 {
1030 .label = "psu1_on",
1031 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1032 .mask = GENMASK(7, 0) & ~BIT(0),
1033 .mode = 0200,
1034 },
1035 {
1036 .label = "psu2_on",
1037 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1038 .mask = GENMASK(7, 0) & ~BIT(1),
1039 .mode = 0200,
1040 },
1041 {
1042 .label = "pwr_cycle",
1043 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1044 .mask = GENMASK(7, 0) & ~BIT(2),
1045 .mode = 0200,
1046 },
1047 {
1048 .label = "pwr_down",
1049 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1050 .mask = GENMASK(7, 0) & ~BIT(3),
1051 .mode = 0200,
1052 },
1053 {
1054 .label = "select_iio",
1055 .reg = MLXPLAT_CPLD_LPC_REG_GP2_OFFSET,
1056 .mask = GENMASK(7, 0) & ~BIT(6),
1057 .mode = 0644,
1058 },
1059 {
1060 .label = "asic_health",
1061 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
1062 .mask = MLXPLAT_CPLD_ASIC_MASK,
1063 .bit = 1,
1064 .mode = 0444,
1065 },
1066};
1067
1068static struct mlxreg_core_platform_data mlxplat_default_regs_io_data = {
1069 .data = mlxplat_mlxcpld_default_regs_io_data,
1070 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_regs_io_data),
1071};
1072
1073/* Platform register access MSN21xx, MSN201x, MSN274x systems families data */
1074static struct mlxreg_core_data mlxplat_mlxcpld_msn21xx_regs_io_data[] = {
1075 {
1076 .label = "cpld1_version",
1077 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET,
1078 .bit = GENMASK(7, 0),
1079 .mode = 0444,
1080 },
1081 {
1082 .label = "cpld2_version",
1083 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET,
1084 .bit = GENMASK(7, 0),
1085 .mode = 0444,
1086 },
1087 {
1088 .label = "reset_long_pb",
1089 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1090 .mask = GENMASK(7, 0) & ~BIT(0),
1091 .mode = 0444,
1092 },
1093 {
1094 .label = "reset_short_pb",
1095 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1096 .mask = GENMASK(7, 0) & ~BIT(1),
1097 .mode = 0444,
1098 },
1099 {
1100 .label = "reset_aux_pwr_or_ref",
1101 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1102 .mask = GENMASK(7, 0) & ~BIT(2),
1103 .mode = 0444,
1104 },
1105 {
1106 .label = "reset_sw_reset",
1107 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1108 .mask = GENMASK(7, 0) & ~BIT(3),
1109 .mode = 0444,
1110 },
1111 {
1112 .label = "reset_main_pwr_fail",
1113 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1114 .mask = GENMASK(7, 0) & ~BIT(4),
1115 .mode = 0444,
1116 },
1117 {
1118 .label = "reset_asic_thermal",
1119 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1120 .mask = GENMASK(7, 0) & ~BIT(5),
1121 .mode = 0444,
1122 },
1123 {
1124 .label = "reset_hotswap_or_halt",
1125 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1126 .mask = GENMASK(7, 0) & ~BIT(6),
1127 .mode = 0444,
1128 },
1129 {
1130 .label = "reset_sff_wd",
1131 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET,
1132 .mask = GENMASK(7, 0) & ~BIT(6),
1133 .mode = 0444,
1134 },
1135 {
1136 .label = "psu1_on",
1137 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1138 .mask = GENMASK(7, 0) & ~BIT(0),
1139 .mode = 0200,
1140 },
1141 {
1142 .label = "psu2_on",
1143 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1144 .mask = GENMASK(7, 0) & ~BIT(1),
1145 .mode = 0200,
1146 },
1147 {
1148 .label = "pwr_cycle",
1149 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1150 .mask = GENMASK(7, 0) & ~BIT(2),
1151 .mode = 0200,
1152 },
1153 {
1154 .label = "pwr_down",
1155 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1156 .mask = GENMASK(7, 0) & ~BIT(3),
1157 .mode = 0200,
1158 },
1159 {
1160 .label = "asic_health",
1161 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
1162 .mask = MLXPLAT_CPLD_ASIC_MASK,
1163 .bit = 1,
1164 .mode = 0444,
1165 },
1166};
1167
1168static struct mlxreg_core_platform_data mlxplat_msn21xx_regs_io_data = {
1169 .data = mlxplat_mlxcpld_msn21xx_regs_io_data,
1170 .counter = ARRAY_SIZE(mlxplat_mlxcpld_msn21xx_regs_io_data),
1171};
1172
1173/* Platform register access for next generation systems families data */
1174static struct mlxreg_core_data mlxplat_mlxcpld_default_ng_regs_io_data[] = {
1175 {
1176 .label = "cpld1_version",
1177 .reg = MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET,
1178 .bit = GENMASK(7, 0),
1179 .mode = 0444,
1180 },
1181 {
1182 .label = "cpld2_version",
1183 .reg = MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET,
1184 .bit = GENMASK(7, 0),
1185 .mode = 0444,
1186 },
1187 {
1188 .label = "cpld3_version",
1189 .reg = MLXPLAT_CPLD_LPC_REG_CPLD3_VER_OFFSET,
1190 .bit = GENMASK(7, 0),
1191 .mode = 0444,
1192 },
1193 {
1194 .label = "cpld4_version",
1195 .reg = MLXPLAT_CPLD_LPC_REG_CPLD4_VER_OFFSET,
1196 .bit = GENMASK(7, 0),
1197 .mode = 0444,
1198 },
1199 {
1200 .label = "reset_long_pb",
1201 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1202 .mask = GENMASK(7, 0) & ~BIT(0),
1203 .mode = 0444,
1204 },
1205 {
1206 .label = "reset_short_pb",
1207 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1208 .mask = GENMASK(7, 0) & ~BIT(1),
1209 .mode = 0444,
1210 },
1211 {
1212 .label = "reset_aux_pwr_or_ref",
1213 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1214 .mask = GENMASK(7, 0) & ~BIT(2),
1215 .mode = 0444,
1216 },
1217 {
1218 .label = "reset_from_comex",
1219 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1220 .mask = GENMASK(7, 0) & ~BIT(4),
1221 .mode = 0444,
1222 },
1223 {
1224 .label = "reset_from_asic",
1225 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1226 .mask = GENMASK(7, 0) & ~BIT(5),
1227 .mode = 0444,
1228 },
1229 {
1230 .label = "reset_swb_wd",
1231 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1232 .mask = GENMASK(7, 0) & ~BIT(6),
1233 .mode = 0444,
1234 },
1235 {
1236 .label = "reset_asic_thermal",
1237 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1238 .mask = GENMASK(7, 0) & ~BIT(7),
1239 .mode = 0444,
1240 },
1241 {
1242 .label = "reset_comex_pwr_fail",
1243 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET,
1244 .mask = GENMASK(7, 0) & ~BIT(3),
1245 .mode = 0444,
1246 },
1247 {
1248 .label = "reset_comex_wd",
1249 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET,
1250 .mask = GENMASK(7, 0) & ~BIT(6),
1251 .mode = 0444,
1252 },
1253 {
1254 .label = "reset_voltmon_upgrade_fail",
1255 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1256 .mask = GENMASK(7, 0) & ~BIT(0),
1257 .mode = 0444,
1258 },
1259 {
1260 .label = "reset_system",
1261 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1262 .mask = GENMASK(7, 0) & ~BIT(1),
1263 .mode = 0444,
1264 },
1265 {
1266 .label = "reset_comex_thermal",
1267 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1268 .mask = GENMASK(7, 0) & ~BIT(3),
1269 .mode = 0444,
1270 },
1271 {
1272 .label = "reset_reload_bios",
1273 .reg = MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET,
1274 .mask = GENMASK(7, 0) & ~BIT(5),
1275 .mode = 0444,
1276 },
1277 {
1278 .label = "psu1_on",
1279 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1280 .mask = GENMASK(7, 0) & ~BIT(0),
1281 .mode = 0200,
1282 },
1283 {
1284 .label = "psu2_on",
1285 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1286 .mask = GENMASK(7, 0) & ~BIT(1),
1287 .mode = 0200,
1288 },
1289 {
1290 .label = "pwr_cycle",
1291 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1292 .mask = GENMASK(7, 0) & ~BIT(2),
1293 .mode = 0200,
1294 },
1295 {
1296 .label = "pwr_down",
1297 .reg = MLXPLAT_CPLD_LPC_REG_GP1_OFFSET,
1298 .mask = GENMASK(7, 0) & ~BIT(3),
1299 .mode = 0200,
1300 },
1301 {
1302 .label = "jtag_enable",
1303 .reg = MLXPLAT_CPLD_LPC_REG_GP2_OFFSET,
1304 .mask = GENMASK(7, 0) & ~BIT(4),
1305 .mode = 0644,
1306 },
1307 {
1308 .label = "asic_health",
1309 .reg = MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET,
1310 .mask = MLXPLAT_CPLD_ASIC_MASK,
1311 .bit = 1,
1312 .mode = 0444,
1313 },
1314 {
1315 .label = "fan_dir",
1316 .reg = MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION,
1317 .bit = GENMASK(7, 0),
1318 .mode = 0444,
1319 },
1320};
1321
1322static struct mlxreg_core_platform_data mlxplat_default_ng_regs_io_data = {
1323 .data = mlxplat_mlxcpld_default_ng_regs_io_data,
1324 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_ng_regs_io_data),
1325};
1326
1327/* Platform FAN default */
1328static struct mlxreg_core_data mlxplat_mlxcpld_default_fan_data[] = {
1329 {
1330 .label = "pwm1",
1331 .reg = MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET,
1332 },
1333 {
1334 .label = "tacho1",
1335 .reg = MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET,
1336 .mask = GENMASK(7, 0),
1337 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1338 .bit = BIT(0),
1339 },
1340 {
1341 .label = "tacho2",
1342 .reg = MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET,
1343 .mask = GENMASK(7, 0),
1344 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1345 .bit = BIT(1),
1346 },
1347 {
1348 .label = "tacho3",
1349 .reg = MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET,
1350 .mask = GENMASK(7, 0),
1351 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1352 .bit = BIT(2),
1353 },
1354 {
1355 .label = "tacho4",
1356 .reg = MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET,
1357 .mask = GENMASK(7, 0),
1358 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1359 .bit = BIT(3),
1360 },
1361 {
1362 .label = "tacho5",
1363 .reg = MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET,
1364 .mask = GENMASK(7, 0),
1365 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1366 .bit = BIT(4),
1367 },
1368 {
1369 .label = "tacho6",
1370 .reg = MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET,
1371 .mask = GENMASK(7, 0),
1372 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1373 .bit = BIT(5),
1374 },
1375 {
1376 .label = "tacho7",
1377 .reg = MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET,
1378 .mask = GENMASK(7, 0),
1379 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1380 .bit = BIT(6),
1381 },
1382 {
1383 .label = "tacho8",
1384 .reg = MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET,
1385 .mask = GENMASK(7, 0),
1386 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET,
1387 .bit = BIT(7),
1388 },
1389 {
1390 .label = "tacho9",
1391 .reg = MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET,
1392 .mask = GENMASK(7, 0),
1393 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET,
1394 .bit = BIT(0),
1395 },
1396 {
1397 .label = "tacho10",
1398 .reg = MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET,
1399 .mask = GENMASK(7, 0),
1400 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET,
1401 .bit = BIT(1),
1402 },
1403 {
1404 .label = "tacho11",
1405 .reg = MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET,
1406 .mask = GENMASK(7, 0),
1407 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET,
1408 .bit = BIT(2),
1409 },
1410 {
1411 .label = "tacho12",
1412 .reg = MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET,
1413 .mask = GENMASK(7, 0),
1414 .capability = MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET,
1415 .bit = BIT(3),
1416 },
1417 {
1418 .label = "conf",
1419 .capability = MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET,
1420 },
1421};
1422
1423static struct mlxreg_core_platform_data mlxplat_default_fan_data = {
1424 .data = mlxplat_mlxcpld_default_fan_data,
1425 .counter = ARRAY_SIZE(mlxplat_mlxcpld_default_fan_data),
1426};
1427
1428/* Watchdog type1: hardware implementation version1
1429 * (MSN2700, MSN2410, MSN2740, MSN2100 and MSN2140 systems).
1430 */
1431static struct mlxreg_core_data mlxplat_mlxcpld_wd_main_regs_type1[] = {
1432 {
1433 .label = "action",
1434 .reg = MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET,
1435 .mask = MLXPLAT_CPLD_WD_RESET_ACT_MASK,
1436 .bit = 0,
1437 },
1438 {
1439 .label = "timeout",
1440 .reg = MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET,
1441 .mask = MLXPLAT_CPLD_WD_TYPE1_TO_MASK,
1442 .health_cntr = MLXPLAT_CPLD_WD_DFLT_TIMEOUT,
1443 },
1444 {
1445 .label = "ping",
1446 .reg = MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET,
1447 .mask = MLXPLAT_CPLD_WD1_CLEAR_MASK,
1448 .bit = 0,
1449 },
1450 {
1451 .label = "reset",
1452 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1453 .mask = GENMASK(7, 0) & ~BIT(6),
1454 .bit = 6,
1455 },
1456};
1457
1458static struct mlxreg_core_data mlxplat_mlxcpld_wd_aux_regs_type1[] = {
1459 {
1460 .label = "action",
1461 .reg = MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET,
1462 .mask = MLXPLAT_CPLD_WD_FAN_ACT_MASK,
1463 .bit = 4,
1464 },
1465 {
1466 .label = "timeout",
1467 .reg = MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET,
1468 .mask = MLXPLAT_CPLD_WD_TYPE1_TO_MASK,
1469 .health_cntr = MLXPLAT_CPLD_WD_DFLT_TIMEOUT,
1470 },
1471 {
1472 .label = "ping",
1473 .reg = MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET,
1474 .mask = MLXPLAT_CPLD_WD1_CLEAR_MASK,
1475 .bit = 1,
1476 },
1477};
1478
1479static struct mlxreg_core_platform_data mlxplat_mlxcpld_wd_set_type1[] = {
1480 {
1481 .data = mlxplat_mlxcpld_wd_main_regs_type1,
1482 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_main_regs_type1),
1483 .version = MLX_WDT_TYPE1,
1484 .identity = "mlx-wdt-main",
1485 },
1486 {
1487 .data = mlxplat_mlxcpld_wd_aux_regs_type1,
1488 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_aux_regs_type1),
1489 .version = MLX_WDT_TYPE1,
1490 .identity = "mlx-wdt-aux",
1491 },
1492};
1493
1494/* Watchdog type2: hardware implementation version 2
1495 * (all systems except (MSN2700, MSN2410, MSN2740, MSN2100 and MSN2140).
1496 */
1497static struct mlxreg_core_data mlxplat_mlxcpld_wd_main_regs_type2[] = {
1498 {
1499 .label = "action",
1500 .reg = MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET,
1501 .mask = MLXPLAT_CPLD_WD_RESET_ACT_MASK,
1502 .bit = 0,
1503 },
1504 {
1505 .label = "timeout",
1506 .reg = MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET,
1507 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
1508 .health_cntr = MLXPLAT_CPLD_WD_DFLT_TIMEOUT,
1509 },
1510 {
1511 .label = "timeleft",
1512 .reg = MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET,
1513 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
1514 },
1515 {
1516 .label = "ping",
1517 .reg = MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET,
1518 .mask = MLXPLAT_CPLD_WD_RESET_ACT_MASK,
1519 .bit = 0,
1520 },
1521 {
1522 .label = "reset",
1523 .reg = MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET,
1524 .mask = GENMASK(7, 0) & ~BIT(6),
1525 .bit = 6,
1526 },
1527};
1528
1529static struct mlxreg_core_data mlxplat_mlxcpld_wd_aux_regs_type2[] = {
1530 {
1531 .label = "action",
1532 .reg = MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET,
1533 .mask = MLXPLAT_CPLD_WD_FAN_ACT_MASK,
1534 .bit = 4,
1535 },
1536 {
1537 .label = "timeout",
1538 .reg = MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET,
1539 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
1540 .health_cntr = MLXPLAT_CPLD_WD_DFLT_TIMEOUT,
1541 },
1542 {
1543 .label = "timeleft",
1544 .reg = MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET,
1545 .mask = MLXPLAT_CPLD_WD_TYPE2_TO_MASK,
1546 },
1547 {
1548 .label = "ping",
1549 .reg = MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET,
1550 .mask = MLXPLAT_CPLD_WD_FAN_ACT_MASK,
1551 .bit = 4,
1552 },
1553};
1554
1555static struct mlxreg_core_platform_data mlxplat_mlxcpld_wd_set_type2[] = {
1556 {
1557 .data = mlxplat_mlxcpld_wd_main_regs_type2,
1558 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_main_regs_type2),
1559 .version = MLX_WDT_TYPE2,
1560 .identity = "mlx-wdt-main",
1561 },
1562 {
1563 .data = mlxplat_mlxcpld_wd_aux_regs_type2,
1564 .counter = ARRAY_SIZE(mlxplat_mlxcpld_wd_aux_regs_type2),
1565 .version = MLX_WDT_TYPE2,
1566 .identity = "mlx-wdt-aux",
1567 },
1568};
1569
1570static bool mlxplat_mlxcpld_writeable_reg(struct device *dev, unsigned int reg)
1571{
1572 switch (reg) {
1573 case MLXPLAT_CPLD_LPC_REG_LED1_OFFSET:
1574 case MLXPLAT_CPLD_LPC_REG_LED2_OFFSET:
1575 case MLXPLAT_CPLD_LPC_REG_LED3_OFFSET:
1576 case MLXPLAT_CPLD_LPC_REG_LED4_OFFSET:
1577 case MLXPLAT_CPLD_LPC_REG_LED5_OFFSET:
1578 case MLXPLAT_CPLD_LPC_REG_GP1_OFFSET:
1579 case MLXPLAT_CPLD_LPC_REG_WP1_OFFSET:
1580 case MLXPLAT_CPLD_LPC_REG_GP2_OFFSET:
1581 case MLXPLAT_CPLD_LPC_REG_WP2_OFFSET:
1582 case MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET:
1583 case MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET:
1584 case MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET:
1585 case MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET:
1586 case MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET:
1587 case MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET:
1588 case MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET:
1589 case MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET:
1590 case MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET:
1591 case MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET:
1592 case MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET:
1593 case MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET:
1594 case MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET:
1595 case MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET:
1596 case MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET:
1597 case MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET:
1598 case MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET:
1599 case MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET:
1600 case MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET:
1601 case MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET:
1602 case MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET:
1603 return true;
1604 }
1605 return false;
1606}
1607
1608static bool mlxplat_mlxcpld_readable_reg(struct device *dev, unsigned int reg)
1609{
1610 switch (reg) {
1611 case MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET:
1612 case MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET:
1613 case MLXPLAT_CPLD_LPC_REG_CPLD3_VER_OFFSET:
1614 case MLXPLAT_CPLD_LPC_REG_CPLD4_VER_OFFSET:
1615 case MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET:
1616 case MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET:
1617 case MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET:
1618 case MLXPLAT_CPLD_LPC_REG_LED1_OFFSET:
1619 case MLXPLAT_CPLD_LPC_REG_LED2_OFFSET:
1620 case MLXPLAT_CPLD_LPC_REG_LED3_OFFSET:
1621 case MLXPLAT_CPLD_LPC_REG_LED4_OFFSET:
1622 case MLXPLAT_CPLD_LPC_REG_LED5_OFFSET:
1623 case MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION:
1624 case MLXPLAT_CPLD_LPC_REG_GP1_OFFSET:
1625 case MLXPLAT_CPLD_LPC_REG_WP1_OFFSET:
1626 case MLXPLAT_CPLD_LPC_REG_GP2_OFFSET:
1627 case MLXPLAT_CPLD_LPC_REG_WP2_OFFSET:
1628 case MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET:
1629 case MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET:
1630 case MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET:
1631 case MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET:
1632 case MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET:
1633 case MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET:
1634 case MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET:
1635 case MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET:
1636 case MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET:
1637 case MLXPLAT_CPLD_LPC_REG_PSU_OFFSET:
1638 case MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET:
1639 case MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET:
1640 case MLXPLAT_CPLD_LPC_REG_PWR_OFFSET:
1641 case MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET:
1642 case MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET:
1643 case MLXPLAT_CPLD_LPC_REG_FAN_OFFSET:
1644 case MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET:
1645 case MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET:
1646 case MLXPLAT_CPLD_LPC_REG_WD_CLEAR_OFFSET:
1647 case MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET:
1648 case MLXPLAT_CPLD_LPC_REG_WD1_TMR_OFFSET:
1649 case MLXPLAT_CPLD_LPC_REG_WD1_ACT_OFFSET:
1650 case MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET:
1651 case MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET:
1652 case MLXPLAT_CPLD_LPC_REG_WD2_ACT_OFFSET:
1653 case MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET:
1654 case MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET:
1655 case MLXPLAT_CPLD_LPC_REG_WD3_ACT_OFFSET:
1656 case MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET:
1657 case MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET:
1658 case MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET:
1659 case MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET:
1660 case MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET:
1661 case MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET:
1662 case MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET:
1663 case MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET:
1664 case MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET:
1665 case MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET:
1666 case MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET:
1667 case MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET:
1668 case MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET:
1669 case MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET:
1670 case MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET:
1671 case MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET:
1672 case MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET:
1673 case MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET:
1674 return true;
1675 }
1676 return false;
1677}
1678
1679static bool mlxplat_mlxcpld_volatile_reg(struct device *dev, unsigned int reg)
1680{
1681 switch (reg) {
1682 case MLXPLAT_CPLD_LPC_REG_CPLD1_VER_OFFSET:
1683 case MLXPLAT_CPLD_LPC_REG_CPLD2_VER_OFFSET:
1684 case MLXPLAT_CPLD_LPC_REG_CPLD3_VER_OFFSET:
1685 case MLXPLAT_CPLD_LPC_REG_CPLD4_VER_OFFSET:
1686 case MLXPLAT_CPLD_LPC_REG_RESET_CAUSE_OFFSET:
1687 case MLXPLAT_CPLD_LPC_REG_RST_CAUSE1_OFFSET:
1688 case MLXPLAT_CPLD_LPC_REG_RST_CAUSE2_OFFSET:
1689 case MLXPLAT_CPLD_LPC_REG_LED1_OFFSET:
1690 case MLXPLAT_CPLD_LPC_REG_LED2_OFFSET:
1691 case MLXPLAT_CPLD_LPC_REG_LED3_OFFSET:
1692 case MLXPLAT_CPLD_LPC_REG_LED4_OFFSET:
1693 case MLXPLAT_CPLD_LPC_REG_LED5_OFFSET:
1694 case MLXPLAT_CPLD_LPC_REG_FAN_DIRECTION:
1695 case MLXPLAT_CPLD_LPC_REG_GP1_OFFSET:
1696 case MLXPLAT_CPLD_LPC_REG_GP2_OFFSET:
1697 case MLXPLAT_CPLD_LPC_REG_AGGR_OFFSET:
1698 case MLXPLAT_CPLD_LPC_REG_AGGR_MASK_OFFSET:
1699 case MLXPLAT_CPLD_LPC_REG_AGGRLO_OFFSET:
1700 case MLXPLAT_CPLD_LPC_REG_AGGRLO_MASK_OFFSET:
1701 case MLXPLAT_CPLD_LPC_REG_AGGRCO_OFFSET:
1702 case MLXPLAT_CPLD_LPC_REG_AGGRCO_MASK_OFFSET:
1703 case MLXPLAT_CPLD_LPC_REG_ASIC_HEALTH_OFFSET:
1704 case MLXPLAT_CPLD_LPC_REG_ASIC_EVENT_OFFSET:
1705 case MLXPLAT_CPLD_LPC_REG_ASIC_MASK_OFFSET:
1706 case MLXPLAT_CPLD_LPC_REG_PSU_OFFSET:
1707 case MLXPLAT_CPLD_LPC_REG_PSU_EVENT_OFFSET:
1708 case MLXPLAT_CPLD_LPC_REG_PSU_MASK_OFFSET:
1709 case MLXPLAT_CPLD_LPC_REG_PWR_OFFSET:
1710 case MLXPLAT_CPLD_LPC_REG_PWR_EVENT_OFFSET:
1711 case MLXPLAT_CPLD_LPC_REG_PWR_MASK_OFFSET:
1712 case MLXPLAT_CPLD_LPC_REG_FAN_OFFSET:
1713 case MLXPLAT_CPLD_LPC_REG_FAN_EVENT_OFFSET:
1714 case MLXPLAT_CPLD_LPC_REG_FAN_MASK_OFFSET:
1715 case MLXPLAT_CPLD_LPC_REG_WD2_TMR_OFFSET:
1716 case MLXPLAT_CPLD_LPC_REG_WD2_TLEFT_OFFSET:
1717 case MLXPLAT_CPLD_LPC_REG_WD3_TMR_OFFSET:
1718 case MLXPLAT_CPLD_LPC_REG_WD3_TLEFT_OFFSET:
1719 case MLXPLAT_CPLD_LPC_REG_PWM1_OFFSET:
1720 case MLXPLAT_CPLD_LPC_REG_TACHO1_OFFSET:
1721 case MLXPLAT_CPLD_LPC_REG_TACHO2_OFFSET:
1722 case MLXPLAT_CPLD_LPC_REG_TACHO3_OFFSET:
1723 case MLXPLAT_CPLD_LPC_REG_TACHO4_OFFSET:
1724 case MLXPLAT_CPLD_LPC_REG_TACHO5_OFFSET:
1725 case MLXPLAT_CPLD_LPC_REG_TACHO6_OFFSET:
1726 case MLXPLAT_CPLD_LPC_REG_TACHO7_OFFSET:
1727 case MLXPLAT_CPLD_LPC_REG_TACHO8_OFFSET:
1728 case MLXPLAT_CPLD_LPC_REG_TACHO9_OFFSET:
1729 case MLXPLAT_CPLD_LPC_REG_TACHO10_OFFSET:
1730 case MLXPLAT_CPLD_LPC_REG_TACHO11_OFFSET:
1731 case MLXPLAT_CPLD_LPC_REG_TACHO12_OFFSET:
1732 case MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET:
1733 case MLXPLAT_CPLD_LPC_REG_FAN_CAP1_OFFSET:
1734 case MLXPLAT_CPLD_LPC_REG_FAN_CAP2_OFFSET:
1735 case MLXPLAT_CPLD_LPC_REG_FAN_DRW_CAP_OFFSET:
1736 case MLXPLAT_CPLD_LPC_REG_TACHO_SPEED_OFFSET:
1737 return true;
1738 }
1739 return false;
1740}
1741
1742static const struct reg_default mlxplat_mlxcpld_regmap_default[] = {
1743 { MLXPLAT_CPLD_LPC_REG_WP1_OFFSET, 0x00 },
1744 { MLXPLAT_CPLD_LPC_REG_WP2_OFFSET, 0x00 },
1745 { MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET, 0x00 },
1746 { MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET, 0x00 },
1747};
1748
1749static const struct reg_default mlxplat_mlxcpld_regmap_ng[] = {
1750 { MLXPLAT_CPLD_LPC_REG_PWM_CONTROL_OFFSET, 0x00 },
1751 { MLXPLAT_CPLD_LPC_REG_WD_CLEAR_WP_OFFSET, 0x00 },
1752};
1753
1754struct mlxplat_mlxcpld_regmap_context {
1755 void __iomem *base;
1756};
1757
1758static struct mlxplat_mlxcpld_regmap_context mlxplat_mlxcpld_regmap_ctx;
1759
1760static int
1761mlxplat_mlxcpld_reg_read(void *context, unsigned int reg, unsigned int *val)
1762{
1763 struct mlxplat_mlxcpld_regmap_context *ctx = context;
1764
1765 *val = ioread8(ctx->base + reg);
1766 return 0;
1767}
1768
1769static int
1770mlxplat_mlxcpld_reg_write(void *context, unsigned int reg, unsigned int val)
1771{
1772 struct mlxplat_mlxcpld_regmap_context *ctx = context;
1773
1774 iowrite8(val, ctx->base + reg);
1775 return 0;
1776}
1777
1778static const struct regmap_config mlxplat_mlxcpld_regmap_config = {
1779 .reg_bits = 8,
1780 .val_bits = 8,
1781 .max_register = 255,
1782 .cache_type = REGCACHE_FLAT,
1783 .writeable_reg = mlxplat_mlxcpld_writeable_reg,
1784 .readable_reg = mlxplat_mlxcpld_readable_reg,
1785 .volatile_reg = mlxplat_mlxcpld_volatile_reg,
1786 .reg_defaults = mlxplat_mlxcpld_regmap_default,
1787 .num_reg_defaults = ARRAY_SIZE(mlxplat_mlxcpld_regmap_default),
1788 .reg_read = mlxplat_mlxcpld_reg_read,
1789 .reg_write = mlxplat_mlxcpld_reg_write,
1790};
1791
1792static const struct regmap_config mlxplat_mlxcpld_regmap_config_ng = {
1793 .reg_bits = 8,
1794 .val_bits = 8,
1795 .max_register = 255,
1796 .cache_type = REGCACHE_FLAT,
1797 .writeable_reg = mlxplat_mlxcpld_writeable_reg,
1798 .readable_reg = mlxplat_mlxcpld_readable_reg,
1799 .volatile_reg = mlxplat_mlxcpld_volatile_reg,
1800 .reg_defaults = mlxplat_mlxcpld_regmap_ng,
1801 .num_reg_defaults = ARRAY_SIZE(mlxplat_mlxcpld_regmap_ng),
1802 .reg_read = mlxplat_mlxcpld_reg_read,
1803 .reg_write = mlxplat_mlxcpld_reg_write,
1804};
1805
1806static struct resource mlxplat_mlxcpld_resources[] = {
1807 [0] = DEFINE_RES_IRQ_NAMED(17, "mlxreg-hotplug"),
1808};
1809
1810static struct platform_device *mlxplat_dev;
1811static struct mlxreg_core_hotplug_platform_data *mlxplat_i2c;
1812static struct mlxreg_core_hotplug_platform_data *mlxplat_hotplug;
1813static struct mlxreg_core_platform_data *mlxplat_led;
1814static struct mlxreg_core_platform_data *mlxplat_regs_io;
1815static struct mlxreg_core_platform_data *mlxplat_fan;
1816static struct mlxreg_core_platform_data
1817 *mlxplat_wd_data[MLXPLAT_CPLD_WD_MAX_DEVS];
1818static const struct regmap_config *mlxplat_regmap_config;
1819
1820static int __init mlxplat_dmi_default_matched(const struct dmi_system_id *dmi)
1821{
1822 int i;
1823
1824 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
1825 mlxplat_mux_data[i].values = mlxplat_default_channels[i];
1826 mlxplat_mux_data[i].n_values =
1827 ARRAY_SIZE(mlxplat_default_channels[i]);
1828 }
1829 mlxplat_hotplug = &mlxplat_mlxcpld_default_data;
1830 mlxplat_hotplug->deferred_nr =
1831 mlxplat_default_channels[i - 1][MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
1832 mlxplat_led = &mlxplat_default_led_data;
1833 mlxplat_regs_io = &mlxplat_default_regs_io_data;
1834 mlxplat_wd_data[0] = &mlxplat_mlxcpld_wd_set_type1[0];
1835
1836 return 1;
1837};
1838
1839static int __init mlxplat_dmi_msn21xx_matched(const struct dmi_system_id *dmi)
1840{
1841 int i;
1842
1843 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
1844 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
1845 mlxplat_mux_data[i].n_values =
1846 ARRAY_SIZE(mlxplat_msn21xx_channels);
1847 }
1848 mlxplat_hotplug = &mlxplat_mlxcpld_msn21xx_data;
1849 mlxplat_hotplug->deferred_nr =
1850 mlxplat_msn21xx_channels[MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
1851 mlxplat_led = &mlxplat_msn21xx_led_data;
1852 mlxplat_regs_io = &mlxplat_msn21xx_regs_io_data;
1853 mlxplat_wd_data[0] = &mlxplat_mlxcpld_wd_set_type1[0];
1854
1855 return 1;
1856};
1857
1858static int __init mlxplat_dmi_msn274x_matched(const struct dmi_system_id *dmi)
1859{
1860 int i;
1861
1862 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
1863 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
1864 mlxplat_mux_data[i].n_values =
1865 ARRAY_SIZE(mlxplat_msn21xx_channels);
1866 }
1867 mlxplat_hotplug = &mlxplat_mlxcpld_msn274x_data;
1868 mlxplat_hotplug->deferred_nr =
1869 mlxplat_msn21xx_channels[MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
1870 mlxplat_led = &mlxplat_default_led_data;
1871 mlxplat_regs_io = &mlxplat_msn21xx_regs_io_data;
1872 mlxplat_wd_data[0] = &mlxplat_mlxcpld_wd_set_type1[0];
1873
1874 return 1;
1875};
1876
1877static int __init mlxplat_dmi_msn201x_matched(const struct dmi_system_id *dmi)
1878{
1879 int i;
1880
1881 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
1882 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
1883 mlxplat_mux_data[i].n_values =
1884 ARRAY_SIZE(mlxplat_msn21xx_channels);
1885 }
1886 mlxplat_hotplug = &mlxplat_mlxcpld_msn201x_data;
1887 mlxplat_hotplug->deferred_nr =
1888 mlxplat_default_channels[i - 1][MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
1889 mlxplat_led = &mlxplat_msn21xx_led_data;
1890 mlxplat_regs_io = &mlxplat_msn21xx_regs_io_data;
1891 mlxplat_wd_data[0] = &mlxplat_mlxcpld_wd_set_type1[0];
1892
1893 return 1;
1894};
1895
1896static int __init mlxplat_dmi_qmb7xx_matched(const struct dmi_system_id *dmi)
1897{
1898 int i;
1899
1900 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
1901 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
1902 mlxplat_mux_data[i].n_values =
1903 ARRAY_SIZE(mlxplat_msn21xx_channels);
1904 }
1905 mlxplat_hotplug = &mlxplat_mlxcpld_default_ng_data;
1906 mlxplat_hotplug->deferred_nr =
1907 mlxplat_msn21xx_channels[MLXPLAT_CPLD_GRP_CHNL_NUM - 1];
1908 mlxplat_led = &mlxplat_default_ng_led_data;
1909 mlxplat_regs_io = &mlxplat_default_ng_regs_io_data;
1910 mlxplat_fan = &mlxplat_default_fan_data;
1911 for (i = 0; i < ARRAY_SIZE(mlxplat_mlxcpld_wd_set_type2); i++)
1912 mlxplat_wd_data[i] = &mlxplat_mlxcpld_wd_set_type2[i];
1913 mlxplat_i2c = &mlxplat_mlxcpld_i2c_ng_data;
1914 mlxplat_regmap_config = &mlxplat_mlxcpld_regmap_config_ng;
1915
1916 return 1;
1917};
1918
1919static const struct dmi_system_id mlxplat_dmi_table[] __initconst = {
1920 {
1921 .callback = mlxplat_dmi_default_matched,
1922 .matches = {
1923 DMI_MATCH(DMI_BOARD_NAME, "VMOD0001"),
1924 },
1925 },
1926 {
1927 .callback = mlxplat_dmi_msn21xx_matched,
1928 .matches = {
1929 DMI_MATCH(DMI_BOARD_NAME, "VMOD0002"),
1930 },
1931 },
1932 {
1933 .callback = mlxplat_dmi_msn274x_matched,
1934 .matches = {
1935 DMI_MATCH(DMI_BOARD_NAME, "VMOD0003"),
1936 },
1937 },
1938 {
1939 .callback = mlxplat_dmi_msn201x_matched,
1940 .matches = {
1941 DMI_MATCH(DMI_BOARD_NAME, "VMOD0004"),
1942 },
1943 },
1944 {
1945 .callback = mlxplat_dmi_qmb7xx_matched,
1946 .matches = {
1947 DMI_MATCH(DMI_BOARD_NAME, "VMOD0005"),
1948 },
1949 },
1950 {
1951 .callback = mlxplat_dmi_qmb7xx_matched,
1952 .matches = {
1953 DMI_MATCH(DMI_BOARD_NAME, "VMOD0007"),
1954 },
1955 },
1956 {
1957 .callback = mlxplat_dmi_msn274x_matched,
1958 .matches = {
1959 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
1960 DMI_MATCH(DMI_PRODUCT_NAME, "MSN274"),
1961 },
1962 },
1963 {
1964 .callback = mlxplat_dmi_default_matched,
1965 .matches = {
1966 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
1967 DMI_MATCH(DMI_PRODUCT_NAME, "MSN24"),
1968 },
1969 },
1970 {
1971 .callback = mlxplat_dmi_default_matched,
1972 .matches = {
1973 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
1974 DMI_MATCH(DMI_PRODUCT_NAME, "MSN27"),
1975 },
1976 },
1977 {
1978 .callback = mlxplat_dmi_default_matched,
1979 .matches = {
1980 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
1981 DMI_MATCH(DMI_PRODUCT_NAME, "MSB"),
1982 },
1983 },
1984 {
1985 .callback = mlxplat_dmi_default_matched,
1986 .matches = {
1987 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
1988 DMI_MATCH(DMI_PRODUCT_NAME, "MSX"),
1989 },
1990 },
1991 {
1992 .callback = mlxplat_dmi_msn21xx_matched,
1993 .matches = {
1994 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
1995 DMI_MATCH(DMI_PRODUCT_NAME, "MSN21"),
1996 },
1997 },
1998 {
1999 .callback = mlxplat_dmi_msn201x_matched,
2000 .matches = {
2001 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2002 DMI_MATCH(DMI_PRODUCT_NAME, "MSN201"),
2003 },
2004 },
2005 {
2006 .callback = mlxplat_dmi_qmb7xx_matched,
2007 .matches = {
2008 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2009 DMI_MATCH(DMI_PRODUCT_NAME, "MQM87"),
2010 },
2011 },
2012 {
2013 .callback = mlxplat_dmi_qmb7xx_matched,
2014 .matches = {
2015 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2016 DMI_MATCH(DMI_PRODUCT_NAME, "MSN37"),
2017 },
2018 },
2019 {
2020 .callback = mlxplat_dmi_qmb7xx_matched,
2021 .matches = {
2022 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2023 DMI_MATCH(DMI_PRODUCT_NAME, "MSN34"),
2024 },
2025 },
2026 {
2027 .callback = mlxplat_dmi_qmb7xx_matched,
2028 .matches = {
2029 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
2030 DMI_MATCH(DMI_PRODUCT_NAME, "MSN38"),
2031 },
2032 },
2033 { }
2034};
2035
2036MODULE_DEVICE_TABLE(dmi, mlxplat_dmi_table);
2037
2038static int mlxplat_mlxcpld_verify_bus_topology(int *nr)
2039{
2040 struct i2c_adapter *search_adap;
2041 int shift, i;
2042
2043 /* Scan adapters from expected id to verify it is free. */
2044 *nr = MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR;
2045 for (i = MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR; i <
2046 MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM; i++) {
2047 search_adap = i2c_get_adapter(i);
2048 if (search_adap) {
2049 i2c_put_adapter(search_adap);
2050 continue;
2051 }
2052
2053 /* Return if expected parent adapter is free. */
2054 if (i == MLXPLAT_CPLD_PHYS_ADAPTER_DEF_NR)
2055 return 0;
2056 break;
2057 }
2058
2059 /* Return with error if free id for adapter is not found. */
2060 if (i == MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM)
2061 return -ENODEV;
2062
2063 /* Shift adapter ids, since expected parent adapter is not free. */
2064 *nr = i;
2065 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
2066 shift = *nr - mlxplat_mux_data[i].parent;
2067 mlxplat_mux_data[i].parent = *nr;
2068 mlxplat_mux_data[i].base_nr += shift;
2069 if (shift > 0)
2070 mlxplat_hotplug->shift_nr = shift;
2071 }
2072
2073 return 0;
2074}
2075
2076static int __init mlxplat_init(void)
2077{
2078 struct mlxplat_priv *priv;
2079 int i, j, nr, err;
2080
2081 if (!dmi_check_system(mlxplat_dmi_table))
2082 return -ENODEV;
2083
2084 mlxplat_dev = platform_device_register_simple(MLX_PLAT_DEVICE_NAME, -1,
2085 mlxplat_lpc_resources,
2086 ARRAY_SIZE(mlxplat_lpc_resources));
2087
2088 if (IS_ERR(mlxplat_dev))
2089 return PTR_ERR(mlxplat_dev);
2090
2091 priv = devm_kzalloc(&mlxplat_dev->dev, sizeof(struct mlxplat_priv),
2092 GFP_KERNEL);
2093 if (!priv) {
2094 err = -ENOMEM;
2095 goto fail_alloc;
2096 }
2097 platform_set_drvdata(mlxplat_dev, priv);
2098
2099 mlxplat_mlxcpld_regmap_ctx.base = devm_ioport_map(&mlxplat_dev->dev,
2100 mlxplat_lpc_resources[1].start, 1);
2101 if (!mlxplat_mlxcpld_regmap_ctx.base) {
2102 err = -ENOMEM;
2103 goto fail_alloc;
2104 }
2105
2106 if (!mlxplat_regmap_config)
2107 mlxplat_regmap_config = &mlxplat_mlxcpld_regmap_config;
2108
2109 priv->regmap = devm_regmap_init(&mlxplat_dev->dev, NULL,
2110 &mlxplat_mlxcpld_regmap_ctx,
2111 mlxplat_regmap_config);
2112 if (IS_ERR(priv->regmap)) {
2113 err = PTR_ERR(priv->regmap);
2114 goto fail_alloc;
2115 }
2116
2117 err = mlxplat_mlxcpld_verify_bus_topology(&nr);
2118 if (nr < 0)
2119 goto fail_alloc;
2120
2121 nr = (nr == MLXPLAT_CPLD_MAX_PHYS_ADAPTER_NUM) ? -1 : nr;
2122 if (mlxplat_i2c)
2123 mlxplat_i2c->regmap = priv->regmap;
2124 priv->pdev_i2c = platform_device_register_resndata(
2125 &mlxplat_dev->dev, "i2c_mlxcpld",
2126 nr, mlxplat_mlxcpld_resources,
2127 ARRAY_SIZE(mlxplat_mlxcpld_resources),
2128 mlxplat_i2c, sizeof(*mlxplat_i2c));
2129 if (IS_ERR(priv->pdev_i2c)) {
2130 err = PTR_ERR(priv->pdev_i2c);
2131 goto fail_alloc;
2132 }
2133
2134 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
2135 priv->pdev_mux[i] = platform_device_register_resndata(
2136 &priv->pdev_i2c->dev,
2137 "i2c-mux-reg", i, NULL,
2138 0, &mlxplat_mux_data[i],
2139 sizeof(mlxplat_mux_data[i]));
2140 if (IS_ERR(priv->pdev_mux[i])) {
2141 err = PTR_ERR(priv->pdev_mux[i]);
2142 goto fail_platform_mux_register;
2143 }
2144 }
2145
2146 /* Add hotplug driver */
2147 mlxplat_hotplug->regmap = priv->regmap;
2148 priv->pdev_hotplug = platform_device_register_resndata(
2149 &mlxplat_dev->dev, "mlxreg-hotplug",
2150 PLATFORM_DEVID_NONE,
2151 mlxplat_mlxcpld_resources,
2152 ARRAY_SIZE(mlxplat_mlxcpld_resources),
2153 mlxplat_hotplug, sizeof(*mlxplat_hotplug));
2154 if (IS_ERR(priv->pdev_hotplug)) {
2155 err = PTR_ERR(priv->pdev_hotplug);
2156 goto fail_platform_mux_register;
2157 }
2158
2159 /* Set default registers. */
2160 for (j = 0; j < mlxplat_regmap_config->num_reg_defaults; j++) {
2161 err = regmap_write(priv->regmap,
2162 mlxplat_regmap_config->reg_defaults[j].reg,
2163 mlxplat_regmap_config->reg_defaults[j].def);
2164 if (err)
2165 goto fail_platform_mux_register;
2166 }
2167
2168 /* Add LED driver. */
2169 mlxplat_led->regmap = priv->regmap;
2170 priv->pdev_led = platform_device_register_resndata(
2171 &mlxplat_dev->dev, "leds-mlxreg",
2172 PLATFORM_DEVID_NONE, NULL, 0,
2173 mlxplat_led, sizeof(*mlxplat_led));
2174 if (IS_ERR(priv->pdev_led)) {
2175 err = PTR_ERR(priv->pdev_led);
2176 goto fail_platform_hotplug_register;
2177 }
2178
2179 /* Add registers io access driver. */
2180 if (mlxplat_regs_io) {
2181 mlxplat_regs_io->regmap = priv->regmap;
2182 priv->pdev_io_regs = platform_device_register_resndata(
2183 &mlxplat_dev->dev, "mlxreg-io",
2184 PLATFORM_DEVID_NONE, NULL, 0,
2185 mlxplat_regs_io,
2186 sizeof(*mlxplat_regs_io));
2187 if (IS_ERR(priv->pdev_io_regs)) {
2188 err = PTR_ERR(priv->pdev_io_regs);
2189 goto fail_platform_led_register;
2190 }
2191 }
2192
2193 /* Add FAN driver. */
2194 if (mlxplat_fan) {
2195 mlxplat_fan->regmap = priv->regmap;
2196 priv->pdev_fan = platform_device_register_resndata(
2197 &mlxplat_dev->dev, "mlxreg-fan",
2198 PLATFORM_DEVID_NONE, NULL, 0,
2199 mlxplat_fan,
2200 sizeof(*mlxplat_fan));
2201 if (IS_ERR(priv->pdev_fan)) {
2202 err = PTR_ERR(priv->pdev_fan);
2203 goto fail_platform_io_regs_register;
2204 }
2205 }
2206
2207 /* Add WD drivers. */
2208 for (j = 0; j < MLXPLAT_CPLD_WD_MAX_DEVS; j++) {
2209 if (mlxplat_wd_data[j]) {
2210 mlxplat_wd_data[j]->regmap = priv->regmap;
2211 priv->pdev_wd[j] = platform_device_register_resndata(
2212 &mlxplat_dev->dev, "mlx-wdt",
2213 j, NULL, 0,
2214 mlxplat_wd_data[j],
2215 sizeof(*mlxplat_wd_data[j]));
2216 if (IS_ERR(priv->pdev_wd[j])) {
2217 err = PTR_ERR(priv->pdev_wd[j]);
2218 goto fail_platform_wd_register;
2219 }
2220 }
2221 }
2222
2223 /* Sync registers with hardware. */
2224 regcache_mark_dirty(priv->regmap);
2225 err = regcache_sync(priv->regmap);
2226 if (err)
2227 goto fail_platform_wd_register;
2228
2229 return 0;
2230
2231fail_platform_wd_register:
2232 while (--j >= 0)
2233 platform_device_unregister(priv->pdev_wd[j]);
2234 if (mlxplat_fan)
2235 platform_device_unregister(priv->pdev_fan);
2236fail_platform_io_regs_register:
2237 if (mlxplat_regs_io)
2238 platform_device_unregister(priv->pdev_io_regs);
2239fail_platform_led_register:
2240 platform_device_unregister(priv->pdev_led);
2241fail_platform_hotplug_register:
2242 platform_device_unregister(priv->pdev_hotplug);
2243fail_platform_mux_register:
2244 while (--i >= 0)
2245 platform_device_unregister(priv->pdev_mux[i]);
2246 platform_device_unregister(priv->pdev_i2c);
2247fail_alloc:
2248 platform_device_unregister(mlxplat_dev);
2249
2250 return err;
2251}
2252module_init(mlxplat_init);
2253
2254static void __exit mlxplat_exit(void)
2255{
2256 struct mlxplat_priv *priv = platform_get_drvdata(mlxplat_dev);
2257 int i;
2258
2259 for (i = MLXPLAT_CPLD_WD_MAX_DEVS - 1; i >= 0 ; i--)
2260 platform_device_unregister(priv->pdev_wd[i]);
2261 if (priv->pdev_fan)
2262 platform_device_unregister(priv->pdev_fan);
2263 if (priv->pdev_io_regs)
2264 platform_device_unregister(priv->pdev_io_regs);
2265 platform_device_unregister(priv->pdev_led);
2266 platform_device_unregister(priv->pdev_hotplug);
2267
2268 for (i = ARRAY_SIZE(mlxplat_mux_data) - 1; i >= 0 ; i--)
2269 platform_device_unregister(priv->pdev_mux[i]);
2270
2271 platform_device_unregister(priv->pdev_i2c);
2272 platform_device_unregister(mlxplat_dev);
2273}
2274module_exit(mlxplat_exit);
2275
2276MODULE_AUTHOR("Vadim Pasternak (vadimp@mellanox.com)");
2277MODULE_DESCRIPTION("Mellanox platform driver");
2278MODULE_LICENSE("Dual BSD/GPL");