adm1021.c 14.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2
/*
    adm1021.c - Part of lm_sensors, Linux kernel modules for hardware
Krzysztof Helt's avatar
Krzysztof Helt committed
3
		monitoring
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl> and
    Philip Edelbrock <phil@netroedge.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
27
#include <linux/hwmon.h>
28
#include <linux/hwmon-sysfs.h>
29
#include <linux/err.h>
30
#include <linux/mutex.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33


/* Addresses to scan */
34 35
static const unsigned short normal_i2c[] = {
	0x18, 0x19, 0x1a, 0x29, 0x2a, 0x2b, 0x4c, 0x4d, 0x4e, I2C_CLIENT_END };
Linus Torvalds's avatar
Linus Torvalds committed
36

37 38
enum chips {
	adm1021, adm1023, max1617, max1617a, thmc10, lm84, gl523sm, mc1066 };
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41 42 43

/* adm1021 constants specified below */

/* The adm1021 registers */
/* Read-only */
44 45
/* For nr in 0-1 */
#define ADM1021_REG_TEMP(nr)		(nr)
Linus Torvalds's avatar
Linus Torvalds committed
46
#define ADM1021_REG_STATUS		0x02
Krzysztof Helt's avatar
Krzysztof Helt committed
47 48 49 50
/* 0x41 = AD, 0x49 = TI, 0x4D = Maxim, 0x23 = Genesys , 0x54 = Onsemi */
#define ADM1021_REG_MAN_ID		0xFE
/* ADM1021 = 0x0X, ADM1023 = 0x3X */
#define ADM1021_REG_DEV_ID		0xFF
Linus Torvalds's avatar
Linus Torvalds committed
51 52 53 54 55 56
/* These use different addresses for reading/writing */
#define ADM1021_REG_CONFIG_R		0x03
#define ADM1021_REG_CONFIG_W		0x09
#define ADM1021_REG_CONV_RATE_R		0x04
#define ADM1021_REG_CONV_RATE_W		0x0A
/* These are for the ADM1023's additional precision on the remote temp sensor */
Krzysztof Helt's avatar
Krzysztof Helt committed
57 58 59 60 61
#define ADM1023_REG_REM_TEMP_PREC	0x10
#define ADM1023_REG_REM_OFFSET		0x11
#define ADM1023_REG_REM_OFFSET_PREC	0x12
#define ADM1023_REG_REM_TOS_PREC	0x13
#define ADM1023_REG_REM_THYST_PREC	0x14
Linus Torvalds's avatar
Linus Torvalds committed
62
/* limits */
63 64 65 66 67
/* For nr in 0-1 */
#define ADM1021_REG_TOS_R(nr)		(0x05 + 2 * (nr))
#define ADM1021_REG_TOS_W(nr)		(0x0B + 2 * (nr))
#define ADM1021_REG_THYST_R(nr)		(0x06 + 2 * (nr))
#define ADM1021_REG_THYST_W(nr)		(0x0C + 2 * (nr))
Linus Torvalds's avatar
Linus Torvalds committed
68 69 70 71 72
/* write-only */
#define ADM1021_REG_ONESHOT		0x0F

/* Initial values */

Krzysztof Helt's avatar
Krzysztof Helt committed
73 74 75
/* Note: Even though I left the low and high limits named os and hyst,
they don't quite work like a thermostat the way the LM75 does.  I.e.,
a lower temp than THYST actually triggers an alarm instead of
Linus Torvalds's avatar
Linus Torvalds committed
76 77 78 79
clearing it.  Weird, ey?   --Phil  */

/* Each client has this additional data */
struct adm1021_data {
80
	struct device *hwmon_dev;
Linus Torvalds's avatar
Linus Torvalds committed
81 82
	enum chips type;

83
	struct mutex update_lock;
Linus Torvalds's avatar
Linus Torvalds committed
84
	char valid;		/* !=0 if following fields are valid */
85
	char low_power;		/* !=0 if device in low power mode */
Linus Torvalds's avatar
Linus Torvalds committed
86 87
	unsigned long last_updated;	/* In jiffies */

88 89 90
	int temp_max[2];		/* Register values */
	int temp_min[2];
	int temp[2];
91 92 93 94
	u8 alarms;
	/* Special values for ADM1023 only */
	u8 remote_temp_offset;
	u8 remote_temp_offset_prec;
Linus Torvalds's avatar
Linus Torvalds committed
95 96
};

