1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Driver for Gateworks System Controller Hardware Monitor module
  4 *
  5 * Copyright (C) 2020 Gateworks Corporation
  6 */
  7#include <linux/hwmon.h>
  8#include <linux/hwmon-sysfs.h>
  9#include <linux/mfd/gsc.h>
 10#include <linux/module.h>
 11#include <linux/of.h>
 12#include <linux/platform_device.h>
 13#include <linux/regmap.h>
 14#include <linux/slab.h>
 15
 16#include <linux/platform_data/gsc_hwmon.h>
 17
 18#define GSC_HWMON_MAX_TEMP_CH	16
 19#define GSC_HWMON_MAX_IN_CH	16
 20
 21#define GSC_HWMON_RESOLUTION	12
 22#define GSC_HWMON_VREF		2500
 23
 24struct gsc_hwmon_data {
 25	struct gsc_dev *gsc;
 26	struct gsc_hwmon_platform_data *pdata;
 27	struct regmap *regmap;
 28	const struct gsc_hwmon_channel *temp_ch[GSC_HWMON_MAX_TEMP_CH];
 29	const struct gsc_hwmon_channel *in_ch[GSC_HWMON_MAX_IN_CH];
 30	u32 temp_config[GSC_HWMON_MAX_TEMP_CH + 1];
 31	u32 in_config[GSC_HWMON_MAX_IN_CH + 1];
 32	struct hwmon_channel_info temp_info;
 33	struct hwmon_channel_info in_info;
 34	const struct hwmon_channel_info *info[3];
 35	struct hwmon_chip_info chip;
 36};
 37
 38static struct regmap_bus gsc_hwmon_regmap_bus = {
 39	.reg_read = gsc_read,
 40	.reg_write = gsc_write,
 41};
 42
 43static const struct regmap_config gsc_hwmon_regmap_config = {
 44	.reg_bits = 8,
 45	.val_bits = 8,
 46	.cache_type = REGCACHE_NONE,
 47};
 48
 49static ssize_t pwm_auto_point_temp_show(struct device *dev,
 50					struct device_attribute *devattr,
 51					char *buf)
 52{
 53	struct gsc_hwmon_data *hwmon = dev_get_drvdata(dev);
 54	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 55	u8 reg = hwmon->pdata->fan_base + (2 * attr->index);
 56	u8 regs[2];
 57	int ret;
 58
 59	ret = regmap_bulk_read(hwmon->regmap, reg, regs, 2);
 60	if (ret)
 61		return ret;
 62
 63	ret = regs[0] | regs[1] << 8;
 64	return sprintf(buf, "%d\n", ret * 10);
 65}
 66
 67static ssize_t pwm_auto_point_temp_store(struct device *dev,
 68					 struct device_attribute *devattr,
 69					 const char *buf, size_t count)
 70{
 71	struct gsc_hwmon_data *hwmon = dev_get_drvdata(dev);
 72	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 73	u8 reg = hwmon->pdata->fan_base + (2 * attr->index);
 74	u8 regs[2];
 75	long temp;
 76	int err;
 77
 78	if (kstrtol(buf, 10, &temp))
 79		return -EINVAL;
 80
 81	temp = clamp_val(temp, 0, 10000);
 82	temp = DIV_ROUND_CLOSEST(temp, 10);
 83
 84	regs[0] = temp & 0xff;
 85	regs[1] = (temp >> 8) & 0xff;
 86	err = regmap_bulk_write(hwmon->regmap, reg, regs, 2);
 87	if (err)
 88		return err;
 89
 90	return count;
 91}
 92
 93static ssize_t pwm_auto_point_pwm_show(struct device *dev,
 94				       struct device_attribute *devattr,
 95				       char *buf)
 96{
 97	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 98
 99	return sprintf(buf, "%d\n", 255 * (50 + (attr->index * 10)) / 100);
100}
101
102static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point1_pwm, pwm_auto_point_pwm, 0);
103static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_temp, pwm_auto_point_temp, 0);
104
105static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point2_pwm, pwm_auto_point_pwm, 1);
106static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_temp, pwm_auto_point_temp, 1);
107
108static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point3_pwm, pwm_auto_point_pwm, 2);
109static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point3_temp, pwm_auto_point_temp, 2);
110
111static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point4_pwm, pwm_auto_point_pwm, 3);
112static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point4_temp, pwm_auto_point_temp, 3);
113
114static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point5_pwm, pwm_auto_point_pwm, 4);
115static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point5_temp, pwm_auto_point_temp, 4);
116
117static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point6_pwm, pwm_auto_point_pwm, 5);
118static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point6_temp, pwm_auto_point_temp, 5);
119
120static struct attribute *gsc_hwmon_attributes[] = {
121	&sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
122	&sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
123	&sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
124	&sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
125	&sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
126	&sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
127	&sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr,
128	&sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr,
129	&sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr,
130	&sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr,
131	&sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr,
132	&sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr,
133	NULL
134};
135
136static const struct attribute_group gsc_hwmon_group = {
137	.attrs = gsc_hwmon_attributes,
138};
139__ATTRIBUTE_GROUPS(gsc_hwmon);
140
141static int
142gsc_hwmon_read(struct device *dev, enum hwmon_sensor_types type, u32 attr,
143	       int channel, long *val)
144{
145	struct gsc_hwmon_data *hwmon = dev_get_drvdata(dev);
146	const struct gsc_hwmon_channel *ch;
147	int sz, ret;
148	long tmp;
149	u8 buf[3];
150
151	switch (type) {
152	case hwmon_in:
153		ch = hwmon->in_ch[channel];
154		break;
155	case hwmon_temp:
156		ch = hwmon->temp_ch[channel];
157		break;
158	default:
159		return -EOPNOTSUPP;
160	}
161
162	sz = (ch->mode == mode_voltage_24bit) ? 3 : 2;
163	ret = regmap_bulk_read(hwmon->regmap, ch->reg, buf, sz);
164	if (ret)
165		return ret;
166
167	tmp = 0;
168	while (sz-- > 0)
169		tmp |= (buf[sz] << (8 * sz));
170
171	switch (ch->mode) {
172	case mode_temperature:
173		if (tmp > 0x8000)
174			tmp -= 0xffff;
175		tmp *= 100; /* convert to millidegrees celsius */
176		break;
177	case mode_voltage_raw:
178		tmp = clamp_val(tmp, 0, BIT(GSC_HWMON_RESOLUTION));
179		/* scale based on ref voltage and ADC resolution */
180		tmp *= GSC_HWMON_VREF;
181		tmp >>= GSC_HWMON_RESOLUTION;
182		/* scale based on optional voltage divider */
183		if (ch->vdiv[0] && ch->vdiv[1]) {
184			tmp *= (ch->vdiv[0] + ch->vdiv[1]);
185			tmp /= ch->vdiv[1];
186		}
187		/* adjust by uV offset */
188		tmp += ch->mvoffset;
189		break;
190	case mode_voltage_24bit:
191	case mode_voltage_16bit:
192		/* no adjustment needed */
193		break;
194	}
195
196	*val = tmp;
197
198	return 0;
199}
200
201static int
202gsc_hwmon_read_string(struct device *dev, enum hwmon_sensor_types type,
203		      u32 attr, int channel, const char **buf)
204{
205	struct gsc_hwmon_data *hwmon = dev_get_drvdata(dev);
206
207	switch (type) {
208	case hwmon_in:
209		*buf = hwmon->in_ch[channel]->name;
210		break;
211	case hwmon_temp:
212		*buf = hwmon->temp_ch[channel]->name;
213		break;
214	default:
215		return -ENOTSUPP;
216	}
217
218	return 0;
219}
220
221static umode_t
222gsc_hwmon_is_visible(const void *_data, enum hwmon_sensor_types type, u32 attr,
223		     int ch)
224{
225	return 0444;
226}
227
228static const struct hwmon_ops gsc_hwmon_ops = {
229	.is_visible = gsc_hwmon_is_visible,
230	.read = gsc_hwmon_read,
231	.read_string = gsc_hwmon_read_string,
232};
233
234static struct gsc_hwmon_platform_data *
235gsc_hwmon_get_devtree_pdata(struct device *dev)
236{
237	struct gsc_hwmon_platform_data *pdata;
238	struct gsc_hwmon_channel *ch;
239	struct fwnode_handle *child;
240	struct device_node *fan;
241	int nchannels;
242
243	nchannels = device_get_child_node_count(dev);
244	if (nchannels == 0)
245		return ERR_PTR(-ENODEV);
246
247	pdata = devm_kzalloc(dev,
248			     sizeof(*pdata) + nchannels * sizeof(*ch),
249			     GFP_KERNEL);
250	if (!pdata)
251		return ERR_PTR(-ENOMEM);
252	ch = (struct gsc_hwmon_channel *)(pdata + 1);
253	pdata->channels = ch;
254	pdata->nchannels = nchannels;
255
256	/* fan controller base address */
257	fan = of_find_compatible_node(dev->parent->of_node, NULL, "gw,gsc-fan");
258	if (fan && of_property_read_u32(fan, "reg", &pdata->fan_base)) {
259		dev_err(dev, "fan node without base\n");
260		return ERR_PTR(-EINVAL);
261	}
262
263	/* allocate structures for channels and count instances of each type */
264	device_for_each_child_node(dev, child) {
265		if (fwnode_property_read_string(child, "label", &ch->name)) {
266			dev_err(dev, "channel without label\n");
267			fwnode_handle_put(child);
268			return ERR_PTR(-EINVAL);
269		}
270		if (fwnode_property_read_u32(child, "reg", &ch->reg)) {
271			dev_err(dev, "channel without reg\n");
272			fwnode_handle_put(child);
273			return ERR_PTR(-EINVAL);
274		}
275		if (fwnode_property_read_u32(child, "gw,mode", &ch->mode)) {
276			dev_err(dev, "channel without mode\n");
277			fwnode_handle_put(child);
278			return ERR_PTR(-EINVAL);
279		}
280		if (ch->mode > mode_max) {
281			dev_err(dev, "invalid channel mode\n");
282			fwnode_handle_put(child);
283			return ERR_PTR(-EINVAL);
284		}
285
286		if (!fwnode_property_read_u32(child,
287					      "gw,voltage-offset-microvolt",
288					      &ch->mvoffset))
289			ch->mvoffset /= 1000;
290		fwnode_property_read_u32_array(child,
291					       "gw,voltage-divider-ohms",
292					       ch->vdiv, ARRAY_SIZE(ch->vdiv));
293		ch++;
294	}
295
296	return pdata;
297}
298
299static int gsc_hwmon_probe(struct platform_device *pdev)
300{
301	struct gsc_dev *gsc = dev_get_drvdata(pdev->dev.parent);
302	struct device *dev = &pdev->dev;
303	struct device *hwmon_dev;
304	struct gsc_hwmon_platform_data *pdata = dev_get_platdata(dev);
305	struct gsc_hwmon_data *hwmon;
306	const struct attribute_group **groups;
307	int i, i_in, i_temp;
308
309	if (!pdata) {
310		pdata = gsc_hwmon_get_devtree_pdata(dev);
311		if (IS_ERR(pdata))
312			return PTR_ERR(pdata);
313	}
314
315	hwmon = devm_kzalloc(dev, sizeof(*hwmon), GFP_KERNEL);
316	if (!hwmon)
317		return -ENOMEM;
318	hwmon->gsc = gsc;
319	hwmon->pdata = pdata;
320
321	hwmon->regmap = devm_regmap_init(dev, &gsc_hwmon_regmap_bus,
322					 gsc->i2c_hwmon,
323					 &gsc_hwmon_regmap_config);
324	if (IS_ERR(hwmon->regmap))
325		return PTR_ERR(hwmon->regmap);
326
327	for (i = 0, i_in = 0, i_temp = 0; i < hwmon->pdata->nchannels; i++) {
328		const struct gsc_hwmon_channel *ch = &pdata->channels[i];
329
330		switch (ch->mode) {
331		case mode_temperature:
332			if (i_temp == GSC_HWMON_MAX_TEMP_CH) {
333				dev_err(gsc->dev, "too many temp channels\n");
334				return -EINVAL;
335			}
336			hwmon->temp_ch[i_temp] = ch;
337			hwmon->temp_config[i_temp] = HWMON_T_INPUT |
338						     HWMON_T_LABEL;
339			i_temp++;
340			break;
341		case mode_voltage_24bit:
342		case mode_voltage_16bit:
343		case mode_voltage_raw:
344			if (i_in == GSC_HWMON_MAX_IN_CH) {
345				dev_err(gsc->dev, "too many input channels\n");
346				return -EINVAL;
347			}
348			hwmon->in_ch[i_in] = ch;
349			hwmon->in_config[i_in] =
350				HWMON_I_INPUT | HWMON_I_LABEL;
351			i_in++;
352			break;
353		default:
354			dev_err(gsc->dev, "invalid mode: %d\n", ch->mode);
355			return -EINVAL;
356		}
357	}
358
359	/* setup config structures */
360	hwmon->chip.ops = &gsc_hwmon_ops;
361	hwmon->chip.info = hwmon->info;
362	hwmon->info[0] = &hwmon->temp_info;
363	hwmon->info[1] = &hwmon->in_info;
364	hwmon->temp_info.type = hwmon_temp;
365	hwmon->temp_info.config = hwmon->temp_config;
366	hwmon->in_info.type = hwmon_in;
367	hwmon->in_info.config = hwmon->in_config;
368
369	groups = pdata->fan_base ? gsc_hwmon_groups : NULL;
370	hwmon_dev = devm_hwmon_device_register_with_info(dev,
371							 KBUILD_MODNAME, hwmon,
372							 &hwmon->chip, groups);
373	return PTR_ERR_OR_ZERO(hwmon_dev);
374}
375
376static const struct of_device_id gsc_hwmon_of_match[] = {
377	{ .compatible = "gw,gsc-adc", },
378	{}
379};
380
381static struct platform_driver gsc_hwmon_driver = {
382	.driver = {
383		.name = "gsc-hwmon",
384		.of_match_table = gsc_hwmon_of_match,
385	},
386	.probe = gsc_hwmon_probe,
387};
388
389module_platform_driver(gsc_hwmon_driver);
390
391MODULE_AUTHOR("Tim Harvey <tharvey@gateworks.com>");
392MODULE_DESCRIPTION("GSC hardware monitor driver");
393MODULE_LICENSE("GPL v2");