1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * thmc50.c - Part of lm_sensors, Linux kernel modules for hardware 4 * monitoring 5 * Copyright (C) 2007 Krzysztof Helt <krzysztof.h1@wp.pl> 6 * Based on 2.4 driver by Frodo Looijaard <frodol@dds.nl> and 7 * Philip Edelbrock <phil@netroedge.com> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/init.h> 12 #include <linux/slab.h> 13 #include <linux/i2c.h> 14 #include <linux/hwmon.h> 15 #include <linux/hwmon-sysfs.h> 16 #include <linux/err.h> 17 #include <linux/mutex.h> 18 #include <linux/jiffies.h> 19 20 MODULE_LICENSE("GPL"); 21 22 /* Addresses to scan */ 23 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END }; 24 25 /* Insmod parameters */ 26 enum chips { thmc50, adm1022 }; 27 28 static unsigned short adm1022_temp3[16]; 29 static unsigned int adm1022_temp3_num; 30 module_param_array(adm1022_temp3, ushort, &adm1022_temp3_num, 0); 31 MODULE_PARM_DESC(adm1022_temp3, 32 "List of adapter,address pairs to enable 3rd temperature (ADM1022 only)"); 33 34 /* Many THMC50 constants specified below */ 35 36 /* The THMC50 registers */ 37 #define THMC50_REG_CONF 0x40 38 #define THMC50_REG_COMPANY_ID 0x3E 39 #define THMC50_REG_DIE_CODE 0x3F 40 #define THMC50_REG_ANALOG_OUT 0x19 41 /* 42 * The mirror status register cannot be used as 43 * reading it does not clear alarms. 44 */ 45 #define THMC50_REG_INTR 0x41 46 47 static const u8 THMC50_REG_TEMP[] = { 0x27, 0x26, 0x20 }; 48 static const u8 THMC50_REG_TEMP_MIN[] = { 0x3A, 0x38, 0x2C }; 49 static const u8 THMC50_REG_TEMP_MAX[] = { 0x39, 0x37, 0x2B }; 50 static const u8 THMC50_REG_TEMP_CRITICAL[] = { 0x13, 0x14, 0x14 }; 51 static const u8 THMC50_REG_TEMP_DEFAULT[] = { 0x17, 0x18, 0x18 }; 52 53 #define THMC50_REG_CONF_nFANOFF 0x20 54 #define THMC50_REG_CONF_PROGRAMMED 0x08 55 56 /* Each client has this additional data */ 57 struct thmc50_data { 58 struct i2c_client *client; 59 const struct attribute_group *groups[3]; 60 61 struct mutex update_lock; 62 enum chips type; 63 unsigned long last_updated; /* In jiffies */ 64 char has_temp3; /* !=0 if it is ADM1022 in temp3 mode */ 65 bool valid; /* true if following fields are valid */ 66 67 /* Register values */ 68 s8 temp_input[3]; 69 s8 temp_max[3]; 70 s8 temp_min[3]; 71 s8 temp_critical[3]; 72 u8 analog_out; 73 u8 alarms; 74 }; 75 76 static struct thmc50_data *thmc50_update_device(struct device *dev) 77 { 78 struct thmc50_data *data = dev_get_drvdata(dev); 79 struct i2c_client *client = data->client; 80 int timeout = HZ / 5 + (data->type == thmc50 ? HZ : 0); 81 82 mutex_lock(&data->update_lock); 83 84 if (time_after(jiffies, data->last_updated + timeout) 85 || !data->valid) { 86 87 int temps = data->has_temp3 ? 3 : 2; 88 int i; 89 int prog = i2c_smbus_read_byte_data(client, THMC50_REG_CONF); 90 91 prog &= THMC50_REG_CONF_PROGRAMMED; 92 93 for (i = 0; i < temps; i++) { 94 data->temp_input[i] = i2c_smbus_read_byte_data(client, 95 THMC50_REG_TEMP[i]); 96 data->temp_max[i] = i2c_smbus_read_byte_data(client, 97 THMC50_REG_TEMP_MAX[i]); 98 data->temp_min[i] = i2c_smbus_read_byte_data(client, 99 THMC50_REG_TEMP_MIN[i]); 100 data->temp_critical[i] = 101 i2c_smbus_read_byte_data(client, 102 prog ? THMC50_REG_TEMP_CRITICAL[i] 103 : THMC50_REG_TEMP_DEFAULT[i]); 104 } 105 data->analog_out = 106 i2c_smbus_read_byte_data(client, THMC50_REG_ANALOG_OUT); 107 data->alarms = 108 i2c_smbus_read_byte_data(client, THMC50_REG_INTR); 109 data->last_updated = jiffies; 110 data->valid = true; 111 } 112 113 mutex_unlock(&data->update_lock); 114 115 return data; 116 } 117 118 static ssize_t analog_out_show(struct device *dev, 119 struct device_attribute *attr, char *buf) 120 { 121 struct thmc50_data *data = thmc50_update_device(dev); 122 return sprintf(buf, "%d\n", data->analog_out); 123 } 124 125 static ssize_t analog_out_store(struct device *dev, 126 struct device_attribute *attr, 127 const char *buf, size_t count) 128 { 129 struct thmc50_data *data = dev_get_drvdata(dev); 130 struct i2c_client *client = data->client; 131 int config; 132 unsigned long tmp; 133 int err; 134 135 err = kstrtoul(buf, 10, &tmp); 136 if (err) 137 return err; 138 139 mutex_lock(&data->update_lock); 140 data->analog_out = clamp_val(tmp, 0, 255); 141 i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT, 142 data->analog_out); 143 144 config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF); 145 if (data->analog_out == 0) 146 config &= ~THMC50_REG_CONF_nFANOFF; 147 else 148 config |= THMC50_REG_CONF_nFANOFF; 149 i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config); 150 151 mutex_unlock(&data->update_lock); 152 return count; 153 } 154 155 /* There is only one PWM mode = DC */ 156 static ssize_t pwm_mode_show(struct device *dev, 157 struct device_attribute *attr, char *buf) 158 { 159 return sprintf(buf, "0\n"); 160 } 161 162 /* Temperatures */ 163 static ssize_t temp_show(struct device *dev, struct device_attribute *attr, 164 char *buf) 165 { 166 int nr = to_sensor_dev_attr(attr)->index; 167 struct thmc50_data *data = thmc50_update_device(dev); 168 return sprintf(buf, "%d\n", data->temp_input[nr] * 1000); 169 } 170 171 static ssize_t temp_min_show(struct device *dev, 172 struct device_attribute *attr, char *buf) 173 { 174 int nr = to_sensor_dev_attr(attr)->index; 175 struct thmc50_data *data = thmc50_update_device(dev); 176 return sprintf(buf, "%d\n", data->temp_min[nr] * 1000); 177 } 178 179 static ssize_t temp_min_store(struct device *dev, 180 struct device_attribute *attr, const char *buf, 181 size_t count) 182 { 183 int nr = to_sensor_dev_attr(attr)->index; 184 struct thmc50_data *data = dev_get_drvdata(dev); 185 struct i2c_client *client = data->client; 186 long val; 187 int err; 188 189 err = kstrtol(buf, 10, &val); 190 if (err) 191 return err; 192 193 mutex_lock(&data->update_lock); 194 data->temp_min[nr] = clamp_val(val / 1000, -128, 127); 195 i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MIN[nr], 196 data->temp_min[nr]); 197 mutex_unlock(&data->update_lock); 198 return count; 199 } 200 201 static ssize_t temp_max_show(struct device *dev, 202 struct device_attribute *attr, char *buf) 203 { 204 int nr = to_sensor_dev_attr(attr)->index; 205 struct thmc50_data *data = thmc50_update_device(dev); 206 return sprintf(buf, "%d\n", data->temp_max[nr] * 1000); 207 } 208 209 static ssize_t temp_max_store(struct device *dev, 210 struct device_attribute *attr, const char *buf, 211 size_t count) 212 { 213 int nr = to_sensor_dev_attr(attr)->index; 214 struct thmc50_data *data = dev_get_drvdata(dev); 215 struct i2c_client *client = data->client; 216 long val; 217 int err; 218 219 err = kstrtol(buf, 10, &val); 220 if (err) 221 return err; 222 223 mutex_lock(&data->update_lock); 224 data->temp_max[nr] = clamp_val(val / 1000, -128, 127); 225 i2c_smbus_write_byte_data(client, THMC50_REG_TEMP_MAX[nr], 226 data->temp_max[nr]); 227 mutex_unlock(&data->update_lock); 228 return count; 229 } 230 231 static ssize_t temp_critical_show(struct device *dev, 232 struct device_attribute *attr, char *buf) 233 { 234 int nr = to_sensor_dev_attr(attr)->index; 235 struct thmc50_data *data = thmc50_update_device(dev); 236 return sprintf(buf, "%d\n", data->temp_critical[nr] * 1000); 237 } 238 239 static ssize_t alarm_show(struct device *dev, struct device_attribute *attr, 240 char *buf) 241 { 242 int index = to_sensor_dev_attr(attr)->index; 243 struct thmc50_data *data = thmc50_update_device(dev); 244 245 return sprintf(buf, "%u\n", (data->alarms >> index) & 1); 246 } 247 248 static SENSOR_DEVICE_ATTR_RO(temp1_input, temp, 0); 249 static SENSOR_DEVICE_ATTR_RW(temp1_min, temp_min, 0); 250 static SENSOR_DEVICE_ATTR_RW(temp1_max, temp_max, 0); 251 static SENSOR_DEVICE_ATTR_RO(temp1_crit, temp_critical, 0); 252 static SENSOR_DEVICE_ATTR_RO(temp2_input, temp, 1); 253 static SENSOR_DEVICE_ATTR_RW(temp2_min, temp_min, 1); 254 static SENSOR_DEVICE_ATTR_RW(temp2_max, temp_max, 1); 255 static SENSOR_DEVICE_ATTR_RO(temp2_crit, temp_critical, 1); 256 static SENSOR_DEVICE_ATTR_RO(temp3_input, temp, 2); 257 static SENSOR_DEVICE_ATTR_RW(temp3_min, temp_min, 2); 258 static SENSOR_DEVICE_ATTR_RW(temp3_max, temp_max, 2); 259 static SENSOR_DEVICE_ATTR_RO(temp3_crit, temp_critical, 2); 260 261 static SENSOR_DEVICE_ATTR_RO(temp1_alarm, alarm, 0); 262 static SENSOR_DEVICE_ATTR_RO(temp2_alarm, alarm, 5); 263 static SENSOR_DEVICE_ATTR_RO(temp3_alarm, alarm, 1); 264 static SENSOR_DEVICE_ATTR_RO(temp2_fault, alarm, 7); 265 static SENSOR_DEVICE_ATTR_RO(temp3_fault, alarm, 2); 266 267 static SENSOR_DEVICE_ATTR_RW(pwm1, analog_out, 0); 268 static SENSOR_DEVICE_ATTR_RO(pwm1_mode, pwm_mode, 0); 269 270 static struct attribute *thmc50_attributes[] = { 271 &sensor_dev_attr_temp1_max.dev_attr.attr, 272 &sensor_dev_attr_temp1_min.dev_attr.attr, 273 &sensor_dev_attr_temp1_input.dev_attr.attr, 274 &sensor_dev_attr_temp1_crit.dev_attr.attr, 275 &sensor_dev_attr_temp1_alarm.dev_attr.attr, 276 &sensor_dev_attr_temp2_max.dev_attr.attr, 277 &sensor_dev_attr_temp2_min.dev_attr.attr, 278 &sensor_dev_attr_temp2_input.dev_attr.attr, 279 &sensor_dev_attr_temp2_crit.dev_attr.attr, 280 &sensor_dev_attr_temp2_alarm.dev_attr.attr, 281 &sensor_dev_attr_temp2_fault.dev_attr.attr, 282 &sensor_dev_attr_pwm1.dev_attr.attr, 283 &sensor_dev_attr_pwm1_mode.dev_attr.attr, 284 NULL 285 }; 286 287 static const struct attribute_group thmc50_group = { 288 .attrs = thmc50_attributes, 289 }; 290 291 /* for ADM1022 3rd temperature mode */ 292 static struct attribute *temp3_attributes[] = { 293 &sensor_dev_attr_temp3_max.dev_attr.attr, 294 &sensor_dev_attr_temp3_min.dev_attr.attr, 295 &sensor_dev_attr_temp3_input.dev_attr.attr, 296 &sensor_dev_attr_temp3_crit.dev_attr.attr, 297 &sensor_dev_attr_temp3_alarm.dev_attr.attr, 298 &sensor_dev_attr_temp3_fault.dev_attr.attr, 299 NULL 300 }; 301 302 static const struct attribute_group temp3_group = { 303 .attrs = temp3_attributes, 304 }; 305 306 /* Return 0 if detection is successful, -ENODEV otherwise */ 307 static int thmc50_detect(struct i2c_client *client, 308 struct i2c_board_info *info) 309 { 310 unsigned company; 311 unsigned revision; 312 unsigned config; 313 struct i2c_adapter *adapter = client->adapter; 314 const char *type_name; 315 316 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 317 pr_debug("thmc50: detect failed, smbus byte data not supported!\n"); 318 return -ENODEV; 319 } 320 321 pr_debug("thmc50: Probing for THMC50 at 0x%2X on bus %d\n", 322 client->addr, i2c_adapter_id(client->adapter)); 323 324 company = i2c_smbus_read_byte_data(client, THMC50_REG_COMPANY_ID); 325 revision = i2c_smbus_read_byte_data(client, THMC50_REG_DIE_CODE); 326 config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF); 327 if (revision < 0xc0 || (config & 0x10)) 328 return -ENODEV; 329 330 if (company == 0x41) { 331 int id = i2c_adapter_id(client->adapter); 332 int i; 333 334 type_name = "adm1022"; 335 for (i = 0; i + 1 < adm1022_temp3_num; i += 2) 336 if (adm1022_temp3[i] == id && 337 adm1022_temp3[i + 1] == client->addr) { 338 /* enable 2nd remote temp */ 339 config |= (1 << 7); 340 i2c_smbus_write_byte_data(client, 341 THMC50_REG_CONF, 342 config); 343 break; 344 } 345 } else if (company == 0x49) { 346 type_name = "thmc50"; 347 } else { 348 pr_debug("thmc50: Detection of THMC50/ADM1022 failed\n"); 349 return -ENODEV; 350 } 351 352 pr_debug("thmc50: Detected %s (version %x, revision %x)\n", 353 type_name, (revision >> 4) - 0xc, revision & 0xf); 354 355 strlcpy(info->type, type_name, I2C_NAME_SIZE); 356 357 return 0; 358 } 359 360 static void thmc50_init_client(struct thmc50_data *data) 361 { 362 struct i2c_client *client = data->client; 363 int config; 364 365 data->analog_out = i2c_smbus_read_byte_data(client, 366 THMC50_REG_ANALOG_OUT); 367 /* set up to at least 1 */ 368 if (data->analog_out == 0) { 369 data->analog_out = 1; 370 i2c_smbus_write_byte_data(client, THMC50_REG_ANALOG_OUT, 371 data->analog_out); 372 } 373 config = i2c_smbus_read_byte_data(client, THMC50_REG_CONF); 374 config |= 0x1; /* start the chip if it is in standby mode */ 375 if (data->type == adm1022 && (config & (1 << 7))) 376 data->has_temp3 = 1; 377 i2c_smbus_write_byte_data(client, THMC50_REG_CONF, config); 378 } 379 380 static const struct i2c_device_id thmc50_id[]; 381 382 static int thmc50_probe(struct i2c_client *client) 383 { 384 struct device *dev = &client->dev; 385 struct thmc50_data *data; 386 struct device *hwmon_dev; 387 int idx = 0; 388 389 data = devm_kzalloc(dev, sizeof(struct thmc50_data), GFP_KERNEL); 390 if (!data) 391 return -ENOMEM; 392 393 data->client = client; 394 data->type = i2c_match_id(thmc50_id, client)->driver_data; 395 mutex_init(&data->update_lock); 396 397 thmc50_init_client(data); 398 399 /* sysfs hooks */ 400 data->groups[idx++] = &thmc50_group; 401 402 /* Register additional ADM1022 sysfs hooks */ 403 if (data->has_temp3) 404 data->groups[idx++] = &temp3_group; 405 406 hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name, 407 data, data->groups); 408 return PTR_ERR_OR_ZERO(hwmon_dev); 409 } 410 411 static const struct i2c_device_id thmc50_id[] = { 412 { "adm1022", adm1022 }, 413 { "thmc50", thmc50 }, 414 { } 415 }; 416 MODULE_DEVICE_TABLE(i2c, thmc50_id); 417 418 static struct i2c_driver thmc50_driver = { 419 .class = I2C_CLASS_HWMON, 420 .driver = { 421 .name = "thmc50", 422 }, 423 .probe_new = thmc50_probe, 424 .id_table = thmc50_id, 425 .detect = thmc50_detect, 426 .address_list = normal_i2c, 427 }; 428 429 module_i2c_driver(thmc50_driver); 430 431 MODULE_AUTHOR("Krzysztof Helt <krzysztof.h1@wp.pl>"); 432 MODULE_DESCRIPTION("THMC50 driver"); 433