[linux-2.6-block.git] / drivers / hwmon / pmbus / max8688.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Hardware monitoring driver for Maxim MAX8688
 *
 * Copyright (c) 2011 Ericsson AB.
 */

#include <linux/bitops.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include "pmbus.h"

#define MAX8688_MFR_VOUT_PEAK		0xd4
#define MAX8688_MFR_IOUT_PEAK		0xd5
#define MAX8688_MFR_TEMPERATURE_PEAK	0xd6
#define MAX8688_MFG_STATUS		0xd8

#define MAX8688_STATUS_OC_FAULT		BIT(4)
#define MAX8688_STATUS_OV_FAULT		BIT(5)
#define MAX8688_STATUS_OV_WARNING	BIT(8)
#define MAX8688_STATUS_UV_FAULT		BIT(9)
#define MAX8688_STATUS_UV_WARNING	BIT(10)
#define MAX8688_STATUS_UC_FAULT		BIT(11)
#define MAX8688_STATUS_OC_WARNING	BIT(12)
#define MAX8688_STATUS_OT_FAULT		BIT(13)
#define MAX8688_STATUS_OT_WARNING	BIT(14)

static int max8688_read_word_data(struct i2c_client *client, int page,
				  int phase, int reg)
{
	int ret;

	if (page > 0)
		return -ENXIO;

	switch (reg) {
	case PMBUS_VIRT_READ_VOUT_MAX:
		ret = pmbus_read_word_data(client, 0, 0xff,
					   MAX8688_MFR_VOUT_PEAK);
		break;
	case PMBUS_VIRT_READ_IOUT_MAX:
		ret = pmbus_read_word_data(client, 0, 0xff,
					   MAX8688_MFR_IOUT_PEAK);
		break;
	case PMBUS_VIRT_READ_TEMP_MAX:
		ret = pmbus_read_word_data(client, 0, 0xff,
					   MAX8688_MFR_TEMPERATURE_PEAK);
		break;
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	case PMBUS_VIRT_RESET_TEMP_HISTORY:
		ret = 0;
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static int max8688_write_word_data(struct i2c_client *client, int page, int reg,
				   u16 word)
{
	int ret;

	switch (reg) {
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
		ret = pmbus_write_word_data(client, 0, MAX8688_MFR_VOUT_PEAK,
					    0);
		break;
	case PMBUS_VIRT_RESET_IOUT_HISTORY:
		ret = pmbus_write_word_data(client, 0, MAX8688_MFR_IOUT_PEAK,
					    0);
		break;
	case PMBUS_VIRT_RESET_TEMP_HISTORY:
		ret = pmbus_write_word_data(client, 0,
					    MAX8688_MFR_TEMPERATURE_PEAK,
					    0xffff);
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static int max8688_read_byte_data(struct i2c_client *client, int page, int reg)
{
	int ret = 0;
	int mfg_status;

	if (page > 0)
		return -ENXIO;

	switch (reg) {
	case PMBUS_STATUS_VOUT:
		mfg_status = pmbus_read_word_data(client, 0, 0xff,
						  MAX8688_MFG_STATUS);
		if (mfg_status < 0)
			return mfg_status;
		if (mfg_status & MAX8688_STATUS_UV_WARNING)
			ret |= PB_VOLTAGE_UV_WARNING;
		if (mfg_status & MAX8688_STATUS_UV_FAULT)
			ret |= PB_VOLTAGE_UV_FAULT;
		if (mfg_status & MAX8688_STATUS_OV_WARNING)
			ret |= PB_VOLTAGE_OV_WARNING;
		if (mfg_status & MAX8688_STATUS_OV_FAULT)
			ret |= PB_VOLTAGE_OV_FAULT;
		break;
	case PMBUS_STATUS_IOUT:
		mfg_status = pmbus_read_word_data(client, 0, 0xff,
						  MAX8688_MFG_STATUS);
		if (mfg_status < 0)
			return mfg_status;
		if (mfg_status & MAX8688_STATUS_UC_FAULT)
			ret |= PB_IOUT_UC_FAULT;
		if (mfg_status & MAX8688_STATUS_OC_WARNING)
			ret |= PB_IOUT_OC_WARNING;
		if (mfg_status & MAX8688_STATUS_OC_FAULT)
			ret |= PB_IOUT_OC_FAULT;
		break;
	case PMBUS_STATUS_TEMPERATURE:
		mfg_status = pmbus_read_word_data(client, 0, 0xff,
						  MAX8688_MFG_STATUS);
		if (mfg_status < 0)
			return mfg_status;
		if (mfg_status & MAX8688_STATUS_OT_WARNING)
			ret |= PB_TEMP_OT_WARNING;
		if (mfg_status & MAX8688_STATUS_OT_FAULT)
			ret |= PB_TEMP_OT_FAULT;
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static struct pmbus_driver_info max8688_info = {
	.pages = 1,
	.format[PSC_VOLTAGE_IN] = direct,
	.format[PSC_VOLTAGE_OUT] = direct,
	.format[PSC_TEMPERATURE] = direct,
	.format[PSC_CURRENT_OUT] = direct,
	.m[PSC_VOLTAGE_IN] = 19995,
	.b[PSC_VOLTAGE_IN] = 0,
	.R[PSC_VOLTAGE_IN] = -1,
	.m[PSC_VOLTAGE_OUT] = 19995,
	.b[PSC_VOLTAGE_OUT] = 0,
	.R[PSC_VOLTAGE_OUT] = -1,
	.m[PSC_CURRENT_OUT] = 23109,
	.b[PSC_CURRENT_OUT] = 0,
	.R[PSC_CURRENT_OUT] = -2,
	.m[PSC_TEMPERATURE] = -7612,
	.b[PSC_TEMPERATURE] = 335,
	.R[PSC_TEMPERATURE] = -3,
	.func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP
		| PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_STATUS_IOUT
		| PMBUS_HAVE_STATUS_TEMP,
	.read_byte_data = max8688_read_byte_data,
	.read_word_data = max8688_read_word_data,
	.write_word_data = max8688_write_word_data,
};

static int max8688_probe(struct i2c_client *client)
{
	return pmbus_do_probe(client, &max8688_info);
}

static const struct i2c_device_id max8688_id[] = {
	{"max8688"},
	{ }
};

MODULE_DEVICE_TABLE(i2c, max8688_id);

/* This is the driver that will be inserted */
static struct i2c_driver max8688_driver = {
	.driver = {
		   .name = "max8688",
		   },
	.probe = max8688_probe,
	.id_table = max8688_id,
};

module_i2c_driver(max8688_driver);

MODULE_AUTHOR("Guenter Roeck");
MODULE_DESCRIPTION("PMBus driver for Maxim MAX8688");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(PMBUS);
Commit	Line	Data
74ba9207	1	// SPDX-License-Identifier: GPL-2.0-or-later
8ea3238b GR	2	/*
	3	* Hardware monitoring driver for Maxim MAX8688
	4	*
	5	* Copyright (c) 2011 Ericsson AB.
8ea3238b GR	6	*/
8ea3238b GR	7
2c052d42	8	#include <linux/bitops.h>
8ea3238b GR	9	#include <linux/kernel.h>
	10	#include <linux/module.h>
	11	#include <linux/init.h>
	12	#include <linux/err.h>
	13	#include <linux/i2c.h>
	14	#include "pmbus.h"
	15
70e94b27 GR	16	#define MAX8688_MFR_VOUT_PEAK 0xd4
	17	#define MAX8688_MFR_IOUT_PEAK 0xd5
	18	#define MAX8688_MFR_TEMPERATURE_PEAK 0xd6
8ea3238b GR	19	#define MAX8688_MFG_STATUS 0xd8
8ea3238b GR	20
2c052d42 GR	21	#define MAX8688_STATUS_OC_FAULT BIT(4)
	22	#define MAX8688_STATUS_OV_FAULT BIT(5)
	23	#define MAX8688_STATUS_OV_WARNING BIT(8)
	24	#define MAX8688_STATUS_UV_FAULT BIT(9)
	25	#define MAX8688_STATUS_UV_WARNING BIT(10)
	26	#define MAX8688_STATUS_UC_FAULT BIT(11)
	27	#define MAX8688_STATUS_OC_WARNING BIT(12)
	28	#define MAX8688_STATUS_OT_FAULT BIT(13)
	29	#define MAX8688_STATUS_OT_WARNING BIT(14)
8ea3238b	30
43f33b6e GR	31	static int max8688_read_word_data(struct i2c_client *client, int page,
43f33b6e GR	32	int phase, int reg)
70e94b27 GR	33	{
	34	int ret;
	35
a46f8cd6	36	if (page > 0)
179144a0	37	return -ENXIO;
70e94b27 GR	38
	39	switch (reg) {
	40	case PMBUS_VIRT_READ_VOUT_MAX:
43f33b6e GR	41	ret = pmbus_read_word_data(client, 0, 0xff,
43f33b6e GR	42	MAX8688_MFR_VOUT_PEAK);
70e94b27 GR	43	break;
70e94b27 GR	44	case PMBUS_VIRT_READ_IOUT_MAX:
43f33b6e GR	45	ret = pmbus_read_word_data(client, 0, 0xff,
43f33b6e GR	46	MAX8688_MFR_IOUT_PEAK);
70e94b27 GR	47	break;
70e94b27 GR	48	case PMBUS_VIRT_READ_TEMP_MAX:
43f33b6e	49	ret = pmbus_read_word_data(client, 0, 0xff,
70e94b27 GR	50	MAX8688_MFR_TEMPERATURE_PEAK);
	51	break;
	52	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	53	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	54	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	55	ret = 0;
	56	break;
	57	default:
	58	ret = -ENODATA;
	59	break;
	60	}
	61	return ret;
	62	}
	63
	64	static int max8688_write_word_data(struct i2c_client *client, int page, int reg,
	65	u16 word)
	66	{
	67	int ret;
	68
	69	switch (reg) {
	70	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	71	ret = pmbus_write_word_data(client, 0, MAX8688_MFR_VOUT_PEAK,
	72	0);
	73	break;
	74	case PMBUS_VIRT_RESET_IOUT_HISTORY:
	75	ret = pmbus_write_word_data(client, 0, MAX8688_MFR_IOUT_PEAK,
	76	0);
	77	break;
	78	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	79	ret = pmbus_write_word_data(client, 0,
	80	MAX8688_MFR_TEMPERATURE_PEAK,
	81	0xffff);
	82	break;
	83	default:
	84	ret = -ENODATA;
	85	break;
	86	}
	87	return ret;
	88	}
	89
2cfa6aed	90	static int max8688_read_byte_data(struct i2c_client *client, int page, int reg)
8ea3238b GR	91	{
	92	int ret = 0;
	93	int mfg_status;
	94
da8e48ab	95	if (page > 0)
179144a0	96	return -ENXIO;
8ea3238b GR	97
	98	switch (reg) {
	99	case PMBUS_STATUS_VOUT:
43f33b6e	100	mfg_status = pmbus_read_word_data(client, 0, 0xff,
8ea3238b GR	101	MAX8688_MFG_STATUS);
	102	if (mfg_status < 0)
	103	return mfg_status;
	104	if (mfg_status & MAX8688_STATUS_UV_WARNING)
	105	ret \|= PB_VOLTAGE_UV_WARNING;
	106	if (mfg_status & MAX8688_STATUS_UV_FAULT)
	107	ret \|= PB_VOLTAGE_UV_FAULT;
	108	if (mfg_status & MAX8688_STATUS_OV_WARNING)
	109	ret \|= PB_VOLTAGE_OV_WARNING;
	110	if (mfg_status & MAX8688_STATUS_OV_FAULT)
	111	ret \|= PB_VOLTAGE_OV_FAULT;
	112	break;
	113	case PMBUS_STATUS_IOUT:
43f33b6e	114	mfg_status = pmbus_read_word_data(client, 0, 0xff,
8ea3238b GR	115	MAX8688_MFG_STATUS);
	116	if (mfg_status < 0)
	117	return mfg_status;
	118	if (mfg_status & MAX8688_STATUS_UC_FAULT)
	119	ret \|= PB_IOUT_UC_FAULT;
	120	if (mfg_status & MAX8688_STATUS_OC_WARNING)
	121	ret \|= PB_IOUT_OC_WARNING;
	122	if (mfg_status & MAX8688_STATUS_OC_FAULT)
	123	ret \|= PB_IOUT_OC_FAULT;
	124	break;
	125	case PMBUS_STATUS_TEMPERATURE:
43f33b6e	126	mfg_status = pmbus_read_word_data(client, 0, 0xff,
8ea3238b GR	127	MAX8688_MFG_STATUS);
	128	if (mfg_status < 0)
	129	return mfg_status;
	130	if (mfg_status & MAX8688_STATUS_OT_WARNING)
	131	ret \|= PB_TEMP_OT_WARNING;
	132	if (mfg_status & MAX8688_STATUS_OT_FAULT)
	133	ret \|= PB_TEMP_OT_FAULT;
	134	break;
	135	default:
	136	ret = -ENODATA;
	137	break;
	138	}
	139	return ret;
	140	}
	141
	142	static struct pmbus_driver_info max8688_info = {
	143	.pages = 1,
1061d851 GR	144	.format[PSC_VOLTAGE_IN] = direct,
	145	.format[PSC_VOLTAGE_OUT] = direct,
	146	.format[PSC_TEMPERATURE] = direct,
	147	.format[PSC_CURRENT_OUT] = direct,
8ea3238b GR	148	.m[PSC_VOLTAGE_IN] = 19995,
	149	.b[PSC_VOLTAGE_IN] = 0,
	150	.R[PSC_VOLTAGE_IN] = -1,
	151	.m[PSC_VOLTAGE_OUT] = 19995,
	152	.b[PSC_VOLTAGE_OUT] = 0,
	153	.R[PSC_VOLTAGE_OUT] = -1,
	154	.m[PSC_CURRENT_OUT] = 23109,
	155	.b[PSC_CURRENT_OUT] = 0,
	156	.R[PSC_CURRENT_OUT] = -2,
	157	.m[PSC_TEMPERATURE] = -7612,
	158	.b[PSC_TEMPERATURE] = 335,
	159	.R[PSC_TEMPERATURE] = -3,
	160	.func[0] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_IOUT \| PMBUS_HAVE_TEMP
	161	\| PMBUS_HAVE_STATUS_VOUT \| PMBUS_HAVE_STATUS_IOUT
	162	\| PMBUS_HAVE_STATUS_TEMP,
2cfa6aed	163	.read_byte_data = max8688_read_byte_data,
70e94b27 GR	164	.read_word_data = max8688_read_word_data,
70e94b27 GR	165	.write_word_data = max8688_write_word_data,
8ea3238b GR	166	};
8ea3238b GR	167
dd431939	168	static int max8688_probe(struct i2c_client *client)
8ea3238b	169	{
dd431939	170	return pmbus_do_probe(client, &max8688_info);
8ea3238b GR	171	}
8ea3238b GR	172
8ea3238b	173	static const struct i2c_device_id max8688_id[] = {
d8a66f36	174	{"max8688"},
8ea3238b GR	175	{ }
	176	};
	177
	178	MODULE_DEVICE_TABLE(i2c, max8688_id);
	179
	180	/* This is the driver that will be inserted */
	181	static struct i2c_driver max8688_driver = {
	182	.driver = {
	183	.name = "max8688",
	184	},
1975d167	185	.probe = max8688_probe,
8ea3238b GR	186	.id_table = max8688_id,
	187	};
	188
f0967eea	189	module_i2c_driver(max8688_driver);
8ea3238b GR	190
	191	MODULE_AUTHOR("Guenter Roeck");
	192	MODULE_DESCRIPTION("PMBus driver for Maxim MAX8688");
	193	MODULE_LICENSE("GPL");
b94ca77e	194	MODULE_IMPORT_NS(PMBUS);