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