drivers/hwmon/gsc-hwmon.c

   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
  24 struct 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
  38 static struct regmap_bus gsc_hwmon_regmap_bus = {
  39         .reg_read = gsc_read,
  40         .reg_write = gsc_write,
  41 };
  42
  43 static const struct regmap_config gsc_hwmon_regmap_config = {
  44         .reg_bits = 8,
  45         .val_bits = 8,
  46         .cache_type = REGCACHE_NONE,
  47 };
  48
  49 static 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
  67 static 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
  93 static 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
 102 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point1_pwm, pwm_auto_point_pwm, 0);
 103 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point1_temp, pwm_auto_point_temp, 0);
 104
 105 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point2_pwm, pwm_auto_point_pwm, 1);
 106 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point2_temp, pwm_auto_point_temp, 1);
 107
 108 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point3_pwm, pwm_auto_point_pwm, 2);
 109 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point3_temp, pwm_auto_point_temp, 2);
 110
 111 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point4_pwm, pwm_auto_point_pwm, 3);
 112 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point4_temp, pwm_auto_point_temp, 3);
 113
 114 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point5_pwm, pwm_auto_point_pwm, 4);
 115 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point5_temp, pwm_auto_point_temp, 4);
 116
 117 static SENSOR_DEVICE_ATTR_RO(pwm1_auto_point6_pwm, pwm_auto_point_pwm, 5);
 118 static SENSOR_DEVICE_ATTR_RW(pwm1_auto_point6_temp, pwm_auto_point_temp, 5);
 119
 120 static 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
 136 static const struct attribute_group gsc_hwmon_group = {
 137         .attrs = gsc_hwmon_attributes,
 138 };
 139 __ATTRIBUTE_GROUPS(gsc_hwmon);
 140
 141 static int
 142 gsc_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
 201 static int
 202 gsc_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
 221 static umode_t
 222 gsc_hwmon_is_visible(const void *_data, enum hwmon_sensor_types type, u32 attr,
 223                      int ch)
 224 {
 225         return 0444;
 226 }
 227
 228 static 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
 234 static struct gsc_hwmon_platform_data *
 235 gsc_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
 299 static 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
 376 static const struct of_device_id gsc_hwmon_of_match[] = {
 377         { .compatible = "gw,gsc-adc", },
 378         {}
 379 };
 380
 381 static 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
 389 module_platform_driver(gsc_hwmon_driver);
 390
 391 MODULE_AUTHOR("Tim Harvey <tharvey@gateworks.com>");
 392 MODULE_DESCRIPTION("GSC hardware monitor driver");
 393 MODULE_LICENSE("GPL v2");