]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/hwmon/ftsteutates.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
hwmon: (tmp102) Improve error handling
[mirror_ubuntu-bionic-kernel.git] / drivers / hwmon / ftsteutates.c
CommitLineData
08426eda
TC		 1/*
2 * Support for the FTS Systemmonitoring Chip "Teutates"
3 *
4 * Copyright (C) 2016 Fujitsu Technology Solutions GmbH,
5 * Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 */
18#include <linux/err.h>
19#include <linux/fs.h>
20#include <linux/hwmon.h>
21#include <linux/hwmon-sysfs.h>
22#include <linux/i2c.h>
23#include <linux/init.h>
24#include <linux/jiffies.h>
25#include <linux/module.h>
26#include <linux/mutex.h>
27#include <linux/slab.h>
28#include <linux/sysfs.h>
29#include <linux/uaccess.h>
08426eda
TC		 30#include <linux/watchdog.h>
31
32#define FTS_DEVICE_ID_REG 0x0000
33#define FTS_DEVICE_REVISION_REG 0x0001
34#define FTS_DEVICE_STATUS_REG 0x0004
35#define FTS_SATELLITE_STATUS_REG 0x0005
36#define FTS_EVENT_STATUS_REG 0x0006
37#define FTS_GLOBAL_CONTROL_REG 0x0007
38
39#define FTS_SENSOR_EVENT_REG 0x0010
40
41#define FTS_FAN_EVENT_REG 0x0014
42#define FTS_FAN_PRESENT_REG 0x0015
43
44#define FTS_POWER_ON_TIME_COUNTER_A 0x007A
45#define FTS_POWER_ON_TIME_COUNTER_B 0x007B
46#define FTS_POWER_ON_TIME_COUNTER_C 0x007C
47
48#define FTS_PAGE_SELECT_REG 0x007F
49
50#define FTS_WATCHDOG_TIME_PRESET 0x000B
51#define FTS_WATCHDOG_CONTROL 0x5081
52
53#define FTS_NO_FAN_SENSORS 0x08
54#define FTS_NO_TEMP_SENSORS 0x10
55#define FTS_NO_VOLT_SENSORS 0x04
56
57static struct i2c_device_id fts_id[] = {
58 { "ftsteutates", 0 },
59 { }
60};
61MODULE_DEVICE_TABLE(i2c, fts_id);
62
63enum WATCHDOG_RESOLUTION {
64 seconds = 1,
65 minutes = 60
66};
67
68struct fts_data {
69 struct i2c_client *client;
70 /* update sensor data lock */
71 struct mutex update_lock;
72 /* read/write register lock */
73 struct mutex access_lock;
74 unsigned long last_updated; /* in jiffies */
75 struct watchdog_device wdd;
76 enum WATCHDOG_RESOLUTION resolution;
77 bool valid; /* false until following fields are valid */
78
79 u8 volt[FTS_NO_VOLT_SENSORS];
80
81 u8 temp_input[FTS_NO_TEMP_SENSORS];
82 u8 temp_alarm;
83
84 u8 fan_present;
85 u8 fan_input[FTS_NO_FAN_SENSORS]; /* in rps */
86 u8 fan_source[FTS_NO_FAN_SENSORS];
87 u8 fan_alarm;
88};
89
90#define FTS_REG_FAN_INPUT(idx) ((idx) + 0x20)
91#define FTS_REG_FAN_SOURCE(idx) ((idx) + 0x30)
92#define FTS_REG_FAN_CONTROL(idx) (((idx) << 16) + 0x4881)
93
94#define FTS_REG_TEMP_INPUT(idx) ((idx) + 0x40)
95#define FTS_REG_TEMP_CONTROL(idx) (((idx) << 16) + 0x0681)
96
97#define FTS_REG_VOLT(idx) ((idx) + 0x18)
98
99/*****************************************************************************/
100/* I2C Helper functions */
101/*****************************************************************************/
102static int fts_read_byte(struct i2c_client *client, unsigned short reg)
103{
104 int ret;
105 unsigned char page = reg >> 8;
106 struct fts_data *data = dev_get_drvdata(&client->dev);
107
108 mutex_lock(&data->access_lock);
109
110 dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
111 ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page);
112 if (ret < 0)
113 goto error;
114
115 reg &= 0xFF;
116 ret = i2c_smbus_read_byte_data(client, reg);
117 dev_dbg(&client->dev, "read - reg: 0x%.02x: val: 0x%.02x\n", reg, ret);
118
119error:
120 mutex_unlock(&data->access_lock);
121 return ret;
122}
123
124static int fts_write_byte(struct i2c_client *client, unsigned short reg,
125 unsigned char value)
126{
127 int ret;
128 unsigned char page = reg >> 8;
129 struct fts_data *data = dev_get_drvdata(&client->dev);
130
131 mutex_lock(&data->access_lock);
132
133 dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
134 ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page);
135 if (ret < 0)
136 goto error;
137
138 reg &= 0xFF;
139 dev_dbg(&client->dev,
140 "write - reg: 0x%.02x: val: 0x%.02x\n", reg, value);
141 ret = i2c_smbus_write_byte_data(client, reg, value);
142
143error:
144 mutex_unlock(&data->access_lock);
145 return ret;
146}
147
148/*****************************************************************************/
149/* Data Updater Helper function */
150/*****************************************************************************/
151static int fts_update_device(struct fts_data *data)
152{
153 int i;
154 int err = 0;
155
156 mutex_lock(&data->update_lock);
157 if (!time_after(jiffies, data->last_updated + 2 * HZ) && data->valid)
158 goto exit;
159
160 err = fts_read_byte(data->client, FTS_DEVICE_STATUS_REG);
161 if (err < 0)
162 goto exit;
163
164 data->valid = !!(err & 0x02); /* Data not ready yet */
165 if (unlikely(!data->valid)) {
166 err = -EAGAIN;
167 goto exit;
168 }
169
170 err = fts_read_byte(data->client, FTS_FAN_PRESENT_REG);
171 if (err < 0)
172 goto exit;
173 data->fan_present = err;
174
175 err = fts_read_byte(data->client, FTS_FAN_EVENT_REG);
176 if (err < 0)
177 goto exit;
178 data->fan_alarm = err;
179
180 for (i = 0; i < FTS_NO_FAN_SENSORS; i++) {
181 if (data->fan_present & BIT(i)) {
182 err = fts_read_byte(data->client, FTS_REG_FAN_INPUT(i));
183 if (err < 0)
184 goto exit;
185 data->fan_input[i] = err;
186
187 err = fts_read_byte(data->client,
188 FTS_REG_FAN_SOURCE(i));
189 if (err < 0)
190 goto exit;
191 data->fan_source[i] = err;
192 } else {
193 data->fan_input[i] = 0;
194 data->fan_source[i] = 0;
195 }
196 }
197
198 err = fts_read_byte(data->client, FTS_SENSOR_EVENT_REG);
199 if (err < 0)
200 goto exit;
201 data->temp_alarm = err;
202
203 for (i = 0; i < FTS_NO_TEMP_SENSORS; i++) {
204 err = fts_read_byte(data->client, FTS_REG_TEMP_INPUT(i));
205 if (err < 0)
206 goto exit;
207 data->temp_input[i] = err;
208 }
209
210 for (i = 0; i < FTS_NO_VOLT_SENSORS; i++) {
211 err = fts_read_byte(data->client, FTS_REG_VOLT(i));
212 if (err < 0)
213 goto exit;
214 data->volt[i] = err;
215 }
216 data->last_updated = jiffies;
217 err = 0;
218exit:
219 mutex_unlock(&data->update_lock);
220 return err;
221}
222
223/*****************************************************************************/
224/* Watchdog functions */
225/*****************************************************************************/
226static int fts_wd_set_resolution(struct fts_data *data,
227 enum WATCHDOG_RESOLUTION resolution)
228{
229 int ret;
230
231 if (data->resolution == resolution)
232 return 0;
233
234 ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL);
235 if (ret < 0)
236 return ret;
237
238 if ((resolution == seconds && ret & BIT(1)) ||
239 (resolution == minutes && (ret & BIT(1)) == 0)) {
240 data->resolution = resolution;
241 return 0;
242 }
243
244 if (resolution == seconds)
245 set_bit(1, (unsigned long *)&ret);
246 else
247 ret &= ~BIT(1);
248
249 ret = fts_write_byte(data->client, FTS_WATCHDOG_CONTROL, ret);
250 if (ret < 0)
251 return ret;
252
253 data->resolution = resolution;
254 return ret;
255}
256
257static int fts_wd_set_timeout(struct watchdog_device *wdd, unsigned int timeout)
258{
259 struct fts_data *data;
260 enum WATCHDOG_RESOLUTION resolution = seconds;
261 int ret;
262
263 data = watchdog_get_drvdata(wdd);
264 /* switch watchdog resolution to minutes if timeout does not fit
265 * into a byte
266 */
267 if (timeout > 0xFF) {
268 timeout = DIV_ROUND_UP(timeout, 60) * 60;
269 resolution = minutes;
270 }
271
272 ret = fts_wd_set_resolution(data, resolution);
273 if (ret < 0)
274 return ret;
275
276 wdd->timeout = timeout;
277 return 0;
278}
279
280static int fts_wd_start(struct watchdog_device *wdd)
281{
282 struct fts_data *data = watchdog_get_drvdata(wdd);
283
284 return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET,
285 wdd->timeout / (u8)data->resolution);
286}
287
288static int fts_wd_stop(struct watchdog_device *wdd)
289{
290 struct fts_data *data;
291
292 data = watchdog_get_drvdata(wdd);
293 return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET, 0);
294}
295
296static const struct watchdog_info fts_wd_info = {
297 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
298 .identity = "FTS Teutates Hardware Watchdog",
299};
300
301static const struct watchdog_ops fts_wd_ops = {
302 .owner = THIS_MODULE,
303 .start = fts_wd_start,
304 .stop = fts_wd_stop,
305 .set_timeout = fts_wd_set_timeout,
306};
307
308static int fts_watchdog_init(struct fts_data *data)
309{
310 int timeout, ret;
311
312 watchdog_set_drvdata(&data->wdd, data);
313
314 timeout = fts_read_byte(data->client, FTS_WATCHDOG_TIME_PRESET);
315 if (timeout < 0)
316 return timeout;
317
318 /* watchdog not running, set timeout to a default of 60 sec. */
319 if (timeout == 0) {
320 ret = fts_wd_set_resolution(data, seconds);
321 if (ret < 0)
322 return ret;
323 data->wdd.timeout = 60;
324 } else {
325 ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL);
326 if (ret < 0)
327 return ret;
328
329 data->resolution = ret & BIT(1) ? seconds : minutes;
330 data->wdd.timeout = timeout * (u8)data->resolution;
331 set_bit(WDOG_HW_RUNNING, &data->wdd.status);
332 }
333
334 /* Register our watchdog part */
335 data->wdd.info = &fts_wd_info;
336 data->wdd.ops = &fts_wd_ops;
337 data->wdd.parent = &data->client->dev;
338 data->wdd.min_timeout = 1;
339
340 /* max timeout 255 minutes. */
341 data->wdd.max_hw_heartbeat_ms = 0xFF * 60 * MSEC_PER_SEC;
342
343 return watchdog_register_device(&data->wdd);
344}
345
346/*****************************************************************************/
347/* SysFS handler functions */
348/*****************************************************************************/
349static ssize_t show_in_value(struct device *dev,
350 struct device_attribute *devattr, char *buf)
351{
352 struct fts_data *data = dev_get_drvdata(dev);
353 int index = to_sensor_dev_attr(devattr)->index;
354 int err;
355
356 err = fts_update_device(data);
357 if (err < 0)
358 return err;
359
360 return sprintf(buf, "%u\n", data->volt[index]);
361}
362
363static ssize_t show_temp_value(struct device *dev,
364 struct device_attribute *devattr, char *buf)
365{
366 struct fts_data *data = dev_get_drvdata(dev);
367 int index = to_sensor_dev_attr(devattr)->index;
368 int err;
369
370 err = fts_update_device(data);
371 if (err < 0)
372 return err;
373
374 return sprintf(buf, "%u\n", data->temp_input[index]);
375}
376
377static ssize_t show_temp_fault(struct device *dev,
378 struct device_attribute *devattr, char *buf)
379{
380 struct fts_data *data = dev_get_drvdata(dev);
381 int index = to_sensor_dev_attr(devattr)->index;
382 int err;
383
384 err = fts_update_device(data);
385 if (err < 0)
386 return err;
387
388 /* 00h Temperature = Sensor Error */
389 return sprintf(buf, "%d\n", data->temp_input[index] == 0);
390}
391
392static ssize_t show_temp_alarm(struct device *dev,
393 struct device_attribute *devattr, char *buf)
394{
395 struct fts_data *data = dev_get_drvdata(dev);
396 int index = to_sensor_dev_attr(devattr)->index;
397 int err;
398
399 err = fts_update_device(data);
400 if (err < 0)
401 return err;
402
403 return sprintf(buf, "%u\n", !!(data->temp_alarm & BIT(index)));
404}
405
406static ssize_t
407clear_temp_alarm(struct device *dev, struct device_attribute *devattr,
408 const char *buf, size_t count)
409{
410 struct fts_data *data = dev_get_drvdata(dev);
411 int index = to_sensor_dev_attr(devattr)->index;
412 long ret;
413
414 ret = fts_update_device(data);
415 if (ret < 0)
416 return ret;
417
418 if (kstrtoul(buf, 10, &ret) || ret != 0)
419 return -EINVAL;
420
421 mutex_lock(&data->update_lock);
422 ret = fts_read_byte(data->client, FTS_REG_TEMP_CONTROL(index));
423 if (ret < 0)
424 goto error;
425
426 ret = fts_write_byte(data->client, FTS_REG_TEMP_CONTROL(index),
427 ret | 0x1);
428 if (ret < 0)
429 goto error;
430
431 data->valid = false;
432error:
433 mutex_unlock(&data->update_lock);
434 return ret;
435}
436
437static ssize_t show_fan_value(struct device *dev,
438 struct device_attribute *devattr, char *buf)
439{
440 struct fts_data *data = dev_get_drvdata(dev);
441 int index = to_sensor_dev_attr(devattr)->index;
442 int err;
443
444 err = fts_update_device(data);
445 if (err < 0)
446 return err;
447
448 return sprintf(buf, "%u\n", data->fan_input[index]);
449}
450
451static ssize_t show_fan_source(struct device *dev,
452 struct device_attribute *devattr, char *buf)
453{
454 struct fts_data *data = dev_get_drvdata(dev);
455 int index = to_sensor_dev_attr(devattr)->index;
456 int err;
457
458 err = fts_update_device(data);
459 if (err < 0)
460 return err;
461
462 return sprintf(buf, "%u\n", data->fan_source[index]);
463}
464
465static ssize_t show_fan_alarm(struct device *dev,
466 struct device_attribute *devattr, char *buf)
467{
468 struct fts_data *data = dev_get_drvdata(dev);
469 int index = to_sensor_dev_attr(devattr)->index;
470 int err;
471
472 err = fts_update_device(data);
473 if (err < 0)
474 return err;
475
476 return sprintf(buf, "%d\n", !!(data->fan_alarm & BIT(index)));
477}
478
479static ssize_t
480clear_fan_alarm(struct device *dev, struct device_attribute *devattr,
481 const char *buf, size_t count)
482{
483 struct fts_data *data = dev_get_drvdata(dev);
484 int index = to_sensor_dev_attr(devattr)->index;
485 long ret;
486
487 ret = fts_update_device(data);
488 if (ret < 0)
489 return ret;
490
491 if (kstrtoul(buf, 10, &ret) || ret != 0)
492 return -EINVAL;
493
494 mutex_lock(&data->update_lock);
495 ret = fts_read_byte(data->client, FTS_REG_FAN_CONTROL(index));
496 if (ret < 0)
497 goto error;
498
499 ret = fts_write_byte(data->client, FTS_REG_FAN_CONTROL(index),
500 ret | 0x1);
501 if (ret < 0)
502 goto error;
503
504 data->valid = false;
505error:
506 mutex_unlock(&data->update_lock);
507 return ret;
508}
509
510/*****************************************************************************/
511/* SysFS structs */
512/*****************************************************************************/
513
514/* Temprature sensors */
515static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_value, NULL, 0);
516static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_value, NULL, 1);
517static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp_value, NULL, 2);
518static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp_value, NULL, 3);
519static SENSOR_DEVICE_ATTR(temp5_input, S_IRUGO, show_temp_value, NULL, 4);
520static SENSOR_DEVICE_ATTR(temp6_input, S_IRUGO, show_temp_value, NULL, 5);
521static SENSOR_DEVICE_ATTR(temp7_input, S_IRUGO, show_temp_value, NULL, 6);
522static SENSOR_DEVICE_ATTR(temp8_input, S_IRUGO, show_temp_value, NULL, 7);
523static SENSOR_DEVICE_ATTR(temp9_input, S_IRUGO, show_temp_value, NULL, 8);
524static SENSOR_DEVICE_ATTR(temp10_input, S_IRUGO, show_temp_value, NULL, 9);
525static SENSOR_DEVICE_ATTR(temp11_input, S_IRUGO, show_temp_value, NULL, 10);
526static SENSOR_DEVICE_ATTR(temp12_input, S_IRUGO, show_temp_value, NULL, 11);
527static SENSOR_DEVICE_ATTR(temp13_input, S_IRUGO, show_temp_value, NULL, 12);
528static SENSOR_DEVICE_ATTR(temp14_input, S_IRUGO, show_temp_value, NULL, 13);
529static SENSOR_DEVICE_ATTR(temp15_input, S_IRUGO, show_temp_value, NULL, 14);
530static SENSOR_DEVICE_ATTR(temp16_input, S_IRUGO, show_temp_value, NULL, 15);
531
532static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
533static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
534static SENSOR_DEVICE_ATTR(temp3_fault, S_IRUGO, show_temp_fault, NULL, 2);
535static SENSOR_DEVICE_ATTR(temp4_fault, S_IRUGO, show_temp_fault, NULL, 3);
536static SENSOR_DEVICE_ATTR(temp5_fault, S_IRUGO, show_temp_fault, NULL, 4);
537static SENSOR_DEVICE_ATTR(temp6_fault, S_IRUGO, show_temp_fault, NULL, 5);
538static SENSOR_DEVICE_ATTR(temp7_fault, S_IRUGO, show_temp_fault, NULL, 6);
539static SENSOR_DEVICE_ATTR(temp8_fault, S_IRUGO, show_temp_fault, NULL, 7);
540static SENSOR_DEVICE_ATTR(temp9_fault, S_IRUGO, show_temp_fault, NULL, 8);
541static SENSOR_DEVICE_ATTR(temp10_fault, S_IRUGO, show_temp_fault, NULL, 9);
542static SENSOR_DEVICE_ATTR(temp11_fault, S_IRUGO, show_temp_fault, NULL, 10);
543static SENSOR_DEVICE_ATTR(temp12_fault, S_IRUGO, show_temp_fault, NULL, 11);
544static SENSOR_DEVICE_ATTR(temp13_fault, S_IRUGO, show_temp_fault, NULL, 12);
545static SENSOR_DEVICE_ATTR(temp14_fault, S_IRUGO, show_temp_fault, NULL, 13);
546static SENSOR_DEVICE_ATTR(temp15_fault, S_IRUGO, show_temp_fault, NULL, 14);
547static SENSOR_DEVICE_ATTR(temp16_fault, S_IRUGO, show_temp_fault, NULL, 15);
548
549static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
550 clear_temp_alarm, 0);
551static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
552 clear_temp_alarm, 1);
553static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
554 clear_temp_alarm, 2);
555static SENSOR_DEVICE_ATTR(temp4_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
556 clear_temp_alarm, 3);
557static SENSOR_DEVICE_ATTR(temp5_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
558 clear_temp_alarm, 4);
559static SENSOR_DEVICE_ATTR(temp6_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
560 clear_temp_alarm, 5);
561static SENSOR_DEVICE_ATTR(temp7_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
562 clear_temp_alarm, 6);
563static SENSOR_DEVICE_ATTR(temp8_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
564 clear_temp_alarm, 7);
565static SENSOR_DEVICE_ATTR(temp9_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
566 clear_temp_alarm, 8);
567static SENSOR_DEVICE_ATTR(temp10_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
568 clear_temp_alarm, 9);
569static SENSOR_DEVICE_ATTR(temp11_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
570 clear_temp_alarm, 10);
571static SENSOR_DEVICE_ATTR(temp12_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
572 clear_temp_alarm, 11);
573static SENSOR_DEVICE_ATTR(temp13_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
574 clear_temp_alarm, 12);
575static SENSOR_DEVICE_ATTR(temp14_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
576 clear_temp_alarm, 13);
577static SENSOR_DEVICE_ATTR(temp15_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
578 clear_temp_alarm, 14);
579static SENSOR_DEVICE_ATTR(temp16_alarm, S_IRUGO | S_IWUSR, show_temp_alarm,
580 clear_temp_alarm, 15);
581
582static struct attribute *fts_temp_attrs[] = {
583 &sensor_dev_attr_temp1_input.dev_attr.attr,
584 &sensor_dev_attr_temp2_input.dev_attr.attr,
585 &sensor_dev_attr_temp3_input.dev_attr.attr,
586 &sensor_dev_attr_temp4_input.dev_attr.attr,
587 &sensor_dev_attr_temp5_input.dev_attr.attr,
588 &sensor_dev_attr_temp6_input.dev_attr.attr,
589 &sensor_dev_attr_temp7_input.dev_attr.attr,
590 &sensor_dev_attr_temp8_input.dev_attr.attr,
591 &sensor_dev_attr_temp9_input.dev_attr.attr,
592 &sensor_dev_attr_temp10_input.dev_attr.attr,
593 &sensor_dev_attr_temp11_input.dev_attr.attr,
594 &sensor_dev_attr_temp12_input.dev_attr.attr,
595 &sensor_dev_attr_temp13_input.dev_attr.attr,
596 &sensor_dev_attr_temp14_input.dev_attr.attr,
597 &sensor_dev_attr_temp15_input.dev_attr.attr,
598 &sensor_dev_attr_temp16_input.dev_attr.attr,
599
600 &sensor_dev_attr_temp1_fault.dev_attr.attr,
601 &sensor_dev_attr_temp2_fault.dev_attr.attr,
602 &sensor_dev_attr_temp3_fault.dev_attr.attr,
603 &sensor_dev_attr_temp4_fault.dev_attr.attr,
604 &sensor_dev_attr_temp5_fault.dev_attr.attr,
605 &sensor_dev_attr_temp6_fault.dev_attr.attr,
606 &sensor_dev_attr_temp7_fault.dev_attr.attr,
607 &sensor_dev_attr_temp8_fault.dev_attr.attr,
608 &sensor_dev_attr_temp9_fault.dev_attr.attr,
609 &sensor_dev_attr_temp10_fault.dev_attr.attr,
610 &sensor_dev_attr_temp11_fault.dev_attr.attr,
611 &sensor_dev_attr_temp12_fault.dev_attr.attr,
612 &sensor_dev_attr_temp13_fault.dev_attr.attr,
613 &sensor_dev_attr_temp14_fault.dev_attr.attr,
614 &sensor_dev_attr_temp15_fault.dev_attr.attr,
615 &sensor_dev_attr_temp16_fault.dev_attr.attr,
616
617 &sensor_dev_attr_temp1_alarm.dev_attr.attr,
618 &sensor_dev_attr_temp2_alarm.dev_attr.attr,
619 &sensor_dev_attr_temp3_alarm.dev_attr.attr,
620 &sensor_dev_attr_temp4_alarm.dev_attr.attr,
621 &sensor_dev_attr_temp5_alarm.dev_attr.attr,
622 &sensor_dev_attr_temp6_alarm.dev_attr.attr,
623 &sensor_dev_attr_temp7_alarm.dev_attr.attr,
624 &sensor_dev_attr_temp8_alarm.dev_attr.attr,
625 &sensor_dev_attr_temp9_alarm.dev_attr.attr,
626 &sensor_dev_attr_temp10_alarm.dev_attr.attr,
627 &sensor_dev_attr_temp11_alarm.dev_attr.attr,
628 &sensor_dev_attr_temp12_alarm.dev_attr.attr,
629 &sensor_dev_attr_temp13_alarm.dev_attr.attr,
630 &sensor_dev_attr_temp14_alarm.dev_attr.attr,
631 &sensor_dev_attr_temp15_alarm.dev_attr.attr,
632 &sensor_dev_attr_temp16_alarm.dev_attr.attr,
633 NULL
634};
635
636/* Fans */
637static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_value, NULL, 0);
638static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_value, NULL, 1);
639static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_value, NULL, 2);
640static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_value, NULL, 3);
641static SENSOR_DEVICE_ATTR(fan5_input, S_IRUGO, show_fan_value, NULL, 4);
642static SENSOR_DEVICE_ATTR(fan6_input, S_IRUGO, show_fan_value, NULL, 5);
643static SENSOR_DEVICE_ATTR(fan7_input, S_IRUGO, show_fan_value, NULL, 6);
644static SENSOR_DEVICE_ATTR(fan8_input, S_IRUGO, show_fan_value, NULL, 7);
645
646static SENSOR_DEVICE_ATTR(fan1_source, S_IRUGO, show_fan_source, NULL, 0);
647static SENSOR_DEVICE_ATTR(fan2_source, S_IRUGO, show_fan_source, NULL, 1);
648static SENSOR_DEVICE_ATTR(fan3_source, S_IRUGO, show_fan_source, NULL, 2);
649static SENSOR_DEVICE_ATTR(fan4_source, S_IRUGO, show_fan_source, NULL, 3);
650static SENSOR_DEVICE_ATTR(fan5_source, S_IRUGO, show_fan_source, NULL, 4);
651static SENSOR_DEVICE_ATTR(fan6_source, S_IRUGO, show_fan_source, NULL, 5);
652static SENSOR_DEVICE_ATTR(fan7_source, S_IRUGO, show_fan_source, NULL, 6);
653static SENSOR_DEVICE_ATTR(fan8_source, S_IRUGO, show_fan_source, NULL, 7);
654
655static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO | S_IWUSR,
656 show_fan_alarm, clear_fan_alarm, 0);
657static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO | S_IWUSR,
658 show_fan_alarm, clear_fan_alarm, 1);
659static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO | S_IWUSR,
660 show_fan_alarm, clear_fan_alarm, 2);
661static SENSOR_DEVICE_ATTR(fan4_alarm, S_IRUGO | S_IWUSR,
662 show_fan_alarm, clear_fan_alarm, 3);
663static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO | S_IWUSR,
664 show_fan_alarm, clear_fan_alarm, 4);
665static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO | S_IWUSR,
666 show_fan_alarm, clear_fan_alarm, 5);
667static SENSOR_DEVICE_ATTR(fan7_alarm, S_IRUGO | S_IWUSR,
668 show_fan_alarm, clear_fan_alarm, 6);
669static SENSOR_DEVICE_ATTR(fan8_alarm, S_IRUGO | S_IWUSR,
670 show_fan_alarm, clear_fan_alarm, 7);
671
672static struct attribute *fts_fan_attrs[] = {
673 &sensor_dev_attr_fan1_input.dev_attr.attr,
674 &sensor_dev_attr_fan2_input.dev_attr.attr,
675 &sensor_dev_attr_fan3_input.dev_attr.attr,
676 &sensor_dev_attr_fan4_input.dev_attr.attr,
677 &sensor_dev_attr_fan5_input.dev_attr.attr,
678 &sensor_dev_attr_fan6_input.dev_attr.attr,
679 &sensor_dev_attr_fan7_input.dev_attr.attr,
680 &sensor_dev_attr_fan8_input.dev_attr.attr,
681
682 &sensor_dev_attr_fan1_source.dev_attr.attr,
683 &sensor_dev_attr_fan2_source.dev_attr.attr,
684 &sensor_dev_attr_fan3_source.dev_attr.attr,
685 &sensor_dev_attr_fan4_source.dev_attr.attr,
686 &sensor_dev_attr_fan5_source.dev_attr.attr,
687 &sensor_dev_attr_fan6_source.dev_attr.attr,
688 &sensor_dev_attr_fan7_source.dev_attr.attr,
689 &sensor_dev_attr_fan8_source.dev_attr.attr,
690
691 &sensor_dev_attr_fan1_alarm.dev_attr.attr,
692 &sensor_dev_attr_fan2_alarm.dev_attr.attr,
693 &sensor_dev_attr_fan3_alarm.dev_attr.attr,
694 &sensor_dev_attr_fan4_alarm.dev_attr.attr,
695 &sensor_dev_attr_fan5_alarm.dev_attr.attr,
696 &sensor_dev_attr_fan6_alarm.dev_attr.attr,
697 &sensor_dev_attr_fan7_alarm.dev_attr.attr,
698 &sensor_dev_attr_fan8_alarm.dev_attr.attr,
699 NULL
700};
701
702/* Voltages */
703static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in_value, NULL, 0);
704static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in_value, NULL, 1);
705static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in_value, NULL, 2);
706static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in_value, NULL, 3);
707static struct attribute *fts_voltage_attrs[] = {
708 &sensor_dev_attr_in1_input.dev_attr.attr,
709 &sensor_dev_attr_in2_input.dev_attr.attr,
710 &sensor_dev_attr_in3_input.dev_attr.attr,
711 &sensor_dev_attr_in4_input.dev_attr.attr,
712 NULL
713};
714
715static const struct attribute_group fts_voltage_attr_group = {
716 .attrs = fts_voltage_attrs
717};
718
719static const struct attribute_group fts_temp_attr_group = {
720 .attrs = fts_temp_attrs
721};
722
723static const struct attribute_group fts_fan_attr_group = {
724 .attrs = fts_fan_attrs
725};
726
727static const struct attribute_group *fts_attr_groups[] = {
728 &fts_voltage_attr_group,
729 &fts_temp_attr_group,
730 &fts_fan_attr_group,
731 NULL
732};
733
734/*****************************************************************************/
735/* Module initialization / remove functions */
736/*****************************************************************************/
737static int fts_remove(struct i2c_client *client)
738{
739 struct fts_data *data = dev_get_drvdata(&client->dev);
740
741 watchdog_unregister_device(&data->wdd);
742 return 0;
743}
744
745static int fts_probe(struct i2c_client *client, const struct i2c_device_id *id)
746{
747 u8 revision;
748 struct fts_data *data;
749 int err;
750 s8 deviceid;
751 struct device *hwmon_dev;
752
753 if (client->addr != 0x73)
754 return -ENODEV;
755
756 /* Baseboard Management Controller check */
757 deviceid = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
758 if (deviceid > 0 && (deviceid & 0xF0) == 0x10) {
759 switch (deviceid & 0x0F) {
760 case 0x01:
761 break;
762 default:
763 dev_dbg(&client->dev,
764 "No Baseboard Management Controller\n");
765 return -ENODEV;
766 }
767 } else {
768 dev_dbg(&client->dev, "No fujitsu board\n");
769 return -ENODEV;
770 }
771
772 data = devm_kzalloc(&client->dev, sizeof(struct fts_data),
773 GFP_KERNEL);
774 if (!data)
775 return -ENOMEM;
776
777 mutex_init(&data->update_lock);
778 mutex_init(&data->access_lock);
779 data->client = client;
780 dev_set_drvdata(&client->dev, data);
781
782 err = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
783 if (err < 0)
784 return err;
785 revision = err;
786
787 hwmon_dev = devm_hwmon_device_register_with_groups(&client->dev,
788 "ftsteutates",
789 data,
790 fts_attr_groups);
791 if (IS_ERR(hwmon_dev))
792 return PTR_ERR(hwmon_dev);
793
794 err = fts_watchdog_init(data);
795 if (err)
796 return err;
797
798 dev_info(&client->dev, "Detected FTS Teutates chip, revision: %d.%d\n",
799 (revision & 0xF0) >> 4, revision & 0x0F);
800 return 0;
801}
802
803/*****************************************************************************/
804/* Module Details */
805/*****************************************************************************/
806static struct i2c_driver fts_driver = {
807 .driver = {
808 .name = "ftsteutates",
809 },
810 .id_table = fts_id,
811 .probe = fts_probe,
812 .remove = fts_remove,
813};
814
815module_i2c_driver(fts_driver);
816
817MODULE_AUTHOR("Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>");
818MODULE_DESCRIPTION("FTS Teutates driver");
819MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror