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