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", 0 }, 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_new = 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); 322