1 /* 2 * Driver for the ADT7411 (I2C/SPI 8 channel 10 bit ADC & temperature-sensor) 3 * 4 * Copyright (C) 2008, 2010 Pengutronix 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 version 2 as 8 * published by the Free Software Foundation. 9 * 10 * TODO: SPI, support for external temperature sensor 11 * use power-down mode for suspend?, interrupt handling? 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/init.h> 17 #include <linux/err.h> 18 #include <linux/mutex.h> 19 #include <linux/jiffies.h> 20 #include <linux/i2c.h> 21 #include <linux/hwmon.h> 22 #include <linux/hwmon-sysfs.h> 23 #include <linux/slab.h> 24 25 #define ADT7411_REG_INT_TEMP_VDD_LSB 0x03 26 #define ADT7411_REG_EXT_TEMP_AIN14_LSB 0x04 27 #define ADT7411_REG_VDD_MSB 0x06 28 #define ADT7411_REG_INT_TEMP_MSB 0x07 29 #define ADT7411_REG_EXT_TEMP_AIN1_MSB 0x08 30 31 #define ADT7411_REG_CFG1 0x18 32 #define ADT7411_CFG1_START_MONITOR (1 << 0) 33 34 #define ADT7411_REG_CFG2 0x19 35 #define ADT7411_CFG2_DISABLE_AVG (1 << 5) 36 37 #define ADT7411_REG_CFG3 0x1a 38 #define ADT7411_CFG3_ADC_CLK_225 (1 << 0) 39 #define ADT7411_CFG3_REF_VDD (1 << 4) 40 41 #define ADT7411_REG_DEVICE_ID 0x4d 42 #define ADT7411_REG_MANUFACTURER_ID 0x4e 43 44 #define ADT7411_DEVICE_ID 0x2 45 #define ADT7411_MANUFACTURER_ID 0x41 46 47 static const unsigned short normal_i2c[] = { 0x48, 0x4a, 0x4b, I2C_CLIENT_END }; 48 49 struct adt7411_data { 50 struct mutex device_lock; /* for "atomic" device accesses */ 51 struct mutex update_lock; 52 unsigned long next_update; 53 int vref_cached; 54 struct i2c_client *client; 55 }; 56 57 /* 58 * When reading a register containing (up to 4) lsb, all associated 59 * msb-registers get locked by the hardware. After _one_ of those msb is read, 60 * _all_ are unlocked. In order to use this locking correctly, reading lsb/msb 61 * is protected here with a mutex, too. 62 */ 63 static int adt7411_read_10_bit(struct i2c_client *client, u8 lsb_reg, 64 u8 msb_reg, u8 lsb_shift) 65 { 66 struct adt7411_data *data = i2c_get_clientdata(client); 67 int val, tmp; 68 69 mutex_lock(&data->device_lock); 70 71 val = i2c_smbus_read_byte_data(client, lsb_reg); 72 if (val < 0) 73 goto exit_unlock; 74 75 tmp = (val >> lsb_shift) & 3; 76 val = i2c_smbus_read_byte_data(client, msb_reg); 77 78 if (val >= 0) 79 val = (val << 2) | tmp; 80 81 exit_unlock: 82 mutex_unlock(&data->device_lock); 83 84 return val; 85 } 86 87 static int adt7411_modify_bit(struct i2c_client *client, u8 reg, u8 bit, 88 bool flag) 89 { 90 struct adt7411_data *data = i2c_get_clientdata(client); 91 int ret, val; 92 93 mutex_lock(&data->device_lock); 94 95 ret = i2c_smbus_read_byte_data(client, reg); 96 if (ret < 0) 97 goto exit_unlock; 98 99 if (flag) 100 val = ret | bit; 101 else 102 val = ret & ~bit; 103 104 ret = i2c_smbus_write_byte_data(client, reg, val); 105 106 exit_unlock: 107 mutex_unlock(&data->device_lock); 108 return ret; 109 } 110 111 static ssize_t adt7411_show_vdd(struct device *dev, 112 struct device_attribute *attr, char *buf) 113 { 114 struct adt7411_data *data = dev_get_drvdata(dev); 115 struct i2c_client *client = data->client; 116 int ret = adt7411_read_10_bit(client, ADT7411_REG_INT_TEMP_VDD_LSB, 117 ADT7411_REG_VDD_MSB, 2); 118 119 return ret < 0 ? ret : sprintf(buf, "%u\n", ret * 7000 / 1024); 120 } 121 122 static ssize_t adt7411_show_temp(struct device *dev, 123 struct device_attribute *attr, char *buf) 124 { 125 struct adt7411_data *data = dev_get_drvdata(dev); 126 struct i2c_client *client = data->client; 127 int val = adt7411_read_10_bit(client, ADT7411_REG_INT_TEMP_VDD_LSB, 128 ADT7411_REG_INT_TEMP_MSB, 0); 129 130 if (val < 0) 131 return val; 132 133 val = val & 0x200 ? val - 0x400 : val; /* 10 bit signed */ 134 135 return sprintf(buf, "%d\n", val * 250); 136 } 137 138 static ssize_t adt7411_show_input(struct device *dev, 139 struct device_attribute *attr, char *buf) 140 { 141 int nr = to_sensor_dev_attr(attr)->index; 142 struct adt7411_data *data = dev_get_drvdata(dev); 143 struct i2c_client *client = data->client; 144 int val; 145 u8 lsb_reg, lsb_shift; 146 147 mutex_lock(&data->update_lock); 148 if (time_after_eq(jiffies, data->next_update)) { 149 val = i2c_smbus_read_byte_data(client, ADT7411_REG_CFG3); 150 if (val < 0) 151 goto exit_unlock; 152 153 if (val & ADT7411_CFG3_REF_VDD) { 154 val = adt7411_read_10_bit(client, 155 ADT7411_REG_INT_TEMP_VDD_LSB, 156 ADT7411_REG_VDD_MSB, 2); 157 if (val < 0) 158 goto exit_unlock; 159 160 data->vref_cached = val * 7000 / 1024; 161 } else { 162 data->vref_cached = 2250; 163 } 164 165 data->next_update = jiffies + HZ; 166 } 167 168 lsb_reg = ADT7411_REG_EXT_TEMP_AIN14_LSB + (nr >> 2); 169 lsb_shift = 2 * (nr & 0x03); 170 val = adt7411_read_10_bit(client, lsb_reg, 171 ADT7411_REG_EXT_TEMP_AIN1_MSB + nr, lsb_shift); 172 if (val < 0) 173 goto exit_unlock; 174 175 val = sprintf(buf, "%u\n", val * data->vref_cached / 1024); 176 exit_unlock: 177 mutex_unlock(&data->update_lock); 178 return val; 179 } 180 181 static ssize_t adt7411_show_bit(struct device *dev, 182 struct device_attribute *attr, char *buf) 183 { 184 struct sensor_device_attribute_2 *attr2 = to_sensor_dev_attr_2(attr); 185 struct adt7411_data *data = dev_get_drvdata(dev); 186 struct i2c_client *client = data->client; 187 int ret = i2c_smbus_read_byte_data(client, attr2->index); 188 189 return ret < 0 ? ret : sprintf(buf, "%u\n", !!(ret & attr2->nr)); 190 } 191 192 static ssize_t adt7411_set_bit(struct device *dev, 193 struct device_attribute *attr, const char *buf, 194 size_t count) 195 { 196 struct sensor_device_attribute_2 *s_attr2 = to_sensor_dev_attr_2(attr); 197 struct adt7411_data *data = dev_get_drvdata(dev); 198 struct i2c_client *client = data->client; 199 int ret; 200 unsigned long flag; 201 202 ret = kstrtoul(buf, 0, &flag); 203 if (ret || flag > 1) 204 return -EINVAL; 205 206 ret = adt7411_modify_bit(client, s_attr2->index, s_attr2->nr, flag); 207 208 /* force update */ 209 mutex_lock(&data->update_lock); 210 data->next_update = jiffies; 211 mutex_unlock(&data->update_lock); 212 213 return ret < 0 ? ret : count; 214 } 215 216 #define ADT7411_BIT_ATTR(__name, __reg, __bit) \ 217 SENSOR_DEVICE_ATTR_2(__name, S_IRUGO | S_IWUSR, adt7411_show_bit, \ 218 adt7411_set_bit, __bit, __reg) 219 220 static DEVICE_ATTR(temp1_input, S_IRUGO, adt7411_show_temp, NULL); 221 static DEVICE_ATTR(in0_input, S_IRUGO, adt7411_show_vdd, NULL); 222 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, adt7411_show_input, NULL, 0); 223 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, adt7411_show_input, NULL, 1); 224 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, adt7411_show_input, NULL, 2); 225 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, adt7411_show_input, NULL, 3); 226 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, adt7411_show_input, NULL, 4); 227 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, adt7411_show_input, NULL, 5); 228 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, adt7411_show_input, NULL, 6); 229 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, adt7411_show_input, NULL, 7); 230 static ADT7411_BIT_ATTR(no_average, ADT7411_REG_CFG2, ADT7411_CFG2_DISABLE_AVG); 231 static ADT7411_BIT_ATTR(fast_sampling, ADT7411_REG_CFG3, ADT7411_CFG3_ADC_CLK_225); 232 static ADT7411_BIT_ATTR(adc_ref_vdd, ADT7411_REG_CFG3, ADT7411_CFG3_REF_VDD); 233 234 static struct attribute *adt7411_attrs[] = { 235 &dev_attr_temp1_input.attr, 236 &dev_attr_in0_input.attr, 237 &sensor_dev_attr_in1_input.dev_attr.attr, 238 &sensor_dev_attr_in2_input.dev_attr.attr, 239 &sensor_dev_attr_in3_input.dev_attr.attr, 240 &sensor_dev_attr_in4_input.dev_attr.attr, 241 &sensor_dev_attr_in5_input.dev_attr.attr, 242 &sensor_dev_attr_in6_input.dev_attr.attr, 243 &sensor_dev_attr_in7_input.dev_attr.attr, 244 &sensor_dev_attr_in8_input.dev_attr.attr, 245 &sensor_dev_attr_no_average.dev_attr.attr, 246 &sensor_dev_attr_fast_sampling.dev_attr.attr, 247 &sensor_dev_attr_adc_ref_vdd.dev_attr.attr, 248 NULL 249 }; 250 251 ATTRIBUTE_GROUPS(adt7411); 252 253 static int adt7411_detect(struct i2c_client *client, 254 struct i2c_board_info *info) 255 { 256 int val; 257 258 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 259 return -ENODEV; 260 261 val = i2c_smbus_read_byte_data(client, ADT7411_REG_MANUFACTURER_ID); 262 if (val < 0 || val != ADT7411_MANUFACTURER_ID) { 263 dev_dbg(&client->dev, 264 "Wrong manufacturer ID. Got %d, expected %d\n", 265 val, ADT7411_MANUFACTURER_ID); 266 return -ENODEV; 267 } 268 269 val = i2c_smbus_read_byte_data(client, ADT7411_REG_DEVICE_ID); 270 if (val < 0 || val != ADT7411_DEVICE_ID) { 271 dev_dbg(&client->dev, 272 "Wrong device ID. Got %d, expected %d\n", 273 val, ADT7411_DEVICE_ID); 274 return -ENODEV; 275 } 276 277 strlcpy(info->type, "adt7411", I2C_NAME_SIZE); 278 279 return 0; 280 } 281 282 static int adt7411_probe(struct i2c_client *client, 283 const struct i2c_device_id *id) 284 { 285 struct device *dev = &client->dev; 286 struct adt7411_data *data; 287 struct device *hwmon_dev; 288 int ret; 289 290 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 291 if (!data) 292 return -ENOMEM; 293 294 i2c_set_clientdata(client, data); 295 data->client = client; 296 mutex_init(&data->device_lock); 297 mutex_init(&data->update_lock); 298 299 ret = adt7411_modify_bit(client, ADT7411_REG_CFG1, 300 ADT7411_CFG1_START_MONITOR, 1); 301 if (ret < 0) 302 return ret; 303 304 /* force update on first occasion */ 305 data->next_update = jiffies; 306 307 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 308 data, 309 adt7411_groups); 310 return PTR_ERR_OR_ZERO(hwmon_dev); 311 } 312 313 static const struct i2c_device_id adt7411_id[] = { 314 { "adt7411", 0 }, 315 { } 316 }; 317 MODULE_DEVICE_TABLE(i2c, adt7411_id); 318 319 static struct i2c_driver adt7411_driver = { 320 .driver = { 321 .name = "adt7411", 322 }, 323 .probe = adt7411_probe, 324 .id_table = adt7411_id, 325 .detect = adt7411_detect, 326 .address_list = normal_i2c, 327 .class = I2C_CLASS_HWMON, 328 }; 329 330 module_i2c_driver(adt7411_driver); 331 332 MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de> and " 333 "Wolfram Sang <w.sang@pengutronix.de>"); 334 MODULE_DESCRIPTION("ADT7411 driver"); 335 MODULE_LICENSE("GPL v2"); 336