[go: nahoru, domu]
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 */
35static const unsigned short normal_i2c[] = { 0x2a, 0x4c, 0x4d, 0x4e, 0x4f,
36					     I2C_CLIENT_END };
37
38enum 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
47static const u8 TMP421_TEMP_MSB[4]		= { 0x00, 0x01, 0x02, 0x03 };
48static 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
62static const struct i2c_device_id tmp421_id[] = {
63	{ "tmp421", 2 },
64	{ "tmp422", 3 },
65	{ "tmp423", 4 },
66	{ "tmp441", 2 },
67	{ "tmp442", 3 },
68	{ }
69};
70MODULE_DEVICE_TABLE(i2c, tmp421_id);
71
72struct 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
82static 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
90static 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
101static 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
128static 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
145static 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
161static 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
178static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_value, NULL, 0);
179static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_value, NULL, 1);
180static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_fault, NULL, 1);
181static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_value, NULL, 2);
182static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_fault, NULL, 2);
183static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_value, NULL, 3);
184static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_fault, NULL, 3);
185
186static 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
197static const struct attribute_group tmp421_group = {
198	.attrs = tmp421_attr,
199	.is_visible = tmp421_is_visible,
200};
201
202static const struct attribute_group *tmp421_groups[] = {
203	&tmp421_group,
204	NULL
205};
206
207static 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
233static 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
292static 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
317static 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
328module_i2c_driver(tmp421_driver);
329
330MODULE_AUTHOR("Andre Prendel <andre.prendel@gmx.de>");
331MODULE_DESCRIPTION("Texas Instruments TMP421/422/423/441/442 temperature sensor driver");
332MODULE_LICENSE("GPL");
333