1 /* 2 * Driver for TI ADC128D818 System Monitor with Temperature Sensor 3 * 4 * Copyright (c) 2014 Guenter Roeck 5 * 6 * Derived from lm80.c 7 * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 8 * and Philip Edelbrock <phil@netroedge.com> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 */ 20 21 #include <linux/module.h> 22 #include <linux/slab.h> 23 #include <linux/jiffies.h> 24 #include <linux/i2c.h> 25 #include <linux/hwmon.h> 26 #include <linux/hwmon-sysfs.h> 27 #include <linux/err.h> 28 #include <linux/regulator/consumer.h> 29 #include <linux/mutex.h> 30 #include <linux/bitops.h> 31 32 /* Addresses to scan 33 * The chip also supports addresses 0x35..0x37. Don't scan those addresses 34 * since they are also used by some EEPROMs, which may result in false 35 * positives. 36 */ 37 static const unsigned short normal_i2c[] = { 38 0x1d, 0x1e, 0x1f, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END }; 39 40 /* registers */ 41 #define ADC128_REG_IN_MAX(nr) (0x2a + (nr) * 2) 42 #define ADC128_REG_IN_MIN(nr) (0x2b + (nr) * 2) 43 #define ADC128_REG_IN(nr) (0x20 + (nr)) 44 45 #define ADC128_REG_TEMP 0x27 46 #define ADC128_REG_TEMP_MAX 0x38 47 #define ADC128_REG_TEMP_HYST 0x39 48 49 #define ADC128_REG_CONFIG 0x00 50 #define ADC128_REG_ALARM 0x01 51 #define ADC128_REG_MASK 0x03 52 #define ADC128_REG_CONV_RATE 0x07 53 #define ADC128_REG_ONESHOT 0x09 54 #define ADC128_REG_SHUTDOWN 0x0a 55 #define ADC128_REG_CONFIG_ADV 0x0b 56 #define ADC128_REG_BUSY_STATUS 0x0c 57 58 #define ADC128_REG_MAN_ID 0x3e 59 #define ADC128_REG_DEV_ID 0x3f 60 61 struct adc128_data { 62 struct i2c_client *client; 63 struct regulator *regulator; 64 int vref; /* Reference voltage in mV */ 65 struct mutex update_lock; 66 bool valid; /* true if following fields are valid */ 67 unsigned long last_updated; /* In jiffies */ 68 69 u16 in[3][7]; /* Register value, normalized to 12 bit 70 * 0: input voltage 71 * 1: min limit 72 * 2: max limit 73 */ 74 s16 temp[3]; /* Register value, normalized to 9 bit 75 * 0: sensor 1: limit 2: hyst 76 */ 77 u8 alarms; /* alarm register value */ 78 }; 79 80 static struct adc128_data *adc128_update_device(struct device *dev) 81 { 82 struct adc128_data *data = dev_get_drvdata(dev); 83 struct i2c_client *client = data->client; 84 struct adc128_data *ret = data; 85 int i, rv; 86 87 mutex_lock(&data->update_lock); 88 89 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { 90 for (i = 0; i < 7; i++) { 91 rv = i2c_smbus_read_word_swapped(client, 92 ADC128_REG_IN(i)); 93 if (rv < 0) 94 goto abort; 95 data->in[0][i] = rv >> 4; 96 97 rv = i2c_smbus_read_byte_data(client, 98 ADC128_REG_IN_MIN(i)); 99 if (rv < 0) 100 goto abort; 101 data->in[1][i] = rv << 4; 102 103 rv = i2c_smbus_read_byte_data(client, 104 ADC128_REG_IN_MAX(i)); 105 if (rv < 0) 106 goto abort; 107 data->in[2][i] = rv << 4; 108 } 109 110 rv = i2c_smbus_read_word_swapped(client, ADC128_REG_TEMP); 111 if (rv < 0) 112 goto abort; 113 data->temp[0] = rv >> 7; 114 115 rv = i2c_smbus_read_byte_data(client, ADC128_REG_TEMP_MAX); 116 if (rv < 0) 117 goto abort; 118 data->temp[1] = rv << 1; 119 120 rv = i2c_smbus_read_byte_data(client, ADC128_REG_TEMP_HYST); 121 if (rv < 0) 122 goto abort; 123 data->temp[2] = rv << 1; 124 125 rv = i2c_smbus_read_byte_data(client, ADC128_REG_ALARM); 126 if (rv < 0) 127 goto abort; 128 data->alarms |= rv; 129 130 data->last_updated = jiffies; 131 data->valid = true; 132 } 133 goto done; 134 135 abort: 136 ret = ERR_PTR(rv); 137 data->valid = false; 138 done: 139 mutex_unlock(&data->update_lock); 140 return ret; 141 } 142 143 static ssize_t adc128_show_in(struct device *dev, struct device_attribute *attr, 144 char *buf) 145 { 146 struct adc128_data *data = adc128_update_device(dev); 147 int index = to_sensor_dev_attr_2(attr)->index; 148 int nr = to_sensor_dev_attr_2(attr)->nr; 149 int val; 150 151 if (IS_ERR(data)) 152 return PTR_ERR(data); 153 154 val = DIV_ROUND_CLOSEST(data->in[index][nr] * data->vref, 4095); 155 return sprintf(buf, "%d\n", val); 156 } 157 158 static ssize_t adc128_set_in(struct device *dev, struct device_attribute *attr, 159 const char *buf, size_t count) 160 { 161 struct adc128_data *data = dev_get_drvdata(dev); 162 int index = to_sensor_dev_attr_2(attr)->index; 163 int nr = to_sensor_dev_attr_2(attr)->nr; 164 u8 reg, regval; 165 long val; 166 int err; 167 168 err = kstrtol(buf, 10, &val); 169 if (err < 0) 170 return err; 171 172 mutex_lock(&data->update_lock); 173 /* 10 mV LSB on limit registers */ 174 regval = clamp_val(DIV_ROUND_CLOSEST(val, 10), 0, 255); 175 data->in[index][nr] = regval << 4; 176 reg = index == 1 ? ADC128_REG_IN_MIN(nr) : ADC128_REG_IN_MAX(nr); 177 i2c_smbus_write_byte_data(data->client, reg, regval); 178 mutex_unlock(&data->update_lock); 179 180 return count; 181 } 182 183 static ssize_t adc128_show_temp(struct device *dev, 184 struct device_attribute *attr, char *buf) 185 { 186 struct adc128_data *data = adc128_update_device(dev); 187 int index = to_sensor_dev_attr(attr)->index; 188 int temp; 189 190 if (IS_ERR(data)) 191 return PTR_ERR(data); 192 193 temp = sign_extend32(data->temp[index], 8); 194 return sprintf(buf, "%d\n", temp * 500);/* 0.5 degrees C resolution */ 195 } 196 197 static ssize_t adc128_set_temp(struct device *dev, 198 struct device_attribute *attr, 199 const char *buf, size_t count) 200 { 201 struct adc128_data *data = dev_get_drvdata(dev); 202 int index = to_sensor_dev_attr(attr)->index; 203 long val; 204 int err; 205 s8 regval; 206 207 err = kstrtol(buf, 10, &val); 208 if (err < 0) 209 return err; 210 211 mutex_lock(&data->update_lock); 212 regval = clamp_val(DIV_ROUND_CLOSEST(val, 1000), -128, 127); 213 data->temp[index] = regval << 1; 214 i2c_smbus_write_byte_data(data->client, 215 index == 1 ? ADC128_REG_TEMP_MAX 216 : ADC128_REG_TEMP_HYST, 217 regval); 218 mutex_unlock(&data->update_lock); 219 220 return count; 221 } 222 223 static ssize_t adc128_show_alarm(struct device *dev, 224 struct device_attribute *attr, char *buf) 225 { 226 struct adc128_data *data = adc128_update_device(dev); 227 int mask = 1 << to_sensor_dev_attr(attr)->index; 228 u8 alarms; 229 230 if (IS_ERR(data)) 231 return PTR_ERR(data); 232 233 /* 234 * Clear an alarm after reporting it to user space. If it is still 235 * active, the next update sequence will set the alarm bit again. 236 */ 237 alarms = data->alarms; 238 data->alarms &= ~mask; 239 240 return sprintf(buf, "%u\n", !!(alarms & mask)); 241 } 242 243 static SENSOR_DEVICE_ATTR_2(in0_input, S_IRUGO, 244 adc128_show_in, NULL, 0, 0); 245 static SENSOR_DEVICE_ATTR_2(in0_min, S_IWUSR | S_IRUGO, 246 adc128_show_in, adc128_set_in, 0, 1); 247 static SENSOR_DEVICE_ATTR_2(in0_max, S_IWUSR | S_IRUGO, 248 adc128_show_in, adc128_set_in, 0, 2); 249 250 static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, 251 adc128_show_in, NULL, 1, 0); 252 static SENSOR_DEVICE_ATTR_2(in1_min, S_IWUSR | S_IRUGO, 253 adc128_show_in, adc128_set_in, 1, 1); 254 static SENSOR_DEVICE_ATTR_2(in1_max, S_IWUSR | S_IRUGO, 255 adc128_show_in, adc128_set_in, 1, 2); 256 257 static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, 258 adc128_show_in, NULL, 2, 0); 259 static SENSOR_DEVICE_ATTR_2(in2_min, S_IWUSR | S_IRUGO, 260 adc128_show_in, adc128_set_in, 2, 1); 261 static SENSOR_DEVICE_ATTR_2(in2_max, S_IWUSR | S_IRUGO, 262 adc128_show_in, adc128_set_in, 2, 2); 263 264 static SENSOR_DEVICE_ATTR_2(in3_input, S_IRUGO, 265 adc128_show_in, NULL, 3, 0); 266 static SENSOR_DEVICE_ATTR_2(in3_min, S_IWUSR | S_IRUGO, 267 adc128_show_in, adc128_set_in, 3, 1); 268 static SENSOR_DEVICE_ATTR_2(in3_max, S_IWUSR | S_IRUGO, 269 adc128_show_in, adc128_set_in, 3, 2); 270 271 static SENSOR_DEVICE_ATTR_2(in4_input, S_IRUGO, 272 adc128_show_in, NULL, 4, 0); 273 static SENSOR_DEVICE_ATTR_2(in4_min, S_IWUSR | S_IRUGO, 274 adc128_show_in, adc128_set_in, 4, 1); 275 static SENSOR_DEVICE_ATTR_2(in4_max, S_IWUSR | S_IRUGO, 276 adc128_show_in, adc128_set_in, 4, 2); 277 278 static SENSOR_DEVICE_ATTR_2(in5_input, S_IRUGO, 279 adc128_show_in, NULL, 5, 0); 280 static SENSOR_DEVICE_ATTR_2(in5_min, S_IWUSR | S_IRUGO, 281 adc128_show_in, adc128_set_in, 5, 1); 282 static SENSOR_DEVICE_ATTR_2(in5_max, S_IWUSR | S_IRUGO, 283 adc128_show_in, adc128_set_in, 5, 2); 284 285 static SENSOR_DEVICE_ATTR_2(in6_input, S_IRUGO, 286 adc128_show_in, NULL, 6, 0); 287 static SENSOR_DEVICE_ATTR_2(in6_min, S_IWUSR | S_IRUGO, 288 adc128_show_in, adc128_set_in, 6, 1); 289 static SENSOR_DEVICE_ATTR_2(in6_max, S_IWUSR | S_IRUGO, 290 adc128_show_in, adc128_set_in, 6, 2); 291 292 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, adc128_show_temp, NULL, 0); 293 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, 294 adc128_show_temp, adc128_set_temp, 1); 295 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, 296 adc128_show_temp, adc128_set_temp, 2); 297 298 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, adc128_show_alarm, NULL, 0); 299 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, adc128_show_alarm, NULL, 1); 300 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, adc128_show_alarm, NULL, 2); 301 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, adc128_show_alarm, NULL, 3); 302 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, adc128_show_alarm, NULL, 4); 303 static SENSOR_DEVICE_ATTR(in5_alarm, S_IRUGO, adc128_show_alarm, NULL, 5); 304 static SENSOR_DEVICE_ATTR(in6_alarm, S_IRUGO, adc128_show_alarm, NULL, 6); 305 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, adc128_show_alarm, NULL, 7); 306 307 static struct attribute *adc128_attrs[] = { 308 &sensor_dev_attr_in0_min.dev_attr.attr, 309 &sensor_dev_attr_in1_min.dev_attr.attr, 310 &sensor_dev_attr_in2_min.dev_attr.attr, 311 &sensor_dev_attr_in3_min.dev_attr.attr, 312 &sensor_dev_attr_in4_min.dev_attr.attr, 313 &sensor_dev_attr_in5_min.dev_attr.attr, 314 &sensor_dev_attr_in6_min.dev_attr.attr, 315 &sensor_dev_attr_in0_max.dev_attr.attr, 316 &sensor_dev_attr_in1_max.dev_attr.attr, 317 &sensor_dev_attr_in2_max.dev_attr.attr, 318 &sensor_dev_attr_in3_max.dev_attr.attr, 319 &sensor_dev_attr_in4_max.dev_attr.attr, 320 &sensor_dev_attr_in5_max.dev_attr.attr, 321 &sensor_dev_attr_in6_max.dev_attr.attr, 322 &sensor_dev_attr_in0_input.dev_attr.attr, 323 &sensor_dev_attr_in1_input.dev_attr.attr, 324 &sensor_dev_attr_in2_input.dev_attr.attr, 325 &sensor_dev_attr_in3_input.dev_attr.attr, 326 &sensor_dev_attr_in4_input.dev_attr.attr, 327 &sensor_dev_attr_in5_input.dev_attr.attr, 328 &sensor_dev_attr_in6_input.dev_attr.attr, 329 &sensor_dev_attr_temp1_input.dev_attr.attr, 330 &sensor_dev_attr_temp1_max.dev_attr.attr, 331 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 332 &sensor_dev_attr_in0_alarm.dev_attr.attr, 333 &sensor_dev_attr_in1_alarm.dev_attr.attr, 334 &sensor_dev_attr_in2_alarm.dev_attr.attr, 335 &sensor_dev_attr_in3_alarm.dev_attr.attr, 336 &sensor_dev_attr_in4_alarm.dev_attr.attr, 337 &sensor_dev_attr_in5_alarm.dev_attr.attr, 338 &sensor_dev_attr_in6_alarm.dev_attr.attr, 339 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 340 NULL 341 }; 342 ATTRIBUTE_GROUPS(adc128); 343 344 static int adc128_detect(struct i2c_client *client, struct i2c_board_info *info) 345 { 346 int man_id, dev_id; 347 348 if (!i2c_check_functionality(client->adapter, 349 I2C_FUNC_SMBUS_BYTE_DATA | 350 I2C_FUNC_SMBUS_WORD_DATA)) 351 return -ENODEV; 352 353 man_id = i2c_smbus_read_byte_data(client, ADC128_REG_MAN_ID); 354 dev_id = i2c_smbus_read_byte_data(client, ADC128_REG_DEV_ID); 355 if (man_id != 0x01 || dev_id != 0x09) 356 return -ENODEV; 357 358 /* Check unused bits for confirmation */ 359 if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG) & 0xf4) 360 return -ENODEV; 361 if (i2c_smbus_read_byte_data(client, ADC128_REG_CONV_RATE) & 0xfe) 362 return -ENODEV; 363 if (i2c_smbus_read_byte_data(client, ADC128_REG_ONESHOT) & 0xfe) 364 return -ENODEV; 365 if (i2c_smbus_read_byte_data(client, ADC128_REG_SHUTDOWN) & 0xfe) 366 return -ENODEV; 367 if (i2c_smbus_read_byte_data(client, ADC128_REG_CONFIG_ADV) & 0xf8) 368 return -ENODEV; 369 if (i2c_smbus_read_byte_data(client, ADC128_REG_BUSY_STATUS) & 0xfc) 370 return -ENODEV; 371 372 strlcpy(info->type, "adc128d818", I2C_NAME_SIZE); 373 374 return 0; 375 } 376 377 static int adc128_init_client(struct adc128_data *data) 378 { 379 struct i2c_client *client = data->client; 380 int err; 381 382 /* 383 * Reset chip to defaults. 384 * This makes most other initializations unnecessary. 385 */ 386 err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x80); 387 if (err) 388 return err; 389 390 /* Start monitoring */ 391 err = i2c_smbus_write_byte_data(client, ADC128_REG_CONFIG, 0x01); 392 if (err) 393 return err; 394 395 /* If external vref is selected, configure the chip to use it */ 396 if (data->regulator) { 397 err = i2c_smbus_write_byte_data(client, 398 ADC128_REG_CONFIG_ADV, 0x01); 399 if (err) 400 return err; 401 } 402 403 return 0; 404 } 405 406 static int adc128_probe(struct i2c_client *client, 407 const struct i2c_device_id *id) 408 { 409 struct device *dev = &client->dev; 410 struct regulator *regulator; 411 struct device *hwmon_dev; 412 struct adc128_data *data; 413 int err, vref; 414 415 data = devm_kzalloc(dev, sizeof(struct adc128_data), GFP_KERNEL); 416 if (!data) 417 return -ENOMEM; 418 419 /* vref is optional. If specified, is used as chip reference voltage */ 420 regulator = devm_regulator_get_optional(dev, "vref"); 421 if (!IS_ERR(regulator)) { 422 data->regulator = regulator; 423 err = regulator_enable(regulator); 424 if (err < 0) 425 return err; 426 vref = regulator_get_voltage(regulator); 427 if (vref < 0) { 428 err = vref; 429 goto error; 430 } 431 data->vref = DIV_ROUND_CLOSEST(vref, 1000); 432 } else { 433 data->vref = 2560; /* 2.56V, in mV */ 434 } 435 436 data->client = client; 437 i2c_set_clientdata(client, data); 438 mutex_init(&data->update_lock); 439 440 /* Initialize the chip */ 441 err = adc128_init_client(data); 442 if (err < 0) 443 goto error; 444 445 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 446 data, adc128_groups); 447 if (IS_ERR(hwmon_dev)) { 448 err = PTR_ERR(hwmon_dev); 449 goto error; 450 } 451 452 return 0; 453 454 error: 455 if (data->regulator) 456 regulator_disable(data->regulator); 457 return err; 458 } 459 460 static int adc128_remove(struct i2c_client *client) 461 { 462 struct adc128_data *data = i2c_get_clientdata(client); 463 464 if (data->regulator) 465 regulator_disable(data->regulator); 466 467 return 0; 468 } 469 470 static const struct i2c_device_id adc128_id[] = { 471 { "adc128d818", 0 }, 472 { } 473 }; 474 MODULE_DEVICE_TABLE(i2c, adc128_id); 475 476 static struct i2c_driver adc128_driver = { 477 .class = I2C_CLASS_HWMON, 478 .driver = { 479 .name = "adc128d818", 480 }, 481 .probe = adc128_probe, 482 .remove = adc128_remove, 483 .id_table = adc128_id, 484 .detect = adc128_detect, 485 .address_list = normal_i2c, 486 }; 487 488 module_i2c_driver(adc128_driver); 489 490 MODULE_AUTHOR("Guenter Roeck"); 491 MODULE_DESCRIPTION("Driver for ADC128D818"); 492 MODULE_LICENSE("GPL"); 493