drivers/hwmon/powr1220.c

   1 /*
   2  * powr1220.c - Driver for the Lattice POWR1220 programmable power supply
   3  * and monitor. Users can read all ADC inputs along with their labels
   4  * using the sysfs nodes.
   5  *
   6  * Copyright (c) 2014 Echo360 http://www.echo360.com
   7  * Scott Kanowitz <skanowitz@echo360.com> <scott.kanowitz@gmail.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/init.h>
  22 #include <linux/slab.h>
  23 #include <linux/jiffies.h>
  24 #include <linux/i2c.h>
  25 #include <linux/hwmon.h>
  26 #include <linux/hwmon-sysfs.h>
  27 #include <linux/err.h>
  28 #include <linux/mutex.h>
  29 #include <linux/delay.h>
  30
  31 #define ADC_STEP_MV                     2
  32 #define ADC_MAX_LOW_MEASUREMENT_MV      2000
  33
  34 enum powr1220_regs {
  35         VMON_STATUS0,
  36         VMON_STATUS1,
  37         VMON_STATUS2,
  38         OUTPUT_STATUS0,
  39         OUTPUT_STATUS1,
  40         OUTPUT_STATUS2,
  41         INPUT_STATUS,
  42         ADC_VALUE_LOW,
  43         ADC_VALUE_HIGH,
  44         ADC_MUX,
  45         UES_BYTE0,
  46         UES_BYTE1,
  47         UES_BYTE2,
  48         UES_BYTE3,
  49         GP_OUTPUT1,
  50         GP_OUTPUT2,
  51         GP_OUTPUT3,
  52         INPUT_VALUE,
  53         RESET,
  54         TRIM1_TRIM,
  55         TRIM2_TRIM,
  56         TRIM3_TRIM,
  57         TRIM4_TRIM,
  58         TRIM5_TRIM,
  59         TRIM6_TRIM,
  60         TRIM7_TRIM,
  61         TRIM8_TRIM,
  62         MAX_POWR1220_REGS
  63 };
  64
  65 enum powr1220_adc_values {
  66         VMON1,
  67         VMON2,
  68         VMON3,
  69         VMON4,
  70         VMON5,
  71         VMON6,
  72         VMON7,
  73         VMON8,
  74         VMON9,
  75         VMON10,
  76         VMON11,
  77         VMON12,
  78         VCCA,
  79         VCCINP,
  80         MAX_POWR1220_ADC_VALUES
  81 };
  82
  83 struct powr1220_data {
  84         struct i2c_client *client;
  85         struct mutex update_lock;
  86         bool adc_valid[MAX_POWR1220_ADC_VALUES];
  87          /* the next value is in jiffies */
  88         unsigned long adc_last_updated[MAX_POWR1220_ADC_VALUES];
  89
  90         /* values */
  91         int adc_maxes[MAX_POWR1220_ADC_VALUES];
  92         int adc_values[MAX_POWR1220_ADC_VALUES];
  93 };
  94
  95 static const char * const input_names[] = {
  96         [VMON1]    = "vmon1",
  97         [VMON2]    = "vmon2",
  98         [VMON3]    = "vmon3",
  99         [VMON4]    = "vmon4",
 100         [VMON5]    = "vmon5",
 101         [VMON6]    = "vmon6",
 102         [VMON7]    = "vmon7",
 103         [VMON8]    = "vmon8",
 104         [VMON9]    = "vmon9",
 105         [VMON10]   = "vmon10",
 106         [VMON11]   = "vmon11",
 107         [VMON12]   = "vmon12",
 108         [VCCA]     = "vcca",
 109         [VCCINP]   = "vccinp",
 110 };
 111
 112 /* Reads the specified ADC channel */
 113 static int powr1220_read_adc(struct device *dev, int ch_num)
 114 {
 115         struct powr1220_data *data = dev_get_drvdata(dev);
 116         int reading;
 117         int result;
 118         int adc_range = 0;
 119
 120         mutex_lock(&data->update_lock);
 121
 122         if (time_after(jiffies, data->adc_last_updated[ch_num] + HZ) ||
 123                         !data->adc_valid[ch_num]) {
 124                 /*
 125                  * figure out if we need to use the attenuator for
 126                  * high inputs or inputs that we don't yet have a measurement
 127                  * for. We dynamically set the attenuator depending on the
 128                  * max reading.
 129                  */
 130                 if (data->adc_maxes[ch_num] > ADC_MAX_LOW_MEASUREMENT_MV ||
 131                                 data->adc_maxes[ch_num] == 0)
 132                         adc_range = 1 << 4;
 133
 134                 /* set the attenuator and mux */
 135                 result = i2c_smbus_write_byte_data(data->client, ADC_MUX,
 136                                 adc_range | ch_num);
 137                 if (result)
 138                         goto exit;
 139
 140                 /*
 141                  * wait at least Tconvert time (200 us) for the
 142                  * conversion to complete
 143                  */
 144                 udelay(200);
 145
 146                 /* get the ADC reading */
 147                 result = i2c_smbus_read_byte_data(data->client, ADC_VALUE_LOW);
 148                 if (result < 0)
 149                         goto exit;
 150
 151                 reading = result >> 4;
 152
 153                 /* get the upper half of the reading */
 154                 result = i2c_smbus_read_byte_data(data->client, ADC_VALUE_HIGH);
 155                 if (result < 0)
 156                         goto exit;
 157
 158                 reading |= result << 4;
 159
 160                 /* now convert the reading to a voltage */
 161                 reading *= ADC_STEP_MV;
 162                 data->adc_values[ch_num] = reading;
 163                 data->adc_valid[ch_num] = true;
 164                 data->adc_last_updated[ch_num] = jiffies;
 165                 result = reading;
 166
 167                 if (reading > data->adc_maxes[ch_num])
 168                         data->adc_maxes[ch_num] = reading;
 169         } else {
 170                 result = data->adc_values[ch_num];
 171         }
 172
 173 exit:
 174         mutex_unlock(&data->update_lock);
 175
 176         return result;
 177 }
 178
 179 /* Shows the voltage associated with the specified ADC channel */
 180 static ssize_t powr1220_voltage_show(struct device *dev,
 181                                      struct device_attribute *dev_attr,
 182                                      char *buf)
 183 {
 184         struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 185         int adc_val = powr1220_read_adc(dev, attr->index);
 186
 187         if (adc_val < 0)
 188                 return adc_val;
 189
 190         return sprintf(buf, "%d\n", adc_val);
 191 }
 192
 193 /* Shows the maximum setting associated with the specified ADC channel */
 194 static ssize_t powr1220_max_show(struct device *dev,
 195                                  struct device_attribute *dev_attr, char *buf)
 196 {
 197         struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 198         struct powr1220_data *data = dev_get_drvdata(dev);
 199
 200         return sprintf(buf, "%d\n", data->adc_maxes[attr->index]);
 201 }
 202
 203 /* Shows the label associated with the specified ADC channel */
 204 static ssize_t powr1220_label_show(struct device *dev,
 205                                    struct device_attribute *dev_attr,
 206                                    char *buf)
 207 {
 208         struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
 209
 210         return sprintf(buf, "%s\n", input_names[attr->index]);
 211 }
 212
 213 static SENSOR_DEVICE_ATTR_RO(in0_input, powr1220_voltage, VMON1);
 214 static SENSOR_DEVICE_ATTR_RO(in1_input, powr1220_voltage, VMON2);
 215 static SENSOR_DEVICE_ATTR_RO(in2_input, powr1220_voltage, VMON3);
 216 static SENSOR_DEVICE_ATTR_RO(in3_input, powr1220_voltage, VMON4);
 217 static SENSOR_DEVICE_ATTR_RO(in4_input, powr1220_voltage, VMON5);
 218 static SENSOR_DEVICE_ATTR_RO(in5_input, powr1220_voltage, VMON6);
 219 static SENSOR_DEVICE_ATTR_RO(in6_input, powr1220_voltage, VMON7);
 220 static SENSOR_DEVICE_ATTR_RO(in7_input, powr1220_voltage, VMON8);
 221 static SENSOR_DEVICE_ATTR_RO(in8_input, powr1220_voltage, VMON9);
 222 static SENSOR_DEVICE_ATTR_RO(in9_input, powr1220_voltage, VMON10);
 223 static SENSOR_DEVICE_ATTR_RO(in10_input, powr1220_voltage, VMON11);
 224 static SENSOR_DEVICE_ATTR_RO(in11_input, powr1220_voltage, VMON12);
 225 static SENSOR_DEVICE_ATTR_RO(in12_input, powr1220_voltage, VCCA);
 226 static SENSOR_DEVICE_ATTR_RO(in13_input, powr1220_voltage, VCCINP);
 227
 228 static SENSOR_DEVICE_ATTR_RO(in0_highest, powr1220_max, VMON1);
 229 static SENSOR_DEVICE_ATTR_RO(in1_highest, powr1220_max, VMON2);
 230 static SENSOR_DEVICE_ATTR_RO(in2_highest, powr1220_max, VMON3);
 231 static SENSOR_DEVICE_ATTR_RO(in3_highest, powr1220_max, VMON4);
 232 static SENSOR_DEVICE_ATTR_RO(in4_highest, powr1220_max, VMON5);
 233 static SENSOR_DEVICE_ATTR_RO(in5_highest, powr1220_max, VMON6);
 234 static SENSOR_DEVICE_ATTR_RO(in6_highest, powr1220_max, VMON7);
 235 static SENSOR_DEVICE_ATTR_RO(in7_highest, powr1220_max, VMON8);
 236 static SENSOR_DEVICE_ATTR_RO(in8_highest, powr1220_max, VMON9);
 237 static SENSOR_DEVICE_ATTR_RO(in9_highest, powr1220_max, VMON10);
 238 static SENSOR_DEVICE_ATTR_RO(in10_highest, powr1220_max, VMON11);
 239 static SENSOR_DEVICE_ATTR_RO(in11_highest, powr1220_max, VMON12);
 240 static SENSOR_DEVICE_ATTR_RO(in12_highest, powr1220_max, VCCA);
 241 static SENSOR_DEVICE_ATTR_RO(in13_highest, powr1220_max, VCCINP);
 242
 243 static SENSOR_DEVICE_ATTR_RO(in0_label, powr1220_label, VMON1);
 244 static SENSOR_DEVICE_ATTR_RO(in1_label, powr1220_label, VMON2);
 245 static SENSOR_DEVICE_ATTR_RO(in2_label, powr1220_label, VMON3);
 246 static SENSOR_DEVICE_ATTR_RO(in3_label, powr1220_label, VMON4);
 247 static SENSOR_DEVICE_ATTR_RO(in4_label, powr1220_label, VMON5);
 248 static SENSOR_DEVICE_ATTR_RO(in5_label, powr1220_label, VMON6);
 249 static SENSOR_DEVICE_ATTR_RO(in6_label, powr1220_label, VMON7);
 250 static SENSOR_DEVICE_ATTR_RO(in7_label, powr1220_label, VMON8);
 251 static SENSOR_DEVICE_ATTR_RO(in8_label, powr1220_label, VMON9);
 252 static SENSOR_DEVICE_ATTR_RO(in9_label, powr1220_label, VMON10);
 253 static SENSOR_DEVICE_ATTR_RO(in10_label, powr1220_label, VMON11);
 254 static SENSOR_DEVICE_ATTR_RO(in11_label, powr1220_label, VMON12);
 255 static SENSOR_DEVICE_ATTR_RO(in12_label, powr1220_label, VCCA);
 256 static SENSOR_DEVICE_ATTR_RO(in13_label, powr1220_label, VCCINP);
 257
 258 static struct attribute *powr1220_attrs[] = {
 259         &sensor_dev_attr_in0_input.dev_attr.attr,
 260         &sensor_dev_attr_in1_input.dev_attr.attr,
 261         &sensor_dev_attr_in2_input.dev_attr.attr,
 262         &sensor_dev_attr_in3_input.dev_attr.attr,
 263         &sensor_dev_attr_in4_input.dev_attr.attr,
 264         &sensor_dev_attr_in5_input.dev_attr.attr,
 265         &sensor_dev_attr_in6_input.dev_attr.attr,
 266         &sensor_dev_attr_in7_input.dev_attr.attr,
 267         &sensor_dev_attr_in8_input.dev_attr.attr,
 268         &sensor_dev_attr_in9_input.dev_attr.attr,
 269         &sensor_dev_attr_in10_input.dev_attr.attr,
 270         &sensor_dev_attr_in11_input.dev_attr.attr,
 271         &sensor_dev_attr_in12_input.dev_attr.attr,
 272         &sensor_dev_attr_in13_input.dev_attr.attr,
 273
 274         &sensor_dev_attr_in0_highest.dev_attr.attr,
 275         &sensor_dev_attr_in1_highest.dev_attr.attr,
 276         &sensor_dev_attr_in2_highest.dev_attr.attr,
 277         &sensor_dev_attr_in3_highest.dev_attr.attr,
 278         &sensor_dev_attr_in4_highest.dev_attr.attr,
 279         &sensor_dev_attr_in5_highest.dev_attr.attr,
 280         &sensor_dev_attr_in6_highest.dev_attr.attr,
 281         &sensor_dev_attr_in7_highest.dev_attr.attr,
 282         &sensor_dev_attr_in8_highest.dev_attr.attr,
 283         &sensor_dev_attr_in9_highest.dev_attr.attr,
 284         &sensor_dev_attr_in10_highest.dev_attr.attr,
 285         &sensor_dev_attr_in11_highest.dev_attr.attr,
 286         &sensor_dev_attr_in12_highest.dev_attr.attr,
 287         &sensor_dev_attr_in13_highest.dev_attr.attr,
 288
 289         &sensor_dev_attr_in0_label.dev_attr.attr,
 290         &sensor_dev_attr_in1_label.dev_attr.attr,
 291         &sensor_dev_attr_in2_label.dev_attr.attr,
 292         &sensor_dev_attr_in3_label.dev_attr.attr,
 293         &sensor_dev_attr_in4_label.dev_attr.attr,
 294         &sensor_dev_attr_in5_label.dev_attr.attr,
 295         &sensor_dev_attr_in6_label.dev_attr.attr,
 296         &sensor_dev_attr_in7_label.dev_attr.attr,
 297         &sensor_dev_attr_in8_label.dev_attr.attr,
 298         &sensor_dev_attr_in9_label.dev_attr.attr,
 299         &sensor_dev_attr_in10_label.dev_attr.attr,
 300         &sensor_dev_attr_in11_label.dev_attr.attr,
 301         &sensor_dev_attr_in12_label.dev_attr.attr,
 302         &sensor_dev_attr_in13_label.dev_attr.attr,
 303
 304         NULL
 305 };
 306
 307 ATTRIBUTE_GROUPS(powr1220);
 308
 309 static int powr1220_probe(struct i2c_client *client,
 310                 const struct i2c_device_id *id)
 311 {
 312         struct powr1220_data *data;
 313         struct device *hwmon_dev;
 314
 315         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 316                 return -ENODEV;
 317
 318         data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
 319         if (!data)
 320                 return -ENOMEM;
 321
 322         mutex_init(&data->update_lock);
 323         data->client = client;
 324
 325         hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
 326                         client->name, data, powr1220_groups);
 327
 328         return PTR_ERR_OR_ZERO(hwmon_dev);
 329 }
 330
 331 static const struct i2c_device_id powr1220_ids[] = {
 332         { "powr1220", 0, },
 333         { }
 334 };
 335
 336 MODULE_DEVICE_TABLE(i2c, powr1220_ids);
 337
 338 static struct i2c_driver powr1220_driver = {
 339         .class          = I2C_CLASS_HWMON,
 340         .driver = {
 341                 .name   = "powr1220",
 342         },
 343         .probe          = powr1220_probe,
 344         .id_table       = powr1220_ids,
 345 };
 346
 347 module_i2c_driver(powr1220_driver);
 348
 349 MODULE_AUTHOR("Scott Kanowitz");
 350 MODULE_DESCRIPTION("POWR1220 driver");
 351 MODULE_LICENSE("GPL");