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 /* Mask event. */
352 ret = regmap_write(priv->regmap, item->reg + MLXREG_HOTPLUG_MASK_OFF,
353 0);
354 if (ret)
355 goto out;
356
357 /* Read status. */
358 ret = regmap_read(priv->regmap, item->reg, ®val);
359 if (ret)
360 goto out;
361
362 /* Set asserted bits and save last status. */
363 regval &= item->mask;
364 asserted = item->cache ^ regval;
365 item->cache = regval;
366 for_each_set_bit(bit, &asserted, 8) {
367 int pos;
368
369 pos = mlxreg_hotplug_item_label_index_get(item->mask, bit);
370 if (pos < 0)
371 goto out;
372
373 data = item->data + pos;
374 if (regval & BIT(bit)) {
375 if (item->inversed)
376 mlxreg_hotplug_device_destroy(priv, data, item->kind);
377 else
378 mlxreg_hotplug_device_create(priv, data, item->kind);
379 } else {
380 if (item->inversed)
381 mlxreg_hotplug_device_create(priv, data, item->kind);
382 else
383 mlxreg_hotplug_device_destroy(priv, data, item->kind);
384 }
385 }
386
387 /* Acknowledge event. */
388 ret = regmap_write(priv->regmap, item->reg + MLXREG_HOTPLUG_EVENT_OFF,
389 0);
390 if (ret)
391 goto out;
392
393 /* Unmask event. */
394 ret = regmap_write(priv->regmap, item->reg + MLXREG_HOTPLUG_MASK_OFF,
395 item->mask);
396
397 out:
398 if (ret)
399 dev_err(priv->dev, "Failed to complete workqueue.\n");
400 }
401
402 static void
mlxreg_hotplug_health_work_helper(struct mlxreg_hotplug_priv_data * priv,struct mlxreg_core_item * item)403 mlxreg_hotplug_health_work_helper(struct mlxreg_hotplug_priv_data *priv,
404 struct mlxreg_core_item *item)
405 {
406 struct mlxreg_core_data *data = item->data;
407 u32 regval;
408 int i, ret = 0;
409
410 for (i = 0; i < item->count; i++, data++) {
411 /* Mask event. */
412 ret = regmap_write(priv->regmap, data->reg +
413 MLXREG_HOTPLUG_MASK_OFF, 0);
414 if (ret)
415 goto out;
416
417 /* Read status. */
418 ret = regmap_read(priv->regmap, data->reg, ®val);
419 if (ret)
420 goto out;
421
422 regval &= data->mask;
423
424 if (item->cache == regval)
425 goto ack_event;
426
427 /*
428 * ASIC health indication is provided through two bits. Bits
429 * value 0x2 indicates that ASIC reached the good health, value
430 * 0x0 indicates ASIC the bad health or dormant state and value
431 * 0x3 indicates the booting state. During ASIC reset it should
432 * pass the following states: dormant -> booting -> good.
433 */
434 if (regval == MLXREG_HOTPLUG_GOOD_HEALTH_MASK) {
435 if (!data->attached) {
436 /*
437 * ASIC is in steady state. Connect associated
438 * device, if configured.
439 */
440 mlxreg_hotplug_device_create(priv, data, item->kind);
441 data->attached = true;
442 }
443 } else {
444 if (data->attached) {
445 /*
446 * ASIC health is failed after ASIC has been
447 * in steady state. Disconnect associated
448 * device, if it has been connected.
449 */
450 mlxreg_hotplug_device_destroy(priv, data, item->kind);
451 data->attached = false;
452 data->health_cntr = 0;
453 }
454 }
455 item->cache = regval;
456 ack_event:
457 /* Acknowledge event. */
458 ret = regmap_write(priv->regmap, data->reg +
459 MLXREG_HOTPLUG_EVENT_OFF, 0);
460 if (ret)
461 goto out;
462
463 /* Unmask event. */
464 ret = regmap_write(priv->regmap, data->reg +
465 MLXREG_HOTPLUG_MASK_OFF, data->mask);
466 if (ret)
467 goto out;
468 }
469
470 out:
471 if (ret)
472 dev_err(priv->dev, "Failed to complete workqueue.\n");
473 }
474
475 /*
476 * mlxreg_hotplug_work_handler - performs traversing of device interrupt
477 * registers according to the below hierarchy schema:
478 *
479 * Aggregation registers (status/mask)
480 * PSU registers: *---*
481 * *-----------------* | |
482 * |status/event/mask|-----> | * |
483 * *-----------------* | |
484 * Power registers: | |
485 * *-----------------* | |
486 * |status/event/mask|-----> | * |
487 * *-----------------* | |
488 * FAN registers: | |--> CPU
489 * *-----------------* | |
490 * |status/event/mask|-----> | * |
491 * *-----------------* | |
492 * ASIC registers: | |
493 * *-----------------* | |
494 * |status/event/mask|-----> | * |
495 * *-----------------* | |
496 * *---*
497 *
498 * In case some system changed are detected: FAN in/out, PSU in/out, power
499 * cable attached/detached, ASIC health good/bad, relevant device is created
500 * or destroyed.
501 */
mlxreg_hotplug_work_handler(struct work_struct * work)502 static void mlxreg_hotplug_work_handler(struct work_struct *work)
503 {
504 struct mlxreg_core_hotplug_platform_data *pdata;
505 struct mlxreg_hotplug_priv_data *priv;
506 struct mlxreg_core_item *item;
507 u32 regval, aggr_asserted;
508 unsigned long flags;
509 int i, ret;
510
511 priv = container_of(work, struct mlxreg_hotplug_priv_data,
512 dwork_irq.work);
513 pdata = dev_get_platdata(&priv->pdev->dev);
514 item = pdata->items;
515
516 /* Mask aggregation event. */
517 ret = regmap_write(priv->regmap, pdata->cell +
518 MLXREG_HOTPLUG_AGGR_MASK_OFF, 0);
519 if (ret < 0)
520 goto out;
521
522 /* Read aggregation status. */
523 ret = regmap_read(priv->regmap, pdata->cell, ®val);
524 if (ret)
525 goto out;
526
527 regval &= pdata->mask;
528 aggr_asserted = priv->aggr_cache ^ regval;
529 priv->aggr_cache = regval;
530
531 /*
532 * Handler is invoked, but no assertion is detected at top aggregation
533 * status level. Set aggr_asserted to mask value to allow handler extra
534 * run over all relevant signals to recover any missed signal.
535 */
536 if (priv->not_asserted == MLXREG_HOTPLUG_NOT_ASSERT) {
537 priv->not_asserted = 0;
538 aggr_asserted = pdata->mask;
539 }
540 if (!aggr_asserted)
541 goto unmask_event;
542
543 /* Handle topology and health configuration changes. */
544 for (i = 0; i < pdata->counter; i++, item++) {
545 if (aggr_asserted & item->aggr_mask) {
546 if (item->health)
547 mlxreg_hotplug_health_work_helper(priv, item);
548 else
549 mlxreg_hotplug_work_helper(priv, item);
550 }
551 }
552
553 spin_lock_irqsave(&priv->lock, flags);
554
555 /*
556 * It is possible, that some signals have been inserted, while
557 * interrupt has been masked by mlxreg_hotplug_work_handler. In this
558 * case such signals will be missed. In order to handle these signals
559 * delayed work is canceled and work task re-scheduled for immediate
560 * execution. It allows to handle missed signals, if any. In other case
561 * work handler just validates that no new signals have been received
562 * during masking.
563 */
564 cancel_delayed_work(&priv->dwork_irq);
565 schedule_delayed_work(&priv->dwork_irq, 0);
566
567 spin_unlock_irqrestore(&priv->lock, flags);
568
569 return;
570
571 unmask_event:
572 priv->not_asserted++;
573 /* Unmask aggregation event (no need acknowledge). */
574 ret = regmap_write(priv->regmap, pdata->cell +
575 MLXREG_HOTPLUG_AGGR_MASK_OFF, pdata->mask);
576
577 out:
578 if (ret)
579 dev_err(priv->dev, "Failed to complete workqueue.\n");
580 }
581
mlxreg_hotplug_set_irq(struct mlxreg_hotplug_priv_data * priv)582 static int mlxreg_hotplug_set_irq(struct mlxreg_hotplug_priv_data *priv)
583 {
584 struct mlxreg_core_hotplug_platform_data *pdata;
585 struct mlxreg_core_item *item;
586 struct mlxreg_core_data *data;
587 u32 regval;
588 int i, j, ret;
589
590 pdata = dev_get_platdata(&priv->pdev->dev);
591 item = pdata->items;
592
593 for (i = 0; i < pdata->counter; i++, item++) {
594 /* Clear group presense event. */
595 ret = regmap_write(priv->regmap, item->reg +
596 MLXREG_HOTPLUG_EVENT_OFF, 0);
597 if (ret)
598 goto out;
599
600 /*
601 * Verify if hardware configuration requires to disable
602 * interrupt capability for some of components.
603 */
604 data = item->data;
605 for (j = 0; j < item->count; j++, data++) {
606 /* Verify if the attribute has capability register. */
607 if (data->capability) {
608 /* Read capability register. */
609 ret = regmap_read(priv->regmap,
610 data->capability, ®val);
611 if (ret)
612 goto out;
613
614 if (!(regval & data->bit))
615 item->mask &= ~BIT(j);
616 }
617 }
618
619 /* Set group initial status as mask and unmask group event. */
620 if (item->inversed) {
621 item->cache = item->mask;
622 ret = regmap_write(priv->regmap, item->reg +
623 MLXREG_HOTPLUG_MASK_OFF,
624 item->mask);
625 if (ret)
626 goto out;
627 }
628 }
629
630 /* Keep aggregation initial status as zero and unmask events. */
631 ret = regmap_write(priv->regmap, pdata->cell +
632 MLXREG_HOTPLUG_AGGR_MASK_OFF, pdata->mask);
633 if (ret)
634 goto out;
635
636 /* Keep low aggregation initial status as zero and unmask events. */
637 if (pdata->cell_low) {
638 ret = regmap_write(priv->regmap, pdata->cell_low +
639 MLXREG_HOTPLUG_AGGR_MASK_OFF,
640 pdata->mask_low);
641 if (ret)
642 goto out;
643 }
644
645 /* Invoke work handler for initializing hot plug devices setting. */
646 mlxreg_hotplug_work_handler(&priv->dwork_irq.work);
647
648 out:
649 if (ret)
650 dev_err(priv->dev, "Failed to set interrupts.\n");
651 enable_irq(priv->irq);
652 return ret;
653 }
654
mlxreg_hotplug_unset_irq(struct mlxreg_hotplug_priv_data * priv)655 static void mlxreg_hotplug_unset_irq(struct mlxreg_hotplug_priv_data *priv)
656 {
657 struct mlxreg_core_hotplug_platform_data *pdata;
658 struct mlxreg_core_item *item;
659 struct mlxreg_core_data *data;
660 int count, i, j;
661
662 pdata = dev_get_platdata(&priv->pdev->dev);
663 item = pdata->items;
664 disable_irq(priv->irq);
665 cancel_delayed_work_sync(&priv->dwork_irq);
666
667 /* Mask low aggregation event, if defined. */
668 if (pdata->cell_low)
669 regmap_write(priv->regmap, pdata->cell_low +
670 MLXREG_HOTPLUG_AGGR_MASK_OFF, 0);
671
672 /* Mask aggregation event. */
673 regmap_write(priv->regmap, pdata->cell + MLXREG_HOTPLUG_AGGR_MASK_OFF,
674 0);
675
676 /* Clear topology configurations. */
677 for (i = 0; i < pdata->counter; i++, item++) {
678 data = item->data;
679 /* Mask group presense event. */
680 regmap_write(priv->regmap, data->reg + MLXREG_HOTPLUG_MASK_OFF,
681 0);
682 /* Clear group presense event. */
683 regmap_write(priv->regmap, data->reg +
684 MLXREG_HOTPLUG_EVENT_OFF, 0);
685
686 /* Remove all the attached devices in group. */
687 count = item->count;
688 for (j = 0; j < count; j++, data++)
689 mlxreg_hotplug_device_destroy(priv, data, item->kind);
690 }
691 }
692
mlxreg_hotplug_irq_handler(int irq,void * dev)693 static irqreturn_t mlxreg_hotplug_irq_handler(int irq, void *dev)
694 {
695 struct mlxreg_hotplug_priv_data *priv;
696
697 priv = (struct mlxreg_hotplug_priv_data *)dev;
698
699 /* Schedule work task for immediate execution.*/
700 schedule_delayed_work(&priv->dwork_irq, 0);
701
702 return IRQ_HANDLED;
703 }
704
mlxreg_hotplug_probe(struct platform_device * pdev)705 static int mlxreg_hotplug_probe(struct platform_device *pdev)
706 {
707 struct mlxreg_core_hotplug_platform_data *pdata;
708 struct mlxreg_hotplug_priv_data *priv;
709 struct i2c_adapter *deferred_adap;
710 int err;
711
712 pdata = dev_get_platdata(&pdev->dev);
713 if (!pdata) {
714 dev_err(&pdev->dev, "Failed to get platform data.\n");
715 return -EINVAL;
716 }
717
718 /* Defer probing if the necessary adapter is not configured yet. */
719 deferred_adap = i2c_get_adapter(pdata->deferred_nr);
720 if (!deferred_adap)
721 return -EPROBE_DEFER;
722 i2c_put_adapter(deferred_adap);
723
724 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
725 if (!priv)
726 return -ENOMEM;
727
728 if (pdata->irq) {
729 priv->irq = pdata->irq;
730 } else {
731 priv->irq = platform_get_irq(pdev, 0);
732 if (priv->irq < 0)
733 return priv->irq;
734 }
735
736 priv->regmap = pdata->regmap;
737 priv->dev = pdev->dev.parent;
738 priv->pdev = pdev;
739
740 err = devm_request_irq(&pdev->dev, priv->irq,
741 mlxreg_hotplug_irq_handler, IRQF_TRIGGER_FALLING
742 | IRQF_SHARED, "mlxreg-hotplug", priv);
743 if (err) {
744 dev_err(&pdev->dev, "Failed to request irq: %d\n", err);
745 return err;
746 }
747
748 disable_irq(priv->irq);
749 spin_lock_init(&priv->lock);
750 INIT_DELAYED_WORK(&priv->dwork_irq, mlxreg_hotplug_work_handler);
751 dev_set_drvdata(&pdev->dev, priv);
752
753 err = mlxreg_hotplug_attr_init(priv);
754 if (err) {
755 dev_err(&pdev->dev, "Failed to allocate attributes: %d\n",
756 err);
757 return err;
758 }
759
760 priv->hwmon = devm_hwmon_device_register_with_groups(&pdev->dev,
761 "mlxreg_hotplug", priv, priv->groups);
762 if (IS_ERR(priv->hwmon)) {
763 dev_err(&pdev->dev, "Failed to register hwmon device %ld\n",
764 PTR_ERR(priv->hwmon));
765 return PTR_ERR(priv->hwmon);
766 }
767
768 /* Perform initial interrupts setup. */
769 mlxreg_hotplug_set_irq(priv);
770 priv->after_probe = true;
771
772 return 0;
773 }
774
mlxreg_hotplug_remove(struct platform_device * pdev)775 static void mlxreg_hotplug_remove(struct platform_device *pdev)
776 {
777 struct mlxreg_hotplug_priv_data *priv = dev_get_drvdata(&pdev->dev);
778
779 /* Clean interrupts setup. */
780 mlxreg_hotplug_unset_irq(priv);
781 devm_free_irq(&pdev->dev, priv->irq, priv);
782 }
783
784 static struct platform_driver mlxreg_hotplug_driver = {
785 .driver = {
786 .name = "mlxreg-hotplug",
787 },
788 .probe = mlxreg_hotplug_probe,
789 .remove_new = mlxreg_hotplug_remove,
790 };
791
792 module_platform_driver(mlxreg_hotplug_driver);
793
794 MODULE_AUTHOR("Vadim Pasternak <vadimp@mellanox.com>");
795 MODULE_DESCRIPTION("Mellanox regmap hotplug platform driver");
796 MODULE_LICENSE("Dual BSD/GPL");
797 MODULE_ALIAS("platform:mlxreg-hotplug");
798