ftsteutates.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Support for the FTS Systemmonitoring Chip "Teutates"
  4 *
  5 * Copyright (C) 2016 Fujitsu Technology Solutions GmbH,
  6 *		  Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>
  7 */
  8#include <linux/err.h>
  9#include <linux/hwmon.h>
 10#include <linux/i2c.h>
 11#include <linux/init.h>
 12#include <linux/jiffies.h>
 13#include <linux/math.h>
 14#include <linux/module.h>
 15#include <linux/slab.h>
 16#include <linux/watchdog.h>
 17
 18#define FTS_DEVICE_ID_REG		0x0000
 19#define FTS_DEVICE_REVISION_REG		0x0001
 20#define FTS_DEVICE_STATUS_REG		0x0004
 21#define FTS_SATELLITE_STATUS_REG	0x0005
 22#define FTS_EVENT_STATUS_REG		0x0006
 23#define FTS_GLOBAL_CONTROL_REG		0x0007
 24
 25#define FTS_DEVICE_DETECT_REG_1		0x0C
 26#define FTS_DEVICE_DETECT_REG_2		0x0D
 27#define FTS_DEVICE_DETECT_REG_3		0x0E
 28
 29#define FTS_SENSOR_EVENT_REG		0x0010
 30
 31#define FTS_FAN_EVENT_REG		0x0014
 32#define FTS_FAN_PRESENT_REG		0x0015
 33
 34#define FTS_POWER_ON_TIME_COUNTER_A	0x007A
 35#define FTS_POWER_ON_TIME_COUNTER_B	0x007B
 36#define FTS_POWER_ON_TIME_COUNTER_C	0x007C
 37
 38#define FTS_PAGE_SELECT_REG		0x007F
 39
 40#define FTS_WATCHDOG_TIME_PRESET	0x000B
 41#define FTS_WATCHDOG_CONTROL		0x5081
 42
 43#define FTS_NO_FAN_SENSORS		0x08
 44#define FTS_NO_TEMP_SENSORS		0x10
 45#define FTS_NO_VOLT_SENSORS		0x04
 46
 47#define FTS_FAN_SOURCE_INVALID		0xff
 48
 49static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
 50
 51static const struct i2c_device_id fts_id[] = {
 52	{ "ftsteutates" },
 53	{ }
 54};
 55MODULE_DEVICE_TABLE(i2c, fts_id);
 56
 57enum WATCHDOG_RESOLUTION {
 58	seconds = 1,
 59	minutes = 60
 60};
 61
 62struct fts_data {
 63	struct i2c_client *client;
 64	unsigned long last_updated; /* in jiffies */
 65	struct watchdog_device wdd;
 66	enum WATCHDOG_RESOLUTION resolution;
 67	bool valid; /* false until following fields are valid */
 68
 69	u8 volt[FTS_NO_VOLT_SENSORS];
 70
 71	u8 temp_input[FTS_NO_TEMP_SENSORS];
 72	u8 temp_alarm;
 73
 74	u8 fan_present;
 75	u8 fan_input[FTS_NO_FAN_SENSORS]; /* in rps */
 76	u8 fan_source[FTS_NO_FAN_SENSORS];
 77	u8 fan_alarm;
 78};
 79
 80#define FTS_REG_FAN_INPUT(idx) ((idx) + 0x20)
 81#define FTS_REG_FAN_SOURCE(idx) ((idx) + 0x30)
 82#define FTS_REG_FAN_CONTROL(idx) (((idx) << 16) + 0x4881)
 83
 84#define FTS_REG_TEMP_INPUT(idx) ((idx) + 0x40)
 85#define FTS_REG_TEMP_CONTROL(idx) (((idx) << 16) + 0x0681)
 86
 87#define FTS_REG_VOLT(idx) ((idx) + 0x18)
 88
 89/*****************************************************************************/
 90/* I2C Helper functions							     */
 91/*****************************************************************************/
 92static int fts_read_byte(struct i2c_client *client, unsigned short reg)
 93{
 94	int ret;
 95	unsigned char page = reg >> 8;
 96
 97	dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
 98	ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page);
 99	if (ret < 0)
