Loading...
Note: File does not exist in v4.6.
1/*
2 * drivers/platform/x86/mlxcpld-hotplug.c
3 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
4 * Copyright (c) 2016 Vadim Pasternak <vadimp@mellanox.com>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. Neither the names of the copyright holders nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * Alternatively, this software may be distributed under the terms of the
19 * GNU General Public License ("GPL") version 2 as published by the Free
20 * Software Foundation.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35#include <linux/bitops.h>
36#include <linux/device.h>
37#include <linux/hwmon.h>
38#include <linux/hwmon-sysfs.h>
39#include <linux/i2c.h>
40#include <linux/interrupt.h>
41#include <linux/io.h>
42#include <linux/module.h>
43#include <linux/platform_data/mlxcpld-hotplug.h>
44#include <linux/platform_device.h>
45#include <linux/spinlock.h>
46#include <linux/wait.h>
47#include <linux/workqueue.h>
48
49/* Offset of event and mask registers from status register */
50#define MLXCPLD_HOTPLUG_EVENT_OFF 1
51#define MLXCPLD_HOTPLUG_MASK_OFF 2
52#define MLXCPLD_HOTPLUG_AGGR_MASK_OFF 1
53
54#define MLXCPLD_HOTPLUG_ATTRS_NUM 8
55
56/**
57 * enum mlxcpld_hotplug_attr_type - sysfs attributes for hotplug events:
58 * @MLXCPLD_HOTPLUG_ATTR_TYPE_PSU: power supply unit attribute;
59 * @MLXCPLD_HOTPLUG_ATTR_TYPE_PWR: power cable attribute;
60 * @MLXCPLD_HOTPLUG_ATTR_TYPE_FAN: FAN drawer attribute;
61 */
62enum mlxcpld_hotplug_attr_type {
63 MLXCPLD_HOTPLUG_ATTR_TYPE_PSU,
64 MLXCPLD_HOTPLUG_ATTR_TYPE_PWR,
65 MLXCPLD_HOTPLUG_ATTR_TYPE_FAN,
66};
67
68/**
69 * struct mlxcpld_hotplug_priv_data - platform private data:
70 * @irq: platform interrupt number;
71 * @pdev: platform device;
72 * @plat: platform data;
73 * @hwmon: hwmon device;
74 * @mlxcpld_hotplug_attr: sysfs attributes array;
75 * @mlxcpld_hotplug_dev_attr: sysfs sensor device attribute array;
76 * @group: sysfs attribute group;
77 * @groups: list of sysfs attribute group for hwmon registration;
78 * @dwork: delayed work template;
79 * @lock: spin lock;
80 * @aggr_cache: last value of aggregation register status;
81 * @psu_cache: last value of PSU register status;
82 * @pwr_cache: last value of power register status;
83 * @fan_cache: last value of FAN register status;
84 */
85struct mlxcpld_hotplug_priv_data {
86 int irq;
87 struct platform_device *pdev;
88 struct mlxcpld_hotplug_platform_data *plat;
89 struct device *hwmon;
90 struct attribute *mlxcpld_hotplug_attr[MLXCPLD_HOTPLUG_ATTRS_NUM + 1];
91 struct sensor_device_attribute_2
92 mlxcpld_hotplug_dev_attr[MLXCPLD_HOTPLUG_ATTRS_NUM];
93 struct attribute_group group;
94 const struct attribute_group *groups[2];
95 struct delayed_work dwork;
96 spinlock_t lock;
97 u8 aggr_cache;
98 u8 psu_cache;
99 u8 pwr_cache;
100 u8 fan_cache;
101};
102
103static ssize_t mlxcpld_hotplug_attr_show(struct device *dev,
104 struct device_attribute *attr,
105 char *buf)
106{
107 struct platform_device *pdev = to_platform_device(dev);
108 struct mlxcpld_hotplug_priv_data *priv = platform_get_drvdata(pdev);
109 int index = to_sensor_dev_attr_2(attr)->index;
110 int nr = to_sensor_dev_attr_2(attr)->nr;
111 u8 reg_val = 0;
112
113 switch (nr) {
114 case MLXCPLD_HOTPLUG_ATTR_TYPE_PSU:
115 /* Bit = 0 : PSU is present. */
116 reg_val = !!!(inb(priv->plat->psu_reg_offset) & BIT(index));
117 break;
118
119 case MLXCPLD_HOTPLUG_ATTR_TYPE_PWR:
120 /* Bit = 1 : power cable is attached. */
121 reg_val = !!(inb(priv->plat->pwr_reg_offset) & BIT(index %
122 priv->plat->pwr_count));
123 break;
124
125 case MLXCPLD_HOTPLUG_ATTR_TYPE_FAN:
126 /* Bit = 0 : FAN is present. */
127 reg_val = !!!(inb(priv->plat->fan_reg_offset) & BIT(index %
128 priv->plat->fan_count));
129 break;
130 }
131
132 return sprintf(buf, "%u\n", reg_val);
133}
134
135#define PRIV_ATTR(i) priv->mlxcpld_hotplug_attr[i]
136#define PRIV_DEV_ATTR(i) priv->mlxcpld_hotplug_dev_attr[i]
137static int mlxcpld_hotplug_attr_init(struct mlxcpld_hotplug_priv_data *priv)
138{
139 int num_attrs = priv->plat->psu_count + priv->plat->pwr_count +
140 priv->plat->fan_count;
141 int i;
142
143 priv->group.attrs = devm_kzalloc(&priv->pdev->dev, num_attrs *
144 sizeof(struct attribute *),
145 GFP_KERNEL);
146 if (!priv->group.attrs)
147 return -ENOMEM;
148
149 for (i = 0; i < num_attrs; i++) {
150 PRIV_ATTR(i) = &PRIV_DEV_ATTR(i).dev_attr.attr;
151
152 if (i < priv->plat->psu_count) {
153 PRIV_ATTR(i)->name = devm_kasprintf(&priv->pdev->dev,
154 GFP_KERNEL, "psu%u", i + 1);
155 PRIV_DEV_ATTR(i).nr = MLXCPLD_HOTPLUG_ATTR_TYPE_PSU;
156 } else if (i < priv->plat->psu_count + priv->plat->pwr_count) {
157 PRIV_ATTR(i)->name = devm_kasprintf(&priv->pdev->dev,
158 GFP_KERNEL, "pwr%u", i %
159 priv->plat->pwr_count + 1);
160 PRIV_DEV_ATTR(i).nr = MLXCPLD_HOTPLUG_ATTR_TYPE_PWR;
161 } else {
162 PRIV_ATTR(i)->name = devm_kasprintf(&priv->pdev->dev,
163 GFP_KERNEL, "fan%u", i %
164 priv->plat->fan_count + 1);
165 PRIV_DEV_ATTR(i).nr = MLXCPLD_HOTPLUG_ATTR_TYPE_FAN;
166 }
167
168 if (!PRIV_ATTR(i)->name) {
169 dev_err(&priv->pdev->dev, "Memory allocation failed for sysfs attribute %d.\n",
170 i + 1);
171 return -ENOMEM;
172 }
173
174 PRIV_DEV_ATTR(i).dev_attr.attr.name = PRIV_ATTR(i)->name;
175 PRIV_DEV_ATTR(i).dev_attr.attr.mode = S_IRUGO;
176 PRIV_DEV_ATTR(i).dev_attr.show = mlxcpld_hotplug_attr_show;
177 PRIV_DEV_ATTR(i).index = i;
178 sysfs_attr_init(&PRIV_DEV_ATTR(i).dev_attr.attr);
179 }
180
181 priv->group.attrs = priv->mlxcpld_hotplug_attr;
182 priv->groups[0] = &priv->group;
183 priv->groups[1] = NULL;
184
185 return 0;
186}
187
188static int mlxcpld_hotplug_device_create(struct device *dev,
189 struct mlxcpld_hotplug_device *item)
190{
191 item->adapter = i2c_get_adapter(item->bus);
192 if (!item->adapter) {
193 dev_err(dev, "Failed to get adapter for bus %d\n",
194 item->bus);
195 return -EFAULT;
196 }
197
198 item->client = i2c_new_device(item->adapter, &item->brdinfo);
199 if (!item->client) {
200 dev_err(dev, "Failed to create client %s at bus %d at addr 0x%02x\n",
201 item->brdinfo.type, item->bus, item->brdinfo.addr);
202 i2c_put_adapter(item->adapter);
203 item->adapter = NULL;
204 return -EFAULT;
205 }
206
207 return 0;
208}
209
210static void mlxcpld_hotplug_device_destroy(struct mlxcpld_hotplug_device *item)
211{
212 if (item->client) {
213 i2c_unregister_device(item->client);
214 item->client = NULL;
215 }
216
217 if (item->adapter) {
218 i2c_put_adapter(item->adapter);
219 item->adapter = NULL;
220 }
221}
222
223static inline void
224mlxcpld_hotplug_work_helper(struct device *dev,
225 struct mlxcpld_hotplug_device *item, u8 is_inverse,
226 u16 offset, u8 mask, u8 *cache)
227{
228 u8 val, asserted;
229 int bit;
230
231 /* Mask event. */
232 outb(0, offset + MLXCPLD_HOTPLUG_MASK_OFF);
233 /* Read status. */
234 val = inb(offset) & mask;
235 asserted = *cache ^ val;
236 *cache = val;
237
238 /*
239 * Validate if item related to received signal type is valid.
240 * It should never happen, excepted the situation when some
241 * piece of hardware is broken. In such situation just produce
242 * error message and return. Caller must continue to handle the
243 * signals from other devices if any.
244 */
245 if (unlikely(!item)) {
246 dev_err(dev, "False signal is received: register at offset 0x%02x, mask 0x%02x.\n",
247 offset, mask);
248 return;
249 }
250
251 for_each_set_bit(bit, (unsigned long *)&asserted, 8) {
252 if (val & BIT(bit)) {
253 if (is_inverse)
254 mlxcpld_hotplug_device_destroy(item + bit);
255 else
256 mlxcpld_hotplug_device_create(dev, item + bit);
257 } else {
258 if (is_inverse)
259 mlxcpld_hotplug_device_create(dev, item + bit);
260 else
261 mlxcpld_hotplug_device_destroy(item + bit);
262 }
263 }
264
265 /* Acknowledge event. */
266 outb(0, offset + MLXCPLD_HOTPLUG_EVENT_OFF);
267 /* Unmask event. */
268 outb(mask, offset + MLXCPLD_HOTPLUG_MASK_OFF);
269}
270
271/*
272 * mlxcpld_hotplug_work_handler - performs traversing of CPLD interrupt
273 * registers according to the below hierarchy schema:
274 *
275 * Aggregation registers (status/mask)
276 * PSU registers: *---*
277 * *-----------------* | |
278 * |status/event/mask|----->| * |
279 * *-----------------* | |
280 * Power registers: | |
281 * *-----------------* | |
282 * |status/event/mask|----->| * |---> CPU
283 * *-----------------* | |
284 * FAN registers:
285 * *-----------------* | |
286 * |status/event/mask|----->| * |
287 * *-----------------* | |
288 * *---*
289 * In case some system changed are detected: FAN in/out, PSU in/out, power
290 * cable attached/detached, relevant device is created or destroyed.
291 */
292static void mlxcpld_hotplug_work_handler(struct work_struct *work)
293{
294 struct mlxcpld_hotplug_priv_data *priv = container_of(work,
295 struct mlxcpld_hotplug_priv_data, dwork.work);
296 u8 val, aggr_asserted;
297 unsigned long flags;
298
299 /* Mask aggregation event. */
300 outb(0, priv->plat->top_aggr_offset + MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
301 /* Read aggregation status. */
302 val = inb(priv->plat->top_aggr_offset) & priv->plat->top_aggr_mask;
303 aggr_asserted = priv->aggr_cache ^ val;
304 priv->aggr_cache = val;
305
306 /* Handle PSU configuration changes. */
307 if (aggr_asserted & priv->plat->top_aggr_psu_mask)
308 mlxcpld_hotplug_work_helper(&priv->pdev->dev, priv->plat->psu,
309 1, priv->plat->psu_reg_offset,
310 priv->plat->psu_mask,
311 &priv->psu_cache);
312
313 /* Handle power cable configuration changes. */
314 if (aggr_asserted & priv->plat->top_aggr_pwr_mask)
315 mlxcpld_hotplug_work_helper(&priv->pdev->dev, priv->plat->pwr,
316 0, priv->plat->pwr_reg_offset,
317 priv->plat->pwr_mask,
318 &priv->pwr_cache);
319
320 /* Handle FAN configuration changes. */
321 if (aggr_asserted & priv->plat->top_aggr_fan_mask)
322 mlxcpld_hotplug_work_helper(&priv->pdev->dev, priv->plat->fan,
323 1, priv->plat->fan_reg_offset,
324 priv->plat->fan_mask,
325 &priv->fan_cache);
326
327 if (aggr_asserted) {
328 spin_lock_irqsave(&priv->lock, flags);
329
330 /*
331 * It is possible, that some signals have been inserted, while
332 * interrupt has been masked by mlxcpld_hotplug_work_handler.
333 * In this case such signals will be missed. In order to handle
334 * these signals delayed work is canceled and work task
335 * re-scheduled for immediate execution. It allows to handle
336 * missed signals, if any. In other case work handler just
337 * validates that no new signals have been received during
338 * masking.
339 */
340 cancel_delayed_work(&priv->dwork);
341 schedule_delayed_work(&priv->dwork, 0);
342
343 spin_unlock_irqrestore(&priv->lock, flags);
344
345 return;
346 }
347
348 /* Unmask aggregation event (no need acknowledge). */
349 outb(priv->plat->top_aggr_mask, priv->plat->top_aggr_offset +
350 MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
351}
352
353static void mlxcpld_hotplug_set_irq(struct mlxcpld_hotplug_priv_data *priv)
354{
355 /* Clear psu presense event. */
356 outb(0, priv->plat->psu_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
357 /* Set psu initial status as mask and unmask psu event. */
358 priv->psu_cache = priv->plat->psu_mask;
359 outb(priv->plat->psu_mask, priv->plat->psu_reg_offset +
360 MLXCPLD_HOTPLUG_MASK_OFF);
361
362 /* Clear power cable event. */
363 outb(0, priv->plat->pwr_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
364 /* Keep power initial status as zero and unmask power event. */
365 outb(priv->plat->pwr_mask, priv->plat->pwr_reg_offset +
366 MLXCPLD_HOTPLUG_MASK_OFF);
367
368 /* Clear fan presense event. */
369 outb(0, priv->plat->fan_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
370 /* Set fan initial status as mask and unmask fan event. */
371 priv->fan_cache = priv->plat->fan_mask;
372 outb(priv->plat->fan_mask, priv->plat->fan_reg_offset +
373 MLXCPLD_HOTPLUG_MASK_OFF);
374
375 /* Keep aggregation initial status as zero and unmask events. */
376 outb(priv->plat->top_aggr_mask, priv->plat->top_aggr_offset +
377 MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
378
379 /* Invoke work handler for initializing hot plug devices setting. */
380 mlxcpld_hotplug_work_handler(&priv->dwork.work);
381
382 enable_irq(priv->irq);
383}
384
385static void mlxcpld_hotplug_unset_irq(struct mlxcpld_hotplug_priv_data *priv)
386{
387 int i;
388
389 disable_irq(priv->irq);
390 cancel_delayed_work_sync(&priv->dwork);
391
392 /* Mask aggregation event. */
393 outb(0, priv->plat->top_aggr_offset + MLXCPLD_HOTPLUG_AGGR_MASK_OFF);
394
395 /* Mask psu presense event. */
396 outb(0, priv->plat->psu_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
397 /* Clear psu presense event. */
398 outb(0, priv->plat->psu_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
399
400 /* Mask power cable event. */
401 outb(0, priv->plat->pwr_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
402 /* Clear power cable event. */
403 outb(0, priv->plat->pwr_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
404
405 /* Mask fan presense event. */
406 outb(0, priv->plat->fan_reg_offset + MLXCPLD_HOTPLUG_MASK_OFF);
407 /* Clear fan presense event. */
408 outb(0, priv->plat->fan_reg_offset + MLXCPLD_HOTPLUG_EVENT_OFF);
409
410 /* Remove all the attached devices. */
411 for (i = 0; i < priv->plat->psu_count; i++)
412 mlxcpld_hotplug_device_destroy(priv->plat->psu + i);
413
414 for (i = 0; i < priv->plat->pwr_count; i++)
415 mlxcpld_hotplug_device_destroy(priv->plat->pwr + i);
416
417 for (i = 0; i < priv->plat->fan_count; i++)
418 mlxcpld_hotplug_device_destroy(priv->plat->fan + i);
419}
420
421static irqreturn_t mlxcpld_hotplug_irq_handler(int irq, void *dev)
422{
423 struct mlxcpld_hotplug_priv_data *priv =
424 (struct mlxcpld_hotplug_priv_data *)dev;
425
426 /* Schedule work task for immediate execution.*/
427 schedule_delayed_work(&priv->dwork, 0);
428
429 return IRQ_HANDLED;
430}
431
432static int mlxcpld_hotplug_probe(struct platform_device *pdev)
433{
434 struct mlxcpld_hotplug_platform_data *pdata;
435 struct mlxcpld_hotplug_priv_data *priv;
436 int err;
437
438 pdata = dev_get_platdata(&pdev->dev);
439 if (!pdata) {
440 dev_err(&pdev->dev, "Failed to get platform data.\n");
441 return -EINVAL;
442 }
443
444 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
445 if (!priv)
446 return -ENOMEM;
447
448 priv->pdev = pdev;
449 priv->plat = pdata;
450
451 priv->irq = platform_get_irq(pdev, 0);
452 if (priv->irq < 0) {
453 dev_err(&pdev->dev, "Failed to get platform irq: %d\n",
454 priv->irq);
455 return priv->irq;
456 }
457
458 err = devm_request_irq(&pdev->dev, priv->irq,
459 mlxcpld_hotplug_irq_handler, 0, pdev->name,
460 priv);
461 if (err) {
462 dev_err(&pdev->dev, "Failed to request irq: %d\n", err);
463 return err;
464 }
465 disable_irq(priv->irq);
466
467 INIT_DELAYED_WORK(&priv->dwork, mlxcpld_hotplug_work_handler);
468 spin_lock_init(&priv->lock);
469
470 err = mlxcpld_hotplug_attr_init(priv);
471 if (err) {
472 dev_err(&pdev->dev, "Failed to allocate attributes: %d\n", err);
473 return err;
474 }
475
476 priv->hwmon = devm_hwmon_device_register_with_groups(&pdev->dev,
477 "mlxcpld_hotplug", priv, priv->groups);
478 if (IS_ERR(priv->hwmon)) {
479 dev_err(&pdev->dev, "Failed to register hwmon device %ld\n",
480 PTR_ERR(priv->hwmon));
481 return PTR_ERR(priv->hwmon);
482 }
483
484 platform_set_drvdata(pdev, priv);
485
486 /* Perform initial interrupts setup. */
487 mlxcpld_hotplug_set_irq(priv);
488
489 return 0;
490}
491
492static int mlxcpld_hotplug_remove(struct platform_device *pdev)
493{
494 struct mlxcpld_hotplug_priv_data *priv = platform_get_drvdata(pdev);
495
496 /* Clean interrupts setup. */
497 mlxcpld_hotplug_unset_irq(priv);
498
499 return 0;
500}
501
502static struct platform_driver mlxcpld_hotplug_driver = {
503 .driver = {
504 .name = "mlxcpld-hotplug",
505 },
506 .probe = mlxcpld_hotplug_probe,
507 .remove = mlxcpld_hotplug_remove,
508};
509
510module_platform_driver(mlxcpld_hotplug_driver);
511
512MODULE_AUTHOR("Vadim Pasternak <vadimp@mellanox.com>");
513MODULE_DESCRIPTION("Mellanox CPLD hotplug platform driver");
514MODULE_LICENSE("Dual BSD/GPL");
515MODULE_ALIAS("platform:mlxcpld-hotplug");