1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Mellanox hotplug driver
4 *
5 * Copyright (C) 2016-2020 Mellanox Technologies
6 */
7
8 #include <linux/bitops.h>
9 #include <linux/device.h>
10 #include <linux/hwmon.h>
11 #include <linux/hwmon-sysfs.h>
12 #include <linux/i2c.h>
13 #include <linux/interrupt.h>
14 #include <linux/module.h>
15 #include <linux/platform_data/mlxreg.h>
16 #include <linux/platform_device.h>
17 #include <linux/spinlock.h>
18 #include <linux/string_helpers.h>
19 #include <linux/regmap.h>
20 #include <linux/workqueue.h>
21
22 /* Offset of event and mask registers from status register. */
23 #define MLXREG_HOTPLUG_EVENT_OFF 1
24 #define MLXREG_HOTPLUG_MASK_OFF 2
25 #define MLXREG_HOTPLUG_AGGR_MASK_OFF 1
26
27 /* ASIC good health mask. */
28 #define MLXREG_HOTPLUG_GOOD_HEALTH_MASK 0x02
29
30 #define MLXREG_HOTPLUG_ATTRS_MAX 128
31 #define MLXREG_HOTPLUG_NOT_ASSERT 3
32
33 /**
34 * struct mlxreg_hotplug_priv_data - platform private data:
35 * @irq: platform device interrupt number;
36 * @dev: basic device;
37 * @pdev: platform device;
38 * @plat: platform data;
39 * @regmap: register map handle;
40 * @dwork_irq: delayed work template;
41 * @lock: spin lock;
42 * @hwmon: hwmon device;
43 * @mlxreg_hotplug_attr: sysfs attributes array;
44 * @mlxreg_hotplug_dev_attr: sysfs sensor device attribute array;
45 * @group: sysfs attribute group;
46 * @groups: list of sysfs attribute group for hwmon registration;
47 * @cell: location of top aggregation interrupt register;
48 * @mask: top aggregation interrupt common mask;
49 * @aggr_cache: last value of aggregation register status;
50 * @after_probe: flag indication probing completion;
51 * @not_asserted: number of entries in workqueue with no signal assertion;
52 */
53 struct mlxreg_hotplug_priv_data {
54 int irq;
55 struct device *dev;
56 struct platform_device *pdev;
57 struct mlxreg_hotplug_platform_data *plat;
58 struct regmap *regmap;
59 struct delayed_work dwork_irq;
60 spinlock_t lock; /* sync with interrupt */
61 struct device *hwmon;
62 struct attribute *mlxreg_hotplug_attr[MLXREG_HOTPLUG_ATTRS_MAX + 1];
63 struct sensor_device_attribute_2
64 mlxreg_hotplug_dev_attr[MLXREG_HOTPLUG_ATTRS_MAX];
65 struct attribute_group group;
66 const struct attribute_group *groups[2];
67 u32 cell;
68 u32 mask;
69 u32 aggr_cache;
70 bool after_probe;
71 u8 not_asserted;
72 };
73
74 /* Environment variables array for udev. */
75 static char *mlxreg_hotplug_udev_envp[] = { NULL, NULL };
76
77 static int
mlxreg_hotplug_udev_event_send(struct kobject * kobj,struct mlxreg_core_data * data,bool action)78 mlxreg_hotplug_udev_event_send(struct kobject *kobj,
79 struct mlxreg_core_data *data, bool action)
80 {
81 char event_str[MLXREG_CORE_LABEL_MAX_SIZE + 2];
82 char label[MLXREG_CORE_LABEL_MAX_SIZE] = { 0 };
83
84 mlxreg_hotplug_udev_envp[0] = event_str;
85 string_upper(label, data->label);
86 snprintf(event_str, MLXREG_CORE_LABEL_MAX_SIZE, "%s=%d", label, !!action);
87
88 return kobject_uevent_env(kobj, KOBJ_CHANGE, mlxreg_hotplug_udev_envp);
89 }
90
91 static void
mlxreg_hotplug_pdata_export(void * pdata,void * regmap)92 mlxreg_hotplug_pdata_export(void *pdata, void *regmap)
93 {
94 struct mlxreg_core_hotplug_platform_data *dev_pdata = pdata;
95
96 /* Export regmap to underlying device. */
97 dev_pdata->regmap = regmap;
98 }
99
mlxreg_hotplug_device_create(struct mlxreg_hotplug_priv_data * priv,struct mlxreg_core_data * data,enum mlxreg_hotplug_kind kind)100 static int mlxreg_hotplug_device_create(struct mlxreg_hotplug_priv_data *priv,
101 struct mlxreg_core_data *data,
102 enum mlxreg_hotplug_kind kind)
103 {
104 struct i2c_board_info *brdinfo = data->hpdev.brdinfo;
105 struct mlxreg_core_hotplug_platform_data *pdata;
106 struct i2c_client *client;
107
108 /* Notify user by sending hwmon uevent. */
109 mlxreg_hotplug_udev_event_send(&priv->hwmon->kobj, data, true);
110
111 /*
112 * Return if adapter number is negative. It could be in case hotplug
113 * event is not associated with hotplug device.
114 */
115 if (data->hpdev.nr < 0 && data->hpdev.action != MLXREG_HOTPLUG_DEVICE_NO_ACTION)
116 return 0;
117
118 pdata = dev_get_platdata(&priv->pdev->dev);
119 switch (data->hpdev.action) {
120 case MLXREG_HOTPLUG_DEVICE_DEFAULT_ACTION:
121 data->hpdev.adapter = i2c_get_adapter(data->hpdev.nr +
122 pdata->shift_nr);
123 if (!data->hpdev.adapter) {
124 dev_err(priv->dev, "Failed to get adapter for bus %d\n",
125 data->hpdev.nr + pdata->shift_nr);
126 return -EFAULT;
127 }
128
129 /* Export platform data to underlying device. */
130 if (brdinfo->platform_data)
131 mlxreg_hotplug_pdata_export(brdinfo->platform_data, pdata->regmap);
132
133 client = i2c_new_client_device(data->hpdev.adapter,
134 brdinfo);
135 if (IS_ERR(client)) {
136 dev_err(priv->dev, "Failed to create client %s at bus %d at addr 0x%02x\n",
137 brdinfo->type, data->hpdev.nr +
138 pdata->shift_nr, brdinfo->addr);
139
140 i2c_put_adapter(data->hpdev.adapter);
141 data->hpdev.adapter = NULL;
142 return PTR_ERR(client);
143 }
144
145 data->hpdev.client = client;
146 break;
147 case MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION:
148 /* Export platform data to underlying device. */
149 if (data->hpdev.brdinfo && data->hpdev.brdinfo->platform_data)
150 mlxreg_hotplug_pdata_export(data->hpdev.brdinfo->platform_data,
151 pdata->regmap);
152 /* Pass parent hotplug device handle to underlying device. */
153 data->notifier = data->hpdev.notifier;
154 data->hpdev.pdev = platform_device_register_resndata(&priv->pdev->dev,
155 brdinfo->type,
156 data->hpdev.nr,
157 NULL, 0, data,
158 sizeof(*data));
159 if (IS_ERR(data->hpdev.pdev))
160 return PTR_ERR(data->hpdev.pdev);
161
162 break;
163 default:
164 break;
165 }
166
167 if (data->hpdev.notifier && data->hpdev.notifier->user_handler)
168 return data->hpdev.notifier->user_handler(data->hpdev.notifier->handle, kind, 1);
169
170 return 0;
171 }
172
173 static void
mlxreg_hotplug_device_destroy(struct mlxreg_hotplug_priv_data * priv,struct mlxreg_core_data * data,enum mlxreg_hotplug_kind kind)174 mlxreg_hotplug_device_destroy(struct mlxreg_hotplug_priv_data *priv,
175 struct mlxreg_core_data *data,
176 enum mlxreg_hotplug_kind kind)
177 {
178 /* Notify user by sending hwmon uevent. */
179 mlxreg_hotplug_udev_event_send(&priv->hwmon->kobj, data, false);
180 if (data->hpdev.notifier && data->hpdev.notifier->user_handler)
181 data->hpdev.notifier->user_handler(data->hpdev.notifier->handle, kind, 0);
182
183 switch (data->hpdev.action) {
184 case MLXREG_HOTPLUG_DEVICE_DEFAULT_ACTION:
185 if (data->hpdev.client) {
186 i2c_unregister_device(data->hpdev.client);
187 data->hpdev.client = NULL;
188 }
189
190 if (data->hpdev.adapter) {
191 i2c_put_adapter(data->hpdev.adapter);
192 data->hpdev.adapter = NULL;
193 }
194 break;
195 case MLXREG_HOTPLUG_DEVICE_PLATFORM_ACTION:
196 if (data->hpdev.pdev)
197 platform_device_unregister(data->hpdev.pdev);
198 break;
199 default:
200 break;
201 }
202 }
203
mlxreg_hotplug_attr_show(struct device * dev,struct device_attribute * attr,char * buf)204 static ssize_t mlxreg_hotplug_attr_show(struct device *dev,
205 struct device_attribute *attr,
206 char *buf)
207 {
208 struct mlxreg_hotplug_priv_data *priv = dev_get_drvdata(dev);
209 struct mlxreg_core_hotplug_platform_data *pdata;
210 int index = to_sensor_dev_attr_2(attr)->index;
211 int nr = to_sensor_dev_attr_2(attr)->nr;
212 struct mlxreg_core_item *item;
213 struct mlxreg_core_data *data;
214 u32 regval;
215 int ret;
216
217 pdata = dev_get_platdata(&priv->pdev->dev);
218 item = pdata->items + nr;
219 data = item->data + index;
220
221 ret = regmap_read(priv->regmap, data->reg, ®val);
222 if (ret)
223 return ret;
224
225 if (item->health) {
226 regval &= data->mask;
227 } else {
228 /* Bit = 0 : functional if item->inversed is true. */
229 if (item->inversed)
230 regval = !(regval & data->mask);
231 else
232 regval = !!(regval & data->mask);
233 }
234
235 return sprintf(buf, "%u\n", regval);
236 }
237
238 #define PRIV_ATTR(i) priv->mlxreg_hotplug_attr[i]
239 #define PRIV_DEV_ATTR(i) priv->mlxreg_hotplug_dev_attr[i]
240
mlxreg_hotplug_item_label_index_get(u32 mask,u32 bit)241 static int mlxreg_hotplug_item_label_index_get(u32 mask, u32 bit)
242 {
243 int i, j;
244
245 for (i = 0, j = -1; i <= bit; i++) {
246 if (mask & BIT(i))
247 j++;
248 }
249 return j;
250 }
251
mlxreg_hotplug_attr_init(struct mlxreg_hotplug_priv_data * priv)252 static int mlxreg_hotplug_attr_init(struct mlxreg_hotplug_priv_data *priv)
253 {
254 struct mlxreg_core_hotplug_platform_data *pdata;
255 struct mlxreg_core_item *item;
256 struct mlxreg_core_data *data;
257 unsigned long mask;
258 u32 regval;
259 int num_attrs = 0, id = 0, i, j, k, count, ret;
260
261 pdata = dev_get_platdata(&priv->pdev->dev);
262 item = pdata->items;
263
264 /* Go over all kinds of items - psu, pwr, fan. */
265 for (i = 0; i < pdata->counter; i++, item++) {
266 if (item->capability) {
267 /*
268 * Read group capability register to get actual number
269 * of interrupt capable components and set group mask
270 * accordingly.
271 */
272 ret = regmap_read(priv->regmap, item->capability,
273 ®val);
274 if (ret)
275 return ret;
276
277 item->mask = GENMASK((regval & item->mask) - 1, 0);
278 }
279
280 data = item->data;
281
282 /* Go over all unmasked units within item. */
283 mask = item->mask;
284 k = 0;
285 count = item->ind ? item->ind : item->count;
286 for_each_set_bit(j, &mask, count) {
287 if (data->capability) {
288 /*
289 * Read capability register and skip non
290 * relevant attributes.
291 */
292 ret = regmap_read(priv->regmap,
293 data->capability, ®val);
294 if (ret)
295 return ret;
296
297 if (!(regval & data->bit)) {
298 data++;
299 continue;
300 }
301 }
302
303 PRIV_ATTR(id) = &PRIV_DEV_ATTR(id).dev_attr.attr;
304 PRIV_ATTR(id)->name = devm_kasprintf(&priv->pdev->dev,
305 GFP_KERNEL,
306 data->label);
307 if (!PRIV_ATTR(id)->name) {
308 dev_err(priv->dev, "Memory allocation failed for attr %d.\n",
309 id);
310 return -ENOMEM;
311 }
312
313 PRIV_DEV_ATTR(id).dev_attr.attr.name =
314 PRIV_ATTR(id)->name;
315 PRIV_DEV_ATTR(id).dev_attr.attr.mode = 0444;
316 PRIV_DEV_ATTR(id).dev_attr.show =
317 mlxreg_hotplug_attr_show;
318 PRIV_DEV_ATTR(id).nr = i;
319 PRIV_DEV_ATTR(id).index = k;
320 sysfs_attr_init(&PRIV_DEV_ATTR(id).dev_attr.attr);
321 data++;
322 id++;
323 k++;
324 }
325 num_attrs += k;
326 }
327
328 priv->group.attrs = devm_kcalloc(&priv->pdev->dev,
329 num_attrs,
330 sizeof(struct attribute *),
331 GFP_KERNEL);
332 if (!priv->group.attrs)
333 return -ENOMEM;
334
335 priv->group.attrs = priv->mlxreg_hotplug_attr;
336 priv->groups[0] = &priv->group;
337 priv->groups[1] = NULL;
338
339 return 0;
340 }
341
342 static void
mlxreg_hotplug_work_helper(struct mlxreg_hotplug_priv_data * priv,struct mlxreg_core_item * item)343 mlxreg_hotplug_work_helper(struct mlxreg_hotplug_priv_data *priv,
344 struct mlxreg_core_item *item)
345 {
346 struct mlxreg_core_data *data;
347 unsigned long asserted;
348 u32 regval, bit;
349 int ret;
350
351 /*
352 * Validate if item related to received signal type is valid.
353 * It should never happen, excepted the situation when some
354 * piece of hardware is broken. In such situation just produce
355 * error message and return. Caller must continue to handle the
356 * signals from other devices if any.
357 */
358 if (unlikely(!item)) {
359 dev_err(priv->dev, "False signal: at offset:mask 0x%02x:0x%02x.\n",
360 item->reg, item->mask);
361
362 return;
363 }
364
365 /* Mask event. */
366 ret = regmap_write(priv->regmap, item->reg + MLXREG_HOTPLUG_MASK_OFF,
367 0);
368 if (ret)
369 goto out;
370
371 /* Read status. */
372 ret = regmap_read(priv->regmap, item->reg, ®val);
373 if (ret)
374 goto out;
375
376 /* Set asserted bits and save last status. */
377 regval &= item->mask;
378 asserted = item->cache ^ regval;
379 item->cache = regval;
380 for_each_set_bit(bit, &asserted, 8) {
381 int pos;
382
383 pos = mlxreg_hotplug_item_label_index_get(item->mask, bit);
384 if (pos < 0)
385 goto out;
386
387 data = item->data + pos;
388 if (regval & BIT(bit)) {
389 if (item->inversed)
390 mlxreg_hotplug_device_destroy(priv, data, item->kind);
391 else
392 mlxreg_hotplug_device_create(priv, data, item->kind);
393 } else {
394 if (item->inversed)
395 mlxreg_hotplug_device_create(priv, data, item->kind);
396 else
397 mlxreg_hotplug_device_destroy(priv, data, item->kind);
398 }
399 }
400
401 /* Acknowledge event. */
402 ret = regmap_write(priv->regmap, item->reg + MLXREG_HOTPLUG_EVENT_OFF,
403 0);
404 if (ret)
405 goto out;
406
407 /* Unmask event. */
408 ret = regmap_write(priv->regmap, item->reg + MLXREG_HOTPLUG_MASK_OFF,
409 item->mask);
410
411 out:
412 if (ret)
413 dev_err(priv->dev, "Failed to complete workqueue.\n");
414 }
415
416 static void
mlxreg_hotplug_health_work_helper(struct mlxreg_hotplug_priv_data * priv,struct mlxreg_core_item * item)417 mlxreg_hotplug_health_work_helper(struct mlxreg_hotplug_priv_data *priv,
418 struct mlxreg_core_item *item)
419 {
420 struct mlxreg_core_data *data = item->data;
421 u32 regval;
422 int i, ret = 0;
423
424 for (i = 0; i < item->count; i++, data++) {
425 /* Mask event. */
426 ret = regmap_write(priv->regmap, data->reg +
427 MLXREG_HOTPLUG_MASK_OFF, 0);
428 if (ret)
429 goto out;
430
431 /* Read status. */
432 ret = regmap_read(priv->regmap, data->reg, ®val);
433 if (ret)
434 goto out;
435
436 regval &= data->mask;
437
438 if (item->cache == regval)
439 goto ack_event;
440
441 /*
442 * ASIC health indication is provided through two bits. Bits
443 * value 0x2 indicates that ASIC reached the good health, value
444 * 0x0 indicates ASIC the bad health or dormant state and value
445 * 0x3 indicates the booting state. During ASIC reset it should
446 * pass the following states: dormant -> booting -> good.
447 */
448 if (regval == MLXREG_HOTPLUG_GOOD_HEALTH_MASK) {
449 if (!data->attached) {
450 /*
451 * ASIC is in steady state. Connect associated
452 * device, if configured.
453 */
454 mlxreg_hotplug_device_create(priv, data, item->kind);
455 data->attached = true;
456 }
457 } else {
458 if (data->attached) {
459 /*
460 * ASIC health is failed after ASIC has been
461 * in steady state. Disconnect associated
462 * device, if it has been connected.
463 */
464 mlxreg_hotplug_device_destroy(priv, data, item->kind);
465 data->attached = false;
466 data->health_cntr = 0;
467 }
468 }
469 item->cache = regval;
470 ack_event:
471 /* Acknowledge event. */
472 ret = regmap_write(priv->regmap, data->reg +
473 MLXREG_HOTPLUG_EVENT_OFF, 0);
474 if (ret)
475 goto out;
476
477 /* Unmask event. */
478 ret = regmap_write(priv->regmap, data->reg +
479 MLXREG_HOTPLUG_MASK_OFF, data->mask);
480 if (ret)
481 goto out;
482 }
483
484 out:
485 if (ret)
486 dev_err(priv->dev, "Failed to complete workqueue.\n");
487 }
488
489 /*
490 * mlxreg_hotplug_work_handler - performs traversing of device interrupt
491 * registers according to the below hierarchy schema:
492 *
493 * Aggregation registers (status/mask)
494 * PSU registers: *---*
495 * *-----------------* | |
496 * |status/event/mask|-----> | * |
497 * *-----------------* | |
498 * Power registers: | |
499 * *-----------------* | |
500 * |status/event/mask|-----> | * |
501 * *-----------------* | |
502 * FAN registers: | |--> CPU
503 * *-----------------* | |
504 * |status/event/mask|-----> | * |
505 * *-----------------* | |
506 * ASIC registers: | |
507 * *-----------------* | |
508 * |status/event/mask|-----> | * |
509 * *-----------------* | |
510 * *---*
511 *
512 * In case some system changed are detected: FAN in/out, PSU in/out, power
513 * cable attached/detached, ASIC health good/bad, relevant device is created
514 * or destroyed.
515 */
mlxreg_hotplug_work_handler(struct work_struct * work)516 static void mlxreg_hotplug_work_handler(struct work_struct *work)
517 {
518 struct mlxreg_core_hotplug_platform_data *pdata;
519 struct mlxreg_hotplug_priv_data *priv;
520 struct mlxreg_core_item *item;
521 u32 regval, aggr_asserted;
522 unsigned long flags;
523 int i, ret;
524
525 priv = container_of(work, struct mlxreg_hotplug_priv_data,
526 dwork_irq.work);
527 pdata = dev_get_platdata(&priv->pdev->dev);
528 item = pdata->items;
529
530 /* Mask aggregation event. */
531 ret = regmap_write(priv->regmap, pdata->cell +
532 MLXREG_HOTPLUG_AGGR_MASK_OFF, 0);
533 if (ret < 0)
534 goto out;
535
536 /* Read aggregation status. */
537 ret = regmap_read(priv->regmap, pdata->cell, ®val);
538 if (ret)
539 goto out;
540
541 regval &= pdata->mask;
542 aggr_asserted = priv->aggr_cache ^ regval;
543 priv->aggr_cache = regval;
544
545 /*
546 * Handler is invoked, but no assertion is detected at top aggregation
547 * status level. Set aggr_asserted to mask value to allow handler extra
548 * run over all relevant signals to recover any missed signal.
549 */
550 if (priv->not_asserted == MLXREG_HOTPLUG_NOT_ASSERT) {
551 priv->not_asserted = 0;
552 aggr_asserted = pdata->mask;
553 }
554 if (!aggr_asserted)
555 goto unmask_event;
556
557 /* Handle topology and health configuration changes. */
558 for (i = 0; i < pdata->counter; i++, item++) {
559 if (aggr_asserted & item->aggr_mask) {
560 if (item->health)
561 mlxreg_hotplug_health_work_helper(priv, item);
562 else
563 mlxreg_hotplug_work_helper(priv, item);
564 }
565 }
566
567 spin_lock_irqsave(&priv->lock, flags);
568
569 /*
570 * It is possible, that some signals have been inserted, while
571 * interrupt has been masked by mlxreg_hotplug_work_handler. In this
572 * case such signals will be missed. In order to handle these signals
573 * delayed work is canceled and work task re-scheduled for immediate
574 * execution. It allows to handle missed signals, if any. In other case
575 * work handler just validates that no new signals have been received
576 * during masking.
577 */
578 cancel_delayed_work(&priv->dwork_irq);
579 schedule_delayed_work(&priv->dwork_irq, 0);
580
581 spin_unlock_irqrestore(&priv->lock, flags);
582
583 return;
584
585 unmask_event:
586 priv->not_asserted++;
587 /* Unmask aggregation event (no need acknowledge). */
588 ret = regmap_write(priv->regmap, pdata->cell +
589 MLXREG_HOTPLUG_AGGR_MASK_OFF, pdata->mask);
590
591 out:
592 if (ret)
593 dev_err(priv->dev, "Failed to complete workqueue.\n");
594 }
595
mlxreg_hotplug_set_irq(struct mlxreg_hotplug_priv_data * priv)596 static int mlxreg_hotplug_set_irq(struct mlxreg_hotplug_priv_data *priv)
597 {
598 struct mlxreg_core_hotplug_platform_data *pdata;
599 struct mlxreg_core_item *item;
600 struct mlxreg_core_data *data;
601 u32 regval;
602 int i, j, ret;
603
604 pdata = dev_get_platdata(&priv->pdev->dev);
605 item = pdata->items;
606
607 for (i = 0; i < pdata->counter; i++, item++) {
608 /* Clear group presense event. */
609 ret = regmap_write(priv->regmap, item->reg +
610 MLXREG_HOTPLUG_EVENT_OFF, 0);
611 if (ret)
612 goto out;
613
614 /*
615 * Verify if hardware configuration requires to disable
616 * interrupt capability for some of components.
617 */
618 data = item->data;
619 for (j = 0; j < item->count; j++, data++) {
620 /* Verify if the attribute has capability register. */
621 if (data->capability) {
622 /* Read capability register. */
623 ret = regmap_read(priv->regmap,
624 data->capability, ®val);
625 if (ret)
626 goto out;
627
628 if (!(regval & data->bit))
629 item->mask &= ~BIT(j);
630 }
631 }
632
633 /* Set group initial status as mask and unmask group event. */
634 if (item->inversed) {
635 item->cache = item->mask;
636 ret = regmap_write(priv->regmap, item->reg +
637 MLXREG_HOTPLUG_MASK_OFF,
638 item->mask);
639 if (ret)
640 goto out;
641 }
642 }
643
644 /* Keep aggregation initial status as zero and unmask events. */
645 ret = regmap_write(priv->regmap, pdata->cell +
646 MLXREG_HOTPLUG_AGGR_MASK_OFF, pdata->mask);
647 if (ret)
648 goto out;
649
650 /* Keep low aggregation initial status as zero and unmask events. */
651 if (pdata->cell_low) {
652 ret = regmap_write(priv->regmap, pdata->cell_low +
653 MLXREG_HOTPLUG_AGGR_MASK_OFF,
654 pdata->mask_low);
655 if (ret)
656 goto out;
657 }
658
659 /* Invoke work handler for initializing hot plug devices setting. */
660 mlxreg_hotplug_work_handler(&priv->dwork_irq.work);
661
662 out:
663 if (ret)
664 dev_err(priv->dev, "Failed to set interrupts.\n");
665 enable_irq(priv->irq);
666 return ret;
667 }
668
mlxreg_hotplug_unset_irq(struct mlxreg_hotplug_priv_data * priv)669 static void mlxreg_hotplug_unset_irq(struct mlxreg_hotplug_priv_data *priv)
670 {
671 struct mlxreg_core_hotplug_platform_data *pdata;
672 struct mlxreg_core_item *item;
673 struct mlxreg_core_data *data;
674 int count, i, j;
675
676 pdata = dev_get_platdata(&priv->pdev->dev);
677 item = pdata->items;
678 disable_irq(priv->irq);
679 cancel_delayed_work_sync(&priv->dwork_irq);
680
681 /* Mask low aggregation event, if defined. */
682 if (pdata->cell_low)
683 regmap_write(priv->regmap, pdata->cell_low +
684 MLXREG_HOTPLUG_AGGR_MASK_OFF, 0);
685
686 /* Mask aggregation event. */
687 regmap_write(priv->regmap, pdata->cell + MLXREG_HOTPLUG_AGGR_MASK_OFF,
688 0);
689
690 /* Clear topology configurations. */
691 for (i = 0; i < pdata->counter; i++, item++) {
692 data = item->data;
693 /* Mask group presense event. */
694 regmap_write(priv->regmap, data->reg + MLXREG_HOTPLUG_MASK_OFF,
695 0);
696 /* Clear group presense event. */
697 regmap_write(priv->regmap, data->reg +
698 MLXREG_HOTPLUG_EVENT_OFF, 0);
699
700 /* Remove all the attached devices in group. */
701 count = item->count;
702 for (j = 0; j < count; j++, data++)
703 mlxreg_hotplug_device_destroy(priv, data, item->kind);
704 }
705 }
706
mlxreg_hotplug_irq_handler(int irq,void * dev)707 static irqreturn_t mlxreg_hotplug_irq_handler(int irq, void *dev)
708 {
709 struct mlxreg_hotplug_priv_data *priv;
710
711 priv = (struct mlxreg_hotplug_priv_data *)dev;
712
713 /* Schedule work task for immediate execution.*/
714 schedule_delayed_work(&priv->dwork_irq, 0);
715
716 return IRQ_HANDLED;
717 }
718
mlxreg_hotplug_probe(struct platform_device * pdev)719 static int mlxreg_hotplug_probe(struct platform_device *pdev)
720 {
721 struct mlxreg_core_hotplug_platform_data *pdata;
722 struct mlxreg_hotplug_priv_data *priv;
723 struct i2c_adapter *deferred_adap;
724 int err;
725
726 pdata = dev_get_platdata(&pdev->dev);
727 if (!pdata) {
728 dev_err(&pdev->dev, "Failed to get platform data.\n");
729 return -EINVAL;
730 }
731
732 /* Defer probing if the necessary adapter is not configured yet. */
733 deferred_adap = i2c_get_adapter(pdata->deferred_nr);
734 if (!deferred_adap)
735 return -EPROBE_DEFER;
736 i2c_put_adapter(deferred_adap);
737
738 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
739 if (!priv)
740 return -ENOMEM;
741
742 if (pdata->irq) {
743 priv->irq = pdata->irq;
744 } else {
745 priv->irq = platform_get_irq(pdev, 0);
746 if (priv->irq < 0)
747 return priv->irq;
748 }
749
750 priv->regmap = pdata->regmap;
751 priv->dev = pdev->dev.parent;
752 priv->pdev = pdev;
753
754 err = devm_request_irq(&pdev->dev, priv->irq,
755 mlxreg_hotplug_irq_handler, IRQF_TRIGGER_FALLING
756 | IRQF_SHARED, "mlxreg-hotplug", priv);
757 if (err) {
758 dev_err(&pdev->dev, "Failed to request irq: %d\n", err);
759 return err;
760 }
761
762 disable_irq(priv->irq);
763 spin_lock_init(&priv->lock);
764 INIT_DELAYED_WORK(&priv->dwork_irq, mlxreg_hotplug_work_handler);
765 dev_set_drvdata(&pdev->dev, priv);
766
767 err = mlxreg_hotplug_attr_init(priv);
768 if (err) {
769 dev_err(&pdev->dev, "Failed to allocate attributes: %d\n",
770 err);
771 return err;
772 }
773
774 priv->hwmon = devm_hwmon_device_register_with_groups(&pdev->dev,
775 "mlxreg_hotplug", priv, priv->groups);
776 if (IS_ERR(priv->hwmon)) {
777 dev_err(&pdev->dev, "Failed to register hwmon device %ld\n",
778 PTR_ERR(priv->hwmon));
779 return PTR_ERR(priv->hwmon);
780 }
781
782 /* Perform initial interrupts setup. */
783 mlxreg_hotplug_set_irq(priv);
784 priv->after_probe = true;
785
786 return 0;
787 }
788
mlxreg_hotplug_remove(struct platform_device * pdev)789 static int mlxreg_hotplug_remove(struct platform_device *pdev)
790 {
791 struct mlxreg_hotplug_priv_data *priv = dev_get_drvdata(&pdev->dev);
792
793 /* Clean interrupts setup. */
794 mlxreg_hotplug_unset_irq(priv);
795 devm_free_irq(&pdev->dev, priv->irq, priv);
796
797 return 0;
798 }
799
800 static struct platform_driver mlxreg_hotplug_driver = {
801 .driver = {
802 .name = "mlxreg-hotplug",
803 },
804 .probe = mlxreg_hotplug_probe,
805 .remove = mlxreg_hotplug_remove,
806 };
807
808 module_platform_driver(mlxreg_hotplug_driver);
809
810 MODULE_AUTHOR("Vadim Pasternak <vadimp@mellanox.com>");
811 MODULE_DESCRIPTION("Mellanox regmap hotplug platform driver");
812 MODULE_LICENSE("Dual BSD/GPL");
813 MODULE_ALIAS("platform:mlxreg-hotplug");
814