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 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 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 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 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 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 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 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 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 struct device_node *child; 340 int err; 341 342 for_each_child_of_node(np, child) { 343 if (strcmp(child->name, "channel")) 344 continue; 345 346 err = isl68137_probe_child_from_dt(dev, child, data); 347 if (err) 348 return err; 349 } 350 351 return 0; 352 } 353 354 static int isl68137_probe(struct i2c_client *client) 355 { 356 struct device *dev = &client->dev; 357 struct pmbus_driver_info *info; 358 struct isl68137_data *data; 359 int i, err; 360 361 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 362 if (!data) 363 return -ENOMEM; 364 365 /* 366 * Initialize all voltage dividers to Rout=1 and Rtotal=1 to simplify 367 * logic in PMBus word read/write functions 368 */ 369 for (i = 0; i < MAX_CHANNELS; i++) 370 memset(data->channel[i].vout_voltage_divider, 371 1, 372 sizeof(data->channel[i].vout_voltage_divider)); 373 374 memcpy(&data->info, &raa_dmpvr_info, sizeof(data->info)); 375 info = &data->info; 376 377 switch (i2c_match_id(raa_dmpvr_id, client)->driver_data) { 378 case raa_dmpvr1_2rail: 379 info->pages = 2; 380 info->R[PSC_VOLTAGE_IN] = 3; 381 info->func[0] &= ~PMBUS_HAVE_VMON; 382 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 383 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 384 | PMBUS_HAVE_POUT; 385 info->read_word_data = raa_dmpvr2_read_word_data; 386 info->write_word_data = raa_dmpvr2_write_word_data; 387 info->groups = isl68137_attribute_groups; 388 break; 389 case raa_dmpvr2_1rail: 390 info->pages = 1; 391 info->read_word_data = raa_dmpvr2_read_word_data; 392 info->write_word_data = raa_dmpvr2_write_word_data; 393 break; 394 case raa_dmpvr2_2rail_nontc: 395 info->func[0] &= ~PMBUS_HAVE_TEMP3; 396 info->func[1] &= ~PMBUS_HAVE_TEMP3; 397 fallthrough; 398 case raa_dmpvr2_2rail: 399 info->pages = 2; 400 info->read_word_data = raa_dmpvr2_read_word_data; 401 info->write_word_data = raa_dmpvr2_write_word_data; 402 break; 403 case raa_dmpvr2_3rail: 404 info->read_word_data = raa_dmpvr2_read_word_data; 405 info->write_word_data = raa_dmpvr2_write_word_data; 406 break; 407 case raa_dmpvr2_hv: 408 info->pages = 1; 409 info->R[PSC_VOLTAGE_IN] = 1; 410 info->m[PSC_VOLTAGE_OUT] = 2; 411 info->R[PSC_VOLTAGE_OUT] = 2; 412 info->m[PSC_CURRENT_IN] = 2; 413 info->m[PSC_POWER] = 2; 414 info->R[PSC_POWER] = -1; 415 info->read_word_data = raa_dmpvr2_read_word_data; 416 info->write_word_data = raa_dmpvr2_write_word_data; 417 break; 418 default: 419 return -ENODEV; 420 } 421 422 err = isl68137_probe_from_dt(dev, data); 423 if (err) 424 return err; 425 426 return pmbus_do_probe(client, info); 427 } 428 429 static const struct i2c_device_id raa_dmpvr_id[] = { 430 {"isl68137", raa_dmpvr1_2rail}, 431 {"isl68220", raa_dmpvr2_2rail}, 432 {"isl68221", raa_dmpvr2_3rail}, 433 {"isl68222", raa_dmpvr2_2rail}, 434 {"isl68223", raa_dmpvr2_2rail}, 435 {"isl68224", raa_dmpvr2_3rail}, 436 {"isl68225", raa_dmpvr2_2rail}, 437 {"isl68226", raa_dmpvr2_3rail}, 438 {"isl68227", raa_dmpvr2_1rail}, 439 {"isl68229", raa_dmpvr2_3rail}, 440 {"isl68233", raa_dmpvr2_2rail}, 441 {"isl68239", raa_dmpvr2_3rail}, 442 443 {"isl69222", raa_dmpvr2_2rail}, 444 {"isl69223", raa_dmpvr2_3rail}, 445 {"isl69224", raa_dmpvr2_2rail}, 446 {"isl69225", raa_dmpvr2_2rail}, 447 {"isl69227", raa_dmpvr2_3rail}, 448 {"isl69228", raa_dmpvr2_3rail}, 449 {"isl69234", raa_dmpvr2_2rail}, 450 {"isl69236", raa_dmpvr2_2rail}, 451 {"isl69239", raa_dmpvr2_3rail}, 452 {"isl69242", raa_dmpvr2_2rail}, 453 {"isl69243", raa_dmpvr2_1rail}, 454 {"isl69247", raa_dmpvr2_2rail}, 455 {"isl69248", raa_dmpvr2_2rail}, 456 {"isl69254", raa_dmpvr2_2rail}, 457 {"isl69255", raa_dmpvr2_2rail}, 458 {"isl69256", raa_dmpvr2_2rail}, 459 {"isl69259", raa_dmpvr2_2rail}, 460 {"isl69260", raa_dmpvr2_2rail}, 461 {"isl69268", raa_dmpvr2_2rail}, 462 {"isl69269", raa_dmpvr2_3rail}, 463 {"isl69298", raa_dmpvr2_2rail}, 464 465 {"raa228000", raa_dmpvr2_hv}, 466 {"raa228004", raa_dmpvr2_hv}, 467 {"raa228006", raa_dmpvr2_hv}, 468 {"raa228228", raa_dmpvr2_2rail_nontc}, 469 {"raa228244", raa_dmpvr2_2rail_nontc}, 470 {"raa228246", raa_dmpvr2_2rail_nontc}, 471 {"raa229001", raa_dmpvr2_2rail}, 472 {"raa229004", raa_dmpvr2_2rail}, 473 {"raa229621", raa_dmpvr2_2rail}, 474 {} 475 }; 476 477 MODULE_DEVICE_TABLE(i2c, raa_dmpvr_id); 478 479 static const struct of_device_id isl68137_of_match[] = { 480 { .compatible = "isil,isl68137", .data = (void *)raa_dmpvr1_2rail }, 481 { .compatible = "renesas,isl68220", .data = (void *)raa_dmpvr2_2rail }, 482 { .compatible = "renesas,isl68221", .data = (void *)raa_dmpvr2_3rail }, 483 { .compatible = "renesas,isl68222", .data = (void *)raa_dmpvr2_2rail }, 484 { .compatible = "renesas,isl68223", .data = (void *)raa_dmpvr2_2rail }, 485 { .compatible = "renesas,isl68224", .data = (void *)raa_dmpvr2_3rail }, 486 { .compatible = "renesas,isl68225", .data = (void *)raa_dmpvr2_2rail }, 487 { .compatible = "renesas,isl68226", .data = (void *)raa_dmpvr2_3rail }, 488 { .compatible = "renesas,isl68227", .data = (void *)raa_dmpvr2_1rail }, 489 { .compatible = "renesas,isl68229", .data = (void *)raa_dmpvr2_3rail }, 490 { .compatible = "renesas,isl68233", .data = (void *)raa_dmpvr2_2rail }, 491 { .compatible = "renesas,isl68239", .data = (void *)raa_dmpvr2_3rail }, 492 493 { .compatible = "renesas,isl69222", .data = (void *)raa_dmpvr2_2rail }, 494 { .compatible = "renesas,isl69223", .data = (void *)raa_dmpvr2_3rail }, 495 { .compatible = "renesas,isl69224", .data = (void *)raa_dmpvr2_2rail }, 496 { .compatible = "renesas,isl69225", .data = (void *)raa_dmpvr2_2rail }, 497 { .compatible = "renesas,isl69227", .data = (void *)raa_dmpvr2_3rail }, 498 { .compatible = "renesas,isl69228", .data = (void *)raa_dmpvr2_3rail }, 499 { .compatible = "renesas,isl69234", .data = (void *)raa_dmpvr2_2rail }, 500 { .compatible = "renesas,isl69236", .data = (void *)raa_dmpvr2_2rail }, 501 { .compatible = "renesas,isl69239", .data = (void *)raa_dmpvr2_3rail }, 502 { .compatible = "renesas,isl69242", .data = (void *)raa_dmpvr2_2rail }, 503 { .compatible = "renesas,isl69243", .data = (void *)raa_dmpvr2_1rail }, 504 { .compatible = "renesas,isl69247", .data = (void *)raa_dmpvr2_2rail }, 505 { .compatible = "renesas,isl69248", .data = (void *)raa_dmpvr2_2rail }, 506 { .compatible = "renesas,isl69254", .data = (void *)raa_dmpvr2_2rail }, 507 { .compatible = "renesas,isl69255", .data = (void *)raa_dmpvr2_2rail }, 508 { .compatible = "renesas,isl69256", .data = (void *)raa_dmpvr2_2rail }, 509 { .compatible = "renesas,isl69259", .data = (void *)raa_dmpvr2_2rail }, 510 { .compatible = "isil,isl69260", .data = (void *)raa_dmpvr2_2rail }, 511 { .compatible = "renesas,isl69268", .data = (void *)raa_dmpvr2_2rail }, 512 { .compatible = "isil,isl69269", .data = (void *)raa_dmpvr2_3rail }, 513 { .compatible = "renesas,isl69298", .data = (void *)raa_dmpvr2_2rail }, 514 515 { .compatible = "renesas,raa228000", .data = (void *)raa_dmpvr2_hv }, 516 { .compatible = "renesas,raa228004", .data = (void *)raa_dmpvr2_hv }, 517 { .compatible = "renesas,raa228006", .data = (void *)raa_dmpvr2_hv }, 518 { .compatible = "renesas,raa228228", .data = (void *)raa_dmpvr2_2rail_nontc }, 519 { .compatible = "renesas,raa228244", .data = (void *)raa_dmpvr2_2rail_nontc }, 520 { .compatible = "renesas,raa228246", .data = (void *)raa_dmpvr2_2rail_nontc }, 521 { .compatible = "renesas,raa229001", .data = (void *)raa_dmpvr2_2rail }, 522 { .compatible = "renesas,raa229004", .data = (void *)raa_dmpvr2_2rail }, 523 { .compatible = "renesas,raa229621", .data = (void *)raa_dmpvr2_2rail }, 524 { }, 525 }; 526 527 MODULE_DEVICE_TABLE(of, isl68137_of_match); 528 529 /* This is the driver that will be inserted */ 530 static struct i2c_driver isl68137_driver = { 531 .driver = { 532 .name = "isl68137", 533 .of_match_table = isl68137_of_match, 534 }, 535 .probe = isl68137_probe, 536 .id_table = raa_dmpvr_id, 537 }; 538 539 module_i2c_driver(isl68137_driver); 540 541 MODULE_AUTHOR("Maxim Sloyko <maxims@google.com>"); 542 MODULE_DESCRIPTION("PMBus driver for Renesas digital multiphase voltage regulators"); 543 MODULE_LICENSE("GPL"); 544 MODULE_IMPORT_NS("PMBUS"); 545