drivers/hwmon/pcf8591.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2001-2004 Aurelien Jarno <aurelien@aurel32.net>
   4  * Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with
   5  * the help of Jean Delvare <jdelvare@suse.de>
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/module.h>
  11 #include <linux/init.h>
  12 #include <linux/slab.h>
  13 #include <linux/i2c.h>
  14 #include <linux/mutex.h>
  15 #include <linux/err.h>
  16 #include <linux/hwmon.h>
  17 #include <linux/kstrtox.h>
  18
  19 /* Insmod parameters */
  20
  21 static int input_mode;
  22 module_param(input_mode, int, 0);
  23 MODULE_PARM_DESC(input_mode,
  24         "Analog input mode:\n"
  25         " 0 = four single ended inputs\n"
  26         " 1 = three differential inputs\n"
  27         " 2 = single ended and differential mixed\n"
  28         " 3 = two differential inputs\n");
  29
  30 /*
  31  * The PCF8591 control byte
  32  *      7    6    5    4    3    2    1    0
  33  *   |  0 |AOEF|   AIP   |  0 |AINC|  AICH   |
  34  */
  35
  36 /* Analog Output Enable Flag (analog output active if 1) */
  37 #define PCF8591_CONTROL_AOEF            0x40
  38
  39 /*
  40  * Analog Input Programming
  41  * 0x00 = four single ended inputs
  42  * 0x10 = three differential inputs
  43  * 0x20 = single ended and differential mixed
  44  * 0x30 = two differential inputs
  45  */
  46 #define PCF8591_CONTROL_AIP_MASK        0x30
  47
  48 /* Autoincrement Flag (switch on if 1) */
  49 #define PCF8591_CONTROL_AINC            0x04
  50
  51 /*
  52  * Channel selection
  53  * 0x00 = channel 0
  54  * 0x01 = channel 1
  55  * 0x02 = channel 2
  56  * 0x03 = channel 3
  57  */
  58 #define PCF8591_CONTROL_AICH_MASK       0x03
  59
  60 /* Initial values */
  61 #define PCF8591_INIT_CONTROL    ((input_mode << 4) | PCF8591_CONTROL_AOEF)
  62 #define PCF8591_INIT_AOUT       0       /* DAC out = 0 */
  63
  64 /* Conversions */
  65 #define REG_TO_SIGNED(reg)      (((reg) & 0x80) ? ((reg) - 256) : (reg))
  66
  67 struct pcf8591_data {
  68         struct device *hwmon_dev;
  69         struct mutex update_lock;
  70
  71         u8 control;
  72         u8 aout;
  73 };
  74
  75 static void pcf8591_init_client(struct i2c_client *client);
  76 static int pcf8591_read_channel(struct device *dev, int channel);
  77
  78 /* following are the sysfs callback functions */
  79 #define show_in_channel(channel)                                        \
  80 static ssize_t show_in##channel##_input(struct device *dev,             \
  81                                         struct device_attribute *attr,  \
  82                                         char *buf)                      \
  83 {                                                                       \
  84         return sprintf(buf, "%d\n", pcf8591_read_channel(dev, channel));\
  85 }                                                                       \
  86 static DEVICE_ATTR(in##channel##_input, S_IRUGO,                        \
  87                    show_in##channel##_input, NULL);
  88
  89 show_in_channel(0);
  90 show_in_channel(1);
  91 show_in_channel(2);
  92 show_in_channel(3);
  93
  94 static ssize_t out0_output_show(struct device *dev,
  95                                 struct device_attribute *attr, char *buf)
  96 {
  97         struct pcf8591_data *data = i2c_get_clientdata(to_i2c_client(dev));
  98         return sprintf(buf, "%d\n", data->aout * 10);
  99 }
 100
 101 static ssize_t out0_output_store(struct device *dev,
 102                                  struct device_attribute *attr,
 103                                  const char *buf, size_t count)
 104 {
 105         unsigned long val;
 106         struct i2c_client *client = to_i2c_client(dev);
 107         struct pcf8591_data *data = i2c_get_clientdata(client);
 108         int err;
 109
 110         err = kstrtoul(buf, 10, &val);
 111         if (err)
 112                 return err;
 113
 114         val /= 10;
 115         if (val > 255)
 116                 return -EINVAL;
 117
 118         data->aout = val;
 119         i2c_smbus_write_byte_data(client, data->control, data->aout);
 120         return count;
 121 }
 122
 123 static DEVICE_ATTR_RW(out0_output);
 124
 125 static ssize_t out0_enable_show(struct device *dev,
 126                                 struct device_attribute *attr, char *buf)
 127 {
 128         struct pcf8591_data *data = i2c_get_clientdata(to_i2c_client(dev));
 129         return sprintf(buf, "%u\n", !(!(data->control & PCF8591_CONTROL_AOEF)));
 130 }
 131
 132 static ssize_t out0_enable_store(struct device *dev,
 133                                  struct device_attribute *attr,
 134                                  const char *buf, size_t count)
 135 {
 136         struct i2c_client *client = to_i2c_client(dev);
 137         struct pcf8591_data *data = i2c_get_clientdata(client);
 138         unsigned long val;
 139         int err;
 140
 141         err = kstrtoul(buf, 10, &val);
 142         if (err)
 143                 return err;
 144
 145         mutex_lock(&data->update_lock);
 146         if (val)
 147                 data->control |= PCF8591_CONTROL_AOEF;
 148         else
 149                 data->control &= ~PCF8591_CONTROL_AOEF;
 150         i2c_smbus_write_byte(client, data->control);
 151         mutex_unlock(&data->update_lock);
 152         return count;
 153 }
 154
 155 static DEVICE_ATTR_RW(out0_enable);
 156
 157 static struct attribute *pcf8591_attributes[] = {
 158         &dev_attr_out0_enable.attr,
 159         &dev_attr_out0_output.attr,
 160         &dev_attr_in0_input.attr,
 161         &dev_attr_in1_input.attr,
 162         NULL
 163 };
 164
 165 static const struct attribute_group pcf8591_attr_group = {
 166         .attrs = pcf8591_attributes,
 167 };
 168
 169 static struct attribute *pcf8591_attributes_opt[] = {
 170         &dev_attr_in2_input.attr,
 171         &dev_attr_in3_input.attr,
 172         NULL
 173 };
 174
 175 static const struct attribute_group pcf8591_attr_group_opt = {
 176         .attrs = pcf8591_attributes_opt,
 177 };
 178
 179 /*
 180  * Real code
 181  */
 182
 183 static int pcf8591_probe(struct i2c_client *client)
 184 {
 185         struct pcf8591_data *data;
 186         int err;
 187
 188         data = devm_kzalloc(&client->dev, sizeof(struct pcf8591_data),
 189                             GFP_KERNEL);
 190         if (!data)
 191                 return -ENOMEM;
 192
 193         i2c_set_clientdata(client, data);
 194         mutex_init(&data->update_lock);
 195
 196         /* Initialize the PCF8591 chip */
 197         pcf8591_init_client(client);
 198
 199         /* Register sysfs hooks */
 200         err = sysfs_create_group(&client->dev.kobj, &pcf8591_attr_group);
 201         if (err)
 202                 return err;
 203
 204         /* Register input2 if not in "two differential inputs" mode */
 205         if (input_mode != 3) {
 206                 err = device_create_file(&client->dev, &dev_attr_in2_input);
 207                 if (err)
 208                         goto exit_sysfs_remove;
 209         }
 210
 211         /* Register input3 only in "four single ended inputs" mode */
 212         if (input_mode == 0) {
 213                 err = device_create_file(&client->dev, &dev_attr_in3_input);
 214                 if (err)
 215                         goto exit_sysfs_remove;
 216         }
 217
 218         data->hwmon_dev = hwmon_device_register(&client->dev);
 219         if (IS_ERR(data->hwmon_dev)) {
 220                 err = PTR_ERR(data->hwmon_dev);
 221                 goto exit_sysfs_remove;
 222         }
 223
 224         return 0;
 225
 226 exit_sysfs_remove:
 227         sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group_opt);
 228         sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group);
 229         return err;
 230 }
 231
 232 static void pcf8591_remove(struct i2c_client *client)
 233 {
 234         struct pcf8591_data *data = i2c_get_clientdata(client);
 235
 236         hwmon_device_unregister(data->hwmon_dev);
 237         sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group_opt);
 238         sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group);
 239 }
 240
 241 /* Called when we have found a new PCF8591. */
 242 static void pcf8591_init_client(struct i2c_client *client)
 243 {
 244         struct pcf8591_data *data = i2c_get_clientdata(client);
 245         data->control = PCF8591_INIT_CONTROL;
 246         data->aout = PCF8591_INIT_AOUT;
 247
 248         i2c_smbus_write_byte_data(client, data->control, data->aout);
 249
 250         /*
 251          * The first byte transmitted contains the conversion code of the
 252          * previous read cycle. FLUSH IT!
 253          */
 254         i2c_smbus_read_byte(client);
 255 }
 256
 257 static int pcf8591_read_channel(struct device *dev, int channel)
 258 {
 259         u8 value;
 260         struct i2c_client *client = to_i2c_client(dev);
 261         struct pcf8591_data *data = i2c_get_clientdata(client);
 262
 263         mutex_lock(&data->update_lock);
 264
 265         if ((data->control & PCF8591_CONTROL_AICH_MASK) != channel) {
 266                 data->control = (data->control & ~PCF8591_CONTROL_AICH_MASK)
 267                               | channel;
 268                 i2c_smbus_write_byte(client, data->control);
 269
 270                 /*
 271                  * The first byte transmitted contains the conversion code of
 272                  * the previous read cycle. FLUSH IT!
 273                  */
 274                 i2c_smbus_read_byte(client);
 275         }
 276         value = i2c_smbus_read_byte(client);
 277
 278         mutex_unlock(&data->update_lock);
 279
 280         if ((channel == 2 && input_mode == 2) ||
 281             (channel != 3 && (input_mode == 1 || input_mode == 3)))
 282                 return 10 * REG_TO_SIGNED(value);
 283         else
 284                 return 10 * value;
 285 }
 286
 287 static const struct i2c_device_id pcf8591_id[] = {
 288         { "pcf8591" },
 289         { }
 290 };
 291 MODULE_DEVICE_TABLE(i2c, pcf8591_id);
 292
 293 static struct i2c_driver pcf8591_driver = {
 294         .driver = {
 295                 .name   = "pcf8591",
 296         },
 297         .probe          = pcf8591_probe,
 298         .remove         = pcf8591_remove,
 299         .id_table       = pcf8591_id,
 300 };
 301
 302 static int __init pcf8591_init(void)
 303 {
 304         if (input_mode < 0 || input_mode > 3) {
 305                 pr_warn("invalid input_mode (%d)\n", input_mode);
 306                 input_mode = 0;
 307         }
 308         return i2c_add_driver(&pcf8591_driver);
 309 }
 310
 311 static void __exit pcf8591_exit(void)
 312 {
 313         i2c_del_driver(&pcf8591_driver);
 314 }
 315
 316 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>");
 317 MODULE_DESCRIPTION("PCF8591 driver");
 318 MODULE_LICENSE("GPL");
 319
 320 module_init(pcf8591_init);
 321 module_exit(pcf8591_exit);