Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 1 | /* |
| 2 | ads7828.c - lm_sensors driver for ads7828 12-bit 8-channel ADC |
| 3 | (C) 2007 EADS Astrium |
| 4 | |
| 5 | This driver is based on the lm75 and other lm_sensors/hwmon drivers |
| 6 | |
Steven Hardy | 5d84291 | 2011-01-12 21:55:08 +0100 | [diff] [blame] | 7 | Written by Steve Hardy <shardy@redhat.com> |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 8 | |
| 9 | Datasheet available at: http://focus.ti.com/lit/ds/symlink/ads7828.pdf |
| 10 | |
| 11 | This program is free software; you can redistribute it and/or modify |
| 12 | it under the terms of the GNU General Public License as published by |
| 13 | the Free Software Foundation; either version 2 of the License, or |
| 14 | (at your option) any later version. |
| 15 | |
| 16 | This program is distributed in the hope that it will be useful, |
| 17 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 18 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 19 | GNU General Public License for more details. |
| 20 | |
| 21 | You should have received a copy of the GNU General Public License |
| 22 | along with this program; if not, write to the Free Software |
| 23 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
| 24 | */ |
| 25 | |
| 26 | #include <linux/module.h> |
| 27 | #include <linux/init.h> |
| 28 | #include <linux/slab.h> |
| 29 | #include <linux/jiffies.h> |
| 30 | #include <linux/i2c.h> |
| 31 | #include <linux/hwmon.h> |
| 32 | #include <linux/hwmon-sysfs.h> |
| 33 | #include <linux/err.h> |
| 34 | #include <linux/mutex.h> |
| 35 | |
| 36 | /* The ADS7828 registers */ |
| 37 | #define ADS7828_NCH 8 /* 8 channels of 12-bit A-D supported */ |
| 38 | #define ADS7828_CMD_SD_SE 0x80 /* Single ended inputs */ |
| 39 | #define ADS7828_CMD_SD_DIFF 0x00 /* Differential inputs */ |
| 40 | #define ADS7828_CMD_PD0 0x0 /* Power Down between A-D conversions */ |
| 41 | #define ADS7828_CMD_PD1 0x04 /* Internal ref OFF && A-D ON */ |
| 42 | #define ADS7828_CMD_PD2 0x08 /* Internal ref ON && A-D OFF */ |
| 43 | #define ADS7828_CMD_PD3 0x0C /* Internal ref ON && A-D ON */ |
| 44 | #define ADS7828_INT_VREF_MV 2500 /* Internal vref is 2.5V, 2500mV */ |
| 45 | |
| 46 | /* Addresses to scan */ |
Mark M. Hoffman | 25e9c86 | 2008-02-17 22:28:03 -0500 | [diff] [blame] | 47 | static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 48 | I2C_CLIENT_END }; |
| 49 | |
Jean Delvare | 1f86df4 | 2009-12-14 21:17:26 +0100 | [diff] [blame] | 50 | /* Module parameters */ |
Rusty Russell | 90ab5ee | 2012-01-13 09:32:20 +1030 | [diff] [blame] | 51 | static bool se_input = 1; /* Default is SE, 0 == diff */ |
| 52 | static bool int_vref = 1; /* Default is internal ref ON */ |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 53 | static int vref_mv = ADS7828_INT_VREF_MV; /* set if vref != 2.5V */ |
| 54 | module_param(se_input, bool, S_IRUGO); |
| 55 | module_param(int_vref, bool, S_IRUGO); |
| 56 | module_param(vref_mv, int, S_IRUGO); |
| 57 | |
| 58 | /* Global Variables */ |
| 59 | static u8 ads7828_cmd_byte; /* cmd byte without channel bits */ |
| 60 | static unsigned int ads7828_lsb_resol; /* resolution of the ADC sample lsb */ |
| 61 | |
| 62 | /* Each client has this additional data */ |
| 63 | struct ads7828_data { |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 64 | struct device *hwmon_dev; |
| 65 | struct mutex update_lock; /* mutex protect updates */ |
| 66 | char valid; /* !=0 if following fields are valid */ |
| 67 | unsigned long last_updated; /* In jiffies */ |
| 68 | u16 adc_input[ADS7828_NCH]; /* ADS7828_NCH 12-bit samples */ |
| 69 | }; |
| 70 | |
| 71 | /* Function declaration - necessary due to function dependencies */ |
Jean Delvare | 310ec79 | 2009-12-14 21:17:23 +0100 | [diff] [blame] | 72 | static int ads7828_detect(struct i2c_client *client, |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 73 | struct i2c_board_info *info); |
| 74 | static int ads7828_probe(struct i2c_client *client, |
| 75 | const struct i2c_device_id *id); |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 76 | |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 77 | static inline u8 channel_cmd_byte(int ch) |
| 78 | { |
| 79 | /* cmd byte C2,C1,C0 - see datasheet */ |
| 80 | u8 cmd = (((ch>>1) | (ch&0x01)<<2)<<4); |
| 81 | cmd |= ads7828_cmd_byte; |
| 82 | return cmd; |
| 83 | } |
| 84 | |
| 85 | /* Update data for the device (all 8 channels) */ |
| 86 | static struct ads7828_data *ads7828_update_device(struct device *dev) |
| 87 | { |
| 88 | struct i2c_client *client = to_i2c_client(dev); |
| 89 | struct ads7828_data *data = i2c_get_clientdata(client); |
| 90 | |
| 91 | mutex_lock(&data->update_lock); |
| 92 | |
| 93 | if (time_after(jiffies, data->last_updated + HZ + HZ / 2) |
| 94 | || !data->valid) { |
| 95 | unsigned int ch; |
| 96 | dev_dbg(&client->dev, "Starting ads7828 update\n"); |
| 97 | |
| 98 | for (ch = 0; ch < ADS7828_NCH; ch++) { |
| 99 | u8 cmd = channel_cmd_byte(ch); |
Jean Delvare | 90f4102 | 2011-11-04 12:00:47 +0100 | [diff] [blame] | 100 | data->adc_input[ch] = |
| 101 | i2c_smbus_read_word_swapped(client, cmd); |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 102 | } |
| 103 | data->last_updated = jiffies; |
| 104 | data->valid = 1; |
| 105 | } |
| 106 | |
| 107 | mutex_unlock(&data->update_lock); |
| 108 | |
| 109 | return data; |
| 110 | } |
| 111 | |
| 112 | /* sysfs callback function */ |
| 113 | static ssize_t show_in(struct device *dev, struct device_attribute *da, |
| 114 | char *buf) |
| 115 | { |
| 116 | struct sensor_device_attribute *attr = to_sensor_dev_attr(da); |
| 117 | struct ads7828_data *data = ads7828_update_device(dev); |
| 118 | /* Print value (in mV as specified in sysfs-interface documentation) */ |
| 119 | return sprintf(buf, "%d\n", (data->adc_input[attr->index] * |
| 120 | ads7828_lsb_resol)/1000); |
| 121 | } |
| 122 | |
| 123 | #define in_reg(offset)\ |
| 124 | static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in,\ |
| 125 | NULL, offset) |
| 126 | |
| 127 | in_reg(0); |
| 128 | in_reg(1); |
| 129 | in_reg(2); |
| 130 | in_reg(3); |
| 131 | in_reg(4); |
| 132 | in_reg(5); |
| 133 | in_reg(6); |
| 134 | in_reg(7); |
| 135 | |
| 136 | static struct attribute *ads7828_attributes[] = { |
| 137 | &sensor_dev_attr_in0_input.dev_attr.attr, |
| 138 | &sensor_dev_attr_in1_input.dev_attr.attr, |
| 139 | &sensor_dev_attr_in2_input.dev_attr.attr, |
| 140 | &sensor_dev_attr_in3_input.dev_attr.attr, |
| 141 | &sensor_dev_attr_in4_input.dev_attr.attr, |
| 142 | &sensor_dev_attr_in5_input.dev_attr.attr, |
| 143 | &sensor_dev_attr_in6_input.dev_attr.attr, |
| 144 | &sensor_dev_attr_in7_input.dev_attr.attr, |
| 145 | NULL |
| 146 | }; |
| 147 | |
| 148 | static const struct attribute_group ads7828_group = { |
| 149 | .attrs = ads7828_attributes, |
| 150 | }; |
| 151 | |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 152 | static int ads7828_remove(struct i2c_client *client) |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 153 | { |
| 154 | struct ads7828_data *data = i2c_get_clientdata(client); |
| 155 | hwmon_device_unregister(data->hwmon_dev); |
| 156 | sysfs_remove_group(&client->dev.kobj, &ads7828_group); |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 157 | kfree(i2c_get_clientdata(client)); |
| 158 | return 0; |
| 159 | } |
| 160 | |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 161 | static const struct i2c_device_id ads7828_id[] = { |
Jean Delvare | 1f86df4 | 2009-12-14 21:17:26 +0100 | [diff] [blame] | 162 | { "ads7828", 0 }, |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 163 | { } |
| 164 | }; |
| 165 | MODULE_DEVICE_TABLE(i2c, ads7828_id); |
| 166 | |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 167 | /* This is the driver that will be inserted */ |
| 168 | static struct i2c_driver ads7828_driver = { |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 169 | .class = I2C_CLASS_HWMON, |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 170 | .driver = { |
| 171 | .name = "ads7828", |
| 172 | }, |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 173 | .probe = ads7828_probe, |
| 174 | .remove = ads7828_remove, |
| 175 | .id_table = ads7828_id, |
| 176 | .detect = ads7828_detect, |
Jean Delvare | c3813d6 | 2009-12-14 21:17:25 +0100 | [diff] [blame] | 177 | .address_list = normal_i2c, |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 178 | }; |
| 179 | |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 180 | /* Return 0 if detection is successful, -ENODEV otherwise */ |
Jean Delvare | 310ec79 | 2009-12-14 21:17:23 +0100 | [diff] [blame] | 181 | static int ads7828_detect(struct i2c_client *client, |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 182 | struct i2c_board_info *info) |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 183 | { |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 184 | struct i2c_adapter *adapter = client->adapter; |
Jean Delvare | 52df644 | 2009-12-09 20:35:57 +0100 | [diff] [blame] | 185 | int ch; |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 186 | |
| 187 | /* Check we have a valid client */ |
| 188 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 189 | return -ENODEV; |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 190 | |
| 191 | /* Now, we do the remaining detection. There is no identification |
| 192 | dedicated register so attempt to sanity check using knowledge of |
| 193 | the chip |
| 194 | - Read from the 8 channel addresses |
| 195 | - Check the top 4 bits of each result are not set (12 data bits) |
| 196 | */ |
Jean Delvare | 52df644 | 2009-12-09 20:35:57 +0100 | [diff] [blame] | 197 | for (ch = 0; ch < ADS7828_NCH; ch++) { |
| 198 | u16 in_data; |
| 199 | u8 cmd = channel_cmd_byte(ch); |
Jean Delvare | 90f4102 | 2011-11-04 12:00:47 +0100 | [diff] [blame] | 200 | in_data = i2c_smbus_read_word_swapped(client, cmd); |
Jean Delvare | 52df644 | 2009-12-09 20:35:57 +0100 | [diff] [blame] | 201 | if (in_data & 0xF000) { |
| 202 | pr_debug("%s : Doesn't look like an ads7828 device\n", |
| 203 | __func__); |
| 204 | return -ENODEV; |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 205 | } |
| 206 | } |
Jean Delvare | 52df644 | 2009-12-09 20:35:57 +0100 | [diff] [blame] | 207 | |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 208 | strlcpy(info->type, "ads7828", I2C_NAME_SIZE); |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 209 | |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 210 | return 0; |
| 211 | } |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 212 | |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 213 | static int ads7828_probe(struct i2c_client *client, |
| 214 | const struct i2c_device_id *id) |
| 215 | { |
| 216 | struct ads7828_data *data; |
| 217 | int err; |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 218 | |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 219 | data = kzalloc(sizeof(struct ads7828_data), GFP_KERNEL); |
| 220 | if (!data) { |
| 221 | err = -ENOMEM; |
| 222 | goto exit; |
| 223 | } |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 224 | |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 225 | i2c_set_clientdata(client, data); |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 226 | mutex_init(&data->update_lock); |
| 227 | |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 228 | /* Register sysfs hooks */ |
| 229 | err = sysfs_create_group(&client->dev.kobj, &ads7828_group); |
| 230 | if (err) |
Jean Delvare | 7347cb3 | 2008-07-16 19:30:10 +0200 | [diff] [blame] | 231 | goto exit_free; |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 232 | |
| 233 | data->hwmon_dev = hwmon_device_register(&client->dev); |
| 234 | if (IS_ERR(data->hwmon_dev)) { |
| 235 | err = PTR_ERR(data->hwmon_dev); |
| 236 | goto exit_remove; |
| 237 | } |
| 238 | |
| 239 | return 0; |
| 240 | |
| 241 | exit_remove: |
| 242 | sysfs_remove_group(&client->dev.kobj, &ads7828_group); |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 243 | exit_free: |
| 244 | kfree(data); |
| 245 | exit: |
| 246 | return err; |
| 247 | } |
| 248 | |
| 249 | static int __init sensors_ads7828_init(void) |
| 250 | { |
| 251 | /* Initialize the command byte according to module parameters */ |
| 252 | ads7828_cmd_byte = se_input ? |
| 253 | ADS7828_CMD_SD_SE : ADS7828_CMD_SD_DIFF; |
| 254 | ads7828_cmd_byte |= int_vref ? |
| 255 | ADS7828_CMD_PD3 : ADS7828_CMD_PD1; |
| 256 | |
| 257 | /* Calculate the LSB resolution */ |
| 258 | ads7828_lsb_resol = (vref_mv*1000)/4096; |
| 259 | |
| 260 | return i2c_add_driver(&ads7828_driver); |
| 261 | } |
| 262 | |
| 263 | static void __exit sensors_ads7828_exit(void) |
| 264 | { |
| 265 | i2c_del_driver(&ads7828_driver); |
| 266 | } |
| 267 | |
Steven Hardy | 5d84291 | 2011-01-12 21:55:08 +0100 | [diff] [blame] | 268 | MODULE_AUTHOR("Steve Hardy <shardy@redhat.com>"); |
Steve Hardy | 5812f92 | 2008-01-22 23:00:02 +0000 | [diff] [blame] | 269 | MODULE_DESCRIPTION("ADS7828 driver"); |
| 270 | MODULE_LICENSE("GPL"); |
| 271 | |
| 272 | module_init(sensors_ads7828_init); |
| 273 | module_exit(sensors_ads7828_exit); |