100		return ret;
101
102	reg &= 0xFF;
103	ret = i2c_smbus_read_byte_data(client, reg);
104	dev_dbg(&client->dev, "read - reg: 0x%.02x: val: 0x%.02x\n", reg, ret);
105	return ret;
106}
107
108static int fts_write_byte(struct i2c_client *client, unsigned short reg,
109			  unsigned char value)
110{
111	int ret;
112	unsigned char page = reg >> 8;
113
114	dev_dbg(&client->dev, "page select - page: 0x%.02x\n", page);
115	ret = i2c_smbus_write_byte_data(client, FTS_PAGE_SELECT_REG, page);
116	if (ret < 0)
117		return ret;
118
119	reg &= 0xFF;
120	dev_dbg(&client->dev,
121		"write - reg: 0x%.02x: val: 0x%.02x\n", reg, value);
122	ret = i2c_smbus_write_byte_data(client, reg, value);
123	return ret;
124}
125
126/*****************************************************************************/
127/* Data Updater Helper function						     */
128/*****************************************************************************/
129static int fts_update_device(struct fts_data *data)
130{
131	int i, err;
132
133	if (!time_after(jiffies, data->last_updated + 2 * HZ) && data->valid)
134		return 0;
135
136	err = fts_read_byte(data->client, FTS_DEVICE_STATUS_REG);
137	if (err < 0)
138		return err;
139
140	data->valid = !!(err & 0x02); /* Data not ready yet */
141	if (unlikely(!data->valid))
142		return -EAGAIN;
143
144	err = fts_read_byte(data->client, FTS_FAN_PRESENT_REG);
145	if (err < 0)
146		return err;
147	data->fan_present = err;
148
149	err = fts_read_byte(data->client, FTS_FAN_EVENT_REG);
150	if (err < 0)
151		return err;
152	data->fan_alarm = err;
153
154	for (i = 0; i < FTS_NO_FAN_SENSORS; i++) {
155		if (data->fan_present & BIT(i)) {
156			err = fts_read_byte(data->client, FTS_REG_FAN_INPUT(i));
157			if (err < 0)
158				return err;
159			data->fan_input[i] = err;
160
161			err = fts_read_byte(data->client,
162					    FTS_REG_FAN_SOURCE(i));
163			if (err < 0)
164				return err;
165			data->fan_source[i] = err;
166		} else {
167			data->fan_input[i] = 0;
168			data->fan_source[i] = FTS_FAN_SOURCE_INVALID;
169		}
170	}
171
172	err = fts_read_byte(data->client, FTS_SENSOR_EVENT_REG);
173	if (err < 0)
174		return err;
175	data->temp_alarm = err;
176
177	for (i = 0; i < FTS_NO_TEMP_SENSORS; i++) {
178		err = fts_read_byte(data->client, FTS_REG_TEMP_INPUT(i));
179		if (err < 0)
180			return err;
181		data->temp_input[i] = err;
182	}
183
184	for (i = 0; i < FTS_NO_VOLT_SENSORS; i++) {
185		err = fts_read_byte(data->client, FTS_REG_VOLT(i));
186		if (err < 0)
187			return err;
188		data->volt[i] = err;
189	}
190	data->last_updated = jiffies;
191	return 0;
192}
193
194/*****************************************************************************/
195/* Watchdog functions							     */
196/*****************************************************************************/
197static int fts_wd_set_resolution(struct fts_data *data,
198				 enum WATCHDOG_RESOLUTION resolution)
199{
200	int ret;
201
202	if (data->resolution == resolution)
203		return 0;
204
205	ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL);
206	if (ret < 0)
207		return ret;
208
209	if ((resolution == seconds && ret & BIT(1)) ||
210	    (resolution == minutes && (ret & BIT(1)) == 0)) {
211		data->resolution = resolution;
212		return 0;
213	}
214
215	if (resolution == seconds)
216		ret |= BIT(1);
217	else
218		ret &= ~BIT(1);
219
220	ret = fts_write_byte(data->client, FTS_WATCHDOG_CONTROL, ret);
221	if (ret < 0)
222		return ret;
223
224	data->resolution = resolution;
225	return ret;
226}
227
228static int fts_wd_set_timeout(struct watchdog_device *wdd, unsigned int timeout)
229{
230	struct fts_data *data;
231	enum WATCHDOG_RESOLUTION resolution = seconds;
232	int ret;
233
234	data = watchdog_get_drvdata(wdd);
235	/* switch watchdog resolution to minutes if timeout does not fit
236	 * into a byte
237	 */
238	if (timeout > 0xFF) {
239		timeout = DIV_ROUND_UP(timeout, 60) * 60;
240		resolution = minutes;
241	}
242
243	ret = fts_wd_set_resolution(data, resolution);
244	if (ret < 0)
245		return ret;
246
247	wdd->timeout = timeout;
248	return 0;
249}
250
251static int fts_wd_start(struct watchdog_device *wdd)
252{
253	struct fts_data *data = watchdog_get_drvdata(wdd);
254
255	return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET,
256			      wdd->timeout / (u8)data->resolution);
257}
258
259static int fts_wd_stop(struct watchdog_device *wdd)
260{
261	struct fts_data *data;
262
263	data = watchdog_get_drvdata(wdd);
264	return fts_write_byte(data->client, FTS_WATCHDOG_TIME_PRESET, 0);
265}
266
267static const struct watchdog_info fts_wd_info = {
268	.options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
269	.identity = "FTS Teutates Hardware Watchdog",
270};
271
272static const struct watchdog_ops fts_wd_ops = {
273	.owner = THIS_MODULE,
274	.start = fts_wd_start,
275	.stop = fts_wd_stop,
276	.set_timeout = fts_wd_set_timeout,
277};
278
279static int fts_watchdog_init(struct fts_data *data)
280{
281	int timeout, ret;
282
283	watchdog_set_drvdata(&data->wdd, data);
284
285	timeout = fts_read_byte(data->client, FTS_WATCHDOG_TIME_PRESET);
286	if (timeout < 0)
287		return timeout;
288
289	/* watchdog not running, set timeout to a default of 60 sec. */
290	if (timeout == 0) {
291		ret = fts_wd_set_resolution(data, seconds);
292		if (ret < 0)
293			return ret;
294		data->wdd.timeout = 60;
295	} else {
296		ret = fts_read_byte(data->client, FTS_WATCHDOG_CONTROL);
297		if (ret < 0)
298			return ret;
299
300		data->resolution = ret & BIT(1) ? seconds : minutes;
301		data->wdd.timeout = timeout * (u8)data->resolution;
302		set_bit(WDOG_HW_RUNNING, &data->wdd.status);
303	}
304
305	/* Register our watchdog part */
306	data->wdd.info = &fts_wd_info;
307	data->wdd.ops = &fts_wd_ops;
308	data->wdd.parent = &data->client->dev;
309	data->wdd.min_timeout = 1;
310
311	/* max timeout 255 minutes. */
312	data->wdd.max_hw_heartbeat_ms = 0xFF * 60 * MSEC_PER_SEC;
313
314	return devm_watchdog_register_device(&data->client->dev, &data->wdd);
315}
316
317static umode_t fts_is_visible(const void *devdata, enum hwmon_sensor_types type, u32 attr,
318			      int channel)
319{
320	switch (type) {
321	case hwmon_temp:
322		switch (attr) {
323		case hwmon_temp_input:
324		case hwmon_temp_fault:
325			return 0444;
326		case hwmon_temp_alarm:
327			return 0644;
328		default:
329			break;
330		}
331		break;
332	case hwmon_fan:
333		switch (attr) {
334		case hwmon_fan_input:
335		case hwmon_fan_fault:
336			return 0444;
337		case hwmon_fan_alarm:
338			return 0644;
339		default:
340			break;
341		}
342		break;
343	case hwmon_pwm:
344	case hwmon_in:
345		return 0444;
346	default:
347		break;
348	}
349
350	return 0;
351}
352
353static int fts_read(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
354		    long *val)
355{
356	struct fts_data *data = dev_get_drvdata(dev);
357	int ret = fts_update_device(data);
358
359	if (ret < 0)
360		return ret;
361
362	switch (type) {
363	case hwmon_temp:
364		switch (attr) {
365		case hwmon_temp_input:
366			*val = (data->temp_input[channel] - 64) * 1000;
367
368			return 0;
369		case hwmon_temp_alarm:
370			*val = !!(data->temp_alarm & BIT(channel));
371
372			return 0;
373		case hwmon_temp_fault:
374			/* 00h Temperature = Sensor Error */;
375			*val = (data->temp_input[channel] == 0);
376
377			return 0;
378		default:
379			break;
380		}
381		break;
382	case hwmon_fan:
383		switch (attr) {
384		case hwmon_fan_input:
385			*val = data->fan_input[channel] * 60;
386
387			return 0;
388		case hwmon_fan_alarm:
389			*val = !!(data->fan_alarm & BIT(channel));
390
391			return 0;
392		case hwmon_fan_fault:
393			*val = !(data->fan_present & BIT(channel));
394
395			return 0;
396		default:
397			break;
398		}
399		break;
400	case hwmon_pwm:
401		switch (attr) {
402		case hwmon_pwm_auto_channels_temp: {
403			u8 fan_source = data->fan_source[channel];
404
405			if (fan_source == FTS_FAN_SOURCE_INVALID || fan_source >= BITS_PER_LONG)
406				*val = 0;
407			else
408				*val = BIT(fan_source);
409
410			return 0;
411		}
412		default:
413			break;
414		}
415		break;
416	case hwmon_in:
417		switch (attr) {
418		case hwmon_in_input:
419			*val = DIV_ROUND_CLOSEST(data->volt[channel] * 3300, 255);
420
421			return 0;
422		default:
423			break;
424		}
425		break;
426	default:
427		break;
428	}
429
430	return -EOPNOTSUPP;
431}
432
433static int fts_write(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel,
434		     long val)
435{
436	struct fts_data *data = dev_get_drvdata(dev);
437	int ret = fts_update_device(data);
438
439	if (ret < 0)
440		return ret;
441
442	switch (type) {
443	case hwmon_temp:
444		switch (attr) {
445		case hwmon_temp_alarm:
446			if (val)
447				return -EINVAL;
448
449			ret = fts_read_byte(data->client, FTS_REG_TEMP_CONTROL(channel));
450			if (ret < 0)
451				return ret;
452			ret = fts_write_byte(data->client, FTS_REG_TEMP_CONTROL(channel),
453					     ret | 0x1);
454			if (ret < 0)
455				return ret;
456			data->valid = false;
457			return 0;
458		default:
459			break;
460		}
461		break;
462	case hwmon_fan:
463		switch (attr) {
464		case hwmon_fan_alarm:
465			if (val)
466				return -EINVAL;
467
468			ret = fts_read_byte(data->client, FTS_REG_FAN_CONTROL(channel));
469			if (ret < 0)
470				return ret;
471			ret = fts_write_byte(data->client, FTS_REG_FAN_CONTROL(channel),
472					     ret | 0x1);
473			if (ret < 0)
474				return ret;
475			data->valid = false;
476			return 0;
477		default:
478			break;
479		}
480		break;
481	default:
482		break;
483	}
484
485	return -EOPNOTSUPP;
486}
487
488static const struct hwmon_ops fts_ops = {
489	.is_visible = fts_is_visible,
490	.read = fts_read,
491	.write = fts_write,
492};
493
494static const struct hwmon_channel_info * const fts_info[] = {
495	HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ),
496	HWMON_CHANNEL_INFO(temp,
497			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
498			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
499			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
500			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
501			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
502			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
503			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
504			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
505			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
506			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
507			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
508			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
509			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
510			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
511			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT,
512			   HWMON_T_INPUT | HWMON_T_ALARM | HWMON_T_FAULT
513			   ),
514	HWMON_CHANNEL_INFO(fan,
515			   HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT,
516			   HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT,
517			   HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT,
518			   HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT,
519			   HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT,
520			   HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT,
521			   HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT,
522			   HWMON_F_INPUT | HWMON_F_ALARM | HWMON_F_FAULT
523			   ),
524	HWMON_CHANNEL_INFO(pwm,
525			   HWMON_PWM_AUTO_CHANNELS_TEMP,
526			   HWMON_PWM_AUTO_CHANNELS_TEMP,
527			   HWMON_PWM_AUTO_CHANNELS_TEMP,
528			   HWMON_PWM_AUTO_CHANNELS_TEMP,
529			   HWMON_PWM_AUTO_CHANNELS_TEMP,
530			   HWMON_PWM_AUTO_CHANNELS_TEMP,
531			   HWMON_PWM_AUTO_CHANNELS_TEMP,
532			   HWMON_PWM_AUTO_CHANNELS_TEMP
533			   ),
534	HWMON_CHANNEL_INFO(in,
535			   HWMON_I_INPUT,
536			   HWMON_I_INPUT,
537			   HWMON_I_INPUT,
538			   HWMON_I_INPUT
539			   ),
540	NULL
541};
542
543static const struct hwmon_chip_info fts_chip_info = {
544	.ops = &fts_ops,
545	.info = fts_info,
546};
547
548/*****************************************************************************/
549/* Module initialization / remove functions				     */
550/*****************************************************************************/
551static int fts_detect(struct i2c_client *client,
552		      struct i2c_board_info *info)
553{
554	int val;
555
556	/* detection works with revision greater or equal to 0x2b */
557	val = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
558	if (val < 0x2b)
559		return -ENODEV;
560
561	/* Device Detect Regs must have 0x17 0x34 and 0x54 */
562	val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_1);
563	if (val != 0x17)
564		return -ENODEV;
565
566	val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_2);
567	if (val != 0x34)
568		return -ENODEV;
569
570	val = i2c_smbus_read_byte_data(client, FTS_DEVICE_DETECT_REG_3);
571	if (val != 0x54)
572		return -ENODEV;
573
574	/*
575	 * 0x10 == Baseboard Management Controller, 0x01 == Teutates
576	 * Device ID Reg needs to be 0x11
577	 */
578	val = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
579	if (val != 0x11)
580		return -ENODEV;
581
582	strscpy(info->type, fts_id[0].name, I2C_NAME_SIZE);
583	info->flags = 0;
584	return 0;
585}
586
587static int fts_probe(struct i2c_client *client)
588{
589	u8 revision;
590	struct fts_data *data;
591	int err;
592	s8 deviceid;
593	struct device *hwmon_dev;
594
595	if (client->addr != 0x73)
596		return -ENODEV;
597
598	/* Baseboard Management Controller check */
599	deviceid = i2c_smbus_read_byte_data(client, FTS_DEVICE_ID_REG);
600	if (deviceid > 0 && (deviceid & 0xF0) == 0x10) {
601		switch (deviceid & 0x0F) {
602		case 0x01:
603			break;
604		default:
605			dev_dbg(&client->dev,
606				"No Baseboard Management Controller\n");
607			return -ENODEV;
608		}
609	} else {
610		dev_dbg(&client->dev, "No fujitsu board\n");
611		return -ENODEV;
612	}
613
614	data = devm_kzalloc(&client->dev, sizeof(struct fts_data),
615			    GFP_KERNEL);
616	if (!data)
617		return -ENOMEM;
618
619	data->client = client;
620	dev_set_drvdata(&client->dev, data);
621
622	err = i2c_smbus_read_byte_data(client, FTS_DEVICE_REVISION_REG);
623	if (err < 0)
624		return err;
625	revision = err;
626
627	hwmon_dev = devm_hwmon_device_register_with_info(&client->dev, "ftsteutates", data,
628							 &fts_chip_info, NULL);
629	if (IS_ERR(hwmon_dev))
630		return PTR_ERR(hwmon_dev);
631
632	err = fts_watchdog_init(data);
633	if (err)
634		return err;
635
636	dev_info(&client->dev, "Detected FTS Teutates chip, revision: %d.%d\n",
637		 (revision & 0xF0) >> 4, revision & 0x0F);
638	return 0;
639}
640
641/*****************************************************************************/
642/* Module Details							     */
643/*****************************************************************************/
644static struct i2c_driver fts_driver = {
645	.class = I2C_CLASS_HWMON,
646	.driver = {
647		.name = "ftsteutates",
648	},
649	.id_table = fts_id,
650	.probe = fts_probe,
651	.detect = fts_detect,
652	.address_list = normal_i2c,
653};
654
655module_i2c_driver(fts_driver);
656
657MODULE_AUTHOR("Thilo Cestonaro <thilo.cestonaro@ts.fujitsu.com>");
658MODULE_DESCRIPTION("FTS Teutates driver");
659MODULE_LICENSE("GPL");