projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
libata: honour host controllers that want just one host
[linux-2.6-block.git] / drivers / hwmon / smsc47m1.c
CommitLineData
1da177e4
LT		 1/*
2 smsc47m1.c - Part of lm_sensors, Linux kernel modules
3 for hardware monitoring
4
6091780e
JD		 5 Supports the SMSC LPC47B27x, LPC47M10x, LPC47M112, LPC47M13x,
6 LPC47M14x, LPC47M15x, LPC47M192 and LPC47M997 Super-I/O chips.
1da177e4
LT		 7
8 Copyright (C) 2002 Mark D. Studebaker <mdsxyz123@yahoo.com>
9 Copyright (C) 2004 Jean Delvare <khali@linux-fr.org>
10 Ported to Linux 2.6 by Gabriele Gorla <gorlik@yahoo.com>
11 and Jean Delvare
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26*/
27
28#include <linux/module.h>
29#include <linux/slab.h>
30#include <linux/ioport.h>
31#include <linux/jiffies.h>
32#include <linux/i2c.h>
fde09509 33#include <linux/i2c-isa.h>
943b0830
MH		 34#include <linux/hwmon.h>
35#include <linux/err.h>
1da177e4 36#include <linux/init.h>
9a61bf63 37#include <linux/mutex.h>
ce8c6ce1 38#include <linux/sysfs.h>
1da177e4
LT		 39#include <asm/io.h>
40
1da177e4 41/* Address is autodetected, there is no default value */
2d8672c5 42static unsigned short address;
1da177e4
LT		 43
44/* Super-I/0 registers and commands */
45
46#define REG 0x2e /* The register to read/write */
47#define VAL 0x2f /* The value to read/write */
48
49static inline void
50superio_outb(int reg, int val)
51{
52 outb(reg, REG);
53 outb(val, VAL);
54}
55
56static inline int
57superio_inb(int reg)
58{
59 outb(reg, REG);
60 return inb(VAL);
61}
62
63/* logical device for fans is 0x0A */
64#define superio_select() superio_outb(0x07, 0x0A)
65
66static inline void
67superio_enter(void)
68{
69 outb(0x55, REG);
70}
71
72static inline void
73superio_exit(void)
74{
75 outb(0xAA, REG);
76}
77
78#define SUPERIO_REG_ACT 0x30
79#define SUPERIO_REG_BASE 0x60
80#define SUPERIO_REG_DEVID 0x20
81
82/* Logical device registers */
83
84#define SMSC_EXTENT 0x80
85
86/* nr is 0 or 1 in the macros below */
87#define SMSC47M1_REG_ALARM 0x04
88#define SMSC47M1_REG_TPIN(nr) (0x34 - (nr))
89#define SMSC47M1_REG_PPIN(nr) (0x36 - (nr))
90#define SMSC47M1_REG_PWM(nr) (0x56 + (nr))
91#define SMSC47M1_REG_FANDIV 0x58
92#define SMSC47M1_REG_FAN(nr) (0x59 + (nr))
93#define SMSC47M1_REG_FAN_PRELOAD(nr) (0x5B + (nr))
94
95#define MIN_FROM_REG(reg,div) ((reg)>=192 ? 0 : \
96 983040/((192-(reg))*(div)))
97#define FAN_FROM_REG(reg,div,preload) ((reg)<=(preload) || (reg)==255 ? 0 : \
98 983040/(((reg)-(preload))*(div)))
99#define DIV_FROM_REG(reg) (1 << (reg))
100#define PWM_FROM_REG(reg) (((reg) & 0x7E) << 1)
101#define PWM_EN_FROM_REG(reg) ((~(reg)) & 0x01)
102#define PWM_TO_REG(reg) (((reg) >> 1) & 0x7E)
103
104struct smsc47m1_data {
105 struct i2c_client client;
943b0830 106 struct class_device *class_dev;
9a61bf63 107 struct mutex lock;
1da177e4 108
9a61bf63 109 struct mutex update_lock;
1da177e4
LT		 110 unsigned long last_updated; /* In jiffies */
111
112 u8 fan[2]; /* Register value */
113 u8 fan_preload[2]; /* Register value */
114 u8 fan_div[2]; /* Register encoding, shifted right */
115 u8 alarms; /* Register encoding */
116 u8 pwm[2]; /* Register value (bit 7 is enable) */
117};
118
119
2d8672c5 120static int smsc47m1_detect(struct i2c_adapter *adapter);
1da177e4
LT		 121static int smsc47m1_detach_client(struct i2c_client *client);
122
123static int smsc47m1_read_value(struct i2c_client *client, u8 reg);
124static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value);
125
126static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
127 int init);
128
129
130static struct i2c_driver smsc47m1_driver = {
cdaf7934 131 .driver = {
87218842 132 .owner = THIS_MODULE,
cdaf7934
LR		 133 .name = "smsc47m1",
134 },
2d8672c5 135 .attach_adapter = smsc47m1_detect,
1da177e4
LT		 136 .detach_client = smsc47m1_detach_client,
137};
138
139/* nr is 0 or 1 in the callback functions below */
140
141static ssize_t get_fan(struct device *dev, char *buf, int nr)
142{
143 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
144 /* This chip (stupidly) stops monitoring fan speed if PWM is
145 enabled and duty cycle is 0%. This is fine if the monitoring
146 and control concern the same fan, but troublesome if they are
147 not (which could as well happen). */
148 int rpm = (data->pwm[nr] & 0x7F) == 0x00 ? 0 :
149 FAN_FROM_REG(data->fan[nr],
150 DIV_FROM_REG(data->fan_div[nr]),
151 data->fan_preload[nr]);
152 return sprintf(buf, "%d\n", rpm);
153}
154
155static ssize_t get_fan_min(struct device *dev, char *buf, int nr)
156{
157 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
158 int rpm = MIN_FROM_REG(data->fan_preload[nr],
159 DIV_FROM_REG(data->fan_div[nr]));
160 return sprintf(buf, "%d\n", rpm);
161}
162
163static ssize_t get_fan_div(struct device *dev, char *buf, int nr)
164{
165 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
166 return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
167}
168
169static ssize_t get_pwm(struct device *dev, char *buf, int nr)
170{
171 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
172 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm[nr]));
173}
174
175static ssize_t get_pwm_en(struct device *dev, char *buf, int nr)
176{
177 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
178 return sprintf(buf, "%d\n", PWM_EN_FROM_REG(data->pwm[nr]));
179}
180
a5099cfc 181static ssize_t get_alarms(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 182{
183 struct smsc47m1_data *data = smsc47m1_update_device(dev, 0);
184 return sprintf(buf, "%d\n", data->alarms);
185}
186
187static ssize_t set_fan_min(struct device *dev, const char *buf,
188 size_t count, int nr)
189{
190 struct i2c_client *client = to_i2c_client(dev);
191 struct smsc47m1_data *data = i2c_get_clientdata(client);
192 long rpmdiv, val = simple_strtol(buf, NULL, 10);
193
9a61bf63 194 mutex_lock(&data->update_lock);
1da177e4
LT		 195 rpmdiv = val * DIV_FROM_REG(data->fan_div[nr]);
196
197 if (983040 > 192 * rpmdiv || 2 * rpmdiv > 983040) {
9a61bf63 198 mutex_unlock(&data->update_lock);
1da177e4
LT		 199 return -EINVAL;
200 }
201
202 data->fan_preload[nr] = 192 - ((983040 + rpmdiv / 2) / rpmdiv);
203 smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
204 data->fan_preload[nr]);
9a61bf63 205 mutex_unlock(&data->update_lock);
1da177e4
LT		 206
207 return count;
208}
209
210/* Note: we save and restore the fan minimum here, because its value is
211 determined in part by the fan clock divider. This follows the principle
d6e05edc 212 of least surprise; the user doesn't expect the fan minimum to change just
1da177e4
LT		 213 because the divider changed. */
214static ssize_t set_fan_div(struct device *dev, const char *buf,
215 size_t count, int nr)
216{
217 struct i2c_client *client = to_i2c_client(dev);
218 struct smsc47m1_data *data = i2c_get_clientdata(client);
219
220 long new_div = simple_strtol(buf, NULL, 10), tmp;
221 u8 old_div = DIV_FROM_REG(data->fan_div[nr]);
222
223 if (new_div == old_div) /* No change */
224 return count;
225
9a61bf63 226 mutex_lock(&data->update_lock);
1da177e4
LT		 227 switch (new_div) {
228 case 1: data->fan_div[nr] = 0; break;
229 case 2: data->fan_div[nr] = 1; break;
230 case 4: data->fan_div[nr] = 2; break;
231 case 8: data->fan_div[nr] = 3; break;
232 default:
9a61bf63 233 mutex_unlock(&data->update_lock);
1da177e4
LT		 234 return -EINVAL;
235 }
236
237 tmp = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV) & 0x0F;
238 tmp |= (data->fan_div[0] << 4) | (data->fan_div[1] << 6);
239 smsc47m1_write_value(client, SMSC47M1_REG_FANDIV, tmp);
240
241 /* Preserve fan min */
242 tmp = 192 - (old_div * (192 - data->fan_preload[nr])
243 + new_div / 2) / new_div;
244 data->fan_preload[nr] = SENSORS_LIMIT(tmp, 0, 191);
245 smsc47m1_write_value(client, SMSC47M1_REG_FAN_PRELOAD(nr),
246 data->fan_preload[nr]);
9a61bf63 247 mutex_unlock(&data->update_lock);
1da177e4
LT		 248
249 return count;
250}
251
252static ssize_t set_pwm(struct device *dev, const char *buf,
253 size_t count, int nr)
254{
255 struct i2c_client *client = to_i2c_client(dev);
256 struct smsc47m1_data *data = i2c_get_clientdata(client);
257
258 long val = simple_strtol(buf, NULL, 10);
259
260 if (val < 0 || val > 255)
261 return -EINVAL;
262
9a61bf63 263 mutex_lock(&data->update_lock);
1da177e4
LT		 264 data->pwm[nr] &= 0x81; /* Preserve additional bits */
265 data->pwm[nr] |= PWM_TO_REG(val);
266 smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
267 data->pwm[nr]);
9a61bf63 268 mutex_unlock(&data->update_lock);
1da177e4
LT		 269
270 return count;
271}
272
273static ssize_t set_pwm_en(struct device *dev, const char *buf,
274 size_t count, int nr)
275{
276 struct i2c_client *client = to_i2c_client(dev);
277 struct smsc47m1_data *data = i2c_get_clientdata(client);
278
279 long val = simple_strtol(buf, NULL, 10);
280
281 if (val != 0 && val != 1)
282 return -EINVAL;
283
9a61bf63 284 mutex_lock(&data->update_lock);
1da177e4
LT		 285 data->pwm[nr] &= 0xFE; /* preserve the other bits */
286 data->pwm[nr] |= !val;
287 smsc47m1_write_value(client, SMSC47M1_REG_PWM(nr),
288 data->pwm[nr]);
9a61bf63 289 mutex_unlock(&data->update_lock);
1da177e4
LT		 290
291 return count;
292}
293
294#define fan_present(offset) \
a5099cfc 295static ssize_t get_fan##offset (struct device *dev, struct device_attribute *attr, char *buf) \
1da177e4
LT		 296{ \
297 return get_fan(dev, buf, offset - 1); \
298} \
a5099cfc 299static ssize_t get_fan##offset##_min (struct device *dev, struct device_attribute *attr, char *buf) \
1da177e4
LT		 300{ \
301 return get_fan_min(dev, buf, offset - 1); \
302} \
a5099cfc 303static ssize_t set_fan##offset##_min (struct device *dev, struct device_attribute *attr, \
1da177e4
LT		 304 const char *buf, size_t count) \
305{ \
306 return set_fan_min(dev, buf, count, offset - 1); \
307} \
a5099cfc 308static ssize_t get_fan##offset##_div (struct device *dev, struct device_attribute *attr, char *buf) \
1da177e4
LT		 309{ \
310 return get_fan_div(dev, buf, offset - 1); \
311} \
a5099cfc 312static ssize_t set_fan##offset##_div (struct device *dev, struct device_attribute *attr, \
1da177e4
LT		 313 const char *buf, size_t count) \
314{ \
315 return set_fan_div(dev, buf, count, offset - 1); \
316} \
a5099cfc 317static ssize_t get_pwm##offset (struct device *dev, struct device_attribute *attr, char *buf) \
1da177e4
LT		 318{ \
319 return get_pwm(dev, buf, offset - 1); \
320} \
a5099cfc 321static ssize_t set_pwm##offset (struct device *dev, struct device_attribute *attr, \
1da177e4
LT		 322 const char *buf, size_t count) \
323{ \
324 return set_pwm(dev, buf, count, offset - 1); \
325} \
a5099cfc 326static ssize_t get_pwm##offset##_en (struct device *dev, struct device_attribute *attr, char *buf) \
1da177e4
LT		 327{ \
328 return get_pwm_en(dev, buf, offset - 1); \
329} \
a5099cfc 330static ssize_t set_pwm##offset##_en (struct device *dev, struct device_attribute *attr, \
1da177e4
LT		 331 const char *buf, size_t count) \
332{ \
333 return set_pwm_en(dev, buf, count, offset - 1); \
334} \
335static DEVICE_ATTR(fan##offset##_input, S_IRUGO, get_fan##offset, \
336 NULL); \
337static DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
338 get_fan##offset##_min, set_fan##offset##_min); \
339static DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
340 get_fan##offset##_div, set_fan##offset##_div); \
341static DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \
342 get_pwm##offset, set_pwm##offset); \
343static DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \
344 get_pwm##offset##_en, set_pwm##offset##_en);
345
346fan_present(1);
347fan_present(2);
348
349static DEVICE_ATTR(alarms, S_IRUGO, get_alarms, NULL);
350
ce8c6ce1
JD		 351/* Almost all sysfs files may or may not be created depending on the chip
352 setup so we create them individually. It is still convenient to define a
353 group to remove them all at once. */
354static struct attribute *smsc47m1_attributes[] = {
355 &dev_attr_fan1_input.attr,
356 &dev_attr_fan1_min.attr,
357 &dev_attr_fan1_div.attr,
358 &dev_attr_fan2_input.attr,
359 &dev_attr_fan2_min.attr,
360 &dev_attr_fan2_div.attr,
361
362 &dev_attr_pwm1.attr,
363 &dev_attr_pwm1_enable.attr,
364 &dev_attr_pwm2.attr,
365 &dev_attr_pwm2_enable.attr,
366
367 &dev_attr_alarms.attr,
368 NULL
369};
370
371static const struct attribute_group smsc47m1_group = {
372 .attrs = smsc47m1_attributes,
373};
374
e6cfb3ad 375static int __init smsc47m1_find(unsigned short *addr)
1da177e4
LT		 376{
377 u8 val;
378
379 superio_enter();
380 val = superio_inb(SUPERIO_REG_DEVID);
381
382 /*
6091780e
JD		 383 * SMSC LPC47M10x/LPC47M112/LPC47M13x (device id 0x59), LPC47M14x
384 * (device id 0x5F) and LPC47B27x (device id 0x51) have fan control.
1da177e4 385 * The LPC47M15x and LPC47M192 chips "with hardware monitoring block"
ec5ce552 386 * can do much more besides (device id 0x60).
b890a07f
JD		 387 * The LPC47M997 is undocumented, but seems to be compatible with
388 * the LPC47M192, and has the same device id.
1da177e4
LT		 389 */
390 if (val == 0x51)
ec5ce552 391 printk(KERN_INFO "smsc47m1: Found SMSC LPC47B27x\n");
1da177e4 392 else if (val == 0x59)
6091780e
JD		 393 printk(KERN_INFO "smsc47m1: Found SMSC "
394 "LPC47M10x/LPC47M112/LPC47M13x\n");
1da177e4 395 else if (val == 0x5F)
ec5ce552
JD		 396 printk(KERN_INFO "smsc47m1: Found SMSC LPC47M14x\n");
397 else if (val == 0x60)
b890a07f
JD		 398 printk(KERN_INFO "smsc47m1: Found SMSC "
399 "LPC47M15x/LPC47M192/LPC47M997\n");
1da177e4
LT		 400 else {
401 superio_exit();
402 return -ENODEV;
403 }
404
405 superio_select();
2d8672c5
JD		 406 *addr = (superio_inb(SUPERIO_REG_BASE) << 8)
407 | superio_inb(SUPERIO_REG_BASE + 1);
1da177e4 408 val = superio_inb(SUPERIO_REG_ACT);
2d8672c5 409 if (*addr == 0 || (val & 0x01) == 0) {
1da177e4
LT		 410 printk(KERN_INFO "smsc47m1: Device is disabled, will not use\n");
411 superio_exit();
412 return -ENODEV;
413 }
414
415 superio_exit();
416 return 0;
417}
418
2d8672c5 419static int smsc47m1_detect(struct i2c_adapter *adapter)
1da177e4
LT		 420{
421 struct i2c_client *new_client;
422 struct smsc47m1_data *data;
423 int err = 0;
424 int fan1, fan2, pwm1, pwm2;
425
cdaf7934 426 if (!request_region(address, SMSC_EXTENT, smsc47m1_driver.driver.name)) {
1da177e4
LT		 427 dev_err(&adapter->dev, "Region 0x%x already in use!\n", address);
428 return -EBUSY;
429 }
430
ba9c2e8d 431 if (!(data = kzalloc(sizeof(struct smsc47m1_data), GFP_KERNEL))) {
1da177e4
LT		 432 err = -ENOMEM;
433 goto error_release;
434 }
1da177e4
LT		 435
436 new_client = &data->client;
437 i2c_set_clientdata(new_client, data);
438 new_client->addr = address;
9a61bf63 439 mutex_init(&data->lock);
1da177e4
LT		 440 new_client->adapter = adapter;
441 new_client->driver = &smsc47m1_driver;
442 new_client->flags = 0;
443
444 strlcpy(new_client->name, "smsc47m1", I2C_NAME_SIZE);
9a61bf63 445 mutex_init(&data->update_lock);
1da177e4
LT		 446
447 /* If no function is properly configured, there's no point in
448 actually registering the chip. */
449 fan1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(0)) & 0x05)
450 == 0x05;
451 fan2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_TPIN(1)) & 0x05)
452 == 0x05;
453 pwm1 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(0)) & 0x05)
454 == 0x04;
455 pwm2 = (smsc47m1_read_value(new_client, SMSC47M1_REG_PPIN(1)) & 0x05)
456 == 0x04;
457 if (!(fan1 || fan2 || pwm1 || pwm2)) {
0dd7699e
JD		 458 dev_warn(&adapter->dev, "Device at 0x%x is not configured, "
459 "will not use\n", new_client->addr);
1da177e4
LT		 460 err = -ENODEV;
461 goto error_free;
462 }
463
464 if ((err = i2c_attach_client(new_client)))
465 goto error_free;
466
467 /* Some values (fan min, clock dividers, pwm registers) may be
468 needed before any update is triggered, so we better read them
469 at least once here. We don't usually do it that way, but in
470 this particular case, manually reading 5 registers out of 8
471 doesn't make much sense and we're better using the existing
472 function. */
473 smsc47m1_update_device(&new_client->dev, 1);
474
943b0830 475 /* Register sysfs hooks */
1da177e4 476 if (fan1) {
ce8c6ce1
JD		 477 if ((err = device_create_file(&new_client->dev,
478 &dev_attr_fan1_input))
479 || (err = device_create_file(&new_client->dev,
480 &dev_attr_fan1_min))
481 || (err = device_create_file(&new_client->dev,
482 &dev_attr_fan1_div)))
483 goto error_remove_files;
1da177e4
LT		 484 } else
485 dev_dbg(&new_client->dev, "Fan 1 not enabled by hardware, "
486 "skipping\n");
487
488 if (fan2) {
ce8c6ce1
JD		 489 if ((err = device_create_file(&new_client->dev,
490 &dev_attr_fan2_input))
491 || (err = device_create_file(&new_client->dev,
492 &dev_attr_fan2_min))
493 || (err = device_create_file(&new_client->dev,
494 &dev_attr_fan2_div)))
495 goto error_remove_files;
1da177e4
LT		 496 } else
497 dev_dbg(&new_client->dev, "Fan 2 not enabled by hardware, "
498 "skipping\n");
499
500 if (pwm1) {
ce8c6ce1
JD		 501 if ((err = device_create_file(&new_client->dev,
502 &dev_attr_pwm1))
503 || (err = device_create_file(&new_client->dev,
504 &dev_attr_pwm1_enable)))
505 goto error_remove_files;
1da177e4
LT		 506 } else
507 dev_dbg(&new_client->dev, "PWM 1 not enabled by hardware, "
508 "skipping\n");
509 if (pwm2) {
ce8c6ce1
JD		 510 if ((err = device_create_file(&new_client->dev,
511 &dev_attr_pwm2))
512 || (err = device_create_file(&new_client->dev,
513 &dev_attr_pwm2_enable)))
514 goto error_remove_files;
1da177e4
LT		 515 } else
516 dev_dbg(&new_client->dev, "PWM 2 not enabled by hardware, "
517 "skipping\n");
518
ce8c6ce1
JD		 519 if ((err = device_create_file(&new_client->dev, &dev_attr_alarms)))
520 goto error_remove_files;
521
522 data->class_dev = hwmon_device_register(&new_client->dev);
523 if (IS_ERR(data->class_dev)) {
524 err = PTR_ERR(data->class_dev);
525 goto error_remove_files;
526 }
1da177e4
LT		 527
528 return 0;
529
ce8c6ce1
JD		 530error_remove_files:
531 sysfs_remove_group(&new_client->dev.kobj, &smsc47m1_group);
943b0830 532 i2c_detach_client(new_client);
1da177e4 533error_free:
1f57ff89 534 kfree(data);
1da177e4
LT		 535error_release:
536 release_region(address, SMSC_EXTENT);
537 return err;
538}
539
540static int smsc47m1_detach_client(struct i2c_client *client)
541{
943b0830 542 struct smsc47m1_data *data = i2c_get_clientdata(client);
1da177e4
LT		 543 int err;
544
943b0830 545 hwmon_device_unregister(data->class_dev);
ce8c6ce1 546 sysfs_remove_group(&client->dev.kobj, &smsc47m1_group);
943b0830 547
7bef5594 548 if ((err = i2c_detach_client(client)))
1da177e4 549 return err;
1da177e4
LT		 550
551 release_region(client->addr, SMSC_EXTENT);
943b0830 552 kfree(data);
1da177e4
LT		 553
554 return 0;
555}
556
557static int smsc47m1_read_value(struct i2c_client *client, u8 reg)
558{
559 int res;
560
9a61bf63 561 mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
1da177e4 562 res = inb_p(client->addr + reg);
9a61bf63 563 mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
1da177e4
LT		 564 return res;
565}
566
567static void smsc47m1_write_value(struct i2c_client *client, u8 reg, u8 value)
568{
9a61bf63 569 mutex_lock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
1da177e4 570 outb_p(value, client->addr + reg);
9a61bf63 571 mutex_unlock(&((struct smsc47m1_data *) i2c_get_clientdata(client))->lock);
1da177e4
LT		 572}
573
574static struct smsc47m1_data *smsc47m1_update_device(struct device *dev,
575 int init)
576{
577 struct i2c_client *client = to_i2c_client(dev);
578 struct smsc47m1_data *data = i2c_get_clientdata(client);
579
9a61bf63 580 mutex_lock(&data->update_lock);
1da177e4
LT		 581
582 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) || init) {
583 int i;
584
585 for (i = 0; i < 2; i++) {
586 data->fan[i] = smsc47m1_read_value(client,
587 SMSC47M1_REG_FAN(i));
588 data->fan_preload[i] = smsc47m1_read_value(client,
589 SMSC47M1_REG_FAN_PRELOAD(i));
590 data->pwm[i] = smsc47m1_read_value(client,
591 SMSC47M1_REG_PWM(i));
592 }
593
594 i = smsc47m1_read_value(client, SMSC47M1_REG_FANDIV);
595 data->fan_div[0] = (i >> 4) & 0x03;
596 data->fan_div[1] = i >> 6;
597
598 data->alarms = smsc47m1_read_value(client,
599 SMSC47M1_REG_ALARM) >> 6;
600 /* Clear alarms if needed */
601 if (data->alarms)
602 smsc47m1_write_value(client, SMSC47M1_REG_ALARM, 0xC0);
603
604 data->last_updated = jiffies;
605 }
606
9a61bf63 607 mutex_unlock(&data->update_lock);
1da177e4
LT		 608 return data;
609}
610
611static int __init sm_smsc47m1_init(void)
612{
2d8672c5 613 if (smsc47m1_find(&address)) {
1da177e4
LT		 614 return -ENODEV;
615 }
616
fde09509 617 return i2c_isa_add_driver(&smsc47m1_driver);
1da177e4
LT		 618}
619
620static void __exit sm_smsc47m1_exit(void)
621{
fde09509 622 i2c_isa_del_driver(&smsc47m1_driver);
1da177e4
LT		 623}
624
625MODULE_AUTHOR("Mark D. Studebaker <mdsxyz123@yahoo.com>");
626MODULE_DESCRIPTION("SMSC LPC47M1xx fan sensors driver");
627MODULE_LICENSE("GPL");
628
629module_init(sm_smsc47m1_init);
630module_exit(sm_smsc47m1_exit);
Linux 6.x block layer and io_uring tree(s)