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 18 /* Insmod parameters */ 19 20 static int input_mode; 21 module_param(input_mode, int, 0); 22 MODULE_PARM_DESC(input_mode, 23 "Analog input mode:\n" 24 " 0 = four single ended inputs\n" 25 " 1 = three differential inputs\n" 26 " 2 = single ended and differential mixed\n" 27 " 3 = two differential inputs\n"); 28 29 /* 30 * The PCF8591 control byte 31 * 7 6 5 4 3 2 1 0 32 * | 0 |AOEF| AIP | 0 |AINC| AICH | 33 */ 34 35 /* Analog Output Enable Flag (analog output active if 1) */ 36 #define PCF8591_CONTROL_AOEF 0x40 37 38 /* 39 * Analog Input Programming 40 * 0x00 = four single ended inputs 41 * 0x10 = three differential inputs 42 * 0x20 = single ended and differential mixed 43 * 0x30 = two differential inputs 44 */ 45 #define PCF8591_CONTROL_AIP_MASK 0x30 46 47 /* Autoincrement Flag (switch on if 1) */ 48 #define PCF8591_CONTROL_AINC 0x04 49 50 /* 51 * Channel selection 52 * 0x00 = channel 0 53 * 0x01 = channel 1 54 * 0x02 = channel 2 55 * 0x03 = channel 3 56 */ 57 #define PCF8591_CONTROL_AICH_MASK 0x03 58 59 /* Initial values */ 60 #define PCF8591_INIT_CONTROL ((input_mode << 4) | PCF8591_CONTROL_AOEF) 61 #define PCF8591_INIT_AOUT 0 /* DAC out = 0 */ 62 63 /* Conversions */ 64 #define REG_TO_SIGNED(reg) (((reg) & 0x80) ? ((reg) - 256) : (reg)) 65 66 struct pcf8591_data { 67 struct device *hwmon_dev; 68 struct mutex update_lock; 69 70 u8 control; 71 u8 aout; 72 }; 73 74 static void pcf8591_init_client(struct i2c_client *client); 75 static int pcf8591_read_channel(struct device *dev, int channel); 76 77 /* following are the sysfs callback functions */ 78 #define show_in_channel(channel) \ 79 static ssize_t show_in##channel##_input(struct device *dev, \ 80 struct device_attribute *attr, \ 81 char *buf) \ 82 { \ 83 return sprintf(buf, "%d\n", pcf8591_read_channel(dev, channel));\ 84 } \ 85 static DEVICE_ATTR(in##channel##_input, S_IRUGO, \ 86 show_in##channel##_input, NULL); 87 88 show_in_channel(0); 89 show_in_channel(1); 90 show_in_channel(2); 91 show_in_channel(3); 92 93 static ssize_t out0_output_show(struct device *dev, 94 struct device_attribute *attr, char *buf) 95 { 96 struct pcf8591_data *data = i2c_get_clientdata(to_i2c_client(dev)); 97 return sprintf(buf, "%d\n", data->aout * 10); 98 } 99 100 static ssize_t out0_output_store(struct device *dev, 101 struct device_attribute *attr, 102 const char *buf, size_t count) 103 { 104 unsigned long val; 105 struct i2c_client *client = to_i2c_client(dev); 106 struct pcf8591_data *data = i2c_get_clientdata(client); 107 int err; 108 109 err = kstrtoul(buf, 10, &val); 110 if (err) 111 return err; 112 113 val /= 10; 114 if (val > 255) 115 return -EINVAL; 116 117 data->aout = val; 118 i2c_smbus_write_byte_data(client, data->control, data->aout); 119 return count; 120 } 121 122 static DEVICE_ATTR_RW(out0_output); 123 124 static ssize_t out0_enable_show(struct device *dev, 125 struct device_attribute *attr, char *buf) 126 { 127 struct pcf8591_data *data = i2c_get_clientdata(to_i2c_client(dev)); 128 return sprintf(buf, "%u\n", !(!(data->control & PCF8591_CONTROL_AOEF))); 129 } 130 131 static ssize_t out0_enable_store(struct device *dev, 132 struct device_attribute *attr, 133 const char *buf, size_t count) 134 { 135 struct i2c_client *client = to_i2c_client(dev); 136 struct pcf8591_data *data = i2c_get_clientdata(client); 137 unsigned long val; 138 int err; 139 140 err = kstrtoul(buf, 10, &val); 141 if (err) 142 return err; 143 144 mutex_lock(&data->update_lock); 145 if (val) 146 data->control |= PCF8591_CONTROL_AOEF; 147 else 148 data->control &= ~PCF8591_CONTROL_AOEF; 149 i2c_smbus_write_byte(client, data->control); 150 mutex_unlock(&data->update_lock); 151 return count; 152 } 153 154 static DEVICE_ATTR_RW(out0_enable); 155 156 static struct attribute *pcf8591_attributes[] = { 157 &dev_attr_out0_enable.attr, 158 &dev_attr_out0_output.attr, 159 &dev_attr_in0_input.attr, 160 &dev_attr_in1_input.attr, 161 NULL 162 }; 163 164 static const struct attribute_group pcf8591_attr_group = { 165 .attrs = pcf8591_attributes, 166 }; 167 168 static struct attribute *pcf8591_attributes_opt[] = { 169 &dev_attr_in2_input.attr, 170 &dev_attr_in3_input.attr, 171 NULL 172 }; 173 174 static const struct attribute_group pcf8591_attr_group_opt = { 175 .attrs = pcf8591_attributes_opt, 176 }; 177 178 /* 179 * Real code 180 */ 181 182 static int pcf8591_probe(struct i2c_client *client) 183 { 184 struct pcf8591_data *data; 185 int err; 186 187 data = devm_kzalloc(&client->dev, sizeof(struct pcf8591_data), 188 GFP_KERNEL); 189 if (!data) 190 return -ENOMEM; 191 192 i2c_set_clientdata(client, data); 193 mutex_init(&data->update_lock); 194 195 /* Initialize the PCF8591 chip */ 196 pcf8591_init_client(client); 197 198 /* Register sysfs hooks */ 199 err = sysfs_create_group(&client->dev.kobj, &pcf8591_attr_group); 200 if (err) 201 return err; 202 203 /* Register input2 if not in "two differential inputs" mode */ 204 if (input_mode != 3) { 205 err = device_create_file(&client->dev, &dev_attr_in2_input); 206 if (err) 207 goto exit_sysfs_remove; 208 } 209 210 /* Register input3 only in "four single ended inputs" mode */ 211 if (input_mode == 0) { 212 err = device_create_file(&client->dev, &dev_attr_in3_input); 213 if (err) 214 goto exit_sysfs_remove; 215 } 216 217 data->hwmon_dev = hwmon_device_register(&client->dev); 218 if (IS_ERR(data->hwmon_dev)) { 219 err = PTR_ERR(data->hwmon_dev); 220 goto exit_sysfs_remove; 221 } 222 223 return 0; 224 225 exit_sysfs_remove: 226 sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group_opt); 227 sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group); 228 return err; 229 } 230 231 static int pcf8591_remove(struct i2c_client *client) 232 { 233 struct pcf8591_data *data = i2c_get_clientdata(client); 234 235 hwmon_device_unregister(data->hwmon_dev); 236 sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group_opt); 237 sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group); 238 return 0; 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