Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2008, 2010 Davide Rizzo <elpa.rizzo@gmail.com>
4 *
5 * The LM95241 is a sensor chip made by National Semiconductors.
6 * It reports up to three temperatures (its own plus up to two external ones).
7 * Complete datasheet can be obtained from National's website at:
8 * http://www.national.com/ds.cgi/LM/LM95241.pdf
9 */
10
11#include <linux/bitops.h>
12#include <linux/err.h>
13#include <linux/i2c.h>
14#include <linux/init.h>
15#include <linux/jiffies.h>
16#include <linux/hwmon.h>
17#include <linux/module.h>
18#include <linux/slab.h>
19
20#define DEVNAME "lm95241"
21
22static const unsigned short normal_i2c[] = {
23 0x19, 0x2a, 0x2b, I2C_CLIENT_END };
24
25/* LM95241 registers */
26#define LM95241_REG_R_MAN_ID 0xFE
27#define LM95241_REG_R_CHIP_ID 0xFF
28#define LM95241_REG_R_STATUS 0x02
29#define LM95241_REG_RW_CONFIG 0x03
30#define LM95241_REG_RW_REM_FILTER 0x06
31#define LM95241_REG_RW_TRUTHERM 0x07
32#define LM95241_REG_W_ONE_SHOT 0x0F
33#define LM95241_REG_R_LOCAL_TEMPH 0x10
34#define LM95241_REG_R_REMOTE1_TEMPH 0x11
35#define LM95241_REG_R_REMOTE2_TEMPH 0x12
36#define LM95241_REG_R_LOCAL_TEMPL 0x20
37#define LM95241_REG_R_REMOTE1_TEMPL 0x21
38#define LM95241_REG_R_REMOTE2_TEMPL 0x22
39#define LM95241_REG_RW_REMOTE_MODEL 0x30
40
41/* LM95241 specific bitfields */
42#define CFG_STOP BIT(6)
43#define CFG_CR0076 0x00
44#define CFG_CR0182 BIT(4)
45#define CFG_CR1000 BIT(5)
46#define CFG_CR2700 (BIT(4) | BIT(5))
47#define CFG_CRMASK (BIT(4) | BIT(5))
48#define R1MS_MASK BIT(0)
49#define R2MS_MASK BIT(2)
50#define R1DF_MASK BIT(1)
51#define R2DF_MASK BIT(2)
52#define R1FE_MASK BIT(0)
53#define R2FE_MASK BIT(2)
54#define R1DM BIT(0)
55#define R2DM BIT(1)
56#define TT1_SHIFT 0
57#define TT2_SHIFT 4
58#define TT_OFF 0
59#define TT_ON 1
60#define TT_MASK 7
61#define NATSEMI_MAN_ID 0x01
62#define LM95231_CHIP_ID 0xA1
63#define LM95241_CHIP_ID 0xA4
64
65static const u8 lm95241_reg_address[] = {
66 LM95241_REG_R_LOCAL_TEMPH,
67 LM95241_REG_R_LOCAL_TEMPL,
68 LM95241_REG_R_REMOTE1_TEMPH,
69 LM95241_REG_R_REMOTE1_TEMPL,
70 LM95241_REG_R_REMOTE2_TEMPH,
71 LM95241_REG_R_REMOTE2_TEMPL
72};
73
74/* Client data (each client gets its own) */
75struct lm95241_data {
76 struct i2c_client *client;
77 unsigned long last_updated; /* in jiffies */
78 unsigned long interval; /* in milli-seconds */
79 bool valid; /* false until following fields are valid */
80 /* registers values */
81 u8 temp[ARRAY_SIZE(lm95241_reg_address)];
82 u8 status, config, model, trutherm;
83};
84
85/* Conversions */
86static int temp_from_reg_signed(u8 val_h, u8 val_l)
87{
88 s16 val_hl = (val_h << 8) | val_l;
89 return val_hl * 1000 / 256;
90}
91
92static int temp_from_reg_unsigned(u8 val_h, u8 val_l)
93{
94 u16 val_hl = (val_h << 8) | val_l;
95 return val_hl * 1000 / 256;
96}
97
98static struct lm95241_data *lm95241_update_device(struct device *dev)
99{
100 struct lm95241_data *data = dev_get_drvdata(dev);
101 struct i2c_client *client = data->client;
102
103 if (time_after(jiffies, data->last_updated
104 + msecs_to_jiffies(data->interval)) ||
105 !data->valid) {
106 int i;
107
108 dev_dbg(dev, "Updating lm95241 data.\n");
109 for (i = 0; i < ARRAY_SIZE(lm95241_reg_address); i++)
110 data->temp[i]
111 = i2c_smbus_read_byte_data(client,
112 lm95241_reg_address[i]);
113
114 data->status = i2c_smbus_read_byte_data(client,
115 LM95241_REG_R_STATUS);
116 data->last_updated = jiffies;
117 data->valid = true;
118 }
119 return data;
120}
121
122static int lm95241_read_chip(struct device *dev, u32 attr, int channel,
123 long *val)
124{
125 struct lm95241_data *data = dev_get_drvdata(dev);
126
127 switch (attr) {
128 case hwmon_chip_update_interval:
129 *val = data->interval;
130 return 0;
131 default:
132 return -EOPNOTSUPP;
133 }
134}
135
136static int lm95241_read_temp(struct device *dev, u32 attr, int channel,
137 long *val)
138{
139 struct lm95241_data *data = lm95241_update_device(dev);
140
141 switch (attr) {
142 case hwmon_temp_input:
143 if (!channel || (data->config & BIT(channel - 1)))
144 *val = temp_from_reg_signed(data->temp[channel * 2],
145 data->temp[channel * 2 + 1]);
146 else
147 *val = temp_from_reg_unsigned(data->temp[channel * 2],
148 data->temp[channel * 2 + 1]);
149 return 0;
150 case hwmon_temp_min:
151 if (channel == 1)
152 *val = (data->config & R1DF_MASK) ? -128000 : 0;
153 else
154 *val = (data->config & R2DF_MASK) ? -128000 : 0;
155 return 0;
156 case hwmon_temp_max:
157 if (channel == 1)
158 *val = (data->config & R1DF_MASK) ? 127875 : 255875;
159 else
160 *val = (data->config & R2DF_MASK) ? 127875 : 255875;
161 return 0;
162 case hwmon_temp_type:
163 if (channel == 1)
164 *val = (data->model & R1MS_MASK) ? 1 : 2;
165 else
166 *val = (data->model & R2MS_MASK) ? 1 : 2;
167 return 0;
168 case hwmon_temp_fault:
169 if (channel == 1)
170 *val = !!(data->status & R1DM);
171 else
172 *val = !!(data->status & R2DM);
173 return 0;
174 default:
175 return -EOPNOTSUPP;
176 }
177}
178
179static int lm95241_read(struct device *dev, enum hwmon_sensor_types type,
180 u32 attr, int channel, long *val)
181{
182 switch (type) {
183 case hwmon_chip:
184 return lm95241_read_chip(dev, attr, channel, val);
185 case hwmon_temp:
186 return lm95241_read_temp(dev, attr, channel, val);
187 default:
188 return -EOPNOTSUPP;
189 }
190}
191
192static int lm95241_write_chip(struct device *dev, u32 attr, int channel,
193 long val)
194{
195 struct lm95241_data *data = dev_get_drvdata(dev);
196 int convrate;
197 u8 config;
198 int ret;
199
200 switch (attr) {
201 case hwmon_chip_update_interval:
202 config = data->config & ~CFG_CRMASK;
203 if (val < 130) {
204 convrate = 76;
205 config |= CFG_CR0076;
206 } else if (val < 590) {
207 convrate = 182;
208 config |= CFG_CR0182;
209 } else if (val < 1850) {
210 convrate = 1000;
211 config |= CFG_CR1000;
212 } else {
213 convrate = 2700;
214 config |= CFG_CR2700;
215 }
216 data->interval = convrate;
217 data->config = config;
218 ret = i2c_smbus_write_byte_data(data->client,
219 LM95241_REG_RW_CONFIG, config);
220 break;
221 default:
222 ret = -EOPNOTSUPP;
223 break;
224 }
225 return ret;
226}
227
228static int lm95241_write_temp(struct device *dev, u32 attr, int channel,
229 long val)
230{
231 struct lm95241_data *data = dev_get_drvdata(dev);
232 struct i2c_client *client = data->client;
233 int ret;
234
235 switch (attr) {
236 case hwmon_temp_min:
237 if (channel == 1) {
238 if (val < 0)
239 data->config |= R1DF_MASK;
240 else
241 data->config &= ~R1DF_MASK;
242 } else {
243 if (val < 0)
244 data->config |= R2DF_MASK;
245 else
246 data->config &= ~R2DF_MASK;
247 }
248 data->valid = false;
249 ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
250 data->config);
251 break;
252 case hwmon_temp_max:
253 if (channel == 1) {
254 if (val <= 127875)
255 data->config |= R1DF_MASK;
256 else
257 data->config &= ~R1DF_MASK;
258 } else {
259 if (val <= 127875)
260 data->config |= R2DF_MASK;
261 else
262 data->config &= ~R2DF_MASK;
263 }
264 data->valid = false;
265 ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG,
266 data->config);
267 break;
268 case hwmon_temp_type:
269 if (val != 1 && val != 2) {
270 ret = -EINVAL;
271 break;
272 }
273 if (channel == 1) {
274 data->trutherm &= ~(TT_MASK << TT1_SHIFT);
275 if (val == 1) {
276 data->model |= R1MS_MASK;
277 data->trutherm |= (TT_ON << TT1_SHIFT);
278 } else {
279 data->model &= ~R1MS_MASK;
280 data->trutherm |= (TT_OFF << TT1_SHIFT);
281 }
282 } else {
283 data->trutherm &= ~(TT_MASK << TT2_SHIFT);
284 if (val == 1) {
285 data->model |= R2MS_MASK;
286 data->trutherm |= (TT_ON << TT2_SHIFT);
287 } else {
288 data->model &= ~R2MS_MASK;
289 data->trutherm |= (TT_OFF << TT2_SHIFT);
290 }
291 }
292 ret = i2c_smbus_write_byte_data(client,
293 LM95241_REG_RW_REMOTE_MODEL,
294 data->model);
295 if (ret < 0)
296 break;
297 ret = i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
298 data->trutherm);
299 break;
300 default:
301 ret = -EOPNOTSUPP;
302 break;
303 }
304 return ret;
305}
306
307static int lm95241_write(struct device *dev, enum hwmon_sensor_types type,
308 u32 attr, int channel, long val)
309{
310 switch (type) {
311 case hwmon_chip:
312 return lm95241_write_chip(dev, attr, channel, val);
313 case hwmon_temp:
314 return lm95241_write_temp(dev, attr, channel, val);
315 default:
316 return -EOPNOTSUPP;
317 }
318}
319
320static umode_t lm95241_is_visible(const void *data,
321 enum hwmon_sensor_types type,
322 u32 attr, int channel)
323{
324 switch (type) {
325 case hwmon_chip:
326 switch (attr) {
327 case hwmon_chip_update_interval:
328 return 0644;
329 }
330 break;
331 case hwmon_temp:
332 switch (attr) {
333 case hwmon_temp_input:
334 return 0444;
335 case hwmon_temp_fault:
336 return 0444;
337 case hwmon_temp_min:
338 case hwmon_temp_max:
339 case hwmon_temp_type:
340 return 0644;
341 }
342 break;
343 default:
344 break;
345 }
346 return 0;
347}
348
349/* Return 0 if detection is successful, -ENODEV otherwise */
350static int lm95241_detect(struct i2c_client *new_client,
351 struct i2c_board_info *info)
352{
353 struct i2c_adapter *adapter = new_client->adapter;
354 const char *name;
355 int mfg_id, chip_id;
356
357 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
358 return -ENODEV;
359
360 mfg_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_MAN_ID);
361 if (mfg_id != NATSEMI_MAN_ID)
362 return -ENODEV;
363
364 chip_id = i2c_smbus_read_byte_data(new_client, LM95241_REG_R_CHIP_ID);
365 switch (chip_id) {
366 case LM95231_CHIP_ID:
367 name = "lm95231";
368 break;
369 case LM95241_CHIP_ID:
370 name = "lm95241";
371 break;
372 default:
373 return -ENODEV;
374 }
375
376 /* Fill the i2c board info */
377 strscpy(info->type, name, I2C_NAME_SIZE);
378 return 0;
379}
380
381static void lm95241_init_client(struct i2c_client *client,
382 struct lm95241_data *data)
383{
384 data->interval = 1000;
385 data->config = CFG_CR1000;
386 data->trutherm = (TT_OFF << TT1_SHIFT) | (TT_OFF << TT2_SHIFT);
387
388 i2c_smbus_write_byte_data(client, LM95241_REG_RW_CONFIG, data->config);
389 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REM_FILTER,
390 R1FE_MASK | R2FE_MASK);
391 i2c_smbus_write_byte_data(client, LM95241_REG_RW_TRUTHERM,
392 data->trutherm);
393 i2c_smbus_write_byte_data(client, LM95241_REG_RW_REMOTE_MODEL,
394 data->model);
395}
396
397static const struct hwmon_channel_info * const lm95241_info[] = {
398 HWMON_CHANNEL_INFO(chip,
399 HWMON_C_UPDATE_INTERVAL),
400 HWMON_CHANNEL_INFO(temp,
401 HWMON_T_INPUT,
402 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
403 HWMON_T_TYPE | HWMON_T_FAULT,
404 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
405 HWMON_T_TYPE | HWMON_T_FAULT),
406 NULL
407};
408
409static const struct hwmon_ops lm95241_hwmon_ops = {
410 .is_visible = lm95241_is_visible,
411 .read = lm95241_read,
412 .write = lm95241_write,
413};
414
415static const struct hwmon_chip_info lm95241_chip_info = {
416 .ops = &lm95241_hwmon_ops,
417 .info = lm95241_info,
418};
419
420static int lm95241_probe(struct i2c_client *client)
421{
422 struct device *dev = &client->dev;
423 struct lm95241_data *data;
424 struct device *hwmon_dev;
425
426 data = devm_kzalloc(dev, sizeof(struct lm95241_data), GFP_KERNEL);
427 if (!data)
428 return -ENOMEM;
429
430 data->client = client;
431
432 /* Initialize the LM95241 chip */
433 lm95241_init_client(client, data);
434
435 hwmon_dev = devm_hwmon_device_register_with_info(dev, client->name,
436 data,
437 &lm95241_chip_info,
438 NULL);
439 return PTR_ERR_OR_ZERO(hwmon_dev);
440}
441
442/* Driver data (common to all clients) */
443static const struct i2c_device_id lm95241_id[] = {
444 { "lm95231" },
445 { "lm95241" },
446 { }
447};
448MODULE_DEVICE_TABLE(i2c, lm95241_id);
449
450static struct i2c_driver lm95241_driver = {
451 .class = I2C_CLASS_HWMON,
452 .driver = {
453 .name = DEVNAME,
454 },
455 .probe = lm95241_probe,
456 .id_table = lm95241_id,
457 .detect = lm95241_detect,
458 .address_list = normal_i2c,
459};
460
461module_i2c_driver(lm95241_driver);
462
463MODULE_AUTHOR("Davide Rizzo <elpa.rizzo@gmail.com>");
464MODULE_DESCRIPTION("LM95231/LM95241 sensor driver");
465MODULE_LICENSE("GPL");