Merge tag 'net-6.5-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net
[platform/kernel/linux-starfive.git] / drivers / hwmon / f75375s.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * f75375s.c - driver for the Fintek F75375/SP, F75373 and
4  *             F75387SG/RG hardware monitoring features
5  * Copyright (C) 2006-2007  Riku Voipio
6  *
7  * Datasheets available at:
8  *
9  * f75375:
10  * http://www.fintek.com.tw/files/productfiles/F75375_V026P.pdf
11  *
12  * f75373:
13  * http://www.fintek.com.tw/files/productfiles/F75373_V025P.pdf
14  *
15  * f75387:
16  * http://www.fintek.com.tw/files/productfiles/F75387_V027P.pdf
17  */
18
19 #include <linux/module.h>
20 #include <linux/jiffies.h>
21 #include <linux/hwmon.h>
22 #include <linux/hwmon-sysfs.h>
23 #include <linux/i2c.h>
24 #include <linux/err.h>
25 #include <linux/mutex.h>
26 #include <linux/f75375s.h>
27 #include <linux/slab.h>
28
29 /* Addresses to scan */
30 static const unsigned short normal_i2c[] = { 0x2d, 0x2e, I2C_CLIENT_END };
31
32 enum chips { f75373, f75375, f75387 };
33
34 /* Fintek F75375 registers  */
35 #define F75375_REG_CONFIG0              0x0
36 #define F75375_REG_CONFIG1              0x1
37 #define F75375_REG_CONFIG2              0x2
38 #define F75375_REG_CONFIG3              0x3
39 #define F75375_REG_ADDR                 0x4
40 #define F75375_REG_INTR                 0x31
41 #define F75375_CHIP_ID                  0x5A
42 #define F75375_REG_VERSION              0x5C
43 #define F75375_REG_VENDOR               0x5D
44 #define F75375_REG_FAN_TIMER            0x60
45
46 #define F75375_REG_VOLT(nr)             (0x10 + (nr))
47 #define F75375_REG_VOLT_HIGH(nr)        (0x20 + (nr) * 2)
48 #define F75375_REG_VOLT_LOW(nr)         (0x21 + (nr) * 2)
49
50 #define F75375_REG_TEMP(nr)             (0x14 + (nr))
51 #define F75387_REG_TEMP11_LSB(nr)       (0x1a + (nr))
52 #define F75375_REG_TEMP_HIGH(nr)        (0x28 + (nr) * 2)
53 #define F75375_REG_TEMP_HYST(nr)        (0x29 + (nr) * 2)
54
55 #define F75375_REG_FAN(nr)              (0x16 + (nr) * 2)
56 #define F75375_REG_FAN_MIN(nr)          (0x2C + (nr) * 2)
57 #define F75375_REG_FAN_FULL(nr)         (0x70 + (nr) * 0x10)
58 #define F75375_REG_FAN_PWM_DUTY(nr)     (0x76 + (nr) * 0x10)
59 #define F75375_REG_FAN_PWM_CLOCK(nr)    (0x7D + (nr) * 0x10)
60
61 #define F75375_REG_FAN_EXP(nr)          (0x74 + (nr) * 0x10)
62 #define F75375_REG_FAN_B_TEMP(nr, step) ((0xA0 + (nr) * 0x10) + (step))
63 #define F75375_REG_FAN_B_SPEED(nr, step) \
64         ((0xA5 + (nr) * 0x10) + (step) * 2)
65
66 #define F75375_REG_PWM1_RAISE_DUTY      0x69
67 #define F75375_REG_PWM2_RAISE_DUTY      0x6A
68 #define F75375_REG_PWM1_DROP_DUTY       0x6B
69 #define F75375_REG_PWM2_DROP_DUTY       0x6C
70
71 #define F75375_FAN_CTRL_LINEAR(nr)      (4 + nr)
72 #define F75387_FAN_CTRL_LINEAR(nr)      (1 + ((nr) * 4))
73 #define FAN_CTRL_MODE(nr)               (4 + ((nr) * 2))
74 #define F75387_FAN_DUTY_MODE(nr)        (2 + ((nr) * 4))
75 #define F75387_FAN_MANU_MODE(nr)        ((nr) * 4)
76
77 /*
78  * Data structures and manipulation thereof
79  */
80
81 struct f75375_data {
82         unsigned short addr;
83         struct device *hwmon_dev;
84
85         const char *name;
86         int kind;
87         struct mutex update_lock; /* protect register access */
88         bool valid;
89         unsigned long last_updated;     /* In jiffies */
90         unsigned long last_limits;      /* In jiffies */
91
92         /* Register values */
93         u8 in[4];
94         u8 in_max[4];
95         u8 in_min[4];
96         u16 fan[2];
97         u16 fan_min[2];
98         u16 fan_max[2];
99         u16 fan_target[2];
100         u8 fan_timer;
101         u8 pwm[2];
102         u8 pwm_mode[2];
103         u8 pwm_enable[2];
104         /*
105          * f75387: For remote temperature reading, it uses signed 11-bit
106          * values with LSB = 0.125 degree Celsius, left-justified in 16-bit
107          * registers. For original 8-bit temp readings, the LSB just is 0.
108          */
109         s16 temp11[2];
110         s8 temp_high[2];
111         s8 temp_max_hyst[2];
112 };
113
114 static int f75375_detect(struct i2c_client *client,
115                          struct i2c_board_info *info);
116 static int f75375_probe(struct i2c_client *client);
117 static void f75375_remove(struct i2c_client *client);
118
119 static const struct i2c_device_id f75375_id[] = {
120         { "f75373", f75373 },
121         { "f75375", f75375 },
122         { "f75387", f75387 },
123         { }
124 };
125 MODULE_DEVICE_TABLE(i2c, f75375_id);
126
127 static struct i2c_driver f75375_driver = {
128         .class = I2C_CLASS_HWMON,
129         .driver = {
130                 .name = "f75375",
131         },
132         .probe = f75375_probe,
133         .remove = f75375_remove,
134         .id_table = f75375_id,
135         .detect = f75375_detect,
136         .address_list = normal_i2c,
137 };
138
139 static inline int f75375_read8(struct i2c_client *client, u8 reg)
140 {
141         return i2c_smbus_read_byte_data(client, reg);
142 }
143
144 /* in most cases, should be called while holding update_lock */
145 static inline u16 f75375_read16(struct i2c_client *client, u8 reg)
146 {
147         return (i2c_smbus_read_byte_data(client, reg) << 8)
148                 | i2c_smbus_read_byte_data(client, reg + 1);
149 }
150
151 static inline void f75375_write8(struct i2c_client *client, u8 reg,
152                 u8 value)
153 {
154         i2c_smbus_write_byte_data(client, reg, value);
155 }
156
157 static inline void f75375_write16(struct i2c_client *client, u8 reg,
158                 u16 value)
159 {
160         int err = i2c_smbus_write_byte_data(client, reg, (value >> 8));
161         if (err)
162                 return;
163         i2c_smbus_write_byte_data(client, reg + 1, (value & 0xFF));
164 }
165
166 static void f75375_write_pwm(struct i2c_client *client, int nr)
167 {
168         struct f75375_data *data = i2c_get_clientdata(client);
169         if (data->kind == f75387)
170                 f75375_write16(client, F75375_REG_FAN_EXP(nr), data->pwm[nr]);
171         else
172                 f75375_write8(client, F75375_REG_FAN_PWM_DUTY(nr),
173                               data->pwm[nr]);
174 }
175
176 static struct f75375_data *f75375_update_device(struct device *dev)
177 {
178         struct i2c_client *client = to_i2c_client(dev);
179         struct f75375_data *data = i2c_get_clientdata(client);
180         int nr;
181
182         mutex_lock(&data->update_lock);
183
184         /* Limit registers cache is refreshed after 60 seconds */
185         if (time_after(jiffies, data->last_limits + 60 * HZ)
186                 || !data->valid) {
187                 for (nr = 0; nr < 2; nr++) {
188                         data->temp_high[nr] =
189                                 f75375_read8(client, F75375_REG_TEMP_HIGH(nr));
190                         data->temp_max_hyst[nr] =
191                                 f75375_read8(client, F75375_REG_TEMP_HYST(nr));
192                         data->fan_max[nr] =
193                                 f75375_read16(client, F75375_REG_FAN_FULL(nr));
194                         data->fan_min[nr] =
195                                 f75375_read16(client, F75375_REG_FAN_MIN(nr));
196                         data->fan_target[nr] =
197                                 f75375_read16(client, F75375_REG_FAN_EXP(nr));
198                 }
199                 for (nr = 0; nr < 4; nr++) {
200                         data->in_max[nr] =
201                                 f75375_read8(client, F75375_REG_VOLT_HIGH(nr));
202                         data->in_min[nr] =
203                                 f75375_read8(client, F75375_REG_VOLT_LOW(nr));
204                 }
205                 data->fan_timer = f75375_read8(client, F75375_REG_FAN_TIMER);
206                 data->last_limits = jiffies;
207         }
208
209         /* Measurement registers cache is refreshed after 2 second */
210         if (time_after(jiffies, data->last_updated + 2 * HZ)
211                 || !data->valid) {
212                 for (nr = 0; nr < 2; nr++) {
213                         data->pwm[nr] = f75375_read8(client,
214                                 F75375_REG_FAN_PWM_DUTY(nr));
215                         /* assign MSB, therefore shift it by 8 bits */
216                         data->temp11[nr] =
217                                 f75375_read8(client, F75375_REG_TEMP(nr)) << 8;
218                         if (data->kind == f75387)
219                                 /* merge F75387's temperature LSB (11-bit) */
220                                 data->temp11[nr] |=
221                                         f75375_read8(client,
222                                                      F75387_REG_TEMP11_LSB(nr));
223                         data->fan[nr] =
224                                 f75375_read16(client, F75375_REG_FAN(nr));
225                 }
226                 for (nr = 0; nr < 4; nr++)
227                         data->in[nr] =
228                                 f75375_read8(client, F75375_REG_VOLT(nr));
229
230                 data->last_updated = jiffies;
231                 data->valid = true;
232         }
233
234         mutex_unlock(&data->update_lock);
235         return data;
236 }
237
238 static inline u16 rpm_from_reg(u16 reg)
239 {
240         if (reg == 0 || reg == 0xffff)
241                 return 0;
242         return 1500000 / reg;
243 }
244
245 static inline u16 rpm_to_reg(int rpm)
246 {
247         if (rpm < 367 || rpm > 0xffff)
248                 return 0xffff;
249         return 1500000 / rpm;
250 }
251
252 static bool duty_mode_enabled(u8 pwm_enable)
253 {
254         switch (pwm_enable) {
255         case 0: /* Manual, duty mode (full speed) */
256         case 1: /* Manual, duty mode */
257         case 4: /* Auto, duty mode */
258                 return true;
259         case 2: /* Auto, speed mode */
260         case 3: /* Manual, speed mode */
261                 return false;
262         default:
263                 WARN(1, "Unexpected pwm_enable value %d\n", pwm_enable);
264                 return true;
265         }
266 }
267
268 static bool auto_mode_enabled(u8 pwm_enable)
269 {
270         switch (pwm_enable) {
271         case 0: /* Manual, duty mode (full speed) */
272         case 1: /* Manual, duty mode */
273         case 3: /* Manual, speed mode */
274                 return false;
275         case 2: /* Auto, speed mode */
276         case 4: /* Auto, duty mode */
277                 return true;
278         default:
279                 WARN(1, "Unexpected pwm_enable value %d\n", pwm_enable);
280                 return false;
281         }
282 }
283
284 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
285                 const char *buf, size_t count)
286 {
287         int nr = to_sensor_dev_attr(attr)->index;
288         struct i2c_client *client = to_i2c_client(dev);
289         struct f75375_data *data = i2c_get_clientdata(client);
290         unsigned long val;
291         int err;
292
293         err = kstrtoul(buf, 10, &val);
294         if (err < 0)
295                 return err;
296
297         mutex_lock(&data->update_lock);
298         data->fan_min[nr] = rpm_to_reg(val);
299         f75375_write16(client, F75375_REG_FAN_MIN(nr), data->fan_min[nr]);
300         mutex_unlock(&data->update_lock);
301         return count;
302 }
303
304 static ssize_t set_fan_target(struct device *dev, struct device_attribute *attr,
305                 const char *buf, size_t count)
306 {
307         int nr = to_sensor_dev_attr(attr)->index;
308         struct i2c_client *client = to_i2c_client(dev);
309         struct f75375_data *data = i2c_get_clientdata(client);
310         unsigned long val;
311         int err;
312
313         err = kstrtoul(buf, 10, &val);
314         if (err < 0)
315                 return err;
316
317         if (auto_mode_enabled(data->pwm_enable[nr]))
318                 return -EINVAL;
319         if (data->kind == f75387 && duty_mode_enabled(data->pwm_enable[nr]))
320                 return -EINVAL;
321
322         mutex_lock(&data->update_lock);
323         data->fan_target[nr] = rpm_to_reg(val);
324         f75375_write16(client, F75375_REG_FAN_EXP(nr), data->fan_target[nr]);
325         mutex_unlock(&data->update_lock);
326         return count;
327 }
328
329 static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
330                 const char *buf, size_t count)
331 {
332         int nr = to_sensor_dev_attr(attr)->index;
333         struct i2c_client *client = to_i2c_client(dev);
334         struct f75375_data *data = i2c_get_clientdata(client);
335         unsigned long val;
336         int err;
337
338         err = kstrtoul(buf, 10, &val);
339         if (err < 0)
340                 return err;
341
342         if (auto_mode_enabled(data->pwm_enable[nr]) ||
343             !duty_mode_enabled(data->pwm_enable[nr]))
344                 return -EINVAL;
345
346         mutex_lock(&data->update_lock);
347         data->pwm[nr] = clamp_val(val, 0, 255);
348         f75375_write_pwm(client, nr);
349         mutex_unlock(&data->update_lock);
350         return count;
351 }
352
353 static ssize_t show_pwm_enable(struct device *dev, struct device_attribute
354                 *attr, char *buf)
355 {
356         int nr = to_sensor_dev_attr(attr)->index;
357         struct f75375_data *data = f75375_update_device(dev);
358         return sprintf(buf, "%d\n", data->pwm_enable[nr]);
359 }
360
361 static int set_pwm_enable_direct(struct i2c_client *client, int nr, int val)
362 {
363         struct f75375_data *data = i2c_get_clientdata(client);
364         u8 fanmode;
365
366         if (val < 0 || val > 4)
367                 return -EINVAL;
368
369         fanmode = f75375_read8(client, F75375_REG_FAN_TIMER);
370         if (data->kind == f75387) {
371                 /* For now, deny dangerous toggling of duty mode */
372                 if (duty_mode_enabled(data->pwm_enable[nr]) !=
373                                 duty_mode_enabled(val))
374                         return -EOPNOTSUPP;
375                 /* clear each fanX_mode bit before setting them properly */
376                 fanmode &= ~(1 << F75387_FAN_DUTY_MODE(nr));
377                 fanmode &= ~(1 << F75387_FAN_MANU_MODE(nr));
378                 switch (val) {
379                 case 0: /* full speed */
380                         fanmode |= (1 << F75387_FAN_MANU_MODE(nr));
381                         fanmode |= (1 << F75387_FAN_DUTY_MODE(nr));
382                         data->pwm[nr] = 255;
383                         break;
384                 case 1: /* PWM */
385                         fanmode  |= (1 << F75387_FAN_MANU_MODE(nr));
386                         fanmode  |= (1 << F75387_FAN_DUTY_MODE(nr));
387                         break;
388                 case 2: /* Automatic, speed mode */
389                         break;
390                 case 3: /* fan speed */
391                         fanmode |= (1 << F75387_FAN_MANU_MODE(nr));
392                         break;
393                 case 4: /* Automatic, pwm */
394                         fanmode |= (1 << F75387_FAN_DUTY_MODE(nr));
395                         break;
396                 }
397         } else {
398                 /* clear each fanX_mode bit before setting them properly */
399                 fanmode &= ~(3 << FAN_CTRL_MODE(nr));
400                 switch (val) {
401                 case 0: /* full speed */
402                         fanmode  |= (3 << FAN_CTRL_MODE(nr));
403                         data->pwm[nr] = 255;
404                         break;
405                 case 1: /* PWM */
406                         fanmode  |= (3 << FAN_CTRL_MODE(nr));
407                         break;
408                 case 2: /* AUTOMATIC*/
409                         fanmode  |= (1 << FAN_CTRL_MODE(nr));
410                         break;
411                 case 3: /* fan speed */
412                         break;
413                 case 4: /* Automatic pwm */
414                         return -EINVAL;
415                 }
416         }
417
418         f75375_write8(client, F75375_REG_FAN_TIMER, fanmode);
419         data->pwm_enable[nr] = val;
420         if (val == 0)
421                 f75375_write_pwm(client, nr);
422         return 0;
423 }
424
425 static ssize_t set_pwm_enable(struct device *dev, struct device_attribute *attr,
426                 const char *buf, size_t count)
427 {
428         int nr = to_sensor_dev_attr(attr)->index;
429         struct i2c_client *client = to_i2c_client(dev);
430         struct f75375_data *data = i2c_get_clientdata(client);
431         unsigned long val;
432         int err;
433
434         err = kstrtoul(buf, 10, &val);
435         if (err < 0)
436                 return err;
437
438         mutex_lock(&data->update_lock);
439         err = set_pwm_enable_direct(client, nr, val);
440         mutex_unlock(&data->update_lock);
441         return err ? err : count;
442 }
443
444 static ssize_t set_pwm_mode(struct device *dev, struct device_attribute *attr,
445                 const char *buf, size_t count)
446 {
447         int nr = to_sensor_dev_attr(attr)->index;
448         struct i2c_client *client = to_i2c_client(dev);
449         struct f75375_data *data = i2c_get_clientdata(client);
450         unsigned long val;
451         int err;
452         u8 conf;
453         char reg, ctrl;
454
455         err = kstrtoul(buf, 10, &val);
456         if (err < 0)
457                 return err;
458
459         if (!(val == 0 || val == 1))
460                 return -EINVAL;
461
462         /* F75373 does not support DC (linear voltage) fan control mode */
463         if (data->kind == f75373 && val == 0)
464                 return -EINVAL;
465
466         /* take care for different registers */
467         if (data->kind == f75387) {
468                 reg = F75375_REG_FAN_TIMER;
469                 ctrl = F75387_FAN_CTRL_LINEAR(nr);
470         } else {
471                 reg = F75375_REG_CONFIG1;
472                 ctrl = F75375_FAN_CTRL_LINEAR(nr);
473         }
474
475         mutex_lock(&data->update_lock);
476         conf = f75375_read8(client, reg);
477         conf &= ~(1 << ctrl);
478
479         if (val == 0)
480                 conf |= (1 << ctrl);
481
482         f75375_write8(client, reg, conf);
483         data->pwm_mode[nr] = val;
484         mutex_unlock(&data->update_lock);
485         return count;
486 }
487
488 static ssize_t show_pwm(struct device *dev, struct device_attribute
489                 *attr, char *buf)
490 {
491         int nr = to_sensor_dev_attr(attr)->index;
492         struct f75375_data *data = f75375_update_device(dev);
493         return sprintf(buf, "%d\n", data->pwm[nr]);
494 }
495
496 static ssize_t show_pwm_mode(struct device *dev, struct device_attribute
497                 *attr, char *buf)
498 {
499         int nr = to_sensor_dev_attr(attr)->index;
500         struct f75375_data *data = f75375_update_device(dev);
501         return sprintf(buf, "%d\n", data->pwm_mode[nr]);
502 }
503
504 #define VOLT_FROM_REG(val) ((val) * 8)
505 #define VOLT_TO_REG(val) ((val) / 8)
506
507 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
508                 char *buf)
509 {
510         int nr = to_sensor_dev_attr(attr)->index;
511         struct f75375_data *data = f75375_update_device(dev);
512         return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in[nr]));
513 }
514
515 static ssize_t show_in_max(struct device *dev, struct device_attribute *attr,
516                 char *buf)
517 {
518         int nr = to_sensor_dev_attr(attr)->index;
519         struct f75375_data *data = f75375_update_device(dev);
520         return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_max[nr]));
521 }
522
523 static ssize_t show_in_min(struct device *dev, struct device_attribute *attr,
524                 char *buf)
525 {
526         int nr = to_sensor_dev_attr(attr)->index;
527         struct f75375_data *data = f75375_update_device(dev);
528         return sprintf(buf, "%d\n", VOLT_FROM_REG(data->in_min[nr]));
529 }
530
531 static ssize_t set_in_max(struct device *dev, struct device_attribute *attr,
532                 const char *buf, size_t count)
533 {
534         int nr = to_sensor_dev_attr(attr)->index;
535         struct i2c_client *client = to_i2c_client(dev);
536         struct f75375_data *data = i2c_get_clientdata(client);
537         unsigned long val;
538         int err;
539
540         err = kstrtoul(buf, 10, &val);
541         if (err < 0)
542                 return err;
543
544         val = clamp_val(VOLT_TO_REG(val), 0, 0xff);
545         mutex_lock(&data->update_lock);
546         data->in_max[nr] = val;
547         f75375_write8(client, F75375_REG_VOLT_HIGH(nr), data->in_max[nr]);
548         mutex_unlock(&data->update_lock);
549         return count;
550 }
551
552 static ssize_t set_in_min(struct device *dev, struct device_attribute *attr,
553                 const char *buf, size_t count)
554 {
555         int nr = to_sensor_dev_attr(attr)->index;
556         struct i2c_client *client = to_i2c_client(dev);
557         struct f75375_data *data = i2c_get_clientdata(client);
558         unsigned long val;
559         int err;
560
561         err = kstrtoul(buf, 10, &val);
562         if (err < 0)
563                 return err;
564
565         val = clamp_val(VOLT_TO_REG(val), 0, 0xff);
566         mutex_lock(&data->update_lock);
567         data->in_min[nr] = val;
568         f75375_write8(client, F75375_REG_VOLT_LOW(nr), data->in_min[nr]);
569         mutex_unlock(&data->update_lock);
570         return count;
571 }
572 #define TEMP_FROM_REG(val) ((val) * 1000)
573 #define TEMP_TO_REG(val) ((val) / 1000)
574 #define TEMP11_FROM_REG(reg)    ((reg) / 32 * 125)
575
576 static ssize_t show_temp11(struct device *dev, struct device_attribute *attr,
577                 char *buf)
578 {
579         int nr = to_sensor_dev_attr(attr)->index;
580         struct f75375_data *data = f75375_update_device(dev);
581         return sprintf(buf, "%d\n", TEMP11_FROM_REG(data->temp11[nr]));
582 }
583
584 static ssize_t show_temp_max(struct device *dev, struct device_attribute *attr,
585                 char *buf)
586 {
587         int nr = to_sensor_dev_attr(attr)->index;
588         struct f75375_data *data = f75375_update_device(dev);
589         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_high[nr]));
590 }
591
592 static ssize_t show_temp_max_hyst(struct device *dev,
593                 struct device_attribute *attr, char *buf)
594 {
595         int nr = to_sensor_dev_attr(attr)->index;
596         struct f75375_data *data = f75375_update_device(dev);
597         return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max_hyst[nr]));
598 }
599
600 static ssize_t set_temp_max(struct device *dev, struct device_attribute *attr,
601                 const char *buf, size_t count)
602 {
603         int nr = to_sensor_dev_attr(attr)->index;
604         struct i2c_client *client = to_i2c_client(dev);
605         struct f75375_data *data = i2c_get_clientdata(client);
606         unsigned long val;
607         int err;
608
609         err = kstrtoul(buf, 10, &val);
610         if (err < 0)
611                 return err;
612
613         val = clamp_val(TEMP_TO_REG(val), 0, 127);
614         mutex_lock(&data->update_lock);
615         data->temp_high[nr] = val;
616         f75375_write8(client, F75375_REG_TEMP_HIGH(nr), data->temp_high[nr]);
617         mutex_unlock(&data->update_lock);
618         return count;
619 }
620
621 static ssize_t set_temp_max_hyst(struct device *dev,
622         struct device_attribute *attr, const char *buf, size_t count)
623 {
624         int nr = to_sensor_dev_attr(attr)->index;
625         struct i2c_client *client = to_i2c_client(dev);
626         struct f75375_data *data = i2c_get_clientdata(client);
627         unsigned long val;
628         int err;
629
630         err = kstrtoul(buf, 10, &val);
631         if (err < 0)
632                 return err;
633
634         val = clamp_val(TEMP_TO_REG(val), 0, 127);
635         mutex_lock(&data->update_lock);
636         data->temp_max_hyst[nr] = val;
637         f75375_write8(client, F75375_REG_TEMP_HYST(nr),
638                 data->temp_max_hyst[nr]);
639         mutex_unlock(&data->update_lock);
640         return count;
641 }
642
643 #define show_fan(thing) \
644 static ssize_t show_##thing(struct device *dev, struct device_attribute *attr, \
645                         char *buf)\
646 {\
647         int nr = to_sensor_dev_attr(attr)->index;\
648         struct f75375_data *data = f75375_update_device(dev); \
649         return sprintf(buf, "%d\n", rpm_from_reg(data->thing[nr])); \
650 }
651
652 show_fan(fan);
653 show_fan(fan_min);
654 show_fan(fan_max);
655 show_fan(fan_target);
656
657 static SENSOR_DEVICE_ATTR(in0_input, S_IRUGO, show_in, NULL, 0);
658 static SENSOR_DEVICE_ATTR(in0_max, S_IRUGO|S_IWUSR,
659         show_in_max, set_in_max, 0);
660 static SENSOR_DEVICE_ATTR(in0_min, S_IRUGO|S_IWUSR,
661         show_in_min, set_in_min, 0);
662 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 1);
663 static SENSOR_DEVICE_ATTR(in1_max, S_IRUGO|S_IWUSR,
664         show_in_max, set_in_max, 1);
665 static SENSOR_DEVICE_ATTR(in1_min, S_IRUGO|S_IWUSR,
666         show_in_min, set_in_min, 1);
667 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 2);
668 static SENSOR_DEVICE_ATTR(in2_max, S_IRUGO|S_IWUSR,
669         show_in_max, set_in_max, 2);
670 static SENSOR_DEVICE_ATTR(in2_min, S_IRUGO|S_IWUSR,
671         show_in_min, set_in_min, 2);
672 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 3);
673 static SENSOR_DEVICE_ATTR(in3_max, S_IRUGO|S_IWUSR,
674         show_in_max, set_in_max, 3);
675 static SENSOR_DEVICE_ATTR(in3_min, S_IRUGO|S_IWUSR,
676         show_in_min, set_in_min, 3);
677 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp11, NULL, 0);
678 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO|S_IWUSR,
679         show_temp_max_hyst, set_temp_max_hyst, 0);
680 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO|S_IWUSR,
681         show_temp_max, set_temp_max, 0);
682 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp11, NULL, 1);
683 static SENSOR_DEVICE_ATTR(temp2_max_hyst, S_IRUGO|S_IWUSR,
684         show_temp_max_hyst, set_temp_max_hyst, 1);
685 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO|S_IWUSR,
686         show_temp_max, set_temp_max, 1);
687 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan, NULL, 0);
688 static SENSOR_DEVICE_ATTR(fan1_max, S_IRUGO, show_fan_max, NULL, 0);
689 static SENSOR_DEVICE_ATTR(fan1_min, S_IRUGO|S_IWUSR,
690         show_fan_min, set_fan_min, 0);
691 static SENSOR_DEVICE_ATTR(fan1_target, S_IRUGO|S_IWUSR,
692         show_fan_target, set_fan_target, 0);
693 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan, NULL, 1);
694 static SENSOR_DEVICE_ATTR(fan2_max, S_IRUGO, show_fan_max, NULL, 1);
695 static SENSOR_DEVICE_ATTR(fan2_min, S_IRUGO|S_IWUSR,
696         show_fan_min, set_fan_min, 1);
697 static SENSOR_DEVICE_ATTR(fan2_target, S_IRUGO|S_IWUSR,
698         show_fan_target, set_fan_target, 1);
699 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO|S_IWUSR,
700         show_pwm, set_pwm, 0);
701 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IRUGO|S_IWUSR,
702         show_pwm_enable, set_pwm_enable, 0);
703 static SENSOR_DEVICE_ATTR(pwm1_mode, S_IRUGO,
704         show_pwm_mode, set_pwm_mode, 0);
705 static SENSOR_DEVICE_ATTR(pwm2, S_IRUGO | S_IWUSR,
706         show_pwm, set_pwm, 1);
707 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IRUGO|S_IWUSR,
708         show_pwm_enable, set_pwm_enable, 1);
709 static SENSOR_DEVICE_ATTR(pwm2_mode, S_IRUGO,
710         show_pwm_mode, set_pwm_mode, 1);
711
712 static struct attribute *f75375_attributes[] = {
713         &sensor_dev_attr_temp1_input.dev_attr.attr,
714         &sensor_dev_attr_temp1_max.dev_attr.attr,
715         &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
716         &sensor_dev_attr_temp2_input.dev_attr.attr,
717         &sensor_dev_attr_temp2_max.dev_attr.attr,
718         &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
719         &sensor_dev_attr_fan1_input.dev_attr.attr,
720         &sensor_dev_attr_fan1_max.dev_attr.attr,
721         &sensor_dev_attr_fan1_min.dev_attr.attr,
722         &sensor_dev_attr_fan1_target.dev_attr.attr,
723         &sensor_dev_attr_fan2_input.dev_attr.attr,
724         &sensor_dev_attr_fan2_max.dev_attr.attr,
725         &sensor_dev_attr_fan2_min.dev_attr.attr,
726         &sensor_dev_attr_fan2_target.dev_attr.attr,
727         &sensor_dev_attr_pwm1.dev_attr.attr,
728         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
729         &sensor_dev_attr_pwm1_mode.dev_attr.attr,
730         &sensor_dev_attr_pwm2.dev_attr.attr,
731         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
732         &sensor_dev_attr_pwm2_mode.dev_attr.attr,
733         &sensor_dev_attr_in0_input.dev_attr.attr,
734         &sensor_dev_attr_in0_max.dev_attr.attr,
735         &sensor_dev_attr_in0_min.dev_attr.attr,
736         &sensor_dev_attr_in1_input.dev_attr.attr,
737         &sensor_dev_attr_in1_max.dev_attr.attr,
738         &sensor_dev_attr_in1_min.dev_attr.attr,
739         &sensor_dev_attr_in2_input.dev_attr.attr,
740         &sensor_dev_attr_in2_max.dev_attr.attr,
741         &sensor_dev_attr_in2_min.dev_attr.attr,
742         &sensor_dev_attr_in3_input.dev_attr.attr,
743         &sensor_dev_attr_in3_max.dev_attr.attr,
744         &sensor_dev_attr_in3_min.dev_attr.attr,
745         NULL
746 };
747
748 static const struct attribute_group f75375_group = {
749         .attrs = f75375_attributes,
750 };
751
752 static void f75375_init(struct i2c_client *client, struct f75375_data *data,
753                 struct f75375s_platform_data *f75375s_pdata)
754 {
755         int nr;
756
757         if (!f75375s_pdata) {
758                 u8 conf, mode;
759                 int nr;
760
761                 conf = f75375_read8(client, F75375_REG_CONFIG1);
762                 mode = f75375_read8(client, F75375_REG_FAN_TIMER);
763                 for (nr = 0; nr < 2; nr++) {
764                         if (data->kind == f75387) {
765                                 bool manu, duty;
766
767                                 if (!(mode & (1 << F75387_FAN_CTRL_LINEAR(nr))))
768                                         data->pwm_mode[nr] = 1;
769
770                                 manu = ((mode >> F75387_FAN_MANU_MODE(nr)) & 1);
771                                 duty = ((mode >> F75387_FAN_DUTY_MODE(nr)) & 1);
772                                 if (!manu && duty)
773                                         /* auto, pwm */
774                                         data->pwm_enable[nr] = 4;
775                                 else if (manu && !duty)
776                                         /* manual, speed */
777                                         data->pwm_enable[nr] = 3;
778                                 else if (!manu && !duty)
779                                         /* automatic, speed */
780                                         data->pwm_enable[nr] = 2;
781                                 else
782                                         /* manual, pwm */
783                                         data->pwm_enable[nr] = 1;
784                         } else {
785                                 if (!(conf & (1 << F75375_FAN_CTRL_LINEAR(nr))))
786                                         data->pwm_mode[nr] = 1;
787
788                                 switch ((mode >> FAN_CTRL_MODE(nr)) & 3) {
789                                 case 0:         /* speed */
790                                         data->pwm_enable[nr] = 3;
791                                         break;
792                                 case 1:         /* automatic */
793                                         data->pwm_enable[nr] = 2;
794                                         break;
795                                 default:        /* manual */
796                                         data->pwm_enable[nr] = 1;
797                                         break;
798                                 }
799                         }
800                 }
801                 return;
802         }
803
804         set_pwm_enable_direct(client, 0, f75375s_pdata->pwm_enable[0]);
805         set_pwm_enable_direct(client, 1, f75375s_pdata->pwm_enable[1]);
806         for (nr = 0; nr < 2; nr++) {
807                 if (auto_mode_enabled(f75375s_pdata->pwm_enable[nr]) ||
808                     !duty_mode_enabled(f75375s_pdata->pwm_enable[nr]))
809                         continue;
810                 data->pwm[nr] = clamp_val(f75375s_pdata->pwm[nr], 0, 255);
811                 f75375_write_pwm(client, nr);
812         }
813
814 }
815
816 static int f75375_probe(struct i2c_client *client)
817 {
818         struct f75375_data *data;
819         struct f75375s_platform_data *f75375s_pdata =
820                         dev_get_platdata(&client->dev);
821         int err;
822
823         if (!i2c_check_functionality(client->adapter,
824                                 I2C_FUNC_SMBUS_BYTE_DATA))
825                 return -EIO;
826         data = devm_kzalloc(&client->dev, sizeof(struct f75375_data),
827                             GFP_KERNEL);
828         if (!data)
829                 return -ENOMEM;
830
831         i2c_set_clientdata(client, data);
832         mutex_init(&data->update_lock);
833         data->kind = i2c_match_id(f75375_id, client)->driver_data;
834
835         err = sysfs_create_group(&client->dev.kobj, &f75375_group);
836         if (err)
837                 return err;
838
839         if (data->kind != f75373) {
840                 err = sysfs_chmod_file(&client->dev.kobj,
841                         &sensor_dev_attr_pwm1_mode.dev_attr.attr,
842                         S_IRUGO | S_IWUSR);
843                 if (err)
844                         goto exit_remove;
845                 err = sysfs_chmod_file(&client->dev.kobj,
846                         &sensor_dev_attr_pwm2_mode.dev_attr.attr,
847                         S_IRUGO | S_IWUSR);
848                 if (err)
849                         goto exit_remove;
850         }
851
852         data->hwmon_dev = hwmon_device_register(&client->dev);
853         if (IS_ERR(data->hwmon_dev)) {
854                 err = PTR_ERR(data->hwmon_dev);
855                 goto exit_remove;
856         }
857
858         f75375_init(client, data, f75375s_pdata);
859
860         return 0;
861
862 exit_remove:
863         sysfs_remove_group(&client->dev.kobj, &f75375_group);
864         return err;
865 }
866
867 static void f75375_remove(struct i2c_client *client)
868 {
869         struct f75375_data *data = i2c_get_clientdata(client);
870         hwmon_device_unregister(data->hwmon_dev);
871         sysfs_remove_group(&client->dev.kobj, &f75375_group);
872 }
873
874 /* Return 0 if detection is successful, -ENODEV otherwise */
875 static int f75375_detect(struct i2c_client *client,
876                          struct i2c_board_info *info)
877 {
878         struct i2c_adapter *adapter = client->adapter;
879         u16 vendid, chipid;
880         u8 version;
881         const char *name;
882
883         vendid = f75375_read16(client, F75375_REG_VENDOR);
884         chipid = f75375_read16(client, F75375_CHIP_ID);
885         if (vendid != 0x1934)
886                 return -ENODEV;
887
888         if (chipid == 0x0306)
889                 name = "f75375";
890         else if (chipid == 0x0204)
891                 name = "f75373";
892         else if (chipid == 0x0410)
893                 name = "f75387";
894         else
895                 return -ENODEV;
896
897         version = f75375_read8(client, F75375_REG_VERSION);
898         dev_info(&adapter->dev, "found %s version: %02X\n", name, version);
899         strscpy(info->type, name, I2C_NAME_SIZE);
900
901         return 0;
902 }
903
904 module_i2c_driver(f75375_driver);
905
906 MODULE_AUTHOR("Riku Voipio");
907 MODULE_LICENSE("GPL");
908 MODULE_DESCRIPTION("F75373/F75375/F75387 hardware monitoring driver");