1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Hardware monitoring driver for Maxim MAX16508, MAX16601 and MAX16602.
4 *
5 * Implementation notes:
6 *
7 * This chip series supports two rails, VCORE and VSA. Telemetry information
8 * for the two rails is reported in two subsequent I2C addresses. The driver
9 * instantiates a dummy I2C client at the second I2C address to report
10 * information for the VSA rail in a single instance of the driver.
11 * Telemetry for the VSA rail is reported to the PMBus core in PMBus page 2.
12 *
13 * The chip reports input current using two separate methods. The input current
14 * reported with the standard READ_IIN command is derived from the output
15 * current. The first method is reported to the PMBus core with PMBus page 0,
16 * the second method is reported with PMBus page 1.
17 *
18 * The chip supports reading per-phase temperatures and per-phase input/output
19 * currents for VCORE. Telemetry is reported in vendor specific registers.
20 * The driver translates the vendor specific register values to PMBus standard
21 * register values and reports per-phase information in PMBus page 0.
22 *
23 * Copyright 2019, 2020 Google LLC.
24 */
25
26 #include <linux/bits.h>
27 #include <linux/i2c.h>
28 #include <linux/init.h>
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31
32 #include "pmbus.h"
33
34 enum chips { max16508, max16601, max16602 };
35
36 #define REG_DEFAULT_NUM_POP 0xc4
37 #define REG_SETPT_DVID 0xd1
38 #define DAC_10MV_MODE BIT(4)
39 #define REG_IOUT_AVG_PK 0xee
40 #define REG_IIN_SENSOR 0xf1
41 #define REG_TOTAL_INPUT_POWER 0xf2
42 #define REG_PHASE_ID 0xf3
43 #define CORE_RAIL_INDICATOR BIT(7)
44 #define REG_PHASE_REPORTING 0xf4
45
46 #define MAX16601_NUM_PHASES 8
47
48 struct max16601_data {
49 enum chips id;
50 struct pmbus_driver_info info;
51 struct i2c_client *vsa;
52 int iout_avg_pkg;
53 };
54
55 #define to_max16601_data(x) container_of(x, struct max16601_data, info)
56
max16601_read_byte(struct i2c_client * client,int page,int reg)57 static int max16601_read_byte(struct i2c_client *client, int page, int reg)
58 {
59 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
60 struct max16601_data *data = to_max16601_data(info);
61
62 if (page > 0) {
63 if (page == 2) /* VSA */
64 return i2c_smbus_read_byte_data(data->vsa, reg);
65 return -EOPNOTSUPP;
66 }
67 return -ENODATA;
68 }
69
max16601_read_word(struct i2c_client * client,int page,int phase,int reg)70 static int max16601_read_word(struct i2c_client *client, int page, int phase,
71 int reg)
72 {
73 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
74 struct max16601_data *data = to_max16601_data(info);
75 u8 buf[I2C_SMBUS_BLOCK_MAX + 1];
76 int ret;
77
78 switch (page) {
79 case 0: /* VCORE */
80 if (phase == 0xff)
81 return -ENODATA;
82 switch (reg) {
83 case PMBUS_READ_IIN:
84 case PMBUS_READ_IOUT:
85 case PMBUS_READ_TEMPERATURE_1:
86 ret = i2c_smbus_write_byte_data(client, REG_PHASE_ID,
87 phase);
88 if (ret)
89 return ret;
90 ret = i2c_smbus_read_block_data(client,
91 REG_PHASE_REPORTING,
92 buf);
93 if (ret < 0)
94 return ret;
95 if (ret < 6)
96 return -EIO;
97 switch (reg) {
98 case PMBUS_READ_TEMPERATURE_1:
99 return buf[1] << 8 | buf[0];
100 case PMBUS_READ_IOUT:
101 return buf[3] << 8 | buf[2];
102 case PMBUS_READ_IIN:
103 return buf[5] << 8 | buf[4];
104 default:
105 break;
106 }
107 }
108 return -EOPNOTSUPP;
109 case 1: /* VCORE, read IIN/PIN from sensor element */
110 switch (reg) {
111 case PMBUS_READ_IIN:
112 return i2c_smbus_read_word_data(client, REG_IIN_SENSOR);
113 case PMBUS_READ_PIN:
114 return i2c_smbus_read_word_data(client,
115 REG_TOTAL_INPUT_POWER);
116 default:
117 break;
118 }
119 return -EOPNOTSUPP;
120 case 2: /* VSA */
121 switch (reg) {
122 case PMBUS_VIRT_READ_IOUT_MAX:
123 ret = i2c_smbus_read_word_data(data->vsa,
124 REG_IOUT_AVG_PK);
125 if (ret < 0)
126 return ret;
127 if (sign_extend32(ret, 10) >
128 sign_extend32(data->iout_avg_pkg, 10))
129 data->iout_avg_pkg = ret;
130 return data->iout_avg_pkg;
131 case PMBUS_VIRT_RESET_IOUT_HISTORY:
132 return 0;
133 case PMBUS_IOUT_OC_FAULT_LIMIT:
134 case PMBUS_IOUT_OC_WARN_LIMIT:
135 case PMBUS_OT_FAULT_LIMIT:
136 case PMBUS_OT_WARN_LIMIT:
137 case PMBUS_READ_IIN:
138 case PMBUS_READ_IOUT:
139 case PMBUS_READ_TEMPERATURE_1:
140 case PMBUS_STATUS_WORD:
141 return i2c_smbus_read_word_data(data->vsa, reg);
142 default:
143 return -EOPNOTSUPP;
144 }
145 default:
146 return -EOPNOTSUPP;
147 }
148 }
149
max16601_write_byte(struct i2c_client * client,int page,u8 reg)150 static int max16601_write_byte(struct i2c_client *client, int page, u8 reg)
151 {
152 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
153 struct max16601_data *data = to_max16601_data(info);
154
155 if (page == 2) {
156 if (reg == PMBUS_CLEAR_FAULTS)
157 return i2c_smbus_write_byte(data->vsa, reg);
158 return -EOPNOTSUPP;
159 }
160 return -ENODATA;
161 }
162
max16601_write_word(struct i2c_client * client,int page,int reg,u16 value)163 static int max16601_write_word(struct i2c_client *client, int page, int reg,
164 u16 value)
165 {
166 const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
167 struct max16601_data *data = to_max16601_data(info);
168
169 switch (page) {
170 case 0: /* VCORE */
171 return -ENODATA;
172 case 1: /* VCORE IIN/PIN from sensor element */
173 default:
174 return -EOPNOTSUPP;
175 case 2: /* VSA */
176 switch (reg) {
177 case PMBUS_VIRT_RESET_IOUT_HISTORY:
178 data->iout_avg_pkg = 0xfc00;
179 return 0;
180 case PMBUS_IOUT_OC_FAULT_LIMIT:
181 case PMBUS_IOUT_OC_WARN_LIMIT:
182 case PMBUS_OT_FAULT_LIMIT:
183 case PMBUS_OT_WARN_LIMIT:
184 return i2c_smbus_write_word_data(data->vsa, reg, value);
185 default:
186 return -EOPNOTSUPP;
187 }
188 }
189 }
190
max16601_identify(struct i2c_client * client,struct pmbus_driver_info * info)191 static int max16601_identify(struct i2c_client *client,
192 struct pmbus_driver_info *info)
193 {
194 struct max16601_data *data = to_max16601_data(info);
195 int reg;
196
197 reg = i2c_smbus_read_byte_data(client, REG_SETPT_DVID);
198 if (reg < 0)
199 return reg;
200 if (reg & DAC_10MV_MODE)
201 info->vrm_version[0] = vr13;
202 else
203 info->vrm_version[0] = vr12;
204
205 if (data->id != max16601 && data->id != max16602)
206 return 0;
207
208 reg = i2c_smbus_read_byte_data(client, REG_DEFAULT_NUM_POP);
209 if (reg < 0)
210 return reg;
211
212 /*
213 * If REG_DEFAULT_NUM_POP returns 0, we don't know how many phases
214 * are populated. Stick with the default in that case.
215 */
216 reg &= 0x0f;
217 if (reg && reg <= MAX16601_NUM_PHASES)
218 info->phases[0] = reg;
219
220 return 0;
221 }
222
223 static struct pmbus_driver_info max16601_info = {
224 .pages = 3,
225 .format[PSC_VOLTAGE_IN] = linear,
226 .format[PSC_VOLTAGE_OUT] = vid,
227 .format[PSC_CURRENT_IN] = linear,
228 .format[PSC_CURRENT_OUT] = linear,
229 .format[PSC_TEMPERATURE] = linear,
230 .format[PSC_POWER] = linear,
231 .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN | PMBUS_HAVE_PIN |
232 PMBUS_HAVE_STATUS_INPUT |
233 PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT |
234 PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
235 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP |
236 PMBUS_HAVE_POUT | PMBUS_PAGE_VIRTUAL | PMBUS_PHASE_VIRTUAL,
237 .func[1] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | PMBUS_PAGE_VIRTUAL,
238 .func[2] = PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT |
239 PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT |
240 PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP | PMBUS_PAGE_VIRTUAL,
241 .phases[0] = MAX16601_NUM_PHASES,
242 .pfunc[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
243 .pfunc[1] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
244 .pfunc[2] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
245 .pfunc[3] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
246 .pfunc[4] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
247 .pfunc[5] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
248 .pfunc[6] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT | PMBUS_HAVE_TEMP,
249 .pfunc[7] = PMBUS_HAVE_IIN | PMBUS_HAVE_IOUT,
250 .identify = max16601_identify,
251 .read_byte_data = max16601_read_byte,
252 .read_word_data = max16601_read_word,
253 .write_byte = max16601_write_byte,
254 .write_word_data = max16601_write_word,
255 };
256
max16601_remove(void * _data)257 static void max16601_remove(void *_data)
258 {
259 struct max16601_data *data = _data;
260
261 i2c_unregister_device(data->vsa);
262 }
263
264 static const struct i2c_device_id max16601_id[] = {
265 {"max16508", max16508},
266 {"max16601", max16601},
267 {"max16602", max16602},
268 {}
269 };
270 MODULE_DEVICE_TABLE(i2c, max16601_id);
271
max16601_get_id(struct i2c_client * client)272 static int max16601_get_id(struct i2c_client *client)
273 {
274 struct device *dev = &client->dev;
275 u8 buf[I2C_SMBUS_BLOCK_MAX + 1];
276 enum chips id;
277 int ret;
278
279 ret = i2c_smbus_read_block_data(client, PMBUS_IC_DEVICE_ID, buf);
280 if (ret < 0 || ret < 11)
281 return -ENODEV;
282
283 /*
284 * PMBUS_IC_DEVICE_ID is expected to return "MAX16601y.xx" or
285 * MAX16602y.xx or "MAX16500y.xx".cdxxcccccccccc
286 */
287 if (!strncmp(buf, "MAX16500", 8)) {
288 id = max16508;
289 } else if (!strncmp(buf, "MAX16601", 8)) {
290 id = max16601;
291 } else if (!strncmp(buf, "MAX16602", 8)) {
292 id = max16602;
293 } else {
294 buf[ret] = '\0';
295 dev_err(dev, "Unsupported chip '%s'\n", buf);
296 return -ENODEV;
297 }
298 return id;
299 }
300
max16601_probe(struct i2c_client * client)301 static int max16601_probe(struct i2c_client *client)
302 {
303 struct device *dev = &client->dev;
304 const struct i2c_device_id *id;
305 struct max16601_data *data;
306 int ret, chip_id;
307
308 if (!i2c_check_functionality(client->adapter,
309 I2C_FUNC_SMBUS_READ_BYTE_DATA |
310 I2C_FUNC_SMBUS_READ_BLOCK_DATA))
311 return -ENODEV;
312
313 chip_id = max16601_get_id(client);
314 if (chip_id < 0)
315 return chip_id;
316
317 id = i2c_match_id(max16601_id, client);
318 if (chip_id != id->driver_data)
319 dev_warn(&client->dev,
320 "Device mismatch: Configured %s (%d), detected %d\n",
321 id->name, (int) id->driver_data, chip_id);
322
323 ret = i2c_smbus_read_byte_data(client, REG_PHASE_ID);
324 if (ret < 0)
325 return ret;
326 if (!(ret & CORE_RAIL_INDICATOR)) {
327 dev_err(dev,
328 "Driver must be instantiated on CORE rail I2C address\n");
329 return -ENODEV;
330 }
331
332 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
333 if (!data)
334 return -ENOMEM;
335
336 data->id = chip_id;
337 data->iout_avg_pkg = 0xfc00;
338 data->vsa = i2c_new_dummy_device(client->adapter, client->addr + 1);
339 if (IS_ERR(data->vsa)) {
340 dev_err(dev, "Failed to register VSA client\n");
341 return PTR_ERR(data->vsa);
342 }
343 ret = devm_add_action_or_reset(dev, max16601_remove, data);
344 if (ret)
345 return ret;
346
347 data->info = max16601_info;
348
349 return pmbus_do_probe(client, &data->info);
350 }
351
352 static struct i2c_driver max16601_driver = {
353 .driver = {
354 .name = "max16601",
355 },
356 .probe_new = max16601_probe,
357 .id_table = max16601_id,
358 };
359
360 module_i2c_driver(max16601_driver);
361
362 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
363 MODULE_DESCRIPTION("PMBus driver for Maxim MAX16601");
364 MODULE_LICENSE("GPL v2");
365 MODULE_IMPORT_NS(PMBUS);
366