97 98
static int adm1021_probe(struct i2c_client *client,
			 const struct i2c_device_id *id);
99
static int adm1021_detect(struct i2c_client *client,
100
			  struct i2c_board_info *info);
Linus Torvalds's avatar
Linus Torvalds committed
101
static void adm1021_init_client(struct i2c_client *client);
102
static int adm1021_remove(struct i2c_client *client);
Linus Torvalds's avatar
Linus Torvalds committed
103 104 105
static struct adm1021_data *adm1021_update_device(struct device *dev);

/* (amalysh) read only mode, otherwise any limit's writing confuse BIOS */
106
static int read_only;
Linus Torvalds's avatar
Linus Torvalds committed
107 108


109 110 111 112 113 114 115 116 117 118 119 120 121
static const struct i2c_device_id adm1021_id[] = {
	{ "adm1021", adm1021 },
	{ "adm1023", adm1023 },
	{ "max1617", max1617 },
	{ "max1617a", max1617a },
	{ "thmc10", thmc10 },
	{ "lm84", lm84 },
	{ "gl523sm", gl523sm },
	{ "mc1066", mc1066 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, adm1021_id);

Linus Torvalds's avatar
Linus Torvalds committed
122 123
/* This is the driver that will be inserted */
static struct i2c_driver adm1021_driver = {
124
	.class		= I2C_CLASS_HWMON,
125 126 127
	.driver = {
		.name	= "adm1021",
	},
128 129 130 131
	.probe		= adm1021_probe,
	.remove		= adm1021_remove,
	.id_table	= adm1021_id,
	.detect		= adm1021_detect,
132
	.address_list	= normal_i2c,
Linus Torvalds's avatar
Linus Torvalds committed
133 134
};

135 136 137 138 139 140
static ssize_t show_temp(struct device *dev,
			 struct device_attribute *devattr, char *buf)
{
	int index = to_sensor_dev_attr(devattr)->index;
	struct adm1021_data *data = adm1021_update_device(dev);

141
	return sprintf(buf, "%d\n", data->temp[index]);
142 143 144 145 146 147 148 149
}

static ssize_t show_temp_max(struct device *dev,
			     struct device_attribute *devattr, char *buf)
{
	int index = to_sensor_dev_attr(devattr)->index;
	struct adm1021_data *data = adm1021_update_device(dev);

150
	return sprintf(buf, "%d\n", data->temp_max[index]);
151 152 153 154 155 156 157 158
}

static ssize_t show_temp_min(struct device *dev,
			     struct device_attribute *devattr, char *buf)
{
	int index = to_sensor_dev_attr(devattr)->index;
	struct adm1021_data *data = adm1021_update_device(dev);

159
	return sprintf(buf, "%d\n", data->temp_min[index]);
Linus Torvalds's avatar
Linus Torvalds committed
160 161
}

162 163 164 165 166 167 168 169
static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	int index = to_sensor_dev_attr(attr)->index;
	struct adm1021_data *data = adm1021_update_device(dev);
	return sprintf(buf, "%u\n", (data->alarms >> index) & 1);
}

Krzysztof Helt's avatar
Krzysztof Helt committed
170 171 172 173 174 175
static ssize_t show_alarms(struct device *dev,
			   struct device_attribute *attr,
			   char *buf)
{
	struct adm1021_data *data = adm1021_update_device(dev);
	return sprintf(buf, "%u\n", data->alarms);
Linus Torvalds's avatar
Linus Torvalds committed
176
}
Krzysztof Helt's avatar
Krzysztof Helt committed
177

178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
static ssize_t set_temp_max(struct device *dev,
			    struct device_attribute *devattr,
			    const char *buf, size_t count)
{
	int index = to_sensor_dev_attr(devattr)->index;
	struct i2c_client *client = to_i2c_client(dev);
	struct adm1021_data *data = i2c_get_clientdata(client);
	long temp = simple_strtol(buf, NULL, 10) / 1000;

	mutex_lock(&data->update_lock);
	data->temp_max[index] = SENSORS_LIMIT(temp, -128, 127);
	if (!read_only)
		i2c_smbus_write_byte_data(client, ADM1021_REG_TOS_W(index),
					  data->temp_max[index]);
	mutex_unlock(&data->update_lock);

	return count;
}

