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