1 /* tmp421.c 2 * 3 * Copyright (C) 2009 Andre Prendel <andre.prendel@gmx.de> 4 * Preliminary support by: 5 * Melvin Rook, Raymond Ng 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 /* 23 * Driver for the Texas Instruments TMP421 SMBus temperature sensor IC. 24 * Supported models: TMP421, TMP422, TMP423 25 */ 26 27 #include <linux/module.h> 28 #include <linux/init.h> 29 #include <linux/slab.h> 30 #include <linux/jiffies.h> 31 #include <linux/i2c.h> 32 #include <linux/hwmon.h> 33 #include <linux/hwmon-sysfs.h> 34 #include <linux/err.h> 35 #include <linux/mutex.h> 36 #include <linux/sysfs.h> 37 38 /* Addresses to scan */ 39 static const unsigned short normal_i2c[] = { 0x2a, 0x4c, 0x4d, 0x4e, 0x4f, 40 I2C_CLIENT_END }; 41 42 enum chips { tmp421, tmp422, tmp423 }; 43 44 /* The TMP421 registers */ 45 #define TMP421_CONFIG_REG_1 0x09 46 #define TMP421_CONVERSION_RATE_REG 0x0B 47 #define TMP421_MANUFACTURER_ID_REG 0xFE 48 #define TMP421_DEVICE_ID_REG 0xFF 49 50 static const u8 TMP421_TEMP_MSB[4] = { 0x00, 0x01, 0x02, 0x03 }; 51 static const u8 TMP421_TEMP_LSB[4] = { 0x10, 0x11, 0x12, 0x13 }; 52 53 /* Flags */ 54 #define TMP421_CONFIG_SHUTDOWN 0x40 55 #define TMP421_CONFIG_RANGE 0x04 56 57 /* Manufacturer / Device ID's */ 58 #define TMP421_MANUFACTURER_ID 0x55 59 #define TMP421_DEVICE_ID 0x21 60 #define TMP422_DEVICE_ID 0x22 61 #define TMP423_DEVICE_ID 0x23 62 63 static const struct i2c_device_id tmp421_id[] = { 64 { "tmp421", 2 }, 65 { "tmp422", 3 }, 66 { "tmp423", 4 }, 67 { } 68 }; 69 MODULE_DEVICE_TABLE(i2c, tmp421_id); 70 71 struct tmp421_data { 72 struct device *hwmon_dev; 73 struct mutex update_lock; 74 char valid; 75 unsigned long last_updated; 76 int channels; 77 u8 config; 78 s16 temp[4]; 79 }; 80 81 static int temp_from_s16(s16 reg) 82 { 83 /* Mask out status bits */ 84 int temp = reg & ~0xf; 85 86 return (temp * 1000 + 128) / 256; 87 } 88 89 static int temp_from_u16(u16 reg) 90 { 91 /* Mask out status bits */ 92 int temp = reg & ~0xf; 93 94 /* Add offset for extended temperature range. */ 95 temp -= 64 * 256; 96 97 return (temp * 1000 + 128) / 256; 98 } 99 100 static struct tmp421_data *tmp421_update_device(struct device *dev) 101 { 102 struct i2c_client *client = to_i2c_client(dev); 103 struct tmp421_data *data = i2c_get_clientdata(client); 104 int i; 105 106 mutex_lock(&data->update_lock); 107 108 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) { 109 data->config = i2c_smbus_read_byte_data(client, 110 TMP421_CONFIG_REG_1); 111 112 for (i = 0; i < data->channels; i++) { 113 data->temp[i] = i2c_smbus_read_byte_data(client, 114 TMP421_TEMP_MSB[i]) << 8; 115 data->temp[i] |= i2c_smbus_read_byte_data(client, 116 TMP421_TEMP_LSB[i]); 117 } 118 data->last_updated = jiffies; 119 data->valid = 1; 120 } 121 122 mutex_unlock(&data->update_lock); 123 124 return data; 125 } 126 127 static ssize_t show_temp_value(struct device *dev, 128 struct device_attribute *devattr, char *buf) 129 { 130 int index = to_sensor_dev_attr(devattr)->index; 131 struct tmp421_data *data = tmp421_update_device(dev); 132 int temp; 133 134 mutex_lock(&data->update_lock); 135 if (data->config & TMP421_CONFIG_RANGE) 136 temp = temp_from_u16(data->temp[index]); 137 else 138 temp = temp_from_s16(data->temp[index]); 139 mutex_unlock(&data->update_lock); 140 141 return sprintf(buf, "%d\n", temp); 142 } 143 144 static ssize_t show_fault(struct device *dev, 145 struct device_attribute *devattr, char *buf) 146 { 147 int index = to_sensor_dev_attr(devattr)->index; 148 struct tmp421_data *data = tmp421_update_device(dev); 149 150 /* 151 * The OPEN bit signals a fault. This is bit 0 of the temperature 152 * register (low byte). 153 */ 154 if (data->temp[index] & 0x01) 155 return sprintf(buf, "1\n"); 156 else 157 return sprintf(buf, "0\n"); 158 } 159 160 static mode_t tmp421_is_visible(struct kobject *kobj, struct attribute *a, 161 int n) 162 { 163 struct device *dev = container_of(kobj, struct device, kobj); 164 struct tmp421_data *data = dev_get_drvdata(dev); 165 struct device_attribute *devattr; 166 unsigned int index; 167 168 devattr = container_of(a, struct device_attribute, attr); 169 index = to_sensor_dev_attr(devattr)->index; 170 171 if (index < data->channels) 172 return a->mode; 173 174 return 0; 175 } 176 177 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_value, NULL, 0); 178 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_value, NULL, 1); 179 static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_fault, NULL, 1); 180 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_value, NULL, 2); 181 static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_fault, NULL, 2); 182 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_value, NULL, 3); 183 static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_fault, NULL, 3); 184 185 static struct attribute *tmp421_attr[] = { 186 &sensor_dev_attr_temp1_input.dev_attr.attr, 187 &sensor_dev_attr_temp2_input.dev_attr.attr, 188 &sensor_dev_attr_temp2_fault.dev_attr.attr, 189 &sensor_dev_attr_temp3_input.dev_attr.attr, 190 &sensor_dev_attr_temp3_fault.dev_attr.attr, 191 &sensor_dev_attr_temp4_input.dev_attr.attr, 192 &sensor_dev_attr_temp4_fault.dev_attr.attr, 193 NULL 194 }; 195 196 static const struct attribute_group tmp421_group = { 197 .attrs = tmp421_attr, 198 .is_visible = tmp421_is_visible, 199 }; 200 201 static int tmp421_init_client(struct i2c_client *client) 202 { 203 int config, config_orig; 204 205 /* Set the conversion rate to 2 Hz */ 206 i2c_smbus_write_byte_data(client, TMP421_CONVERSION_RATE_REG, 0x05); 207 208 /* Start conversions (disable shutdown if necessary) */ 209 config = i2c_smbus_read_byte_data(client, TMP421_CONFIG_REG_1); 210 if (config < 0) { 211 dev_err(&client->dev, "Could not read configuration" 212 " register (%d)\n", config); 213 return -ENODEV; 214 } 215 216 config_orig = config; 217 config &= ~TMP421_CONFIG_SHUTDOWN; 218 219 if (config != config_orig) { 220 dev_info(&client->dev, "Enable monitoring chip\n"); 221 i2c_smbus_write_byte_data(client, TMP421_CONFIG_REG_1, config); 222 } 223 224 return 0; 225 } 226 227 static int tmp421_detect(struct i2c_client *client, 228 struct i2c_board_info *info) 229 { 230 enum chips kind; 231 struct i2c_adapter *adapter = client->adapter; 232 const char *names[] = { "TMP421", "TMP422", "TMP423" }; 233 u8 reg; 234 235 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 236 return -ENODEV; 237 238 reg = i2c_smbus_read_byte_data(client, TMP421_MANUFACTURER_ID_REG); 239 if (reg != TMP421_MANUFACTURER_ID) 240 return -ENODEV; 241 242 reg = i2c_smbus_read_byte_data(client, TMP421_DEVICE_ID_REG); 243 switch (reg) { 244 case TMP421_DEVICE_ID: 245 kind = tmp421; 246 break; 247 case TMP422_DEVICE_ID: 248 kind = tmp422; 249 break; 250 case TMP423_DEVICE_ID: 251 kind = tmp423; 252 break; 253 default: 254 return -ENODEV; 255 } 256 257 strlcpy(info->type, tmp421_id[kind].name, I2C_NAME_SIZE); 258 dev_info(&adapter->dev, "Detected TI %s chip at 0x%02x\n", 259 names[kind], client->addr); 260 261 return 0; 262 } 263 264 static int tmp421_probe(struct i2c_client *client, 265 const struct i2c_device_id *id) 266 { 267 struct tmp421_data *data; 268 int err; 269 270 data = kzalloc(sizeof(struct tmp421_data), GFP_KERNEL); 271 if (!data) 272 return -ENOMEM; 273 274 i2c_set_clientdata(client, data); 275 mutex_init(&data->update_lock); 276 data->channels = id->driver_data; 277 278 err = tmp421_init_client(client); 279 if (err) 280 goto exit_free; 281 282 err = sysfs_create_group(&client->dev.kobj, &tmp421_group); 283 if (err) 284 goto exit_free; 285 286 data->hwmon_dev = hwmon_device_register(&client->dev); 287 if (IS_ERR(data->hwmon_dev)) { 288 err = PTR_ERR(data->hwmon_dev); 289 data->hwmon_dev = NULL; 290 goto exit_remove; 291 } 292 return 0; 293 294 exit_remove: 295 sysfs_remove_group(&client->dev.kobj, &tmp421_group); 296 297 exit_free: 298 kfree(data); 299 300 return err; 301 } 302 303 static int tmp421_remove(struct i2c_client *client) 304 { 305 struct tmp421_data *data = i2c_get_clientdata(client); 306 307 hwmon_device_unregister(data->hwmon_dev); 308 sysfs_remove_group(&client->dev.kobj, &tmp421_group); 309 310 kfree(data); 311 312 return 0; 313 } 314 315 static struct i2c_driver tmp421_driver = { 316 .class = I2C_CLASS_HWMON, 317 .driver = { 318 .name = "tmp421", 319 }, 320 .probe = tmp421_probe, 321 .remove = tmp421_remove, 322 .id_table = tmp421_id, 323 .detect = tmp421_detect, 324 .address_list = normal_i2c, 325 }; 326 327 static int __init tmp421_init(void) 328 { 329 return i2c_add_driver(&tmp421_driver); 330 } 331 332 static void __exit tmp421_exit(void) 333 { 334 i2c_del_driver(&tmp421_driver); 335 } 336 337 MODULE_AUTHOR("Andre Prendel <andre.prendel@gmx.de>"); 338 MODULE_DESCRIPTION("Texas Instruments TMP421/422/423 temperature sensor" 339 " driver"); 340 MODULE_LICENSE("GPL"); 341 342 module_init(tmp421_init); 343 module_exit(tmp421_exit); 344