Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 9914518e79800c977e20eda1335d43a4df813e3d

Authored by Shubhrajyoti Datta
Committed by Jean Delvare
1 parent 960f12f4d1
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

hwmon: (lm75) Add suspend/resume feature 

There is a shutdown feature at suspend it can be enabled to
reduce current consumption and resume it can be switched off.

Signed-off-by: Shubhrajyoti Datta <shubhrajyoti@ti.com>
Signed-off-by: Jean Delvare <khali@linux-fr.org>

Showing 2 changed files with 40 additions and 0 deletions Inline Diff

drivers/hwmon/lm75.c
Diff comments   View file @ 9914518
1 /* 1 /*
2 lm75.c - Part of lm_sensors, Linux kernel modules for hardware 2 lm75.c - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring 3 monitoring
4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> 4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
5 5
6 This program is free software; you can redistribute it and/or modify 6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by 7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or 8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version. 9 (at your option) any later version.
10 10
11 This program is distributed in the hope that it will be useful, 11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details. 14 GNU General Public License for more details.
15 15
16 You should have received a copy of the GNU General Public License 16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software 17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */ 19 */
20 20
21 #include <linux/module.h> 21 #include <linux/module.h>
22 #include <linux/init.h> 22 #include <linux/init.h>
23 #include <linux/slab.h> 23 #include <linux/slab.h>
24 #include <linux/jiffies.h> 24 #include <linux/jiffies.h>
25 #include <linux/i2c.h> 25 #include <linux/i2c.h>
26 #include <linux/hwmon.h> 26 #include <linux/hwmon.h>
27 #include <linux/hwmon-sysfs.h> 27 #include <linux/hwmon-sysfs.h>
28 #include <linux/err.h> 28 #include <linux/err.h>
29 #include <linux/mutex.h> 29 #include <linux/mutex.h>
30 #include "lm75.h" 30 #include "lm75.h"
31 31
32 32
33 /* 33 /*
34 * This driver handles the LM75 and compatible digital temperature sensors. 34 * This driver handles the LM75 and compatible digital temperature sensors.
35 */ 35 */
36 36
37 enum lm75_type { /* keep sorted in alphabetical order */ 37 enum lm75_type { /* keep sorted in alphabetical order */
38 ds1775, 38 ds1775,
39 ds75, 39 ds75,
40 lm75, 40 lm75,
41 lm75a, 41 lm75a,
42 max6625, 42 max6625,
43 max6626, 43 max6626,
44 mcp980x, 44 mcp980x,
45 stds75, 45 stds75,
46 tcn75, 46 tcn75,
47 tmp100, 47 tmp100,
48 tmp101, 48 tmp101,
49 tmp105, 49 tmp105,
50 tmp175, 50 tmp175,
51 tmp275, 51 tmp275,
52 tmp75, 52 tmp75,
53 }; 53 };
54 54
55 /* Addresses scanned */ 55 /* Addresses scanned */
56 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c, 56 static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4b, 0x4c,
57 0x4d, 0x4e, 0x4f, I2C_CLIENT_END }; 57 0x4d, 0x4e, 0x4f, I2C_CLIENT_END };
58 58
59 59
60 /* The LM75 registers */ 60 /* The LM75 registers */
61 #define LM75_REG_CONF 0x01 61 #define LM75_REG_CONF 0x01
62 static const u8 LM75_REG_TEMP[3] = { 62 static const u8 LM75_REG_TEMP[3] = {
63 0x00, /* input */ 63 0x00, /* input */
64 0x03, /* max */ 64 0x03, /* max */
65 0x02, /* hyst */ 65 0x02, /* hyst */
66 }; 66 };
67 67
68 /* Each client has this additional data */ 68 /* Each client has this additional data */
69 struct lm75_data { 69 struct lm75_data {
70 struct device *hwmon_dev; 70 struct device *hwmon_dev;
71 struct mutex update_lock; 71 struct mutex update_lock;
72 u8 orig_conf; 72 u8 orig_conf;
73 char valid; /* !=0 if registers are valid */ 73 char valid; /* !=0 if registers are valid */
74 unsigned long last_updated; /* In jiffies */ 74 unsigned long last_updated; /* In jiffies */
75 u16 temp[3]; /* Register values, 75 u16 temp[3]; /* Register values,
76 0 = input 76 0 = input
77 1 = max 77 1 = max
78 2 = hyst */ 78 2 = hyst */
79 }; 79 };
80 80
81 static int lm75_read_value(struct i2c_client *client, u8 reg); 81 static int lm75_read_value(struct i2c_client *client, u8 reg);
82 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value); 82 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value);
83 static struct lm75_data *lm75_update_device(struct device *dev); 83 static struct lm75_data *lm75_update_device(struct device *dev);
84 84
85 85
86 /*-----------------------------------------------------------------------*/ 86 /*-----------------------------------------------------------------------*/
87 87
88 /* sysfs attributes for hwmon */ 88 /* sysfs attributes for hwmon */
89 89
90 static ssize_t show_temp(struct device *dev, struct device_attribute *da, 90 static ssize_t show_temp(struct device *dev, struct device_attribute *da,
91 char *buf) 91 char *buf)
92 { 92 {
93 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 93 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
94 struct lm75_data *data = lm75_update_device(dev); 94 struct lm75_data *data = lm75_update_device(dev);
95 return sprintf(buf, "%d\n", 95 return sprintf(buf, "%d\n",
96 LM75_TEMP_FROM_REG(data->temp[attr->index])); 96 LM75_TEMP_FROM_REG(data->temp[attr->index]));
97 } 97 }
98 98
99 static ssize_t set_temp(struct device *dev, struct device_attribute *da, 99 static ssize_t set_temp(struct device *dev, struct device_attribute *da,
100 const char *buf, size_t count) 100 const char *buf, size_t count)
101 { 101 {
102 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 102 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
103 struct i2c_client *client = to_i2c_client(dev); 103 struct i2c_client *client = to_i2c_client(dev);
104 struct lm75_data *data = i2c_get_clientdata(client); 104 struct lm75_data *data = i2c_get_clientdata(client);
105 int nr = attr->index; 105 int nr = attr->index;
106 long temp = simple_strtol(buf, NULL, 10); 106 long temp = simple_strtol(buf, NULL, 10);
107 107
108 mutex_lock(&data->update_lock); 108 mutex_lock(&data->update_lock);
109 data->temp[nr] = LM75_TEMP_TO_REG(temp); 109 data->temp[nr] = LM75_TEMP_TO_REG(temp);
110 lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]); 110 lm75_write_value(client, LM75_REG_TEMP[nr], data->temp[nr]);
111 mutex_unlock(&data->update_lock); 111 mutex_unlock(&data->update_lock);
112 return count; 112 return count;
113 } 113 }
114 114
115 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, 115 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
116 show_temp, set_temp, 1); 116 show_temp, set_temp, 1);
117 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO, 117 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IWUSR | S_IRUGO,
118 show_temp, set_temp, 2); 118 show_temp, set_temp, 2);
119 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0); 119 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
120 120
121 static struct attribute *lm75_attributes[] = { 121 static struct attribute *lm75_attributes[] = {
122 &sensor_dev_attr_temp1_input.dev_attr.attr, 122 &sensor_dev_attr_temp1_input.dev_attr.attr,
123 &sensor_dev_attr_temp1_max.dev_attr.attr, 123 &sensor_dev_attr_temp1_max.dev_attr.attr,
124 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr, 124 &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
125 125
126 NULL 126 NULL
127 }; 127 };
128 128
129 static const struct attribute_group lm75_group = { 129 static const struct attribute_group lm75_group = {
130 .attrs = lm75_attributes, 130 .attrs = lm75_attributes,
131 }; 131 };
132 132
133 /*-----------------------------------------------------------------------*/ 133 /*-----------------------------------------------------------------------*/
134 134
135 /* device probe and removal */ 135 /* device probe and removal */
136 136
137 static int 137 static int
138 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id) 138 lm75_probe(struct i2c_client *client, const struct i2c_device_id *id)
139 { 139 {
140 struct lm75_data *data; 140 struct lm75_data *data;
141 int status; 141 int status;
142 u8 set_mask, clr_mask; 142 u8 set_mask, clr_mask;
143 int new; 143 int new;
144 144
145 if (!i2c_check_functionality(client->adapter, 145 if (!i2c_check_functionality(client->adapter,
146 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA)) 146 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
147 return -EIO; 147 return -EIO;
148 148
149 data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL); 149 data = kzalloc(sizeof(struct lm75_data), GFP_KERNEL);
150 if (!data) 150 if (!data)
151 return -ENOMEM; 151 return -ENOMEM;
152 152
153 i2c_set_clientdata(client, data); 153 i2c_set_clientdata(client, data);
154 mutex_init(&data->update_lock); 154 mutex_init(&data->update_lock);
155 155
156 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range. 156 /* Set to LM75 resolution (9 bits, 1/2 degree C) and range.
157 * Then tweak to be more precise when appropriate. 157 * Then tweak to be more precise when appropriate.
158 */ 158 */
159 set_mask = 0; 159 set_mask = 0;
160 clr_mask = (1 << 0) /* continuous conversions */ 160 clr_mask = (1 << 0) /* continuous conversions */
161 | (1 << 6) | (1 << 5); /* 9-bit mode */ 161 | (1 << 6) | (1 << 5); /* 9-bit mode */
162 162
163 /* configure as specified */ 163 /* configure as specified */
164 status = lm75_read_value(client, LM75_REG_CONF); 164 status = lm75_read_value(client, LM75_REG_CONF);
165 if (status < 0) { 165 if (status < 0) {
166 dev_dbg(&client->dev, "Can't read config? %d\n", status); 166 dev_dbg(&client->dev, "Can't read config? %d\n", status);
167 goto exit_free; 167 goto exit_free;
168 } 168 }
169 data->orig_conf = status; 169 data->orig_conf = status;
170 new = status & ~clr_mask; 170 new = status & ~clr_mask;
171 new |= set_mask; 171 new |= set_mask;
172 if (status != new) 172 if (status != new)
173 lm75_write_value(client, LM75_REG_CONF, new); 173 lm75_write_value(client, LM75_REG_CONF, new);
174 dev_dbg(&client->dev, "Config %02x\n", new); 174 dev_dbg(&client->dev, "Config %02x\n", new);
175 175
176 /* Register sysfs hooks */ 176 /* Register sysfs hooks */
177 status = sysfs_create_group(&client->dev.kobj, &lm75_group); 177 status = sysfs_create_group(&client->dev.kobj, &lm75_group);
178 if (status) 178 if (status)
179 goto exit_free; 179 goto exit_free;
180 180
181 data->hwmon_dev = hwmon_device_register(&client->dev); 181 data->hwmon_dev = hwmon_device_register(&client->dev);
182 if (IS_ERR(data->hwmon_dev)) { 182 if (IS_ERR(data->hwmon_dev)) {
183 status = PTR_ERR(data->hwmon_dev); 183 status = PTR_ERR(data->hwmon_dev);
184 goto exit_remove; 184 goto exit_remove;
185 } 185 }
186 186
187 dev_info(&client->dev, "%s: sensor '%s'\n", 187 dev_info(&client->dev, "%s: sensor '%s'\n",
188 dev_name(data->hwmon_dev), client->name); 188 dev_name(data->hwmon_dev), client->name);
189 189
190 return 0; 190 return 0;
191 191
192 exit_remove: 192 exit_remove:
193 sysfs_remove_group(&client->dev.kobj, &lm75_group); 193 sysfs_remove_group(&client->dev.kobj, &lm75_group);
194 exit_free: 194 exit_free:
195 kfree(data); 195 kfree(data);
196 return status; 196 return status;
197 } 197 }
198 198
199 static int lm75_remove(struct i2c_client *client) 199 static int lm75_remove(struct i2c_client *client)
200 { 200 {
201 struct lm75_data *data = i2c_get_clientdata(client); 201 struct lm75_data *data = i2c_get_clientdata(client);
202 202
203 hwmon_device_unregister(data->hwmon_dev); 203 hwmon_device_unregister(data->hwmon_dev);
204 sysfs_remove_group(&client->dev.kobj, &lm75_group); 204 sysfs_remove_group(&client->dev.kobj, &lm75_group);
205 lm75_write_value(client, LM75_REG_CONF, data->orig_conf); 205 lm75_write_value(client, LM75_REG_CONF, data->orig_conf);
206 kfree(data); 206 kfree(data);
207 return 0; 207 return 0;
208 } 208 }
209 209
210 static const struct i2c_device_id lm75_ids[] = { 210 static const struct i2c_device_id lm75_ids[] = {
211 { "ds1775", ds1775, }, 211 { "ds1775", ds1775, },
212 { "ds75", ds75, }, 212 { "ds75", ds75, },
213 { "lm75", lm75, }, 213 { "lm75", lm75, },
214 { "lm75a", lm75a, }, 214 { "lm75a", lm75a, },
215 { "max6625", max6625, }, 215 { "max6625", max6625, },
216 { "max6626", max6626, }, 216 { "max6626", max6626, },
217 { "mcp980x", mcp980x, }, 217 { "mcp980x", mcp980x, },
218 { "stds75", stds75, }, 218 { "stds75", stds75, },
219 { "tcn75", tcn75, }, 219 { "tcn75", tcn75, },
220 { "tmp100", tmp100, }, 220 { "tmp100", tmp100, },
221 { "tmp101", tmp101, }, 221 { "tmp101", tmp101, },
222 { "tmp105", tmp105, }, 222 { "tmp105", tmp105, },
223 { "tmp175", tmp175, }, 223 { "tmp175", tmp175, },
224 { "tmp275", tmp275, }, 224 { "tmp275", tmp275, },
225 { "tmp75", tmp75, }, 225 { "tmp75", tmp75, },
226 { /* LIST END */ } 226 { /* LIST END */ }
227 }; 227 };
228 MODULE_DEVICE_TABLE(i2c, lm75_ids); 228 MODULE_DEVICE_TABLE(i2c, lm75_ids);
229 229
230 /* Return 0 if detection is successful, -ENODEV otherwise */ 230 /* Return 0 if detection is successful, -ENODEV otherwise */
231 static int lm75_detect(struct i2c_client *new_client, 231 static int lm75_detect(struct i2c_client *new_client,
232 struct i2c_board_info *info) 232 struct i2c_board_info *info)
233 { 233 {
234 struct i2c_adapter *adapter = new_client->adapter; 234 struct i2c_adapter *adapter = new_client->adapter;
235 int i; 235 int i;
236 int cur, conf, hyst, os; 236 int cur, conf, hyst, os;
237 237
238 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 238 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
239 I2C_FUNC_SMBUS_WORD_DATA)) 239 I2C_FUNC_SMBUS_WORD_DATA))
240 return -ENODEV; 240 return -ENODEV;
241 241
242 /* Now, we do the remaining detection. There is no identification- 242 /* Now, we do the remaining detection. There is no identification-
243 dedicated register so we have to rely on several tricks: 243 dedicated register so we have to rely on several tricks:
244 unused bits, registers cycling over 8-address boundaries, 244 unused bits, registers cycling over 8-address boundaries,
245 addresses 0x04-0x07 returning the last read value. 245 addresses 0x04-0x07 returning the last read value.
246 The cycling+unused addresses combination is not tested, 246 The cycling+unused addresses combination is not tested,
247 since it would significantly slow the detection down and would 247 since it would significantly slow the detection down and would
248 hardly add any value. */ 248 hardly add any value. */
249 249
250 /* Unused addresses */ 250 /* Unused addresses */
251 cur = i2c_smbus_read_word_data(new_client, 0); 251 cur = i2c_smbus_read_word_data(new_client, 0);
252 conf = i2c_smbus_read_byte_data(new_client, 1); 252 conf = i2c_smbus_read_byte_data(new_client, 1);
253 hyst = i2c_smbus_read_word_data(new_client, 2); 253 hyst = i2c_smbus_read_word_data(new_client, 2);
254 if (i2c_smbus_read_word_data(new_client, 4) != hyst 254 if (i2c_smbus_read_word_data(new_client, 4) != hyst
255 || i2c_smbus_read_word_data(new_client, 5) != hyst 255 || i2c_smbus_read_word_data(new_client, 5) != hyst
256 || i2c_smbus_read_word_data(new_client, 6) != hyst 256 || i2c_smbus_read_word_data(new_client, 6) != hyst
257 || i2c_smbus_read_word_data(new_client, 7) != hyst) 257 || i2c_smbus_read_word_data(new_client, 7) != hyst)
258 return -ENODEV; 258 return -ENODEV;
259 os = i2c_smbus_read_word_data(new_client, 3); 259 os = i2c_smbus_read_word_data(new_client, 3);
260 if (i2c_smbus_read_word_data(new_client, 4) != os 260 if (i2c_smbus_read_word_data(new_client, 4) != os
261 || i2c_smbus_read_word_data(new_client, 5) != os 261 || i2c_smbus_read_word_data(new_client, 5) != os
262 || i2c_smbus_read_word_data(new_client, 6) != os 262 || i2c_smbus_read_word_data(new_client, 6) != os
263 || i2c_smbus_read_word_data(new_client, 7) != os) 263 || i2c_smbus_read_word_data(new_client, 7) != os)
264 return -ENODEV; 264 return -ENODEV;
265 265
266 /* Unused bits */ 266 /* Unused bits */
267 if (conf & 0xe0) 267 if (conf & 0xe0)
268 return -ENODEV; 268 return -ENODEV;
269 269
270 /* Addresses cycling */ 270 /* Addresses cycling */
271 for (i = 8; i < 0xff; i += 8) { 271 for (i = 8; i < 0xff; i += 8) {
272 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf 272 if (i2c_smbus_read_byte_data(new_client, i + 1) != conf
273 || i2c_smbus_read_word_data(new_client, i + 2) != hyst 273 || i2c_smbus_read_word_data(new_client, i + 2) != hyst
274 || i2c_smbus_read_word_data(new_client, i + 3) != os) 274 || i2c_smbus_read_word_data(new_client, i + 3) != os)
275 return -ENODEV; 275 return -ENODEV;
276 } 276 }
277 277
278 strlcpy(info->type, "lm75", I2C_NAME_SIZE); 278 strlcpy(info->type, "lm75", I2C_NAME_SIZE);
279 279
280 return 0; 280 return 0;
281 } 281 }
282 282
283 #ifdef CONFIG_PM
284 static int lm75_suspend(struct device *dev)
285 {
286 int status;
287 struct i2c_client *client = to_i2c_client(dev);
288 status = lm75_read_value(client, LM75_REG_CONF);
289 if (status < 0) {
290 dev_dbg(&client->dev, "Can't read config? %d\n", status);
291 return status;
292 }
293 status = status | LM75_SHUTDOWN;
294 lm75_write_value(client, LM75_REG_CONF, status);
295 return 0;
296 }
297
298 static int lm75_resume(struct device *dev)
299 {
300 int status;
301 struct i2c_client *client = to_i2c_client(dev);
302 status = lm75_read_value(client, LM75_REG_CONF);
303 if (status < 0) {
304 dev_dbg(&client->dev, "Can't read config? %d\n", status);
305 return status;
306 }
307 status = status & ~LM75_SHUTDOWN;
308 lm75_write_value(client, LM75_REG_CONF, status);
309 return 0;
310 }
311
312 static const struct dev_pm_ops lm75_dev_pm_ops = {
313 .suspend = lm75_suspend,
314 .resume = lm75_resume,
315 };
316 #define LM75_DEV_PM_OPS (&lm75_dev_pm_ops)
317 #else
318 #define LM75_DEV_PM_OPS NULL
319 #endif /* CONFIG_PM */
320
283 static struct i2c_driver lm75_driver = { 321 static struct i2c_driver lm75_driver = {
284 .class = I2C_CLASS_HWMON, 322 .class = I2C_CLASS_HWMON,
285 .driver = { 323 .driver = {
286 .name = "lm75", 324 .name = "lm75",
325 .pm = LM75_DEV_PM_OPS,
287 }, 326 },
288 .probe = lm75_probe, 327 .probe = lm75_probe,
289 .remove = lm75_remove, 328 .remove = lm75_remove,
290 .id_table = lm75_ids, 329 .id_table = lm75_ids,
291 .detect = lm75_detect, 330 .detect = lm75_detect,
292 .address_list = normal_i2c, 331 .address_list = normal_i2c,
293 }; 332 };
294 333
295 /*-----------------------------------------------------------------------*/ 334 /*-----------------------------------------------------------------------*/
296 335
297 /* register access */ 336 /* register access */
298 337
299 /* All registers are word-sized, except for the configuration register. 338 /* All registers are word-sized, except for the configuration register.
300 LM75 uses a high-byte first convention, which is exactly opposite to 339 LM75 uses a high-byte first convention, which is exactly opposite to
301 the SMBus standard. */ 340 the SMBus standard. */
302 static int lm75_read_value(struct i2c_client *client, u8 reg) 341 static int lm75_read_value(struct i2c_client *client, u8 reg)
303 { 342 {
304 int value; 343 int value;
305 344
306 if (reg == LM75_REG_CONF) 345 if (reg == LM75_REG_CONF)
307 return i2c_smbus_read_byte_data(client, reg); 346 return i2c_smbus_read_byte_data(client, reg);
308 347
309 value = i2c_smbus_read_word_data(client, reg); 348 value = i2c_smbus_read_word_data(client, reg);
310 return (value < 0) ? value : swab16(value); 349 return (value < 0) ? value : swab16(value);
311 } 350 }
312 351
313 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value) 352 static int lm75_write_value(struct i2c_client *client, u8 reg, u16 value)
314 { 353 {
315 if (reg == LM75_REG_CONF) 354 if (reg == LM75_REG_CONF)
316 return i2c_smbus_write_byte_data(client, reg, value); 355 return i2c_smbus_write_byte_data(client, reg, value);
317 else 356 else
318 return i2c_smbus_write_word_data(client, reg, swab16(value)); 357 return i2c_smbus_write_word_data(client, reg, swab16(value));
319 } 358 }
320 359
321 static struct lm75_data *lm75_update_device(struct device *dev) 360 static struct lm75_data *lm75_update_device(struct device *dev)
322 { 361 {
323 struct i2c_client *client = to_i2c_client(dev); 362 struct i2c_client *client = to_i2c_client(dev);
324 struct lm75_data *data = i2c_get_clientdata(client); 363 struct lm75_data *data = i2c_get_clientdata(client);
325 364
326 mutex_lock(&data->update_lock); 365 mutex_lock(&data->update_lock);
327 366
328 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 367 if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
329 || !data->valid) { 368 || !data->valid) {
330 int i; 369 int i;
331 dev_dbg(&client->dev, "Starting lm75 update\n"); 370 dev_dbg(&client->dev, "Starting lm75 update\n");
332 371
333 for (i = 0; i < ARRAY_SIZE(data->temp); i++) { 372 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
334 int status; 373 int status;
335 374
336 status = lm75_read_value(client, LM75_REG_TEMP[i]); 375 status = lm75_read_value(client, LM75_REG_TEMP[i]);
337 if (status < 0) 376 if (status < 0)
338 dev_dbg(&client->dev, "reg %d, err %d\n", 377 dev_dbg(&client->dev, "reg %d, err %d\n",
339 LM75_REG_TEMP[i], status); 378 LM75_REG_TEMP[i], status);
340 else 379 else
341 data->temp[i] = status; 380 data->temp[i] = status;
342 } 381 }
343 data->last_updated = jiffies; 382 data->last_updated = jiffies;
344 data->valid = 1; 383 data->valid = 1;
345 } 384 }
346 385
347 mutex_unlock(&data->update_lock); 386 mutex_unlock(&data->update_lock);
348 387
349 return data; 388 return data;
350 } 389 }
351 390
352 /*-----------------------------------------------------------------------*/ 391 /*-----------------------------------------------------------------------*/
353 392
354 /* module glue */ 393 /* module glue */
355 394
356 static int __init sensors_lm75_init(void) 395 static int __init sensors_lm75_init(void)
357 { 396 {
358 return i2c_add_driver(&lm75_driver); 397 return i2c_add_driver(&lm75_driver);
359 } 398 }
360 399
361 static void __exit sensors_lm75_exit(void) 400 static void __exit sensors_lm75_exit(void)
362 { 401 {
363 i2c_del_driver(&lm75_driver); 402 i2c_del_driver(&lm75_driver);
364 } 403 }
365 404
366 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>"); 405 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
367 MODULE_DESCRIPTION("LM75 driver"); 406 MODULE_DESCRIPTION("LM75 driver");
368 MODULE_LICENSE("GPL"); 407 MODULE_LICENSE("GPL");
369 408
370 module_init(sensors_lm75_init); 409 module_init(sensors_lm75_init);
371 module_exit(sensors_lm75_exit); 410 module_exit(sensors_lm75_exit);
372 411
drivers/hwmon/lm75.h
Diff comments   View file @ 9914518
1 /* 1 /*
2 lm75.h - Part of lm_sensors, Linux kernel modules for hardware 2 lm75.h - Part of lm_sensors, Linux kernel modules for hardware
3 monitoring 3 monitoring
4 Copyright (c) 2003 Mark M. Hoffman <mhoffman@lightlink.com> 4 Copyright (c) 2003 Mark M. Hoffman <mhoffman@lightlink.com>
5 5
6 This program is free software; you can redistribute it and/or modify 6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by 7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or 8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version. 9 (at your option) any later version.
10 10
11 This program is distributed in the hope that it will be useful, 11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details. 14 GNU General Public License for more details.
15 15
16 You should have received a copy of the GNU General Public License 16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software 17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */ 19 */
20 20
21 /* 21 /*
22 This file contains common code for encoding/decoding LM75 type 22 This file contains common code for encoding/decoding LM75 type
23 temperature readings, which are emulated by many of the chips 23 temperature readings, which are emulated by many of the chips
24 we support. As the user is unlikely to load more than one driver 24 we support. As the user is unlikely to load more than one driver
25 which contains this code, we don't worry about the wasted space. 25 which contains this code, we don't worry about the wasted space.
26 */ 26 */
27 27
28 #include <linux/hwmon.h> 28 #include <linux/hwmon.h>
29 29
30 /* straight from the datasheet */ 30 /* straight from the datasheet */
31 #define LM75_TEMP_MIN (-55000) 31 #define LM75_TEMP_MIN (-55000)
32 #define LM75_TEMP_MAX 125000 32 #define LM75_TEMP_MAX 125000
33 #define LM75_SHUTDOWN 0x01
33 34
34 /* TEMP: 0.001C/bit (-55C to +125C) 35 /* TEMP: 0.001C/bit (-55C to +125C)
35 REG: (0.5C/bit, two's complement) << 7 */ 36 REG: (0.5C/bit, two's complement) << 7 */
36 static inline u16 LM75_TEMP_TO_REG(long temp) 37 static inline u16 LM75_TEMP_TO_REG(long temp)
37 { 38 {
38 int ntemp = SENSORS_LIMIT(temp, LM75_TEMP_MIN, LM75_TEMP_MAX); 39 int ntemp = SENSORS_LIMIT(temp, LM75_TEMP_MIN, LM75_TEMP_MAX);
39 ntemp += (ntemp<0 ? -250 : 250); 40 ntemp += (ntemp<0 ? -250 : 250);
40 return (u16)((ntemp / 500) << 7); 41 return (u16)((ntemp / 500) << 7);
41 } 42 }
42 43
43 static inline int LM75_TEMP_FROM_REG(u16 reg) 44 static inline int LM75_TEMP_FROM_REG(u16 reg)
44 { 45 {
45 /* use integer division instead of equivalent right shift to 46 /* use integer division instead of equivalent right shift to
46 guarantee arithmetic shift and preserve the sign */ 47 guarantee arithmetic shift and preserve the sign */
47 return ((s16)reg / 128) * 500; 48 return ((s16)reg / 128) * 500;
48 } 49 }
49 50
50 51