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

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

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

#define MAX16064_MFR_VOUT_PEAK		0xd4
#define MAX16064_MFR_TEMPERATURE_PEAK	0xd6

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

	switch (reg) {
	case PMBUS_VIRT_READ_VOUT_MAX:
		ret = pmbus_read_word_data(client, page, phase,
					   MAX16064_MFR_VOUT_PEAK);
		break;
	case PMBUS_VIRT_READ_TEMP_MAX:
		ret = pmbus_read_word_data(client, page, phase,
					   MAX16064_MFR_TEMPERATURE_PEAK);
		break;
	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	case PMBUS_VIRT_RESET_TEMP_HISTORY:
		ret = 0;
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static int max16064_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, page,
					    MAX16064_MFR_VOUT_PEAK, 0);
		break;
	case PMBUS_VIRT_RESET_TEMP_HISTORY:
		ret = pmbus_write_word_data(client, page,
					    MAX16064_MFR_TEMPERATURE_PEAK,
					    0xffff);
		break;
	default:
		ret = -ENODATA;
		break;
	}
	return ret;
}

static struct pmbus_driver_info max16064_info = {
	.pages = 4,
	.format[PSC_VOLTAGE_IN] = direct,
	.format[PSC_VOLTAGE_OUT] = direct,
	.format[PSC_TEMPERATURE] = 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_TEMPERATURE] = -7612,
	.b[PSC_TEMPERATURE] = 335,
	.R[PSC_TEMPERATURE] = -3,
	.func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_TEMP
		| PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_STATUS_TEMP,
	.func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
	.func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
	.func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT,
	.read_word_data = max16064_read_word_data,
	.write_word_data = max16064_write_word_data,
};

static int max16064_probe(struct i2c_client *client)
{
	return pmbus_do_probe(client, &max16064_info);
}

static const struct i2c_device_id max16064_id[] = {
	{"max16064"},
	{}
};

MODULE_DEVICE_TABLE(i2c, max16064_id);

/* This is the driver that will be inserted */
static struct i2c_driver max16064_driver = {
	.driver = {
		   .name = "max16064",
		   },
	.probe = max16064_probe,
	.id_table = max16064_id,
};

module_i2c_driver(max16064_driver);

MODULE_AUTHOR("Guenter Roeck");
MODULE_DESCRIPTION("PMBus driver for Maxim MAX16064");
MODULE_LICENSE("GPL");
MODULE_IMPORT_NS(PMBUS);
Commit	Line	Data
74ba9207	1	// SPDX-License-Identifier: GPL-2.0-or-later
dcb7d066 GR	2	/*
	3	* Hardware monitoring driver for Maxim MAX16064
	4	*
	5	* Copyright (c) 2011 Ericsson AB.
dcb7d066 GR	6	*/
	7
	8	#include <linux/kernel.h>
	9	#include <linux/module.h>
	10	#include <linux/init.h>
	11	#include <linux/err.h>
	12	#include <linux/i2c.h>
	13	#include "pmbus.h"
	14
8ebed854 GR	15	#define MAX16064_MFR_VOUT_PEAK 0xd4
	16	#define MAX16064_MFR_TEMPERATURE_PEAK 0xd6
	17
43f33b6e GR	18	static int max16064_read_word_data(struct i2c_client *client, int page,
43f33b6e GR	19	int phase, int reg)
8ebed854 GR	20	{
	21	int ret;
	22
	23	switch (reg) {
	24	case PMBUS_VIRT_READ_VOUT_MAX:
43f33b6e	25	ret = pmbus_read_word_data(client, page, phase,
8ebed854 GR	26	MAX16064_MFR_VOUT_PEAK);
	27	break;
	28	case PMBUS_VIRT_READ_TEMP_MAX:
43f33b6e	29	ret = pmbus_read_word_data(client, page, phase,
8ebed854 GR	30	MAX16064_MFR_TEMPERATURE_PEAK);
	31	break;
	32	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	33	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	34	ret = 0;
	35	break;
	36	default:
	37	ret = -ENODATA;
	38	break;
	39	}
	40	return ret;
	41	}
	42
	43	static int max16064_write_word_data(struct i2c_client *client, int page,
	44	int reg, u16 word)
	45	{
	46	int ret;
	47
	48	switch (reg) {
	49	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	50	ret = pmbus_write_word_data(client, page,
	51	MAX16064_MFR_VOUT_PEAK, 0);
	52	break;
	53	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	54	ret = pmbus_write_word_data(client, page,
	55	MAX16064_MFR_TEMPERATURE_PEAK,
	56	0xffff);
	57	break;
	58	default:
	59	ret = -ENODATA;
	60	break;
	61	}
	62	return ret;
	63	}
	64
dcb7d066 GR	65	static struct pmbus_driver_info max16064_info = {
dcb7d066 GR	66	.pages = 4,
1061d851 GR	67	.format[PSC_VOLTAGE_IN] = direct,
	68	.format[PSC_VOLTAGE_OUT] = direct,
	69	.format[PSC_TEMPERATURE] = direct,
dcb7d066 GR	70	.m[PSC_VOLTAGE_IN] = 19995,
	71	.b[PSC_VOLTAGE_IN] = 0,
	72	.R[PSC_VOLTAGE_IN] = -1,
	73	.m[PSC_VOLTAGE_OUT] = 19995,
	74	.b[PSC_VOLTAGE_OUT] = 0,
	75	.R[PSC_VOLTAGE_OUT] = -1,
	76	.m[PSC_TEMPERATURE] = -7612,
	77	.b[PSC_TEMPERATURE] = 335,
	78	.R[PSC_TEMPERATURE] = -3,
	79	.func[0] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_TEMP
	80	\| PMBUS_HAVE_STATUS_VOUT \| PMBUS_HAVE_STATUS_TEMP,
	81	.func[1] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT,
	82	.func[2] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT,
	83	.func[3] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT,
8ebed854 GR	84	.read_word_data = max16064_read_word_data,
8ebed854 GR	85	.write_word_data = max16064_write_word_data,
dcb7d066 GR	86	};
dcb7d066 GR	87
dd431939	88	static int max16064_probe(struct i2c_client *client)
dcb7d066	89	{
dd431939	90	return pmbus_do_probe(client, &max16064_info);
dcb7d066 GR	91	}
dcb7d066 GR	92
dcb7d066	93	static const struct i2c_device_id max16064_id[] = {
d8a66f36	94	{"max16064"},
dcb7d066 GR	95	{}
	96	};
	97
	98	MODULE_DEVICE_TABLE(i2c, max16064_id);
	99
	100	/* This is the driver that will be inserted */
	101	static struct i2c_driver max16064_driver = {
	102	.driver = {
	103	.name = "max16064",
	104	},
1975d167	105	.probe = max16064_probe,
dcb7d066 GR	106	.id_table = max16064_id,
	107	};
	108
f0967eea	109	module_i2c_driver(max16064_driver);
dcb7d066 GR	110
	111	MODULE_AUTHOR("Guenter Roeck");
	112	MODULE_DESCRIPTION("PMBus driver for Maxim MAX16064");
	113	MODULE_LICENSE("GPL");
b94ca77e	114	MODULE_IMPORT_NS(PMBUS);