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