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