1 /* 2 * Copyright (c) 2011 David George <david.george@ska.ac.za> 3 * 4 * based on adm1021.c 5 * some credit to Christoph Scheurer, but largely a rewrite 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/module.h> 23 #include <linux/init.h> 24 #include <linux/slab.h> 25 #include <linux/jiffies.h> 26 #include <linux/i2c.h> 27 #include <linux/hwmon.h> 28 #include <linux/hwmon-sysfs.h> 29 #include <linux/err.h> 30 #include <linux/mutex.h> 31 32 /* Addresses to scan */ 33 static const unsigned short max1668_addr_list[] = { 34 0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END }; 35 36 /* max1668 registers */ 37 38 #define MAX1668_REG_TEMP(nr) (nr) 39 #define MAX1668_REG_STAT1 0x05 40 #define MAX1668_REG_STAT2 0x06 41 #define MAX1668_REG_MAN_ID 0xfe 42 #define MAX1668_REG_DEV_ID 0xff 43 44 /* limits */ 45 46 /* write high limits */ 47 #define MAX1668_REG_LIMH_WR(nr) (0x13 + 2 * (nr)) 48 /* write low limits */ 49 #define MAX1668_REG_LIML_WR(nr) (0x14 + 2 * (nr)) 50 /* read high limits */ 51 #define MAX1668_REG_LIMH_RD(nr) (0x08 + 2 * (nr)) 52 /* read low limits */ 53 #define MAX1668_REG_LIML_RD(nr) (0x09 + 2 * (nr)) 54 55 /* manufacturer and device ID Constants */ 56 #define MAN_ID_MAXIM 0x4d 57 #define DEV_ID_MAX1668 0x3 58 #define DEV_ID_MAX1805 0x5 59 #define DEV_ID_MAX1989 0xb 60 61 /* read only mode module parameter */ 62 static bool read_only; 63 module_param(read_only, bool, 0); 64 MODULE_PARM_DESC(read_only, "Don't set any values, read only mode"); 65 66 enum chips { max1668, max1805, max1989 }; 67 68 struct max1668_data { 69 struct i2c_client *client; 70 const struct attribute_group *groups[3]; 71 enum chips type; 72 73 struct mutex update_lock; 74 char valid; /* !=0 if following fields are valid */ 75 unsigned long last_updated; /* In jiffies */ 76 77 /* 1x local and 4x remote */ 78 s8 temp_max[5]; 79 s8 temp_min[5]; 80 s8 temp[5]; 81 u16 alarms; 82 }; 83 84 static struct max1668_data *max1668_update_device(struct device *dev) 85 { 86 struct max1668_data *data = dev_get_drvdata(dev); 87 struct i2c_client *client = data->client; 88 struct max1668_data *ret = data; 89 s32 val; 90 int i; 91 92 mutex_lock(&data->update_lock); 93 94 if (data->valid && !time_after(jiffies, 95 data->last_updated + HZ + HZ / 2)) 96 goto abort; 97 98 for (i = 0; i < 5; i++) { 99 val = i2c_smbus_read_byte_data(client, MAX1668_REG_TEMP(i)); 100 if (unlikely(val < 0)) { 101 ret = ERR_PTR(val); 102 goto abort; 103 } 104 data->temp[i] = (s8) val; 105 106 val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIMH_RD(i)); 107 if (unlikely(val < 0)) { 108 ret = ERR_PTR(val); 109 goto abort; 110 } 111 data->temp_max[i] = (s8) val; 112 113 val = i2c_smbus_read_byte_data(client, MAX1668_REG_LIML_RD(i)); 114 if (unlikely(val < 0)) { 115 ret = ERR_PTR(val); 116 goto abort; 117 } 118 data->temp_min[i] = (s8) val; 119 } 120 121 val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT1); 122 if (unlikely(val < 0)) { 123 ret = ERR_PTR(val); 124 goto abort; 125 } 126 data->alarms = val << 8; 127 128 val = i2c_smbus_read_byte_data(client, MAX1668_REG_STAT2); 129 if (unlikely(val < 0)) { 130 ret = ERR_PTR(val); 131 goto abort; 132 } 133 data->alarms |= val; 134 135 data->last_updated = jiffies; 136 data->valid = 1; 137 abort: 138 mutex_unlock(&data->update_lock); 139 140 return ret; 141 } 142 143 static ssize_t show_temp(struct device *dev, 144 struct device_attribute *devattr, char *buf) 145 { 146 int index = to_sensor_dev_attr(devattr)->index; 147 struct max1668_data *data = max1668_update_device(dev); 148 149 if (IS_ERR(data)) 150 return PTR_ERR(data); 151 152 return sprintf(buf, "%d\n", data->temp[index] * 1000); 153 } 154 155 static ssize_t show_temp_max(struct device *dev, 156 struct device_attribute *devattr, char *buf) 157 { 158 int index = to_sensor_dev_attr(devattr)->index; 159 struct max1668_data *data = max1668_update_device(dev); 160 161 if (IS_ERR(data)) 162 return PTR_ERR(data); 163 164 return sprintf(buf, "%d\n", data->temp_max[index] * 1000); 165 } 166 167 static ssize_t show_temp_min(struct device *dev, 168 struct device_attribute *devattr, char *buf) 169 { 170 int index = to_sensor_dev_attr(devattr)->index; 171 struct max1668_data *data = max1668_update_device(dev); 172 173 if (IS_ERR(data)) 174 return PTR_ERR(data); 175 176 return sprintf(buf, "%d\n", data->temp_min[index] * 1000); 177 } 178 179 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr, 180 char *buf) 181 { 182 int index = to_sensor_dev_attr(attr)->index; 183 struct max1668_data *data = max1668_update_device(dev); 184 185 if (IS_ERR(data)) 186 return PTR_ERR(data); 187 188 return sprintf(buf, "%u\n", (data->alarms >> index) & 0x1); 189 } 190 191 static ssize_t show_fault(struct device *dev, 192 struct device_attribute *devattr, char *buf) 193 { 194 int index = to_sensor_dev_attr(devattr)->index; 195 struct max1668_data *data = max1668_update_device(dev); 196 197 if (IS_ERR(data)) 198 return PTR_ERR(data); 199 200 return sprintf(buf, "%u\n", 201 (data->alarms & (1 << 12)) && data->temp[index] == 127); 202 } 203 204 static ssize_t set_temp_max(struct device *dev, 205 struct device_attribute *devattr, 206 const char *buf, size_t count) 207 { 208 int index = to_sensor_dev_attr(devattr)->index; 209 struct max1668_data *data = dev_get_drvdata(dev); 210 struct i2c_client *client = data->client; 211 long temp; 212 int ret; 213 214 ret = kstrtol(buf, 10, &temp); 215 if (ret < 0) 216 return ret; 217 218 mutex_lock(&data->update_lock); 219 data->temp_max[index] = clamp_val(temp/1000, -128, 127); 220 ret = i2c_smbus_write_byte_data(client, 221 MAX1668_REG_LIMH_WR(index), 222 data->temp_max[index]); 223 if (ret < 0) 224 count = ret; 225 mutex_unlock(&data->update_lock); 226 227 return count; 228 } 229 230 static ssize_t set_temp_min(struct device *dev, 231 struct device_attribute *devattr, 232 const char *buf, size_t count) 233 { 234 int index = to_sensor_dev_attr(devattr)->index; 235 struct max1668_data *data = dev_get_drvdata(dev); 236 struct i2c_client *client = data->client; 237 long temp; 238 int ret; 239 240 ret = kstrtol(buf, 10, &temp); 241 if (ret < 0) 242 return ret; 243 244 mutex_lock(&data->update_lock); 245 data->temp_min[index] = clamp_val(temp/1000, -128, 127); 246 ret = i2c_smbus_write_byte_data(client, 247 MAX1668_REG_LIML_WR(index), 248 data->temp_min[index]); 249 if (ret < 0) 250 count = ret; 251 mutex_unlock(&data->update_lock); 252 253 return count; 254 } 255 256 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 257 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO, show_temp_max, 258 set_temp_max, 0); 259 static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO, show_temp_min, 260 set_temp_min, 0); 261 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1); 262 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO, show_temp_max, 263 set_temp_max, 1); 264 static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO, show_temp_min, 265 set_temp_min, 1); 266 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2); 267 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO, show_temp_max, 268 set_temp_max, 2); 269 static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO, show_temp_min, 270 set_temp_min, 2); 271 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 3); 272 static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO, show_temp_max, 273 set_temp_max, 3); 274 static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO, show_temp_min, 275 set_temp_min, 3); 276 static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp, NULL, 4); 277 static SENSOR_DEVICE_ATTR(temp5_max, S_IRUGO, show_temp_max, 278 set_temp_max, 4); 279 static SENSOR_DEVICE_ATTR(temp5_min, S_IRUGO, show_temp_min, 280 set_temp_min, 4); 281 282 static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 14); 283 static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 13); 284 static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 7); 285 static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 6); 286 static SENSOR_DEVICE_ATTR(temp3_min_alarm, S_IRUGO, show_alarm, NULL, 5); 287 static SENSOR_DEVICE_ATTR(temp3_max_alarm, S_IRUGO, show_alarm, NULL, 4); 288 static SENSOR_DEVICE_ATTR(temp4_min_alarm, S_IRUGO, show_alarm, NULL, 3); 289 static SENSOR_DEVICE_ATTR(temp4_max_alarm, S_IRUGO, show_alarm, NULL, 2); 290 static SENSOR_DEVICE_ATTR(temp5_min_alarm, S_IRUGO, show_alarm, NULL, 1); 291 static SENSOR_DEVICE_ATTR(temp5_max_alarm, S_IRUGO, show_alarm, NULL, 0); 292 293 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_fault, NULL, 1); 294 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_fault, NULL, 2); 295 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_fault, NULL, 3); 296 static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_fault, NULL, 4); 297 298 /* Attributes common to MAX1668, MAX1989 and MAX1805 */ 299 static struct attribute *max1668_attribute_common[] = { 300 &sensor_dev_attr_temp1_max.dev_attr.attr, 301 &sensor_dev_attr_temp1_min.dev_attr.attr, 302 &sensor_dev_attr_temp1_input.dev_attr.attr, 303 &sensor_dev_attr_temp2_max.dev_attr.attr, 304 &sensor_dev_attr_temp2_min.dev_attr.attr, 305 &sensor_dev_attr_temp2_input.dev_attr.attr, 306 &sensor_dev_attr_temp3_max.dev_attr.attr, 307 &sensor_dev_attr_temp3_min.dev_attr.attr, 308 &sensor_dev_attr_temp3_input.dev_attr.attr, 309 310 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 311 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 312 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 313 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 314 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 315 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 316 317 &sensor_dev_attr_temp2_fault.dev_attr.attr, 318 &sensor_dev_attr_temp3_fault.dev_attr.attr, 319 NULL 320 }; 321 322 /* Attributes not present on MAX1805 */ 323 static struct attribute *max1668_attribute_unique[] = { 324 &sensor_dev_attr_temp4_max.dev_attr.attr, 325 &sensor_dev_attr_temp4_min.dev_attr.attr, 326 &sensor_dev_attr_temp4_input.dev_attr.attr, 327 &sensor_dev_attr_temp5_max.dev_attr.attr, 328 &sensor_dev_attr_temp5_min.dev_attr.attr, 329 &sensor_dev_attr_temp5_input.dev_attr.attr, 330 331 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, 332 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr, 333 &sensor_dev_attr_temp5_max_alarm.dev_attr.attr, 334 &sensor_dev_attr_temp5_min_alarm.dev_attr.attr, 335 336 &sensor_dev_attr_temp4_fault.dev_attr.attr, 337 &sensor_dev_attr_temp5_fault.dev_attr.attr, 338 NULL 339 }; 340 341 static umode_t max1668_attribute_mode(struct kobject *kobj, 342 struct attribute *attr, int index) 343 { 344 umode_t ret = S_IRUGO; 345 if (read_only) 346 return ret; 347 if (attr == &sensor_dev_attr_temp1_max.dev_attr.attr || 348 attr == &sensor_dev_attr_temp2_max.dev_attr.attr || 349 attr == &sensor_dev_attr_temp3_max.dev_attr.attr || 350 attr == &sensor_dev_attr_temp4_max.dev_attr.attr || 351 attr == &sensor_dev_attr_temp5_max.dev_attr.attr || 352 attr == &sensor_dev_attr_temp1_min.dev_attr.attr || 353 attr == &sensor_dev_attr_temp2_min.dev_attr.attr || 354 attr == &sensor_dev_attr_temp3_min.dev_attr.attr || 355 attr == &sensor_dev_attr_temp4_min.dev_attr.attr || 356 attr == &sensor_dev_attr_temp5_min.dev_attr.attr) 357 ret |= S_IWUSR; 358 return ret; 359 } 360 361 static const struct attribute_group max1668_group_common = { 362 .attrs = max1668_attribute_common, 363 .is_visible = max1668_attribute_mode 364 }; 365 366 static const struct attribute_group max1668_group_unique = { 367 .attrs = max1668_attribute_unique, 368 .is_visible = max1668_attribute_mode 369 }; 370 371 /* Return 0 if detection is successful, -ENODEV otherwise */ 372 static int max1668_detect(struct i2c_client *client, 373 struct i2c_board_info *info) 374 { 375 struct i2c_adapter *adapter = client->adapter; 376 const char *type_name; 377 int man_id, dev_id; 378 379 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 380 return -ENODEV; 381 382 /* Check for unsupported part */ 383 man_id = i2c_smbus_read_byte_data(client, MAX1668_REG_MAN_ID); 384 if (man_id != MAN_ID_MAXIM) 385 return -ENODEV; 386 387 dev_id = i2c_smbus_read_byte_data(client, MAX1668_REG_DEV_ID); 388 if (dev_id < 0) 389 return -ENODEV; 390 391 type_name = NULL; 392 if (dev_id == DEV_ID_MAX1668) 393 type_name = "max1668"; 394 else if (dev_id == DEV_ID_MAX1805) 395 type_name = "max1805"; 396 else if (dev_id == DEV_ID_MAX1989) 397 type_name = "max1989"; 398 399 if (!type_name) 400 return -ENODEV; 401 402 strlcpy(info->type, type_name, I2C_NAME_SIZE); 403 404 return 0; 405 } 406 407 static int max1668_probe(struct i2c_client *client, 408 const struct i2c_device_id *id) 409 { 410 struct i2c_adapter *adapter = client->adapter; 411 struct device *dev = &client->dev; 412 struct device *hwmon_dev; 413 struct max1668_data *data; 414 415 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 416 return -ENODEV; 417 418 data = devm_kzalloc(dev, sizeof(struct max1668_data), GFP_KERNEL); 419 if (!data) 420 return -ENOMEM; 421 422 data->client = client; 423 data->type = id->driver_data; 424 mutex_init(&data->update_lock); 425 426 /* sysfs hooks */ 427 data->groups[0] = &max1668_group_common; 428 if (data->type == max1668 || data->type == max1989) 429 data->groups[1] = &max1668_group_unique; 430 431 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 432 data, data->groups); 433 return PTR_ERR_OR_ZERO(hwmon_dev); 434 } 435 436 static const struct i2c_device_id max1668_id[] = { 437 { "max1668", max1668 }, 438 { "max1805", max1805 }, 439 { "max1989", max1989 }, 440 { } 441 }; 442 MODULE_DEVICE_TABLE(i2c, max1668_id); 443 444 /* This is the driver that will be inserted */ 445 static struct i2c_driver max1668_driver = { 446 .class = I2C_CLASS_HWMON, 447 .driver = { 448 .name = "max1668", 449 }, 450 .probe = max1668_probe, 451 .id_table = max1668_id, 452 .detect = max1668_detect, 453 .address_list = max1668_addr_list, 454 }; 455 456 module_i2c_driver(max1668_driver); 457 458 MODULE_AUTHOR("David George <david.george@ska.ac.za>"); 459 MODULE_DESCRIPTION("MAX1668 remote temperature sensor driver"); 460 MODULE_LICENSE("GPL"); 461