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