blob: 9bde9644b102d9bcdade74ce20db444b832f9270 [file] [log] [blame]
Adrien Demarez4e233cb2009-12-09 20:35:50 +01001/*
2 * LM73 Sensor driver
3 * Based on LM75
4 *
5 * Copyright (C) 2007, CenoSYS (www.cenosys.com).
6 * Copyright (C) 2009, Bollore telecom (www.bolloretelecom.eu).
7 *
8 * Guillaume Ligneul <guillaume.ligneul@gmail.com>
9 * Adrien Demarez <adrien.demarez@bolloretelecom.eu>
10 * Jeremy Laine <jeremy.laine@bolloretelecom.eu>
Chris Verges2bf92332013-01-05 01:41:20 -080011 * Chris Verges <kg4ysn@gmail.com>
Adrien Demarez4e233cb2009-12-09 20:35:50 +010012 *
13 * This software program is licensed subject to the GNU General Public License
14 * (GPL).Version 2,June 1991, available at
15 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
16 */
17
18#include <linux/module.h>
19#include <linux/init.h>
Adrien Demarez4e233cb2009-12-09 20:35:50 +010020#include <linux/i2c.h>
21#include <linux/hwmon.h>
22#include <linux/hwmon-sysfs.h>
23#include <linux/err.h>
24
25
26/* Addresses scanned */
27static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4c,
28 0x4d, 0x4e, I2C_CLIENT_END };
29
Adrien Demarez4e233cb2009-12-09 20:35:50 +010030/* LM73 registers */
31#define LM73_REG_INPUT 0x00
32#define LM73_REG_CONF 0x01
33#define LM73_REG_MAX 0x02
34#define LM73_REG_MIN 0x03
35#define LM73_REG_CTRL 0x04
36#define LM73_REG_ID 0x07
37
Jean Delvare90f41022011-11-04 12:00:47 +010038#define LM73_ID 0x9001 /* 0x0190, byte-swapped */
Adrien Demarez4e233cb2009-12-09 20:35:50 +010039#define DRVNAME "lm73"
Guenter Roeck91bba682013-01-10 21:16:47 -080040#define LM73_TEMP_MIN (-256000 / 250)
41#define LM73_TEMP_MAX (255750 / 250)
Adrien Demarez4e233cb2009-12-09 20:35:50 +010042
Chris Verges8c14d122013-01-05 01:41:19 -080043#define LM73_CTRL_RES_SHIFT 5
44#define LM73_CTRL_RES_MASK (BIT(5) | BIT(6))
45#define LM73_CTRL_TO_MASK BIT(7)
Adrien Demarez4e233cb2009-12-09 20:35:50 +010046
Chris Verges2bf92332013-01-05 01:41:20 -080047#define LM73_CTRL_HI_SHIFT 2
48#define LM73_CTRL_LO_SHIFT 1
49
Chris Verges8c14d122013-01-05 01:41:19 -080050static const unsigned short lm73_convrates[] = {
51 14, /* 11-bits (0.25000 C/LSB): RES1 Bit = 0, RES0 Bit = 0 */
52 28, /* 12-bits (0.12500 C/LSB): RES1 Bit = 0, RES0 Bit = 1 */
53 56, /* 13-bits (0.06250 C/LSB): RES1 Bit = 1, RES0 Bit = 0 */
54 112, /* 14-bits (0.03125 C/LSB): RES1 Bit = 1, RES0 Bit = 1 */
55};
56
57struct lm73_data {
58 struct device *hwmon_dev;
59 struct mutex lock;
60 u8 ctrl; /* control register value */
61};
62
63/*-----------------------------------------------------------------------*/
Adrien Demarez4e233cb2009-12-09 20:35:50 +010064
65static ssize_t set_temp(struct device *dev, struct device_attribute *da,
66 const char *buf, size_t count)
67{
68 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
69 struct i2c_client *client = to_i2c_client(dev);
70 long temp;
71 short value;
Chris Verges06029342012-12-21 01:58:34 -080072 s32 err;
Adrien Demarez4e233cb2009-12-09 20:35:50 +010073
Frans Meulenbroeks179c4fd2012-01-04 20:58:52 +010074 int status = kstrtol(buf, 10, &temp);
Adrien Demarez4e233cb2009-12-09 20:35:50 +010075 if (status < 0)
76 return status;
77
78 /* Write value */
Guenter Roeck91bba682013-01-10 21:16:47 -080079 value = clamp_val(temp / 250, LM73_TEMP_MIN, LM73_TEMP_MAX) << 5;
Chris Verges06029342012-12-21 01:58:34 -080080 err = i2c_smbus_write_word_swapped(client, attr->index, value);
81 return (err < 0) ? err : count;
Adrien Demarez4e233cb2009-12-09 20:35:50 +010082}
83
84static ssize_t show_temp(struct device *dev, struct device_attribute *da,
85 char *buf)
86{
87 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
88 struct i2c_client *client = to_i2c_client(dev);
Chris Verges06029342012-12-21 01:58:34 -080089 int temp;
90
91 s32 err = i2c_smbus_read_word_swapped(client, attr->index);
92 if (err < 0)
93 return err;
94
Adrien Demarez4e233cb2009-12-09 20:35:50 +010095 /* use integer division instead of equivalent right shift to
96 guarantee arithmetic shift and preserve the sign */
Chris Verges06029342012-12-21 01:58:34 -080097 temp = (((s16) err) * 250) / 32;
98 return scnprintf(buf, PAGE_SIZE, "%d\n", temp);
Adrien Demarez4e233cb2009-12-09 20:35:50 +010099}
100
Chris Verges8c14d122013-01-05 01:41:19 -0800101static ssize_t set_convrate(struct device *dev, struct device_attribute *da,
102 const char *buf, size_t count)
103{
104 struct i2c_client *client = to_i2c_client(dev);
105 struct lm73_data *data = i2c_get_clientdata(client);
106 unsigned long convrate;
107 s32 err;
108 int res = 0;
109
110 err = kstrtoul(buf, 10, &convrate);
111 if (err < 0)
112 return err;
113
114 /*
115 * Convert the desired conversion rate into register bits.
116 * res is already initialized, and everything past the second-to-last
117 * value in the array is treated as belonging to the last value
118 * in the array.
119 */
120 while (res < (ARRAY_SIZE(lm73_convrates) - 1) &&
121 convrate > lm73_convrates[res])
122 res++;
123
124 mutex_lock(&data->lock);
125 data->ctrl &= LM73_CTRL_TO_MASK;
126 data->ctrl |= res << LM73_CTRL_RES_SHIFT;
127 err = i2c_smbus_write_byte_data(client, LM73_REG_CTRL, data->ctrl);
128 mutex_unlock(&data->lock);
129
130 if (err < 0)
131 return err;
132
133 return count;
134}
135
136static ssize_t show_convrate(struct device *dev, struct device_attribute *da,
137 char *buf)
138{
139 struct i2c_client *client = to_i2c_client(dev);
140 struct lm73_data *data = i2c_get_clientdata(client);
141 int res;
142
143 res = (data->ctrl & LM73_CTRL_RES_MASK) >> LM73_CTRL_RES_SHIFT;
144 return scnprintf(buf, PAGE_SIZE, "%hu\n", lm73_convrates[res]);
145}
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100146
Chris Verges2bf92332013-01-05 01:41:20 -0800147static ssize_t show_maxmin_alarm(struct device *dev,
148 struct device_attribute *da, char *buf)
149{
150 struct i2c_client *client = to_i2c_client(dev);
151 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
152 struct lm73_data *data = i2c_get_clientdata(client);
153 s32 ctrl;
154
155 mutex_lock(&data->lock);
156 ctrl = i2c_smbus_read_byte_data(client, LM73_REG_CTRL);
157 if (ctrl < 0)
158 goto abort;
159 data->ctrl = ctrl;
160 mutex_unlock(&data->lock);
161
162 return scnprintf(buf, PAGE_SIZE, "%d\n", (ctrl >> attr->index) & 1);
163
164abort:
165 mutex_unlock(&data->lock);
166 return ctrl;
167}
168
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100169/*-----------------------------------------------------------------------*/
170
171/* sysfs attributes for hwmon */
172
173static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
174 show_temp, set_temp, LM73_REG_MAX);
175static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
176 show_temp, set_temp, LM73_REG_MIN);
177static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO,
178 show_temp, NULL, LM73_REG_INPUT);
Chris Verges8c14d122013-01-05 01:41:19 -0800179static SENSOR_DEVICE_ATTR(update_interval, S_IWUSR | S_IRUGO,
180 show_convrate, set_convrate, 0);
Chris Verges2bf92332013-01-05 01:41:20 -0800181static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO,
182 show_maxmin_alarm, NULL, LM73_CTRL_HI_SHIFT);
183static SENSOR_DEVICE_ATTR(temp1_min_alarm, S_IRUGO,
184 show_maxmin_alarm, NULL, LM73_CTRL_LO_SHIFT);
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100185
186static struct attribute *lm73_attributes[] = {
187 &sensor_dev_attr_temp1_input.dev_attr.attr,
188 &sensor_dev_attr_temp1_max.dev_attr.attr,
189 &sensor_dev_attr_temp1_min.dev_attr.attr,
Chris Verges8c14d122013-01-05 01:41:19 -0800190 &sensor_dev_attr_update_interval.dev_attr.attr,
Chris Verges2bf92332013-01-05 01:41:20 -0800191 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
192 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100193 NULL
194};
195
196static const struct attribute_group lm73_group = {
197 .attrs = lm73_attributes,
198};
199
200/*-----------------------------------------------------------------------*/
201
202/* device probe and removal */
203
204static int
205lm73_probe(struct i2c_client *client, const struct i2c_device_id *id)
206{
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100207 int status;
Chris Verges8c14d122013-01-05 01:41:19 -0800208 struct lm73_data *data;
209 int ctrl;
210
211 data = devm_kzalloc(&client->dev, sizeof(struct lm73_data),
212 GFP_KERNEL);
213 if (!data)
214 return -ENOMEM;
215
216 i2c_set_clientdata(client, data);
217 mutex_init(&data->lock);
218
219 ctrl = i2c_smbus_read_byte_data(client, LM73_REG_CTRL);
220 if (ctrl < 0)
221 return ctrl;
222 data->ctrl = ctrl;
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100223
224 /* Register sysfs hooks */
225 status = sysfs_create_group(&client->dev.kobj, &lm73_group);
226 if (status)
227 return status;
228
Chris Verges8c14d122013-01-05 01:41:19 -0800229 data->hwmon_dev = hwmon_device_register(&client->dev);
230 if (IS_ERR(data->hwmon_dev)) {
231 status = PTR_ERR(data->hwmon_dev);
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100232 goto exit_remove;
233 }
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100234
235 dev_info(&client->dev, "%s: sensor '%s'\n",
Chris Verges8c14d122013-01-05 01:41:19 -0800236 dev_name(data->hwmon_dev), client->name);
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100237
238 return 0;
239
240exit_remove:
241 sysfs_remove_group(&client->dev.kobj, &lm73_group);
242 return status;
243}
244
245static int lm73_remove(struct i2c_client *client)
246{
Chris Verges8c14d122013-01-05 01:41:19 -0800247 struct lm73_data *data = i2c_get_clientdata(client);
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100248
Chris Verges8c14d122013-01-05 01:41:19 -0800249 hwmon_device_unregister(data->hwmon_dev);
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100250 sysfs_remove_group(&client->dev.kobj, &lm73_group);
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100251 return 0;
252}
253
254static const struct i2c_device_id lm73_ids[] = {
Jean Delvare1f86df42009-12-14 21:17:26 +0100255 { "lm73", 0 },
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100256 { /* LIST END */ }
257};
258MODULE_DEVICE_TABLE(i2c, lm73_ids);
259
260/* Return 0 if detection is successful, -ENODEV otherwise */
Jean Delvare310ec792009-12-14 21:17:23 +0100261static int lm73_detect(struct i2c_client *new_client,
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100262 struct i2c_board_info *info)
263{
264 struct i2c_adapter *adapter = new_client->adapter;
Jean Delvare24d6e2a2011-11-04 12:00:46 +0100265 int id, ctrl, conf;
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100266
267 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
268 I2C_FUNC_SMBUS_WORD_DATA))
269 return -ENODEV;
270
Jean Delvare24d6e2a2011-11-04 12:00:46 +0100271 /*
272 * Do as much detection as possible with byte reads first, as word
273 * reads can confuse other devices.
274 */
275 ctrl = i2c_smbus_read_byte_data(new_client, LM73_REG_CTRL);
276 if (ctrl < 0 || (ctrl & 0x10))
277 return -ENODEV;
278
279 conf = i2c_smbus_read_byte_data(new_client, LM73_REG_CONF);
280 if (conf < 0 || (conf & 0x0c))
281 return -ENODEV;
282
283 id = i2c_smbus_read_byte_data(new_client, LM73_REG_ID);
284 if (id < 0 || id != (LM73_ID & 0xff))
285 return -ENODEV;
286
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100287 /* Check device ID */
288 id = i2c_smbus_read_word_data(new_client, LM73_REG_ID);
Jean Delvare24d6e2a2011-11-04 12:00:46 +0100289 if (id < 0 || id != LM73_ID)
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100290 return -ENODEV;
291
292 strlcpy(info->type, "lm73", I2C_NAME_SIZE);
293
294 return 0;
295}
296
297static struct i2c_driver lm73_driver = {
298 .class = I2C_CLASS_HWMON,
299 .driver = {
300 .name = "lm73",
301 },
302 .probe = lm73_probe,
303 .remove = lm73_remove,
304 .id_table = lm73_ids,
305 .detect = lm73_detect,
Jean Delvarec3813d62009-12-14 21:17:25 +0100306 .address_list = normal_i2c,
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100307};
308
Axel Linf0967ee2012-01-20 15:38:18 +0800309module_i2c_driver(lm73_driver);
Adrien Demarez4e233cb2009-12-09 20:35:50 +0100310
311MODULE_AUTHOR("Guillaume Ligneul <guillaume.ligneul@gmail.com>");
312MODULE_DESCRIPTION("LM73 driver");
313MODULE_LICENSE("GPL");