static ssize_t set_temp_min(struct device *dev,
			    struct device_attribute *devattr,
			    const char *buf, size_t count)
{
	int index = to_sensor_dev_attr(devattr)->index;
	struct i2c_client *client = to_i2c_client(dev);
	struct adm1021_data *data = i2c_get_clientdata(client);
	long temp = simple_strtol(buf, NULL, 10) / 1000;

	mutex_lock(&data->update_lock);
	data->temp_min[index] = SENSORS_LIMIT(temp, -128, 127);
	if (!read_only)
		i2c_smbus_write_byte_data(client, ADM1021_REG_THYST_W(index),
					  data->temp_min[index]);
	mutex_unlock(&data->update_lock);

	return count;
Linus Torvalds's avatar
Linus Torvalds committed
214 215
}

216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244
static ssize_t show_low_power(struct device *dev,
			      struct device_attribute *devattr, char *buf)
{
	struct adm1021_data *data = adm1021_update_device(dev);
	return sprintf(buf, "%d\n", data->low_power);
}

static ssize_t set_low_power(struct device *dev,
			     struct device_attribute *devattr,
			     const char *buf, size_t count)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct adm1021_data *data = i2c_get_clientdata(client);
	int low_power = simple_strtol(buf, NULL, 10) != 0;

	mutex_lock(&data->update_lock);
	if (low_power != data->low_power) {
		int config = i2c_smbus_read_byte_data(
			client, ADM1021_REG_CONFIG_R);
		data->low_power = low_power;
		i2c_smbus_write_byte_data(client, ADM1021_REG_CONFIG_W,
			(config & 0xBF) | (low_power << 6));
	}
	mutex_unlock(&data->update_lock);

	return count;
}


245 246 247 248 249 250 251 252 253 254
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
			  set_temp_max, 0);
static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_min,
			  set_temp_min, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
			  set_temp_max, 1);
static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_temp_min,
			  set_temp_min, 1);
255 256 257 258 259 260
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 6);
static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO, show_alarm, NULL, 5);
static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 4);
static SENSOR_DEVICE_ATTR(temp2_min_alarm, S_IRUGO, show_alarm, NULL, 3);
static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_alarm, NULL, 2);

261
static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
262
static DEVICE_ATTR(low_power, S_IWUSR | S_IRUGO, show_low_power, set_low_power);
Linus Torvalds's avatar
Linus Torvalds committed
263

264
static struct attribute *adm1021_attributes[] = {
265 266 267 268 269 270
	&sensor_dev_attr_temp1_max.dev_attr.attr,
	&sensor_dev_attr_temp1_min.dev_attr.attr,
	&sensor_dev_attr_temp1_input.dev_attr.attr,
	&sensor_dev_attr_temp2_max.dev_attr.attr,
	&sensor_dev_attr_temp2_min.dev_attr.attr,
	&sensor_dev_attr_temp2_input.dev_attr.attr,
271 272 273 274 275
	&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
	&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
	&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
	&sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
	&sensor_dev_attr_temp2_fault.dev_attr.attr,
276
	&dev_attr_alarms.attr,
277
	&dev_attr_low_power.attr,
278 279 280 281 282 283 284
	NULL
};

static const struct attribute_group adm1021_group = {
	.attrs = adm1021_attributes,
};

285
/* Return 0 if detection is successful, -ENODEV otherwise */
286
static int adm1021_detect(struct i2c_client *client,
287
			  struct i2c_board_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
288
{
289
	struct i2c_adapter *adapter = client->adapter;
290 291
	const char *type_name;
	int conv_rate, status, config, man_id, dev_id;
Linus Torvalds's avatar
Linus Torvalds committed
292

Krzysztof Helt's avatar
Krzysztof Helt committed
293 294 295
	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
		pr_debug("adm1021: detect failed, "
			 "smbus byte data not supported!\n");
296
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
297 298
	}

Krzysztof Helt's avatar
Krzysztof Helt committed
299 300 301 302
	status = i2c_smbus_read_byte_data(client, ADM1021_REG_STATUS);
	conv_rate = i2c_smbus_read_byte_data(client,
					     ADM1021_REG_CONV_RATE_R);
	config = i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R);
