1 /* 2 Copyright (C) 2001-2004 Aurelien Jarno <aurelien@aurel32.net> 3 Ported to Linux 2.6 by Aurelien Jarno <aurelien@aurel32.net> with 4 the help of Jean Delvare <khali@linux-fr.org> 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 21 #include <linux/module.h> 22 #include <linux/init.h> 23 #include <linux/slab.h> 24 #include <linux/i2c.h> 25 #include <linux/mutex.h> 26 27 /* Addresses to scan */ 28 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c, 29 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 30 31 /* Insmod parameters */ 32 I2C_CLIENT_INSMOD_1(pcf8591); 33 34 static int input_mode; 35 module_param(input_mode, int, 0); 36 MODULE_PARM_DESC(input_mode, 37 "Analog input mode:\n" 38 " 0 = four single ended inputs\n" 39 " 1 = three differential inputs\n" 40 " 2 = single ended and differential mixed\n" 41 " 3 = two differential inputs\n"); 42 43 /* The PCF8591 control byte 44 7 6 5 4 3 2 1 0 45 | 0 |AOEF| AIP | 0 |AINC| AICH | */ 46 47 /* Analog Output Enable Flag (analog output active if 1) */ 48 #define PCF8591_CONTROL_AOEF 0x40 49 50 /* Analog Input Programming 51 0x00 = four single ended inputs 52 0x10 = three differential inputs 53 0x20 = single ended and differential mixed 54 0x30 = two differential inputs */ 55 #define PCF8591_CONTROL_AIP_MASK 0x30 56 57 /* Autoincrement Flag (switch on if 1) */ 58 #define PCF8591_CONTROL_AINC 0x04 59 60 /* Channel selection 61 0x00 = channel 0 62 0x01 = channel 1 63 0x02 = channel 2 64 0x03 = channel 3 */ 65 #define PCF8591_CONTROL_AICH_MASK 0x03 66 67 /* Initial values */ 68 #define PCF8591_INIT_CONTROL ((input_mode << 4) | PCF8591_CONTROL_AOEF) 69 #define PCF8591_INIT_AOUT 0 /* DAC out = 0 */ 70 71 /* Conversions */ 72 #define REG_TO_SIGNED(reg) (((reg) & 0x80)?((reg) - 256):(reg)) 73 74 struct pcf8591_data { 75 struct mutex update_lock; 76 77 u8 control; 78 u8 aout; 79 }; 80 81 static void pcf8591_init_client(struct i2c_client *client); 82 static int pcf8591_read_channel(struct device *dev, int channel); 83 84 /* following are the sysfs callback functions */ 85 #define show_in_channel(channel) \ 86 static ssize_t show_in##channel##_input(struct device *dev, struct device_attribute *attr, char *buf) \ 87 { \ 88 return sprintf(buf, "%d\n", pcf8591_read_channel(dev, channel));\ 89 } \ 90 static DEVICE_ATTR(in##channel##_input, S_IRUGO, \ 91 show_in##channel##_input, NULL); 92 93 show_in_channel(0); 94 show_in_channel(1); 95 show_in_channel(2); 96 show_in_channel(3); 97 98 static ssize_t show_out0_ouput(struct device *dev, struct device_attribute *attr, char *buf) 99 { 100 struct pcf8591_data *data = i2c_get_clientdata(to_i2c_client(dev)); 101 return sprintf(buf, "%d\n", data->aout * 10); 102 } 103 104 static ssize_t set_out0_output(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 105 { 106 unsigned int value; 107 struct i2c_client *client = to_i2c_client(dev); 108 struct pcf8591_data *data = i2c_get_clientdata(client); 109 if ((value = (simple_strtoul(buf, NULL, 10) + 5) / 10) <= 255) { 110 data->aout = value; 111 i2c_smbus_write_byte_data(client, data->control, data->aout); 112 return count; 113 } 114 return -EINVAL; 115 } 116 117 static DEVICE_ATTR(out0_output, S_IWUSR | S_IRUGO, 118 show_out0_ouput, set_out0_output); 119 120 static ssize_t show_out0_enable(struct device *dev, struct device_attribute *attr, char *buf) 121 { 122 struct pcf8591_data *data = i2c_get_clientdata(to_i2c_client(dev)); 123 return sprintf(buf, "%u\n", !(!(data->control & PCF8591_CONTROL_AOEF))); 124 } 125 126 static ssize_t set_out0_enable(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 127 { 128 struct i2c_client *client = to_i2c_client(dev); 129 struct pcf8591_data *data = i2c_get_clientdata(client); 130 unsigned long val = simple_strtoul(buf, NULL, 10); 131 132 mutex_lock(&data->update_lock); 133 if (val) 134 data->control |= PCF8591_CONTROL_AOEF; 135 else 136 data->control &= ~PCF8591_CONTROL_AOEF; 137 i2c_smbus_write_byte(client, data->control); 138 mutex_unlock(&data->update_lock); 139 return count; 140 } 141 142 static DEVICE_ATTR(out0_enable, S_IWUSR | S_IRUGO, 143 show_out0_enable, set_out0_enable); 144 145 static struct attribute *pcf8591_attributes[] = { 146 &dev_attr_out0_enable.attr, 147 &dev_attr_out0_output.attr, 148 &dev_attr_in0_input.attr, 149 &dev_attr_in1_input.attr, 150 NULL 151 }; 152 153 static const struct attribute_group pcf8591_attr_group = { 154 .attrs = pcf8591_attributes, 155 }; 156 157 static struct attribute *pcf8591_attributes_opt[] = { 158 &dev_attr_in2_input.attr, 159 &dev_attr_in3_input.attr, 160 NULL 161 }; 162 163 static const struct attribute_group pcf8591_attr_group_opt = { 164 .attrs = pcf8591_attributes_opt, 165 }; 166 167 /* 168 * Real code 169 */ 170 171 /* Return 0 if detection is successful, -ENODEV otherwise */ 172 static int pcf8591_detect(struct i2c_client *client, int kind, 173 struct i2c_board_info *info) 174 { 175 struct i2c_adapter *adapter = client->adapter; 176 177 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE 178 | I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) 179 return -ENODEV; 180 181 /* Now, we would do the remaining detection. But the PCF8591 is plainly 182 impossible to detect! Stupid chip. */ 183 184 strlcpy(info->type, "pcf8591", I2C_NAME_SIZE); 185 186 return 0; 187 } 188 189 static int pcf8591_probe(struct i2c_client *client, 190 const struct i2c_device_id *id) 191 { 192 struct pcf8591_data *data; 193 int err; 194 195 if (!(data = kzalloc(sizeof(struct pcf8591_data), GFP_KERNEL))) { 196 err = -ENOMEM; 197 goto exit; 198 } 199 200 i2c_set_clientdata(client, data); 201 mutex_init(&data->update_lock); 202 203 /* Initialize the PCF8591 chip */ 204 pcf8591_init_client(client); 205 206 /* Register sysfs hooks */ 207 err = sysfs_create_group(&client->dev.kobj, &pcf8591_attr_group); 208 if (err) 209 goto exit_kfree; 210 211 /* Register input2 if not in "two differential inputs" mode */ 212 if (input_mode != 3) { 213 if ((err = device_create_file(&client->dev, 214 &dev_attr_in2_input))) 215 goto exit_sysfs_remove; 216 } 217 218 /* Register input3 only in "four single ended inputs" mode */ 219 if (input_mode == 0) { 220 if ((err = device_create_file(&client->dev, 221 &dev_attr_in3_input))) 222 goto exit_sysfs_remove; 223 } 224 225 return 0; 226 227 exit_sysfs_remove: 228 sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group_opt); 229 sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group); 230 exit_kfree: 231 kfree(data); 232 exit: 233 return err; 234 } 235 236 static int pcf8591_remove(struct i2c_client *client) 237 { 238 sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group_opt); 239 sysfs_remove_group(&client->dev.kobj, &pcf8591_attr_group); 240 kfree(i2c_get_clientdata(client)); 241 return 0; 242 } 243 244 /* Called when we have found a new PCF8591. */ 245 static void pcf8591_init_client(struct i2c_client *client) 246 { 247 struct pcf8591_data *data = i2c_get_clientdata(client); 248 data->control = PCF8591_INIT_CONTROL; 249 data->aout = PCF8591_INIT_AOUT; 250 251 i2c_smbus_write_byte_data(client, data->control, data->aout); 252 253 /* The first byte transmitted contains the conversion code of the 254 previous read cycle. FLUSH IT! */ 255 i2c_smbus_read_byte(client); 256 } 257 258 static int pcf8591_read_channel(struct device *dev, int channel) 259 { 260 u8 value; 261 struct i2c_client *client = to_i2c_client(dev); 262 struct pcf8591_data *data = i2c_get_clientdata(client); 263 264 mutex_lock(&data->update_lock); 265 266 if ((data->control & PCF8591_CONTROL_AICH_MASK) != channel) { 267 data->control = (data->control & ~PCF8591_CONTROL_AICH_MASK) 268 | channel; 269 i2c_smbus_write_byte(client, data->control); 270 271 /* The first byte transmitted contains the conversion code of 272 the previous read cycle. FLUSH IT! */ 273 i2c_smbus_read_byte(client); 274 } 275 value = i2c_smbus_read_byte(client); 276 277 mutex_unlock(&data->update_lock); 278 279 if ((channel == 2 && input_mode == 2) || 280 (channel != 3 && (input_mode == 1 || input_mode == 3))) 281 return (10 * REG_TO_SIGNED(value)); 282 else 283 return (10 * value); 284 } 285 286 static const struct i2c_device_id pcf8591_id[] = { 287 { "pcf8591", 0 }, 288 { } 289 }; 290 MODULE_DEVICE_TABLE(i2c, pcf8591_id); 291 292 static struct i2c_driver pcf8591_driver = { 293 .driver = { 294 .name = "pcf8591", 295 }, 296 .probe = pcf8591_probe, 297 .remove = pcf8591_remove, 298 .id_table = pcf8591_id, 299 300 .class = I2C_CLASS_HWMON, /* Nearest choice */ 301 .detect = pcf8591_detect, 302 .address_data = &addr_data, 303 }; 304 305 static int __init pcf8591_init(void) 306 { 307 if (input_mode < 0 || input_mode > 3) { 308 printk(KERN_WARNING "pcf8591: invalid input_mode (%d)\n", 309 input_mode); 310 input_mode = 0; 311 } 312 return i2c_add_driver(&pcf8591_driver); 313 } 314 315 static void __exit pcf8591_exit(void) 316 { 317 i2c_del_driver(&pcf8591_driver); 318 } 319 320 MODULE_AUTHOR("Aurelien Jarno <aurelien@aurel32.net>"); 321 MODULE_DESCRIPTION("PCF8591 driver"); 322 MODULE_LICENSE("GPL"); 323 324 module_init(pcf8591_init); 325 module_exit(pcf8591_exit); 326