Loading...
Note: File does not exist in v3.1.
1/*
2 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
3 * Copyright (c) 2016 Vadim Pasternak <vadimp@mellanox.com>
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the names of the copyright holders nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
16 *
17 * Alternatively, this software may be distributed under the terms of the
18 * GNU General Public License ("GPL") version 2 as published by the Free
19 * Software Foundation.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
25 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 * POSSIBILITY OF SUCH DAMAGE.
32 */
33
34#include <linux/device.h>
35#include <linux/dmi.h>
36#include <linux/i2c.h>
37#include <linux/i2c-mux.h>
38#include <linux/module.h>
39#include <linux/platform_device.h>
40#include <linux/platform_data/i2c-mux-reg.h>
41#include <linux/platform_data/mlxcpld-hotplug.h>
42
43#define MLX_PLAT_DEVICE_NAME "mlxplat"
44
45/* LPC bus IO offsets */
46#define MLXPLAT_CPLD_LPC_I2C_BASE_ADRR 0x2000
47#define MLXPLAT_CPLD_LPC_REG_BASE_ADRR 0x2500
48#define MLXPLAT_CPLD_LPC_IO_RANGE 0x100
49#define MLXPLAT_CPLD_LPC_I2C_CH1_OFF 0xdb
50#define MLXPLAT_CPLD_LPC_I2C_CH2_OFF 0xda
51#define MLXPLAT_CPLD_LPC_PIO_OFFSET 0x10000UL
52#define MLXPLAT_CPLD_LPC_REG1 ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
53 MLXPLAT_CPLD_LPC_I2C_CH1_OFF) | \
54 MLXPLAT_CPLD_LPC_PIO_OFFSET)
55#define MLXPLAT_CPLD_LPC_REG2 ((MLXPLAT_CPLD_LPC_REG_BASE_ADRR + \
56 MLXPLAT_CPLD_LPC_I2C_CH2_OFF) | \
57 MLXPLAT_CPLD_LPC_PIO_OFFSET)
58
59/* Start channel numbers */
60#define MLXPLAT_CPLD_CH1 2
61#define MLXPLAT_CPLD_CH2 10
62
63/* Number of LPC attached MUX platform devices */
64#define MLXPLAT_CPLD_LPC_MUX_DEVS 2
65
66/* mlxplat_priv - platform private data
67 * @pdev_i2c - i2c controller platform device
68 * @pdev_mux - array of mux platform devices
69 */
70struct mlxplat_priv {
71 struct platform_device *pdev_i2c;
72 struct platform_device *pdev_mux[MLXPLAT_CPLD_LPC_MUX_DEVS];
73 struct platform_device *pdev_hotplug;
74};
75
76/* Regions for LPC I2C controller and LPC base register space */
77static const struct resource mlxplat_lpc_resources[] = {
78 [0] = DEFINE_RES_NAMED(MLXPLAT_CPLD_LPC_I2C_BASE_ADRR,
79 MLXPLAT_CPLD_LPC_IO_RANGE,
80 "mlxplat_cpld_lpc_i2c_ctrl", IORESOURCE_IO),
81 [1] = DEFINE_RES_NAMED(MLXPLAT_CPLD_LPC_REG_BASE_ADRR,
82 MLXPLAT_CPLD_LPC_IO_RANGE,
83 "mlxplat_cpld_lpc_regs",
84 IORESOURCE_IO),
85};
86
87/* Platform default channels */
88static const int mlxplat_default_channels[][8] = {
89 {
90 MLXPLAT_CPLD_CH1, MLXPLAT_CPLD_CH1 + 1, MLXPLAT_CPLD_CH1 + 2,
91 MLXPLAT_CPLD_CH1 + 3, MLXPLAT_CPLD_CH1 + 4, MLXPLAT_CPLD_CH1 +
92 5, MLXPLAT_CPLD_CH1 + 6, MLXPLAT_CPLD_CH1 + 7
93 },
94 {
95 MLXPLAT_CPLD_CH2, MLXPLAT_CPLD_CH2 + 1, MLXPLAT_CPLD_CH2 + 2,
96 MLXPLAT_CPLD_CH2 + 3, MLXPLAT_CPLD_CH2 + 4, MLXPLAT_CPLD_CH2 +
97 5, MLXPLAT_CPLD_CH2 + 6, MLXPLAT_CPLD_CH2 + 7
98 },
99};
100
101/* Platform channels for MSN21xx system family */
102static const int mlxplat_msn21xx_channels[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
103
104/* Platform mux data */
105static struct i2c_mux_reg_platform_data mlxplat_mux_data[] = {
106 {
107 .parent = 1,
108 .base_nr = MLXPLAT_CPLD_CH1,
109 .write_only = 1,
110 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG1,
111 .reg_size = 1,
112 .idle_in_use = 1,
113 },
114 {
115 .parent = 1,
116 .base_nr = MLXPLAT_CPLD_CH2,
117 .write_only = 1,
118 .reg = (void __iomem *)MLXPLAT_CPLD_LPC_REG2,
119 .reg_size = 1,
120 .idle_in_use = 1,
121 },
122
123};
124
125/* Platform hotplug devices */
126static struct mlxcpld_hotplug_device mlxplat_mlxcpld_hotplug_psu[] = {
127 {
128 .brdinfo = { I2C_BOARD_INFO("24c02", 0x51) },
129 .bus = 10,
130 },
131 {
132 .brdinfo = { I2C_BOARD_INFO("24c02", 0x50) },
133 .bus = 10,
134 },
135};
136
137static struct mlxcpld_hotplug_device mlxplat_mlxcpld_hotplug_pwr[] = {
138 {
139 .brdinfo = { I2C_BOARD_INFO("dps460", 0x59) },
140 .bus = 10,
141 },
142 {
143 .brdinfo = { I2C_BOARD_INFO("dps460", 0x58) },
144 .bus = 10,
145 },
146};
147
148static struct mlxcpld_hotplug_device mlxplat_mlxcpld_hotplug_fan[] = {
149 {
150 .brdinfo = { I2C_BOARD_INFO("24c32", 0x50) },
151 .bus = 11,
152 },
153 {
154 .brdinfo = { I2C_BOARD_INFO("24c32", 0x50) },
155 .bus = 12,
156 },
157 {
158 .brdinfo = { I2C_BOARD_INFO("24c32", 0x50) },
159 .bus = 13,
160 },
161 {
162 .brdinfo = { I2C_BOARD_INFO("24c32", 0x50) },
163 .bus = 14,
164 },
165};
166
167/* Platform hotplug default data */
168static
169struct mlxcpld_hotplug_platform_data mlxplat_mlxcpld_hotplug_default_data = {
170 .top_aggr_offset = (MLXPLAT_CPLD_LPC_REG_BASE_ADRR | 0x3a),
171 .top_aggr_mask = 0x48,
172 .top_aggr_psu_mask = 0x08,
173 .psu_reg_offset = (MLXPLAT_CPLD_LPC_REG_BASE_ADRR | 0x58),
174 .psu_mask = 0x03,
175 .psu_count = ARRAY_SIZE(mlxplat_mlxcpld_hotplug_psu),
176 .psu = mlxplat_mlxcpld_hotplug_psu,
177 .top_aggr_pwr_mask = 0x08,
178 .pwr_reg_offset = (MLXPLAT_CPLD_LPC_REG_BASE_ADRR | 0x64),
179 .pwr_mask = 0x03,
180 .pwr_count = ARRAY_SIZE(mlxplat_mlxcpld_hotplug_pwr),
181 .pwr = mlxplat_mlxcpld_hotplug_pwr,
182 .top_aggr_fan_mask = 0x40,
183 .fan_reg_offset = (MLXPLAT_CPLD_LPC_REG_BASE_ADRR | 0x88),
184 .fan_mask = 0x0f,
185 .fan_count = ARRAY_SIZE(mlxplat_mlxcpld_hotplug_fan),
186 .fan = mlxplat_mlxcpld_hotplug_fan,
187};
188
189/* Platform hotplug MSN21xx system family data */
190static
191struct mlxcpld_hotplug_platform_data mlxplat_mlxcpld_hotplug_msn21xx_data = {
192 .top_aggr_offset = (MLXPLAT_CPLD_LPC_REG_BASE_ADRR | 0x3a),
193 .top_aggr_mask = 0x04,
194 .top_aggr_pwr_mask = 0x04,
195 .pwr_reg_offset = (MLXPLAT_CPLD_LPC_REG_BASE_ADRR | 0x64),
196 .pwr_mask = 0x03,
197 .pwr_count = ARRAY_SIZE(mlxplat_mlxcpld_hotplug_pwr),
198};
199
200static struct resource mlxplat_mlxcpld_hotplug_resources[] = {
201 [0] = DEFINE_RES_IRQ_NAMED(17, "mlxcpld-hotplug"),
202};
203
204struct platform_device *mlxplat_dev;
205struct mlxcpld_hotplug_platform_data *mlxplat_hotplug;
206
207static int __init mlxplat_dmi_default_matched(const struct dmi_system_id *dmi)
208{
209 int i;
210
211 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
212 mlxplat_mux_data[i].values = mlxplat_default_channels[i];
213 mlxplat_mux_data[i].n_values =
214 ARRAY_SIZE(mlxplat_default_channels[i]);
215 }
216 mlxplat_hotplug = &mlxplat_mlxcpld_hotplug_default_data;
217
218 return 1;
219};
220
221static int __init mlxplat_dmi_msn21xx_matched(const struct dmi_system_id *dmi)
222{
223 int i;
224
225 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
226 mlxplat_mux_data[i].values = mlxplat_msn21xx_channels;
227 mlxplat_mux_data[i].n_values =
228 ARRAY_SIZE(mlxplat_msn21xx_channels);
229 }
230 mlxplat_hotplug = &mlxplat_mlxcpld_hotplug_msn21xx_data;
231
232 return 1;
233};
234
235static struct dmi_system_id mlxplat_dmi_table[] __initdata = {
236 {
237 .callback = mlxplat_dmi_default_matched,
238 .matches = {
239 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
240 DMI_MATCH(DMI_PRODUCT_NAME, "MSN24"),
241 },
242 },
243 {
244 .callback = mlxplat_dmi_default_matched,
245 .matches = {
246 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
247 DMI_MATCH(DMI_PRODUCT_NAME, "MSN27"),
248 },
249 },
250 {
251 .callback = mlxplat_dmi_default_matched,
252 .matches = {
253 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
254 DMI_MATCH(DMI_PRODUCT_NAME, "MSB"),
255 },
256 },
257 {
258 .callback = mlxplat_dmi_default_matched,
259 .matches = {
260 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
261 DMI_MATCH(DMI_PRODUCT_NAME, "MSX"),
262 },
263 },
264 {
265 .callback = mlxplat_dmi_msn21xx_matched,
266 .matches = {
267 DMI_MATCH(DMI_BOARD_VENDOR, "Mellanox Technologies"),
268 DMI_MATCH(DMI_PRODUCT_NAME, "MSN21"),
269 },
270 },
271 { }
272};
273
274static int __init mlxplat_init(void)
275{
276 struct mlxplat_priv *priv;
277 int i, err;
278
279 if (!dmi_check_system(mlxplat_dmi_table))
280 return -ENODEV;
281
282 mlxplat_dev = platform_device_register_simple(MLX_PLAT_DEVICE_NAME, -1,
283 mlxplat_lpc_resources,
284 ARRAY_SIZE(mlxplat_lpc_resources));
285
286 if (IS_ERR(mlxplat_dev))
287 return PTR_ERR(mlxplat_dev);
288
289 priv = devm_kzalloc(&mlxplat_dev->dev, sizeof(struct mlxplat_priv),
290 GFP_KERNEL);
291 if (!priv) {
292 err = -ENOMEM;
293 goto fail_alloc;
294 }
295 platform_set_drvdata(mlxplat_dev, priv);
296
297 priv->pdev_i2c = platform_device_register_simple("i2c_mlxcpld", -1,
298 NULL, 0);
299 if (IS_ERR(priv->pdev_i2c)) {
300 err = PTR_ERR(priv->pdev_i2c);
301 goto fail_alloc;
302 }
303
304 for (i = 0; i < ARRAY_SIZE(mlxplat_mux_data); i++) {
305 priv->pdev_mux[i] = platform_device_register_resndata(
306 &mlxplat_dev->dev,
307 "i2c-mux-reg", i, NULL,
308 0, &mlxplat_mux_data[i],
309 sizeof(mlxplat_mux_data[i]));
310 if (IS_ERR(priv->pdev_mux[i])) {
311 err = PTR_ERR(priv->pdev_mux[i]);
312 goto fail_platform_mux_register;
313 }
314 }
315
316 priv->pdev_hotplug = platform_device_register_resndata(
317 &mlxplat_dev->dev, "mlxcpld-hotplug", -1,
318 mlxplat_mlxcpld_hotplug_resources,
319 ARRAY_SIZE(mlxplat_mlxcpld_hotplug_resources),
320 mlxplat_hotplug, sizeof(*mlxplat_hotplug));
321 if (IS_ERR(priv->pdev_hotplug)) {
322 err = PTR_ERR(priv->pdev_hotplug);
323 goto fail_platform_mux_register;
324 }
325
326 return 0;
327
328fail_platform_mux_register:
329 while (--i >= 0)
330 platform_device_unregister(priv->pdev_mux[i]);
331 platform_device_unregister(priv->pdev_i2c);
332fail_alloc:
333 platform_device_unregister(mlxplat_dev);
334
335 return err;
336}
337module_init(mlxplat_init);
338
339static void __exit mlxplat_exit(void)
340{
341 struct mlxplat_priv *priv = platform_get_drvdata(mlxplat_dev);
342 int i;
343
344 platform_device_unregister(priv->pdev_hotplug);
345
346 for (i = ARRAY_SIZE(mlxplat_mux_data) - 1; i >= 0 ; i--)
347 platform_device_unregister(priv->pdev_mux[i]);
348
349 platform_device_unregister(priv->pdev_i2c);
350 platform_device_unregister(mlxplat_dev);
351}
352module_exit(mlxplat_exit);
353
354MODULE_AUTHOR("Vadim Pasternak (vadimp@mellanox.com)");
355MODULE_DESCRIPTION("Mellanox platform driver");
356MODULE_LICENSE("Dual BSD/GPL");
357MODULE_ALIAS("dmi:*:*Mellanox*:MSN24*:");
358MODULE_ALIAS("dmi:*:*Mellanox*:MSN27*:");
359MODULE_ALIAS("dmi:*:*Mellanox*:MSB*:");
360MODULE_ALIAS("dmi:*:*Mellanox*:MSX*:");
361MODULE_ALIAS("dmi:*:*Mellanox*:MSN21*:");