[mirror_ubuntu-jammy-kernel.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 reg)
{
	int ret;

	switch (reg) {
	case PMBUS_VIRT_READ_VOUT_MAX:
		ret = pmbus_read_word_data(client, page,
					   MAX16064_MFR_VOUT_PEAK);
		break;
	case PMBUS_VIRT_READ_TEMP_MAX:
		ret = pmbus_read_word_data(client, page,
					   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,
			  const struct i2c_device_id *id)
{
	return pmbus_do_probe(client, id, &max16064_info);
}

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

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,
	.remove = pmbus_do_remove,
	.id_table = max16064_id,
};

module_i2c_driver(max16064_driver);

MODULE_AUTHOR("Guenter Roeck");
MODULE_DESCRIPTION("PMBus driver for Maxim MAX16064");
MODULE_LICENSE("GPL");
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
	18	static int max16064_read_word_data(struct i2c_client *client, int page, int reg)
	19	{
	20	int ret;
	21
	22	switch (reg) {
	23	case PMBUS_VIRT_READ_VOUT_MAX:
	24	ret = pmbus_read_word_data(client, page,
	25	MAX16064_MFR_VOUT_PEAK);
	26	break;
	27	case PMBUS_VIRT_READ_TEMP_MAX:
	28	ret = pmbus_read_word_data(client, page,
	29	MAX16064_MFR_TEMPERATURE_PEAK);
	30	break;
	31	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	32	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	33	ret = 0;
	34	break;
	35	default:
	36	ret = -ENODATA;
	37	break;
	38	}
	39	return ret;
	40	}
	41
	42	static int max16064_write_word_data(struct i2c_client *client, int page,
	43	int reg, u16 word)
	44	{
	45	int ret;
	46
	47	switch (reg) {
	48	case PMBUS_VIRT_RESET_VOUT_HISTORY:
	49	ret = pmbus_write_word_data(client, page,
	50	MAX16064_MFR_VOUT_PEAK, 0);
	51	break;
	52	case PMBUS_VIRT_RESET_TEMP_HISTORY:
	53	ret = pmbus_write_word_data(client, page,
	54	MAX16064_MFR_TEMPERATURE_PEAK,
	55	0xffff);
	56	break;
	57	default:
	58	ret = -ENODATA;
	59	break;
	60	}
	61	return ret;
	62	}
	63
dcb7d066 GR	64	static struct pmbus_driver_info max16064_info = {
dcb7d066 GR	65	.pages = 4,
1061d851 GR	66	.format[PSC_VOLTAGE_IN] = direct,
	67	.format[PSC_VOLTAGE_OUT] = direct,
	68	.format[PSC_TEMPERATURE] = direct,
dcb7d066 GR	69	.m[PSC_VOLTAGE_IN] = 19995,
	70	.b[PSC_VOLTAGE_IN] = 0,
	71	.R[PSC_VOLTAGE_IN] = -1,
	72	.m[PSC_VOLTAGE_OUT] = 19995,
	73	.b[PSC_VOLTAGE_OUT] = 0,
	74	.R[PSC_VOLTAGE_OUT] = -1,
	75	.m[PSC_TEMPERATURE] = -7612,
	76	.b[PSC_TEMPERATURE] = 335,
	77	.R[PSC_TEMPERATURE] = -3,
	78	.func[0] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_TEMP
	79	\| PMBUS_HAVE_STATUS_VOUT \| PMBUS_HAVE_STATUS_TEMP,
	80	.func[1] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT,
	81	.func[2] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT,
	82	.func[3] = PMBUS_HAVE_VOUT \| PMBUS_HAVE_STATUS_VOUT,
8ebed854 GR	83	.read_word_data = max16064_read_word_data,
8ebed854 GR	84	.write_word_data = max16064_write_word_data,
dcb7d066 GR	85	};
	86
	87	static int max16064_probe(struct i2c_client *client,
	88	const struct i2c_device_id *id)
	89	{
	90	return pmbus_do_probe(client, id, &max16064_info);
	91	}
	92
dcb7d066 GR	93	static const struct i2c_device_id max16064_id[] = {
	94	{"max16064", 0},
	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	},
	105	.probe = max16064_probe,
dd285ad7	106	.remove = pmbus_do_remove,
dcb7d066 GR	107	.id_table = max16064_id,
	108	};
	109
f0967eea	110	module_i2c_driver(max16064_driver);
dcb7d066 GR	111
	112	MODULE_AUTHOR("Guenter Roeck");
	113	MODULE_DESCRIPTION("PMBus driver for Maxim MAX16064");
	114	MODULE_LICENSE("GPL");