Linus Torvalds's avatar
Linus Torvalds committed
303

304 305 306 307
	/* Check unused bits */
	if ((status & 0x03) || (config & 0x3F) || (conv_rate & 0xF8)) {
		pr_debug("adm1021: detect failed, chip not detected!\n");
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
308 309 310
	}

	/* Determine the chip type. */
311 312
	man_id = i2c_smbus_read_byte_data(client, ADM1021_REG_MAN_ID);
	dev_id = i2c_smbus_read_byte_data(client, ADM1021_REG_DEV_ID);
Linus Torvalds's avatar
Linus Torvalds committed
313

314
	if (man_id == 0x4d && dev_id == 0x01)
Linus Torvalds's avatar
Linus Torvalds committed
315
		type_name = "max1617a";
316 317 318 319 320 321
	else if (man_id == 0x41) {
		if ((dev_id & 0xF0) == 0x30)
			type_name = "adm1023";
		else
			type_name = "adm1021";
	} else if (man_id == 0x49)
Linus Torvalds's avatar
Linus Torvalds committed
322
		type_name = "thmc10";
323
	else if (man_id == 0x23)
Linus Torvalds's avatar
Linus Torvalds committed
324
		type_name = "gl523sm";
325
	else if (man_id == 0x54)
Linus Torvalds's avatar
Linus Torvalds committed
326
		type_name = "mc1066";
327 328 329 330 331 332 333 334
	/* LM84 Mfr ID in a different place, and it has more unused bits */
	else if (conv_rate == 0x00
		 && (config & 0x7F) == 0x00
		 && (status & 0xAB) == 0x00)
		type_name = "lm84";
	else
		type_name = "max1617";

Krzysztof Helt's avatar
Krzysztof Helt committed
335
	pr_debug("adm1021: Detected chip %s at adapter %d, address 0x%02x.\n",
336 337
		 type_name, i2c_adapter_id(adapter), client->addr);
	strlcpy(info->type, type_name, I2C_NAME_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
338

339 340
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
341

342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
static int adm1021_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct adm1021_data *data;
	int err;

	data = kzalloc(sizeof(struct adm1021_data), GFP_KERNEL);
	if (!data) {
		pr_debug("adm1021: detect failed, kzalloc failed!\n");
		err = -ENOMEM;
		goto error0;
	}

	i2c_set_clientdata(client, data);
	data->type = id->driver_data;
	mutex_init(&data->update_lock);
Linus Torvalds's avatar
Linus Torvalds committed
358 359

	/* Initialize the ADM1021 chip */
360
	if (data->type != lm84 && !read_only)
Krzysztof Helt's avatar
Krzysztof Helt committed
361
		adm1021_init_client(client);
Linus Torvalds's avatar
Linus Torvalds committed
362 363

	/* Register sysfs hooks */
Krzysztof Helt's avatar
Krzysztof Helt committed
364
	if ((err = sysfs_create_group(&client->dev.kobj, &adm1021_group)))
365
		goto error1;
366

367 368 369
	data->hwmon_dev = hwmon_device_register(&client->dev);
	if (IS_ERR(data->hwmon_dev)) {
		err = PTR_ERR(data->hwmon_dev);
370
		goto error3;
371 372
	}

Linus Torvalds's avatar
Linus Torvalds committed
373 374
	return 0;

375
error3:
Krzysztof Helt's avatar
Krzysztof Helt committed
376
	sysfs_remove_group(&client->dev.kobj, &adm1021_group);
Linus Torvalds's avatar
Linus Torvalds committed
377 378 379 380 381 382 383 384 385
error1:
	kfree(data);
error0:
	return err;
}

