1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Hwmon client for industrial I/O devices 3 * 4 * Copyright (c) 2011 Jonathan Cameron 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/slab.h> 9 #include <linux/mod_devicetable.h> 10 #include <linux/module.h> 11 #include <linux/err.h> 12 #include <linux/platform_device.h> 13 #include <linux/property.h> 14 15 #include <linux/hwmon.h> 16 #include <linux/hwmon-sysfs.h> 17 #include <linux/iio/consumer.h> 18 #include <linux/iio/types.h> 19 20 /** 21 * struct iio_hwmon_state - device instance state 22 * @channels: filled with array of channels from iio 23 * @num_channels: number of channels in channels (saves counting twice) 24 * @attr_group: the group of attributes 25 * @groups: null terminated array of attribute groups 26 * @attrs: null terminated array of attribute pointers. 27 */ 28 struct iio_hwmon_state { 29 struct iio_channel *channels; 30 int num_channels; 31 struct attribute_group attr_group; 32 const struct attribute_group *groups[2]; 33 struct attribute **attrs; 34 }; 35 36 static ssize_t iio_hwmon_read_label(struct device *dev, 37 struct device_attribute *attr, 38 char *buf) 39 { 40 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 41 struct iio_hwmon_state *state = dev_get_drvdata(dev); 42 struct iio_channel *chan = &state->channels[sattr->index]; 43 44 return iio_read_channel_label(chan, buf); 45 } 46 47 /* 48 * Assumes that IIO and hwmon operate in the same base units. 49 * This is supposed to be true, but needs verification for 50 * new channel types. 51 */ 52 static ssize_t iio_hwmon_read_val(struct device *dev, 53 struct device_attribute *attr, 54 char *buf) 55 { 56 int result; 57 int ret; 58 struct sensor_device_attribute *sattr = to_sensor_dev_attr(attr); 59 struct iio_hwmon_state *state = dev_get_drvdata(dev); 60 struct iio_channel *chan = &state->channels[sattr->index]; 61 enum iio_chan_type type; 62 63 ret = iio_get_channel_type(chan, &type); 64 if (ret < 0) 65 return ret; 66 67 if (type == IIO_POWER) 68 /* mili-Watts to micro-Watts conversion */ 69 ret = iio_read_channel_processed_scale(chan, &result, 1000); 70 else 71 ret = iio_read_channel_processed(chan, &result); 72 if (ret < 0) 73 return ret; 74 75 return sprintf(buf, "%d\n", result); 76 } 77 78 static int iio_hwmon_probe(struct platform_device *pdev) 79 { 80 struct device *dev = &pdev->dev; 81 struct iio_hwmon_state *st; 82 struct sensor_device_attribute *a; 83 int ret, i, attr = 0; 84 int in_i = 1, temp_i = 1, curr_i = 1, humidity_i = 1, power_i = 1; 85 enum iio_chan_type type; 86 struct iio_channel *channels; 87 struct device *hwmon_dev; 88 char *sname; 89 void *buf; 90 91 channels = devm_iio_channel_get_all(dev); 92 if (IS_ERR(channels)) { 93 ret = PTR_ERR(channels); 94 if (ret == -ENODEV) 95 ret = -EPROBE_DEFER; 96 return dev_err_probe(dev, ret, 97 "Failed to get channels\n"); 98 } 99 100 st = devm_kzalloc(dev, sizeof(*st), GFP_KERNEL); 101 buf = (void *)devm_get_free_pages(dev, GFP_KERNEL, 0); 102 if (!st || !buf) 103 return -ENOMEM; 104 105 st->channels = channels; 106 107 /* count how many channels we have */ 108 while (st->channels[st->num_channels].indio_dev) 109 st->num_channels++; 110 111 st->attrs = devm_kcalloc(dev, 112 2 * st->num_channels + 1, sizeof(*st->attrs), 113 GFP_KERNEL); 114 if (st->attrs == NULL) 115 return -ENOMEM; 116 117 for (i = 0; i < st->num_channels; i++) { 118 const char *prefix; 119 int n; 120 121 a = devm_kzalloc(dev, sizeof(*a), GFP_KERNEL); 122 if (a == NULL) 123 return -ENOMEM; 124 125 sysfs_attr_init(&a->dev_attr.attr); 126 ret = iio_get_channel_type(&st->channels[i], &type); 127 if (ret < 0) 128 return ret; 129 130 switch (type) { 131 case IIO_VOLTAGE: 132 n = in_i++; 133 prefix = "in"; 134 break; 135 case IIO_TEMP: 136 n = temp_i++; 137 prefix = "temp"; 138 break; 139 case IIO_CURRENT: 140 n = curr_i++; 141 prefix = "curr"; 142 break; 143 case IIO_POWER: 144 n = power_i++; 145 prefix = "power"; 146 break; 147 case IIO_HUMIDITYRELATIVE: 148 n = humidity_i++; 149 prefix = "humidity"; 150 break; 151 default: 152 return -EINVAL; 153 } 154 155 a->dev_attr.attr.name = devm_kasprintf(dev, GFP_KERNEL, 156 "%s%d_input", 157 prefix, n); 158 if (a->dev_attr.attr.name == NULL) 159 return -ENOMEM; 160 161 a->dev_attr.show = iio_hwmon_read_val; 162 a->dev_attr.attr.mode = 0444; 163 a->index = i; 164 st->attrs[attr++] = &a->dev_attr.attr; 165 166 /* Let's see if we have a label... */ 167 if (iio_read_channel_label(&st->channels[i], buf) < 0) 168 continue; 169 170 a = devm_kzalloc(dev, sizeof(*a), GFP_KERNEL); 171 if (a == NULL) 172 return -ENOMEM; 173 174 sysfs_attr_init(&a->dev_attr.attr); 175 a->dev_attr.attr.name = devm_kasprintf(dev, GFP_KERNEL, 176 "%s%d_label", 177 prefix, n); 178 if (!a->dev_attr.attr.name) 179 return -ENOMEM; 180 181 a->dev_attr.show = iio_hwmon_read_label; 182 a->dev_attr.attr.mode = 0444; 183 a->index = i; 184 st->attrs[attr++] = &a->dev_attr.attr; 185 } 186 187 devm_free_pages(dev, (unsigned long)buf); 188 189 st->attr_group.attrs = st->attrs; 190 st->groups[0] = &st->attr_group; 191 192 if (dev_fwnode(dev)) { 193 sname = devm_kasprintf(dev, GFP_KERNEL, "%pfwP", dev_fwnode(dev)); 194 if (!sname) 195 return -ENOMEM; 196 strreplace(sname, '-', '_'); 197 } else { 198 sname = "iio_hwmon"; 199 } 200 201 hwmon_dev = devm_hwmon_device_register_with_groups(dev, sname, st, 202 st->groups); 203 return PTR_ERR_OR_ZERO(hwmon_dev); 204 } 205 206 static const struct of_device_id iio_hwmon_of_match[] = { 207 { .compatible = "iio-hwmon", }, 208 { } 209 }; 210 MODULE_DEVICE_TABLE(of, iio_hwmon_of_match); 211 212 static struct platform_driver iio_hwmon_driver = { 213 .driver = { 214 .name = "iio_hwmon", 215 .of_match_table = iio_hwmon_of_match, 216 }, 217 .probe = iio_hwmon_probe, 218 }; 219 220 module_platform_driver(iio_hwmon_driver); 221 222 MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>"); 223 MODULE_DESCRIPTION("IIO to hwmon driver"); 224 MODULE_LICENSE("GPL v2"); 225