xref: /linux/drivers/hwmon/pmbus/isl68137.c (revision fa3c727e05996811a2a57c5114e88200c05b6161) 
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Hardware monitoring driver for Renesas Digital Multiphase Voltage Regulators
4  *
5  * Copyright (c) 2017 Google Inc
6  * Copyright (c) 2020 Renesas Electronics America
7  *
8  */
9 
10 #include <linux/err.h>
11 #include <linux/hwmon-sysfs.h>
12 #include <linux/i2c.h>
13 #include <linux/init.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/string.h>
18 #include <linux/sysfs.h>
19 
20 #include "pmbus.h"
21 
22 #define ISL68137_VOUT_AVS	0x30
23 #define RAA_DMPVR2_READ_VMON	0xc8
24 #define MAX_CHANNELS            4
25 
26 enum chips {
27 	isl68137,
28 	isl68220,
29 	isl68221,
30 	isl68222,
31 	isl68223,
32 	isl68224,
33 	isl68225,
34 	isl68226,
35 	isl68227,
36 	isl68229,
37 	isl68233,
38 	isl68239,
39 	isl69222,
40 	isl69223,
41 	isl69224,
42 	isl69225,
43 	isl69227,
44 	isl69228,
45 	isl69234,
46 	isl69236,
47 	isl69239,
48 	isl69242,
49 	isl69243,
50 	isl69247,
51 	isl69248,
52 	isl69254,
53 	isl69255,
54 	isl69256,
55 	isl69259,
56 	isl69260,
57 	isl69268,
58 	isl69269,
59 	isl69298,
60 	raa228000,
61 	raa228004,
62 	raa228006,
63 	raa228228,
64 	raa228244,
65 	raa228246,
66 	raa229001,
67 	raa229004,
68 	raa229621,
69 };
70 
71 enum variants {
72 	raa_dmpvr1_2rail,
73 	raa_dmpvr2_1rail,
74 	raa_dmpvr2_2rail,
75 	raa_dmpvr2_2rail_nontc,
76 	raa_dmpvr2_3rail,
77 	raa_dmpvr2_hv,
78 };
79 
80 struct isl68137_channel {
81 	u32 vout_voltage_divider[2];
82 };
83 
84 struct isl68137_data {
85 	struct pmbus_driver_info info;
86 	struct isl68137_channel channel[MAX_CHANNELS];
87 };
88 
89 #define to_isl68137_data(x)	container_of(x, struct isl68137_data, info)
90 
91 static const struct i2c_device_id raa_dmpvr_id[];
92 
isl68137_avs_enable_show_page(struct i2c_client * client,int page,char * buf)93 static ssize_t isl68137_avs_enable_show_page(struct i2c_client *client,
94 					     int page,
95 					     char *buf)
96 {
97 	int val = pmbus_read_byte_data(client, page, PMBUS_OPERATION);
98 
99 	return sprintf(buf, "%d\n",
100 		       (val & ISL68137_VOUT_AVS) == ISL68137_VOUT_AVS ? 1 : 0);
101 }
102 
isl68137_avs_enable_store_page(struct i2c_client * client,int page,const char * buf,size_t count)103 static ssize_t isl68137_avs_enable_store_page(struct i2c_client *client,
104 					      int page,
105 					      const char *buf, size_t count)
106 {
107 	int rc, op_val;
108 	bool result;
109 
110 	rc = kstrtobool(buf, &result);
111 	if (rc)
112 		return rc;
113 
114 	op_val = result ? ISL68137_VOUT_AVS : 0;
115 
116 	/*
117 	 * Writes to VOUT setpoint over AVSBus will persist after the VRM is
118 	 * switched to PMBus control. Switching back to AVSBus control
119 	 * restores this persisted setpoint rather than re-initializing to
120 	 * PMBus VOUT_COMMAND. Writing VOUT_COMMAND first over PMBus before
121 	 * enabling AVS control is the workaround.
122 	 */
123 	if (op_val == ISL68137_VOUT_AVS) {
124 		rc = pmbus_read_word_data(client, page, 0xff,
125 					  PMBUS_VOUT_COMMAND);
126 		if (rc < 0)
127 			return rc;
128 
129 		rc = pmbus_write_word_data(client, page, PMBUS_VOUT_COMMAND,
130 					   rc);
131 		if (rc < 0)
132 			return rc;
133 	}
134 
135 	rc = pmbus_update_byte_data(client, page, PMBUS_OPERATION,
136 				    ISL68137_VOUT_AVS, op_val);
137 
138 	return (rc < 0) ? rc : count;
139 }
140 
isl68137_avs_enable_show(struct device * dev,struct device_attribute * devattr,char * buf)141 static ssize_t isl68137_avs_enable_show(struct device *dev,
142 					struct device_attribute *devattr,
143 					char *buf)
144 {
145 	struct i2c_client *client = to_i2c_client(dev->parent);
146 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
147 
148 	return isl68137_avs_enable_show_page(client, attr->index, buf);
149 }
150 
isl68137_avs_enable_store(struct device * dev,struct device_attribute * devattr,const char * buf,size_t count)151 static ssize_t isl68137_avs_enable_store(struct device *dev,
152 				struct device_attribute *devattr,
153 				const char *buf, size_t count)
154 {
155 	struct i2c_client *client = to_i2c_client(dev->parent);
156 	struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
157 
158 	return isl68137_avs_enable_store_page(client, attr->index, buf, count);
159 }
160 
161 static SENSOR_DEVICE_ATTR_RW(avs0_enable, isl68137_avs_enable, 0);
162 static SENSOR_DEVICE_ATTR_RW(avs1_enable, isl68137_avs_enable, 1);
163 
164 static struct attribute *enable_attrs[] = {
165 	&sensor_dev_attr_avs0_enable.dev_attr.attr,
166 	&sensor_dev_attr_avs1_enable.dev_attr.attr,
167 	NULL,
168 };
169 
170 static const struct attribute_group enable_group = {
171 	.attrs = enable_attrs,
172 };
173 
174 static const struct attribute_group *isl68137_attribute_groups[] = {
175 	&enable_group,
176 	NULL,
177 };
178 
raa_dmpvr2_read_word_data(struct i2c_client * client,int page,int phase,int reg)179 static int raa_dmpvr2_read_word_data(struct i2c_client *client, int page,
180 				     int phase, int reg)
181 {
182 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
183 	const struct isl68137_data *data = to_isl68137_data(info);
184 	int ret;
185 	u64 temp;
186 
187 	switch (reg) {
188 	case PMBUS_VIRT_READ_VMON:
189 		ret = pmbus_read_word_data(client, page, phase,
190 					   RAA_DMPVR2_READ_VMON);
191 		break;
192 	case PMBUS_READ_POUT:
193 	case PMBUS_READ_VOUT:
194 		/*
195 		 * In cases where a voltage divider is attached to the target
196 		 * rail between Vout and the Vsense pin, both Vout and Pout
197 		 * should be scaled by the voltage divider scaling factor.
198 		 * I.e. Vout = Vsense * Rtotal / Rout
199 		 */
200 		ret = pmbus_read_word_data(client, page, phase, reg);
201 		if (ret > 0) {
202 			temp = DIV_U64_ROUND_CLOSEST((u64)ret *
203 				data->channel[page].vout_voltage_divider[1],
204 				data->channel[page].vout_voltage_divider[0]);
205 			ret = clamp_val(temp, 0, 0xffff);
206 		}
207 		break;
208 	default:
209 		ret = -ENODATA;
210 		break;
211 	}
212 
213 	return ret;
214 }
215 
raa_dmpvr2_write_word_data(struct i2c_client * client,int page,int reg,u16 word)216 static int raa_dmpvr2_write_word_data(struct i2c_client *client, int page,
217 				      int reg, u16 word)
218 {
219 	const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
220 	const struct isl68137_data *data = to_isl68137_data(info);
221 	int ret;
222 	u64 temp;
223 
224 	switch (reg) {
225 	case PMBUS_VOUT_MAX:
226 	case PMBUS_VOUT_MARGIN_HIGH:
227 	case PMBUS_VOUT_MARGIN_LOW:
228 	case PMBUS_VOUT_OV_FAULT_LIMIT:
229 	case PMBUS_VOUT_UV_FAULT_LIMIT:
230 	case PMBUS_VOUT_COMMAND:
231 		/*
232 		 * In cases where a voltage divider is attached to the target
233 		 * rail between Vout and the Vsense pin, Vout related PMBus
234 		 * commands should be scaled based on the expected voltage
235 		 * at the Vsense pin.
236 		 * I.e. Vsense = Vout * Rout / Rtotal
237 		 */
238 		temp = DIV_U64_ROUND_CLOSEST((u64)word *
239 				data->channel[page].vout_voltage_divider[0],
240 				data->channel[page].vout_voltage_divider[1]);
241 		ret = clamp_val(temp, 0, 0xffff);
242 		break;
243 	default:
244 		ret = -ENODATA;
245 		break;
246 	}
247 	return ret;
248 }
249 
250 static struct pmbus_driver_info raa_dmpvr_info = {
251 	.pages = 3,
252 	.format[PSC_VOLTAGE_IN] = direct,
253 	.format[PSC_VOLTAGE_OUT] = direct,
254 	.format[PSC_CURRENT_IN] = direct,
255 	.format[PSC_CURRENT_OUT] = direct,
256 	.format[PSC_POWER] = direct,
257 	.format[PSC_TEMPERATURE] = direct,
258 	.m[PSC_VOLTAGE_IN] = 1,
259 	.b[PSC_VOLTAGE_IN] = 0,
260 	.R[PSC_VOLTAGE_IN] = 2,
261 	.m[PSC_VOLTAGE_OUT] = 1,
262 	.b[PSC_VOLTAGE_OUT] = 0,
263 	.R[PSC_VOLTAGE_OUT] = 3,
264 	.m[PSC_CURRENT_IN] = 1,
265 	.b[PSC_CURRENT_IN] = 0,
266 	.R[PSC_CURRENT_IN] = 2,
267 	.m[PSC_CURRENT_OUT] = 1,
268 	.b[PSC_CURRENT_OUT] = 0,
269 	.R[PSC_CURRENT_OUT] = 1,
270 	.m[PSC_POWER] = 1,
271 	.b[PSC_POWER] = 0,
272 	.R[PSC_POWER] = 0,
273 	.m[PSC_TEMPERATURE] = 1,
274 	.b[PSC_TEMPERATURE] = 0,
275 	.R[PSC_TEMPERATURE] = 0,
276 	.func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
277 	    | PMBUS_HAVE_STATUS_INPUT | PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP2
278 	    | PMBUS_HAVE_TEMP3 | PMBUS_HAVE_STATUS_TEMP
279 	    | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
280 	    | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT
281 		| PMBUS_HAVE_VMON,
282 	.func[1] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT
283 	    | PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP3 | PMBUS_HAVE_STATUS_TEMP
284 	    | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT
285 	    | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT,
286 	.func[2] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | PMBUS_HAVE_STATUS_INPUT
287 	    | PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP3 | PMBUS_HAVE_STATUS_TEMP
288 	    | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_IOUT
289 	    | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT,
290 };
291 
isl68137_probe_child_from_dt(struct device * dev,struct device_node * child,struct isl68137_data * data)292 static int isl68137_probe_child_from_dt(struct device *dev,
293 					struct device_node *child,
294 					struct isl68137_data *data)
295 {
296 	u32 channel, rout, rtotal;
297 	int err;
298 
299 	err = of_property_read_u32(child, "reg", &channel);
300 	if (err) {
301 		dev_err(dev, "missing reg property of %pOFn\n", child);
302 		return err;
303 	}
304 	if (channel >= data->info.pages) {
305 		dev_err(dev, "invalid reg %d of %pOFn\n", channel, child);
306 		return -EINVAL;
307 	}
308 
309 	err = of_property_read_u32_array(child, "vout-voltage-divider",
310 					 data->channel[channel].vout_voltage_divider,
311 					 ARRAY_SIZE(data->channel[channel].vout_voltage_divider));
312 	if (err && err != -EINVAL) {
313 		dev_err(dev,
314 			"malformed vout-voltage-divider value for channel %d\n",
315 			channel);
316 		return err;
317 	}
318 
319 	rout = data->channel[channel].vout_voltage_divider[0];
320 	rtotal = data->channel[channel].vout_voltage_divider[1];
321 	if (rout == 0) {
322 		dev_err(dev,
323 			"Voltage divider output resistance must be greater than 0\n");
324 		return -EINVAL;
325 	}
326 	if (rtotal < rout) {
327 		dev_err(dev,
328 			"Voltage divider total resistance is less than output resistance\n");
329 		return -EINVAL;
330 	}
331 
332 	return 0;
333 }
334 
isl68137_probe_from_dt(struct device * dev,struct isl68137_data * data)335 static int isl68137_probe_from_dt(struct device *dev,
336 				  struct isl68137_data *data)
337 {
338 	const struct device_node *np = dev->of_node;
339 	int err;
340 
341 	for_each_child_of_node_scoped(np, child) {
342 		if (strcmp(child->name, "channel"))
343 			continue;
344 
345 		err = isl68137_probe_child_from_dt(dev, child, data);
346 		if (err)
347 			return err;
348 	}
349 
350 	return 0;
351 }
352 
isl68137_probe(struct i2c_client * client)353 static int isl68137_probe(struct i2c_client *client)
354 {
355 	struct device *dev = &client->dev;
356 	struct pmbus_driver_info *info;
357 	struct isl68137_data *data;
358 	int i, err;
359 
360 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
361 	if (!data)
362 		return -ENOMEM;
363 
364 	/*
365 	 * Initialize all voltage dividers to Rout=1 and Rtotal=1 to simplify
366 	 * logic in PMBus word read/write functions
367 	 */
368 	for (i = 0; i < MAX_CHANNELS; i++)
369 		memset(data->channel[i].vout_voltage_divider,
370 		       1,
371 		       sizeof(data->channel[i].vout_voltage_divider));
372 
373 	memcpy(&data->info, &raa_dmpvr_info, sizeof(data->info));
374 	info = &data->info;
375 
376 	switch (i2c_match_id(raa_dmpvr_id, client)->driver_data) {
377 	case raa_dmpvr1_2rail:
378 		info->pages = 2;
379 		info->R[PSC_VOLTAGE_IN] = 3;
380 		info->func[0] &= ~PMBUS_HAVE_VMON;
381 		info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
382 		    | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
383 		    | PMBUS_HAVE_POUT;
384 		info->read_word_data = raa_dmpvr2_read_word_data;
385 		info->write_word_data = raa_dmpvr2_write_word_data;
386 		info->groups = isl68137_attribute_groups;
387 		break;
388 	case raa_dmpvr2_1rail:
389 		info->pages = 1;
390 		info->read_word_data = raa_dmpvr2_read_word_data;
391 		info->write_word_data = raa_dmpvr2_write_word_data;
392 		break;
393 	case raa_dmpvr2_2rail_nontc:
394 		info->func[0] &= ~PMBUS_HAVE_TEMP3;
395 		info->func[1] &= ~PMBUS_HAVE_TEMP3;
396 		fallthrough;
397 	case raa_dmpvr2_2rail:
398 		info->pages = 2;
399 		info->read_word_data = raa_dmpvr2_read_word_data;
400 		info->write_word_data = raa_dmpvr2_write_word_data;
401 		break;
402 	case raa_dmpvr2_3rail:
403 		info->read_word_data = raa_dmpvr2_read_word_data;
404 		info->write_word_data = raa_dmpvr2_write_word_data;
405 		break;
406 	case raa_dmpvr2_hv:
407 		info->pages = 1;
408 		info->R[PSC_VOLTAGE_IN] = 1;
409 		info->m[PSC_VOLTAGE_OUT] = 2;
410 		info->R[PSC_VOLTAGE_OUT] = 2;
411 		info->m[PSC_CURRENT_IN] = 2;
412 		info->m[PSC_POWER] = 2;
413 		info->R[PSC_POWER] = -1;
414 		info->read_word_data = raa_dmpvr2_read_word_data;
415 		info->write_word_data = raa_dmpvr2_write_word_data;
416 		break;
417 	default:
418 		return -ENODEV;
419 	}
420 
421 	err = isl68137_probe_from_dt(dev, data);
422 	if (err)
423 		return err;
424 
425 	return pmbus_do_probe(client, info);
426 }
427 
428 static const struct i2c_device_id raa_dmpvr_id[] = {
429 	{"isl68137", raa_dmpvr1_2rail},
430 	{"isl68220", raa_dmpvr2_2rail},
431 	{"isl68221", raa_dmpvr2_3rail},
432 	{"isl68222", raa_dmpvr2_2rail},
433 	{"isl68223", raa_dmpvr2_2rail},
434 	{"isl68224", raa_dmpvr2_3rail},
435 	{"isl68225", raa_dmpvr2_2rail},
436 	{"isl68226", raa_dmpvr2_3rail},
437 	{"isl68227", raa_dmpvr2_1rail},
438 	{"isl68229", raa_dmpvr2_3rail},
439 	{"isl68233", raa_dmpvr2_2rail},
440 	{"isl68239", raa_dmpvr2_3rail},
441 
442 	{"isl69222", raa_dmpvr2_2rail},
443 	{"isl69223", raa_dmpvr2_3rail},
444 	{"isl69224", raa_dmpvr2_2rail},
445 	{"isl69225", raa_dmpvr2_2rail},
446 	{"isl69227", raa_dmpvr2_3rail},
447 	{"isl69228", raa_dmpvr2_3rail},
448 	{"isl69234", raa_dmpvr2_2rail},
449 	{"isl69236", raa_dmpvr2_2rail},
450 	{"isl69239", raa_dmpvr2_3rail},
451 	{"isl69242", raa_dmpvr2_2rail},
452 	{"isl69243", raa_dmpvr2_1rail},
453 	{"isl69247", raa_dmpvr2_2rail},
454 	{"isl69248", raa_dmpvr2_2rail},
455 	{"isl69254", raa_dmpvr2_2rail},
456 	{"isl69255", raa_dmpvr2_2rail},
457 	{"isl69256", raa_dmpvr2_2rail},
458 	{"isl69259", raa_dmpvr2_2rail},
459 	{"isl69260", raa_dmpvr2_2rail},
460 	{"isl69268", raa_dmpvr2_2rail},
461 	{"isl69269", raa_dmpvr2_3rail},
462 	{"isl69298", raa_dmpvr2_2rail},
463 
464 	{"raa228000", raa_dmpvr2_hv},
465 	{"raa228004", raa_dmpvr2_hv},
466 	{"raa228006", raa_dmpvr2_hv},
467 	{"raa228228", raa_dmpvr2_2rail_nontc},
468 	{"raa228244", raa_dmpvr2_2rail_nontc},
469 	{"raa228246", raa_dmpvr2_2rail_nontc},
470 	{"raa229001", raa_dmpvr2_2rail},
471 	{"raa229004", raa_dmpvr2_2rail},
472 	{"raa229621", raa_dmpvr2_2rail},
473 	{}
474 };
475 
476 MODULE_DEVICE_TABLE(i2c, raa_dmpvr_id);
477 
478 static const struct of_device_id isl68137_of_match[] = {
479 	{ .compatible = "isil,isl68137", .data = (void *)raa_dmpvr1_2rail },
480 	{ .compatible = "renesas,isl68220", .data = (void *)raa_dmpvr2_2rail },
481 	{ .compatible = "renesas,isl68221", .data = (void *)raa_dmpvr2_3rail },
482 	{ .compatible = "renesas,isl68222", .data = (void *)raa_dmpvr2_2rail },
483 	{ .compatible = "renesas,isl68223", .data = (void *)raa_dmpvr2_2rail },
484 	{ .compatible = "renesas,isl68224", .data = (void *)raa_dmpvr2_3rail },
485 	{ .compatible = "renesas,isl68225", .data = (void *)raa_dmpvr2_2rail },
486 	{ .compatible = "renesas,isl68226", .data = (void *)raa_dmpvr2_3rail },
487 	{ .compatible = "renesas,isl68227", .data = (void *)raa_dmpvr2_1rail },
488 	{ .compatible = "renesas,isl68229", .data = (void *)raa_dmpvr2_3rail },
489 	{ .compatible = "renesas,isl68233", .data = (void *)raa_dmpvr2_2rail },
490 	{ .compatible = "renesas,isl68239", .data = (void *)raa_dmpvr2_3rail },
491 
492 	{ .compatible = "renesas,isl69222", .data = (void *)raa_dmpvr2_2rail },
493 	{ .compatible = "renesas,isl69223", .data = (void *)raa_dmpvr2_3rail },
494 	{ .compatible = "renesas,isl69224", .data = (void *)raa_dmpvr2_2rail },
495 	{ .compatible = "renesas,isl69225", .data = (void *)raa_dmpvr2_2rail },
496 	{ .compatible = "renesas,isl69227", .data = (void *)raa_dmpvr2_3rail },
497 	{ .compatible = "renesas,isl69228", .data = (void *)raa_dmpvr2_3rail },
498 	{ .compatible = "renesas,isl69234", .data = (void *)raa_dmpvr2_2rail },
499 	{ .compatible = "renesas,isl69236", .data = (void *)raa_dmpvr2_2rail },
500 	{ .compatible = "renesas,isl69239", .data = (void *)raa_dmpvr2_3rail },
501 	{ .compatible = "renesas,isl69242", .data = (void *)raa_dmpvr2_2rail },
502 	{ .compatible = "renesas,isl69243", .data = (void *)raa_dmpvr2_1rail },
503 	{ .compatible = "renesas,isl69247", .data = (void *)raa_dmpvr2_2rail },
504 	{ .compatible = "renesas,isl69248", .data = (void *)raa_dmpvr2_2rail },
505 	{ .compatible = "renesas,isl69254", .data = (void *)raa_dmpvr2_2rail },
506 	{ .compatible = "renesas,isl69255", .data = (void *)raa_dmpvr2_2rail },
507 	{ .compatible = "renesas,isl69256", .data = (void *)raa_dmpvr2_2rail },
508 	{ .compatible = "renesas,isl69259", .data = (void *)raa_dmpvr2_2rail },
509 	{ .compatible = "isil,isl69260", .data = (void *)raa_dmpvr2_2rail },
510 	{ .compatible = "renesas,isl69268", .data = (void *)raa_dmpvr2_2rail },
511 	{ .compatible = "isil,isl69269", .data = (void *)raa_dmpvr2_3rail },
512 	{ .compatible = "renesas,isl69298", .data = (void *)raa_dmpvr2_2rail },
513 
514 	{ .compatible = "renesas,raa228000", .data = (void *)raa_dmpvr2_hv },
515 	{ .compatible = "renesas,raa228004", .data = (void *)raa_dmpvr2_hv },
516 	{ .compatible = "renesas,raa228006", .data = (void *)raa_dmpvr2_hv },
517 	{ .compatible = "renesas,raa228228", .data = (void *)raa_dmpvr2_2rail_nontc },
518 	{ .compatible = "renesas,raa228244", .data = (void *)raa_dmpvr2_2rail_nontc },
519 	{ .compatible = "renesas,raa228246", .data = (void *)raa_dmpvr2_2rail_nontc },
520 	{ .compatible = "renesas,raa229001", .data = (void *)raa_dmpvr2_2rail },
521 	{ .compatible = "renesas,raa229004", .data = (void *)raa_dmpvr2_2rail },
522 	{ .compatible = "renesas,raa229621", .data = (void *)raa_dmpvr2_2rail },
523 	{ },
524 };
525 
526 MODULE_DEVICE_TABLE(of, isl68137_of_match);
527 
528 /* This is the driver that will be inserted */
529 static struct i2c_driver isl68137_driver = {
530 	.driver = {
531 		.name = "isl68137",
532 		.of_match_table = isl68137_of_match,
533 	},
534 	.probe = isl68137_probe,
535 	.id_table = raa_dmpvr_id,
536 };
537 
538 module_i2c_driver(isl68137_driver);
539 
540 MODULE_AUTHOR("Maxim Sloyko <maxims@google.com>");
541 MODULE_DESCRIPTION("PMBus driver for Renesas digital multiphase voltage regulators");
542 MODULE_LICENSE("GPL");
543 MODULE_IMPORT_NS("PMBUS");
544