static void adm1021_init_client(struct i2c_client *client)
{
	/* Enable ADC and disable suspend mode */
Krzysztof Helt's avatar
Krzysztof Helt committed
386 387
	i2c_smbus_write_byte_data(client, ADM1021_REG_CONFIG_W,
		i2c_smbus_read_byte_data(client, ADM1021_REG_CONFIG_R) & 0xBF);
Linus Torvalds's avatar
Linus Torvalds committed
388
	/* Set Conversion rate to 1/sec (this can be tinkered with) */
Krzysztof Helt's avatar
Krzysztof Helt committed
389
	i2c_smbus_write_byte_data(client, ADM1021_REG_CONV_RATE_W, 0x04);
Linus Torvalds's avatar
Linus Torvalds committed
390 391
}

392
static int adm1021_remove(struct i2c_client *client)
Linus Torvalds's avatar
Linus Torvalds committed
393
{
394
	struct adm1021_data *data = i2c_get_clientdata(client);
Linus Torvalds's avatar
Linus Torvalds committed
395

396
	hwmon_device_unregister(data->hwmon_dev);
397
	sysfs_remove_group(&client->dev.kobj, &adm1021_group);
398 399

	kfree(data);
Linus Torvalds's avatar
Linus Torvalds committed
400 401 402 403 404 405 406 407
	return 0;
}

static struct adm1021_data *adm1021_update_device(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct adm1021_data *data = i2c_get_clientdata(client);

408
	mutex_lock(&data->update_lock);
Linus Torvalds's avatar
Linus Torvalds committed
409 410 411

	if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
	    || !data->valid) {
412 413
		int i;

Linus Torvalds's avatar
Linus Torvalds committed
414 415
		dev_dbg(&client->dev, "Starting adm1021 update\n");

416
		for (i = 0; i < 2; i++) {
417 418 419 420 421 422 423 424 425
			data->temp[i] = 1000 *
				(s8) i2c_smbus_read_byte_data(
					client, ADM1021_REG_TEMP(i));
			data->temp_max[i] = 1000 *
				(s8) i2c_smbus_read_byte_data(
					client, ADM1021_REG_TOS_R(i));
			data->temp_min[i] = 1000 *
				(s8) i2c_smbus_read_byte_data(
					client, ADM1021_REG_THYST_R(i));
426
		}
Krzysztof Helt's avatar
Krzysztof Helt committed
427 428
		data->alarms = i2c_smbus_read_byte_data(client,
						ADM1021_REG_STATUS) & 0x7c;
Linus Torvalds's avatar
Linus Torvalds committed
429
		if (data->type == adm1023) {
430 431 432 433 434 435 436 437
			/* The ADM1023 provides 3 extra bits of precision for
			 * the remote sensor in extra registers. */
			data->temp[1] += 125 * (i2c_smbus_read_byte_data(
				client, ADM1023_REG_REM_TEMP_PREC) >> 5);
			data->temp_max[1] += 125 * (i2c_smbus_read_byte_data(
				client, ADM1023_REG_REM_TOS_PREC) >> 5);
			data->temp_min[1] += 125 * (i2c_smbus_read_byte_data(
				client, ADM1023_REG_REM_THYST_PREC) >> 5);
Krzysztof Helt's avatar
Krzysztof Helt committed
438 439 440 441 442 443
			data->remote_temp_offset =
				i2c_smbus_read_byte_data(client,
						ADM1023_REG_REM_OFFSET);
			data->remote_temp_offset_prec =
				i2c_smbus_read_byte_data(client,
						ADM1023_REG_REM_OFFSET_PREC);
Linus Torvalds's avatar
Linus Torvalds committed
444 445 446 447 448
		}
		data->last_updated = jiffies;
		data->valid = 1;
	}

449
	mutex_unlock(&data->update_lock);
Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473

	return data;
}

static int __init sensors_adm1021_init(void)
{
	return i2c_add_driver(&adm1021_driver);
}

static void __exit sensors_adm1021_exit(void)
{
	i2c_del_driver(&adm1021_driver);
}

MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl> and "
		"Philip Edelbrock <phil@netroedge.com>");
MODULE_DESCRIPTION("adm1021 driver");
MODULE_LICENSE("GPL");

module_param(read_only, bool, 0);
MODULE_PARM_DESC(read_only, "Don't set any values, read only mode");

module_init(sensors_adm1021_init)
module_exit(sensors_adm1021_exit)