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 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 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 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 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 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 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 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 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 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