drivers/hwmon/pmbus/isl68137.c

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