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