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