1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * Hardware monitoring driver for PIM4006, PIM4328 and PIM4820
  4 *
  5 * Copyright (c) 2021 Flextronics International Sweden AB
  6 */
  7
  8#include <linux/err.h>
  9#include <linux/i2c.h>
 10#include <linux/init.h>
 11#include <linux/kernel.h>
 12#include <linux/module.h>
 13#include <linux/pmbus.h>
 14#include <linux/slab.h>
 15#include "pmbus.h"
 16
 17enum chips { pim4006, pim4328, pim4820 };
 18
 19struct pim4328_data {
 20	enum chips id;
 21	struct pmbus_driver_info info;
 22};
 23
 24#define to_pim4328_data(x)  container_of(x, struct pim4328_data, info)
 25
 26/* PIM4006 and PIM4328 */
 27#define PIM4328_MFR_READ_VINA		0xd3
 28#define PIM4328_MFR_READ_VINB		0xd4
 29
 30/* PIM4006 */
 31#define PIM4328_MFR_READ_IINA		0xd6
 32#define PIM4328_MFR_READ_IINB		0xd7
 33#define PIM4328_MFR_FET_CHECKSTATUS	0xd9
 34
 35/* PIM4328 */
 36#define PIM4328_MFR_STATUS_BITS		0xd5
 37
 38/* PIM4820 */
 39#define PIM4328_MFR_READ_STATUS		0xd0
 40
 41static const struct i2c_device_id pim4328_id[] = {
 42	{"bmr455", pim4328},
 43	{"pim4006", pim4006},
 44	{"pim4106", pim4006},
 45	{"pim4206", pim4006},
 46	{"pim4306", pim4006},
 47	{"pim4328", pim4328},
 48	{"pim4406", pim4006},
 49	{"pim4820", pim4820},
 50	{}
 51};
 52MODULE_DEVICE_TABLE(i2c, pim4328_id);
 53
 54static int pim4328_read_word_data(struct i2c_client *client, int page,
 55				  int phase, int reg)
 56{
 57	int ret;
 58
 59	if (page > 0)
 60		return -ENXIO;
 61
 62	if (phase == 0xff)
 63		return -ENODATA;
 64
 65	switch (reg) {
 66	case PMBUS_READ_VIN:
 67		ret = pmbus_read_word_data(client, page, phase,
 68					   phase == 0 ? PIM4328_MFR_READ_VINA
 69						      : PIM4328_MFR_READ_VINB);
 70		break;
 71	case PMBUS_READ_IIN:
 72		ret = pmbus_read_word_data(client, page, phase,
 73					   phase == 0 ? PIM4328_MFR_READ_IINA
 74						      : PIM4328_MFR_READ_IINB);
 75		break;
 76	default:
 77		ret = -ENODATA;
 78	}
 79
 80	return ret;
 81}
 82
 83static int pim4328_read_byte_data(struct i2c_client *client, int page, int reg)
 84{
 85	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 86	struct pim4328_data *data = to_pim4328_data(info);
 87	int ret, status;
 88
 89	if (page > 0)
 90		return -ENXIO;
 91
 92	switch (reg) {
 93	case PMBUS_STATUS_BYTE:
 94		ret = pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
 95		if (ret < 0)
 96			return ret;
 97		if (data->id == pim4006) {
 98			status = pmbus_read_word_data(client, page, 0xff,
 99						      PIM4328_MFR_FET_CHECKSTATUS);
100			if (status < 0)
101				return status;
102			if (status & 0x0630) /* Input UV */
103				ret |= PB_STATUS_VIN_UV;
104		} else if (data->id == pim4328) {
105			status = pmbus_read_byte_data(client, page,
106						      PIM4328_MFR_STATUS_BITS);
107			if (status < 0)
108				return status;
109			if (status & 0x04) /* Input UV */
110				ret |= PB_STATUS_VIN_UV;
111			if (status & 0x40) /* Output UV */
112				ret |= PB_STATUS_NONE_ABOVE;
113		} else if (data->id == pim4820) {
114			status = pmbus_read_byte_data(client, page,
115						      PIM4328_MFR_READ_STATUS);
116			if (status < 0)
117				return status;
118			if (status & 0x05) /* Input OV or OC */
119				ret |= PB_STATUS_NONE_ABOVE;
120			if (status & 0x1a) /* Input UV */
121				ret |= PB_STATUS_VIN_UV;
122			if (status & 0x40) /* OT */
123				ret |= PB_STATUS_TEMPERATURE;
124		}
125		break;
126	default:
127		ret = -ENODATA;
128	}
129
130	return ret;
131}
132
133static int pim4328_probe(struct i2c_client *client)
134{
135	int status;
136	u8 device_id[I2C_SMBUS_BLOCK_MAX + 1];
137	const struct i2c_device_id *mid;
138	struct pim4328_data *data;
139	struct pmbus_driver_info *info;
140	struct pmbus_platform_data *pdata;
141	struct device *dev = &client->dev;
142
143	if (!i2c_check_functionality(client->adapter,
144				     I2C_FUNC_SMBUS_READ_BYTE_DATA
145				     | I2C_FUNC_SMBUS_BLOCK_DATA))
146		return -ENODEV;
147
148	data = devm_kzalloc(&client->dev, sizeof(struct pim4328_data),
149			    GFP_KERNEL);
150	if (!data)
151		return -ENOMEM;
152
153	status = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, device_id);
154	if (status < 0) {
155		dev_err(&client->dev, "Failed to read Manufacturer Model\n");
156		return status;
157	}
158	for (mid = pim4328_id; mid->name[0]; mid++) {
159		if (!strncasecmp(mid->name, device_id, strlen(mid->name)))
160			break;
161	}
162	if (!mid->name[0]) {
163		dev_err(&client->dev, "Unsupported device\n");
164		return -ENODEV;
165	}
166
167	if (strcmp(client->name, mid->name))
168		dev_notice(&client->dev,
169			   "Device mismatch: Configured %s, detected %s\n",
170			   client->name, mid->name);
171
172	data->id = mid->driver_data;
173	info = &data->info;
174	info->pages = 1;
175	info->read_byte_data = pim4328_read_byte_data;
176	info->read_word_data = pim4328_read_word_data;
177
178	pdata = devm_kzalloc(dev, sizeof(struct pmbus_platform_data),
179			     GFP_KERNEL);
180	if (!pdata)
181		return -ENOMEM;
182	dev->platform_data = pdata;
183	pdata->flags = PMBUS_NO_CAPABILITY | PMBUS_NO_WRITE_PROTECT;
184
185	switch (data->id) {
186	case pim4006:
187		info->phases[0] = 2;
188		info->func[0] = PMBUS_PHASE_VIRTUAL | PMBUS_HAVE_VIN
189			| PMBUS_HAVE_TEMP | PMBUS_HAVE_IOUT;
190		info->pfunc[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN;
191		info->pfunc[1] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN;
192		break;
193	case pim4328:
194		info->phases[0] = 2;
195		info->func[0] = PMBUS_PHASE_VIRTUAL
196			| PMBUS_HAVE_VCAP | PMBUS_HAVE_VIN
197			| PMBUS_HAVE_TEMP | PMBUS_HAVE_IOUT;
198		info->pfunc[0] = PMBUS_HAVE_VIN;
199		info->pfunc[1] = PMBUS_HAVE_VIN;
200		info->format[PSC_VOLTAGE_IN] = direct;
201		info->format[PSC_TEMPERATURE] = direct;
202		info->format[PSC_CURRENT_OUT] = direct;
203		pdata->flags |= PMBUS_USE_COEFFICIENTS_CMD;
204		break;
205	case pim4820:
206		info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_TEMP
207			| PMBUS_HAVE_IIN;
208		info->format[PSC_VOLTAGE_IN] = direct;
209		info->format[PSC_TEMPERATURE] = direct;
210		info->format[PSC_CURRENT_IN] = direct;
211		pdata->flags |= PMBUS_USE_COEFFICIENTS_CMD;
212		break;
213	default:
214		return -ENODEV;
215	}
216
217	return pmbus_do_probe(client, info);
218}
219
220static struct i2c_driver pim4328_driver = {
221	.driver = {
222		   .name = "pim4328",
223		   },
224	.probe_new = pim4328_probe,
225	.id_table = pim4328_id,
226};
227
228module_i2c_driver(pim4328_driver);
229
230MODULE_AUTHOR("Erik Rosen <erik.rosen@metormote.com>");
231MODULE_DESCRIPTION("PMBus driver for PIM4006, PIM4328, PIM4820 power interface modules");
232MODULE_LICENSE("GPL");
233MODULE_IMPORT_NS(PMBUS);