drivers/hwmon/pmbus/pmbus_core.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Hardware monitoring driver for PMBus devices
   4  *
   5  * Copyright (c) 2010, 2011 Ericsson AB.
   6  * Copyright (c) 2012 Guenter Roeck
   7  */
   8
   9 #include <linux/debugfs.h>
  10 #include <linux/kernel.h>
  11 #include <linux/math64.h>
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/err.h>
  15 #include <linux/slab.h>
  16 #include <linux/i2c.h>
  17 #include <linux/hwmon.h>
  18 #include <linux/hwmon-sysfs.h>
  19 #include <linux/jiffies.h>
  20 #include <linux/pmbus.h>
  21 #include <linux/regulator/driver.h>
  22 #include <linux/regulator/machine.h>
  23 #include "pmbus.h"
  24
  25 /*
  26  * Number of additional attribute pointers to allocate
  27  * with each call to krealloc
  28  */
  29 #define PMBUS_ATTR_ALLOC_SIZE   32
  30
  31 /*
  32  * Index into status register array, per status register group
  33  */
  34 #define PB_STATUS_BASE          0
  35 #define PB_STATUS_VOUT_BASE     (PB_STATUS_BASE + PMBUS_PAGES)
  36 #define PB_STATUS_IOUT_BASE     (PB_STATUS_VOUT_BASE + PMBUS_PAGES)
  37 #define PB_STATUS_FAN_BASE      (PB_STATUS_IOUT_BASE + PMBUS_PAGES)
  38 #define PB_STATUS_FAN34_BASE    (PB_STATUS_FAN_BASE + PMBUS_PAGES)
  39 #define PB_STATUS_TEMP_BASE     (PB_STATUS_FAN34_BASE + PMBUS_PAGES)
  40 #define PB_STATUS_INPUT_BASE    (PB_STATUS_TEMP_BASE + PMBUS_PAGES)
  41 #define PB_STATUS_VMON_BASE     (PB_STATUS_INPUT_BASE + 1)
  42
  43 #define PB_NUM_STATUS_REG       (PB_STATUS_VMON_BASE + 1)
  44
  45 #define PMBUS_NAME_SIZE         24
  46
  47 struct pmbus_sensor {
  48         struct pmbus_sensor *next;
  49         char name[PMBUS_NAME_SIZE];     /* sysfs sensor name */
  50         struct device_attribute attribute;
  51         u8 page;                /* page number */
  52         u16 reg;                /* register */
  53         enum pmbus_sensor_classes class;        /* sensor class */
  54         bool update;            /* runtime sensor update needed */
  55         bool convert;           /* Whether or not to apply linear/vid/direct */
  56         int data;               /* Sensor data.
  57                                    Negative if there was a read error */
  58 };
  59 #define to_pmbus_sensor(_attr) \
  60         container_of(_attr, struct pmbus_sensor, attribute)
  61
  62 struct pmbus_boolean {
  63         char name[PMBUS_NAME_SIZE];     /* sysfs boolean name */
  64         struct sensor_device_attribute attribute;
  65         struct pmbus_sensor *s1;
  66         struct pmbus_sensor *s2;
  67 };
  68 #define to_pmbus_boolean(_attr) \
  69         container_of(_attr, struct pmbus_boolean, attribute)
  70
  71 struct pmbus_label {
  72         char name[PMBUS_NAME_SIZE];     /* sysfs label name */
  73         struct device_attribute attribute;
  74         char label[PMBUS_NAME_SIZE];    /* label */
  75 };
  76 #define to_pmbus_label(_attr) \
  77         container_of(_attr, struct pmbus_label, attribute)
  78
  79 struct pmbus_data {
  80         struct device *dev;
  81         struct device *hwmon_dev;
  82
  83         u32 flags;              /* from platform data */
  84
  85         int exponent[PMBUS_PAGES];
  86                                 /* linear mode: exponent for output voltages */
  87
  88         const struct pmbus_driver_info *info;
  89
  90         int max_attributes;
  91         int num_attributes;
  92         struct attribute_group group;
  93         const struct attribute_group **groups;
  94         struct dentry *debugfs;         /* debugfs device directory */
  95
  96         struct pmbus_sensor *sensors;
  97
  98         struct mutex update_lock;
  99         bool valid;
 100         unsigned long last_updated;     /* in jiffies */
 101
 102         /*
 103          * A single status register covers multiple attributes,
 104          * so we keep them all together.
 105          */
 106         u16 status[PB_NUM_STATUS_REG];
 107
 108         bool has_status_word;           /* device uses STATUS_WORD register */
 109         int (*read_status)(struct i2c_client *client, int page);
 110
 111         u8 currpage;
 112 };
 113
 114 struct pmbus_debugfs_entry {
 115         struct i2c_client *client;
 116         u8 page;
 117         u8 reg;
 118 };
 119
 120 static const int pmbus_fan_rpm_mask[] = {
 121         PB_FAN_1_RPM,
 122         PB_FAN_2_RPM,
 123         PB_FAN_1_RPM,
 124         PB_FAN_2_RPM,
 125 };
 126
 127 static const int pmbus_fan_config_registers[] = {
 128         PMBUS_FAN_CONFIG_12,
 129         PMBUS_FAN_CONFIG_12,
 130         PMBUS_FAN_CONFIG_34,
 131         PMBUS_FAN_CONFIG_34
 132 };
 133
 134 static const int pmbus_fan_command_registers[] = {
 135         PMBUS_FAN_COMMAND_1,
 136         PMBUS_FAN_COMMAND_2,
 137         PMBUS_FAN_COMMAND_3,
 138         PMBUS_FAN_COMMAND_4,
 139 };
 140
 141 void pmbus_clear_cache(struct i2c_client *client)
 142 {
 143         struct pmbus_data *data = i2c_get_clientdata(client);
 144
 145         data->valid = false;
 146 }
 147 EXPORT_SYMBOL_GPL(pmbus_clear_cache);
 148
 149 int pmbus_set_page(struct i2c_client *client, int page)
 150 {
 151         struct pmbus_data *data = i2c_get_clientdata(client);
 152         int rv;
 153
 154         if (page < 0 || page == data->currpage)
 155                 return 0;
 156
 157         if (!(data->info->func[page] & PMBUS_PAGE_VIRTUAL)) {
 158                 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
 159                 if (rv < 0)
 160                         return rv;
 161
 162                 rv = i2c_smbus_read_byte_data(client, PMBUS_PAGE);
 163                 if (rv < 0)
 164                         return rv;
 165
 166                 if (rv != page)
 167                         return -EIO;
 168         }
 169
 170         data->currpage = page;
 171
 172         return 0;
 173 }
 174 EXPORT_SYMBOL_GPL(pmbus_set_page);
 175
 176 int pmbus_write_byte(struct i2c_client *client, int page, u8 value)
 177 {
 178         int rv;
 179
 180         rv = pmbus_set_page(client, page);
 181         if (rv < 0)
 182                 return rv;
 183
 184         return i2c_smbus_write_byte(client, value);
 185 }
 186 EXPORT_SYMBOL_GPL(pmbus_write_byte);
 187
 188 /*
 189  * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if
 190  * a device specific mapping function exists and calls it if necessary.
 191  */
 192 static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value)
 193 {
 194         struct pmbus_data *data = i2c_get_clientdata(client);
 195         const struct pmbus_driver_info *info = data->info;
 196         int status;
 197
 198         if (info->write_byte) {
 199                 status = info->write_byte(client, page, value);
 200                 if (status != -ENODATA)
 201                         return status;
 202         }
 203         return pmbus_write_byte(client, page, value);
 204 }
 205
 206 int pmbus_write_word_data(struct i2c_client *client, int page, u8 reg,
 207                           u16 word)
 208 {
 209         int rv;
 210
 211         rv = pmbus_set_page(client, page);
 212         if (rv < 0)
 213                 return rv;
 214
 215         return i2c_smbus_write_word_data(client, reg, word);
 216 }
 217 EXPORT_SYMBOL_GPL(pmbus_write_word_data);
 218
 219
 220 static int pmbus_write_virt_reg(struct i2c_client *client, int page, int reg,
 221                                 u16 word)
 222 {
 223         int bit;
 224         int id;
 225         int rv;
 226
 227         switch (reg) {
 228         case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4:
 229                 id = reg - PMBUS_VIRT_FAN_TARGET_1;
 230                 bit = pmbus_fan_rpm_mask[id];
 231                 rv = pmbus_update_fan(client, page, id, bit, bit, word);
 232                 break;
 233         default:
 234                 rv = -ENXIO;
 235                 break;
 236         }
 237
 238         return rv;
 239 }
 240
 241 /*
 242  * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if
 243  * a device specific mapping function exists and calls it if necessary.
 244  */
 245 static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg,
 246                                   u16 word)
 247 {
 248         struct pmbus_data *data = i2c_get_clientdata(client);
 249         const struct pmbus_driver_info *info = data->info;
 250         int status;
 251
 252         if (info->write_word_data) {
 253                 status = info->write_word_data(client, page, reg, word);
 254                 if (status != -ENODATA)
 255                         return status;
 256         }
 257
 258         if (reg >= PMBUS_VIRT_BASE)
 259                 return pmbus_write_virt_reg(client, page, reg, word);
 260
 261         return pmbus_write_word_data(client, page, reg, word);
 262 }
 263
 264 int pmbus_update_fan(struct i2c_client *client, int page, int id,
 265                      u8 config, u8 mask, u16 command)
 266 {
 267         int from;
 268         int rv;
 269         u8 to;
 270
 271         from = pmbus_read_byte_data(client, page,
 272                                     pmbus_fan_config_registers[id]);
 273         if (from < 0)
 274                 return from;
 275
 276         to = (from & ~mask) | (config & mask);
 277         if (to != from) {
 278                 rv = pmbus_write_byte_data(client, page,
 279                                            pmbus_fan_config_registers[id], to);
 280                 if (rv < 0)
 281                         return rv;
 282         }
 283
 284         return _pmbus_write_word_data(client, page,
 285                                       pmbus_fan_command_registers[id], command);
 286 }
 287 EXPORT_SYMBOL_GPL(pmbus_update_fan);
 288
 289 int pmbus_read_word_data(struct i2c_client *client, int page, u8 reg)
 290 {
 291         int rv;
 292
 293         rv = pmbus_set_page(client, page);
 294         if (rv < 0)
 295                 return rv;
 296
 297         return i2c_smbus_read_word_data(client, reg);
 298 }
 299 EXPORT_SYMBOL_GPL(pmbus_read_word_data);
 300
 301 static int pmbus_read_virt_reg(struct i2c_client *client, int page, int reg)
 302 {
 303         int rv;
 304         int id;
 305
 306         switch (reg) {
 307         case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4:
 308                 id = reg - PMBUS_VIRT_FAN_TARGET_1;
 309                 rv = pmbus_get_fan_rate_device(client, page, id, rpm);
 310                 break;
 311         default:
 312                 rv = -ENXIO;
 313                 break;
 314         }
 315
 316         return rv;
 317 }
 318
 319 /*
 320  * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if
 321  * a device specific mapping function exists and calls it if necessary.
 322  */
 323 static int _pmbus_read_word_data(struct i2c_client *client, int page, int reg)
 324 {
 325         struct pmbus_data *data = i2c_get_clientdata(client);
 326         const struct pmbus_driver_info *info = data->info;
 327         int status;
 328
 329         if (info->read_word_data) {
 330                 status = info->read_word_data(client, page, reg);
 331                 if (status != -ENODATA)
 332                         return status;
 333         }
 334
 335         if (reg >= PMBUS_VIRT_BASE)
 336                 return pmbus_read_virt_reg(client, page, reg);
 337
 338         return pmbus_read_word_data(client, page, reg);
 339 }
 340
 341 int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg)
 342 {
 343         int rv;
 344
 345         rv = pmbus_set_page(client, page);
 346         if (rv < 0)
 347                 return rv;
 348
 349         return i2c_smbus_read_byte_data(client, reg);
 350 }
 351 EXPORT_SYMBOL_GPL(pmbus_read_byte_data);
 352
 353 int pmbus_write_byte_data(struct i2c_client *client, int page, u8 reg, u8 value)
 354 {
 355         int rv;
 356
 357         rv = pmbus_set_page(client, page);
 358         if (rv < 0)
 359                 return rv;
 360
 361         return i2c_smbus_write_byte_data(client, reg, value);
 362 }
 363 EXPORT_SYMBOL_GPL(pmbus_write_byte_data);
 364
 365 int pmbus_update_byte_data(struct i2c_client *client, int page, u8 reg,
 366                            u8 mask, u8 value)
 367 {
 368         unsigned int tmp;
 369         int rv;
 370
 371         rv = pmbus_read_byte_data(client, page, reg);
 372         if (rv < 0)
 373                 return rv;
 374
 375         tmp = (rv & ~mask) | (value & mask);
 376
 377         if (tmp != rv)
 378                 rv = pmbus_write_byte_data(client, page, reg, tmp);
 379
 380         return rv;
 381 }
 382 EXPORT_SYMBOL_GPL(pmbus_update_byte_data);
 383
 384 /*
 385  * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
 386  * a device specific mapping function exists and calls it if necessary.
 387  */
 388 static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg)
 389 {
 390         struct pmbus_data *data = i2c_get_clientdata(client);
 391         const struct pmbus_driver_info *info = data->info;
 392         int status;
 393
 394         if (info->read_byte_data) {
 395                 status = info->read_byte_data(client, page, reg);
 396                 if (status != -ENODATA)
 397                         return status;
 398         }
 399         return pmbus_read_byte_data(client, page, reg);
 400 }
 401
 402 static struct pmbus_sensor *pmbus_find_sensor(struct pmbus_data *data, int page,
 403                                               int reg)
 404 {
 405         struct pmbus_sensor *sensor;
 406
 407         for (sensor = data->sensors; sensor; sensor = sensor->next) {
 408                 if (sensor->page == page && sensor->reg == reg)
 409                         return sensor;
 410         }
 411
 412         return ERR_PTR(-EINVAL);
 413 }
 414
 415 static int pmbus_get_fan_rate(struct i2c_client *client, int page, int id,
 416                               enum pmbus_fan_mode mode,
 417                               bool from_cache)
 418 {
 419         struct pmbus_data *data = i2c_get_clientdata(client);
 420         bool want_rpm, have_rpm;
 421         struct pmbus_sensor *s;
 422         int config;
 423         int reg;
 424
 425         want_rpm = (mode == rpm);
 426
 427         if (from_cache) {
 428                 reg = want_rpm ? PMBUS_VIRT_FAN_TARGET_1 : PMBUS_VIRT_PWM_1;
 429                 s = pmbus_find_sensor(data, page, reg + id);
 430                 if (IS_ERR(s))
 431                         return PTR_ERR(s);
 432
 433                 return s->data;
 434         }
 435
 436         config = pmbus_read_byte_data(client, page,
 437                                       pmbus_fan_config_registers[id]);
 438         if (config < 0)
 439                 return config;
 440
 441         have_rpm = !!(config & pmbus_fan_rpm_mask[id]);
 442         if (want_rpm == have_rpm)
 443                 return pmbus_read_word_data(client, page,
 444                                             pmbus_fan_command_registers[id]);
 445
 446         /* Can't sensibly map between RPM and PWM, just return zero */
 447         return 0;
 448 }
 449
 450 int pmbus_get_fan_rate_device(struct i2c_client *client, int page, int id,
 451                               enum pmbus_fan_mode mode)
 452 {
 453         return pmbus_get_fan_rate(client, page, id, mode, false);
 454 }
 455 EXPORT_SYMBOL_GPL(pmbus_get_fan_rate_device);
 456
 457 int pmbus_get_fan_rate_cached(struct i2c_client *client, int page, int id,
 458                               enum pmbus_fan_mode mode)
 459 {
 460         return pmbus_get_fan_rate(client, page, id, mode, true);
 461 }
 462 EXPORT_SYMBOL_GPL(pmbus_get_fan_rate_cached);
 463
 464 static void pmbus_clear_fault_page(struct i2c_client *client, int page)
 465 {
 466         _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
 467 }
 468
 469 void pmbus_clear_faults(struct i2c_client *client)
 470 {
 471         struct pmbus_data *data = i2c_get_clientdata(client);
 472         int i;
 473
 474         for (i = 0; i < data->info->pages; i++)
 475                 pmbus_clear_fault_page(client, i);
 476 }
 477 EXPORT_SYMBOL_GPL(pmbus_clear_faults);
 478
 479 static int pmbus_check_status_cml(struct i2c_client *client)
 480 {
 481         struct pmbus_data *data = i2c_get_clientdata(client);
 482         int status, status2;
 483
 484         status = data->read_status(client, -1);
 485         if (status < 0 || (status & PB_STATUS_CML)) {
 486                 status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
 487                 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND))
 488                         return -EIO;
 489         }
 490         return 0;
 491 }
 492
 493 static bool pmbus_check_register(struct i2c_client *client,
 494                                  int (*func)(struct i2c_client *client,
 495                                              int page, int reg),
 496                                  int page, int reg)
 497 {
 498         int rv;
 499         struct pmbus_data *data = i2c_get_clientdata(client);
 500
 501         rv = func(client, page, reg);
 502         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
 503                 rv = pmbus_check_status_cml(client);
 504         pmbus_clear_fault_page(client, -1);
 505         return rv >= 0;
 506 }
 507
 508 static bool pmbus_check_status_register(struct i2c_client *client, int page)
 509 {
 510         int status;
 511         struct pmbus_data *data = i2c_get_clientdata(client);
 512
 513         status = data->read_status(client, page);
 514         if (status >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK) &&
 515             (status & PB_STATUS_CML)) {
 516                 status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
 517                 if (status < 0 || (status & PB_CML_FAULT_INVALID_COMMAND))
 518                         status = -EIO;
 519         }
 520
 521         pmbus_clear_fault_page(client, -1);
 522         return status >= 0;
 523 }
 524
 525 bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg)
 526 {
 527         return pmbus_check_register(client, _pmbus_read_byte_data, page, reg);
 528 }
 529 EXPORT_SYMBOL_GPL(pmbus_check_byte_register);
 530
 531 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
 532 {
 533         return pmbus_check_register(client, _pmbus_read_word_data, page, reg);
 534 }
 535 EXPORT_SYMBOL_GPL(pmbus_check_word_register);
 536
 537 const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client *client)
 538 {
 539         struct pmbus_data *data = i2c_get_clientdata(client);
 540
 541         return data->info;
 542 }
 543 EXPORT_SYMBOL_GPL(pmbus_get_driver_info);
 544
 545 static struct _pmbus_status {
 546         u32 func;
 547         u16 base;
 548         u16 reg;
 549 } pmbus_status[] = {
 550         { PMBUS_HAVE_STATUS_VOUT, PB_STATUS_VOUT_BASE, PMBUS_STATUS_VOUT },
 551         { PMBUS_HAVE_STATUS_IOUT, PB_STATUS_IOUT_BASE, PMBUS_STATUS_IOUT },
 552         { PMBUS_HAVE_STATUS_TEMP, PB_STATUS_TEMP_BASE,
 553           PMBUS_STATUS_TEMPERATURE },
 554         { PMBUS_HAVE_STATUS_FAN12, PB_STATUS_FAN_BASE, PMBUS_STATUS_FAN_12 },
 555         { PMBUS_HAVE_STATUS_FAN34, PB_STATUS_FAN34_BASE, PMBUS_STATUS_FAN_34 },
 556 };
 557
 558 static struct pmbus_data *pmbus_update_device(struct device *dev)
 559 {
 560         struct i2c_client *client = to_i2c_client(dev->parent);
 561         struct pmbus_data *data = i2c_get_clientdata(client);
 562         const struct pmbus_driver_info *info = data->info;
 563         struct pmbus_sensor *sensor;
 564
 565         mutex_lock(&data->update_lock);
 566         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
 567                 int i, j;
 568
 569                 for (i = 0; i < info->pages; i++) {
 570                         data->status[PB_STATUS_BASE + i]
 571                             = data->read_status(client, i);
 572                         for (j = 0; j < ARRAY_SIZE(pmbus_status); j++) {
 573                                 struct _pmbus_status *s = &pmbus_status[j];
 574
 575                                 if (!(info->func[i] & s->func))
 576                                         continue;
 577                                 data->status[s->base + i]
 578                                         = _pmbus_read_byte_data(client, i,
 579                                                                 s->reg);
 580                         }
 581                 }
 582
 583                 if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
 584                         data->status[PB_STATUS_INPUT_BASE]
 585                           = _pmbus_read_byte_data(client, 0,
 586                                                   PMBUS_STATUS_INPUT);
 587
 588                 if (info->func[0] & PMBUS_HAVE_STATUS_VMON)
 589                         data->status[PB_STATUS_VMON_BASE]
 590                           = _pmbus_read_byte_data(client, 0,
 591                                                   PMBUS_VIRT_STATUS_VMON);
 592
 593                 for (sensor = data->sensors; sensor; sensor = sensor->next) {
 594                         if (!data->valid || sensor->update)
 595                                 sensor->data
 596                                     = _pmbus_read_word_data(client,
 597                                                             sensor->page,
 598                                                             sensor->reg);
 599                 }
 600                 pmbus_clear_faults(client);
 601                 data->last_updated = jiffies;
 602                 data->valid = 1;
 603         }
 604         mutex_unlock(&data->update_lock);
 605         return data;
 606 }
 607
 608 /*
 609  * Convert linear sensor values to milli- or micro-units
 610  * depending on sensor type.
 611  */
 612 static long pmbus_reg2data_linear(struct pmbus_data *data,
 613                                   struct pmbus_sensor *sensor)
 614 {
 615         s16 exponent;
 616         s32 mantissa;
 617         long val;
 618
 619         if (sensor->class == PSC_VOLTAGE_OUT) { /* LINEAR16 */
 620                 exponent = data->exponent[sensor->page];
 621                 mantissa = (u16) sensor->data;
 622         } else {                                /* LINEAR11 */
 623                 exponent = ((s16)sensor->data) >> 11;
 624                 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5;
 625         }
 626
 627         val = mantissa;
 628
 629         /* scale result to milli-units for all sensors except fans */
 630         if (sensor->class != PSC_FAN)
 631                 val = val * 1000L;
 632
 633         /* scale result to micro-units for power sensors */
 634         if (sensor->class == PSC_POWER)
 635                 val = val * 1000L;
 636
 637         if (exponent >= 0)
 638                 val <<= exponent;
 639         else
 640                 val >>= -exponent;
 641
 642         return val;
 643 }
 644
 645 /*
 646  * Convert direct sensor values to milli- or micro-units
 647  * depending on sensor type.
 648  */
 649 static long pmbus_reg2data_direct(struct pmbus_data *data,
 650                                   struct pmbus_sensor *sensor)
 651 {
 652         s64 b, val = (s16)sensor->data;
 653         s32 m, R;
 654
 655         m = data->info->m[sensor->class];
 656         b = data->info->b[sensor->class];
 657         R = data->info->R[sensor->class];
 658
 659         if (m == 0)
 660                 return 0;
 661
 662         /* X = 1/m * (Y * 10^-R - b) */
 663         R = -R;
 664         /* scale result to milli-units for everything but fans */
 665         if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) {
 666                 R += 3;
 667                 b *= 1000;
 668         }
 669
 670         /* scale result to micro-units for power sensors */
 671         if (sensor->class == PSC_POWER) {
 672                 R += 3;
 673                 b *= 1000;
 674         }
 675
 676         while (R > 0) {
 677                 val *= 10;
 678                 R--;
 679         }
 680         while (R < 0) {
 681                 val = div_s64(val + 5LL, 10L);  /* round closest */
 682                 R++;
 683         }
 684
 685         val = div_s64(val - b, m);
 686         return clamp_val(val, LONG_MIN, LONG_MAX);
 687 }
 688
 689 /*
 690  * Convert VID sensor values to milli- or micro-units
 691  * depending on sensor type.
 692  */
 693 static long pmbus_reg2data_vid(struct pmbus_data *data,
 694                                struct pmbus_sensor *sensor)
 695 {
 696         long val = sensor->data;
 697         long rv = 0;
 698
 699         switch (data->info->vrm_version[sensor->page]) {
 700         case vr11:
 701                 if (val >= 0x02 && val <= 0xb2)
 702                         rv = DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100);
 703                 break;
 704         case vr12:
 705                 if (val >= 0x01)
 706                         rv = 250 + (val - 1) * 5;
 707                 break;
 708         case vr13:
 709                 if (val >= 0x01)
 710                         rv = 500 + (val - 1) * 10;
 711                 break;
 712         case imvp9:
 713                 if (val >= 0x01)
 714                         rv = 200 + (val - 1) * 10;
 715                 break;
 716         case amd625mv:
 717                 if (val >= 0x0 && val <= 0xd8)
 718                         rv = DIV_ROUND_CLOSEST(155000 - val * 625, 100);
 719                 break;
 720         }
 721         return rv;
 722 }
 723
 724 static long pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
 725 {
 726         long val;
 727
 728         if (!sensor->convert)
 729                 return sensor->data;
 730
 731         switch (data->info->format[sensor->class]) {
 732         case direct:
 733                 val = pmbus_reg2data_direct(data, sensor);
 734                 break;
 735         case vid:
 736                 val = pmbus_reg2data_vid(data, sensor);
 737                 break;
 738         case linear:
 739         default:
 740                 val = pmbus_reg2data_linear(data, sensor);
 741                 break;
 742         }
 743         return val;
 744 }
 745
 746 #define MAX_MANTISSA    (1023 * 1000)
 747 #define MIN_MANTISSA    (511 * 1000)
 748
 749 static u16 pmbus_data2reg_linear(struct pmbus_data *data,
 750                                  struct pmbus_sensor *sensor, long val)
 751 {
 752         s16 exponent = 0, mantissa;
 753         bool negative = false;
 754
 755         /* simple case */
 756         if (val == 0)
 757                 return 0;
 758
 759         if (sensor->class == PSC_VOLTAGE_OUT) {
 760                 /* LINEAR16 does not support negative voltages */
 761                 if (val < 0)
 762                         return 0;
 763
 764                 /*
 765                  * For a static exponents, we don't have a choice
 766                  * but to adjust the value to it.
 767                  */
 768                 if (data->exponent[sensor->page] < 0)
 769                         val <<= -data->exponent[sensor->page];
 770                 else
 771                         val >>= data->exponent[sensor->page];
 772                 val = DIV_ROUND_CLOSEST(val, 1000);
 773                 return val & 0xffff;
 774         }
 775
 776         if (val < 0) {
 777                 negative = true;
 778                 val = -val;
 779         }
 780
 781         /* Power is in uW. Convert to mW before converting. */
 782         if (sensor->class == PSC_POWER)
 783                 val = DIV_ROUND_CLOSEST(val, 1000L);
 784
 785         /*
 786          * For simplicity, convert fan data to milli-units
 787          * before calculating the exponent.
 788          */
 789         if (sensor->class == PSC_FAN)
 790                 val = val * 1000;
 791
 792         /* Reduce large mantissa until it fits into 10 bit */
 793         while (val >= MAX_MANTISSA && exponent < 15) {
 794                 exponent++;
 795                 val >>= 1;
 796         }
 797         /* Increase small mantissa to improve precision */
 798         while (val < MIN_MANTISSA && exponent > -15) {
 799                 exponent--;
 800                 val <<= 1;
 801         }
 802
 803         /* Convert mantissa from milli-units to units */
 804         mantissa = DIV_ROUND_CLOSEST(val, 1000);
 805
 806         /* Ensure that resulting number is within range */
 807         if (mantissa > 0x3ff)
 808                 mantissa = 0x3ff;
 809
 810         /* restore sign */
 811         if (negative)
 812                 mantissa = -mantissa;
 813
 814         /* Convert to 5 bit exponent, 11 bit mantissa */
 815         return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
 816 }
 817
 818 static u16 pmbus_data2reg_direct(struct pmbus_data *data,
 819                                  struct pmbus_sensor *sensor, long val)
 820 {
 821         s64 b, val64 = val;
 822         s32 m, R;
 823
 824         m = data->info->m[sensor->class];
 825         b = data->info->b[sensor->class];
 826         R = data->info->R[sensor->class];
 827
 828         /* Power is in uW. Adjust R and b. */
 829         if (sensor->class == PSC_POWER) {
 830                 R -= 3;
 831                 b *= 1000;
 832         }
 833
 834         /* Calculate Y = (m * X + b) * 10^R */
 835         if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) {
 836                 R -= 3;         /* Adjust R and b for data in milli-units */
 837                 b *= 1000;
 838         }
 839         val64 = val64 * m + b;
 840
 841         while (R > 0) {
 842                 val64 *= 10;
 843                 R--;
 844         }
 845         while (R < 0) {
 846                 val64 = div_s64(val64 + 5LL, 10L);  /* round closest */
 847                 R++;
 848         }
 849
 850         return (u16)clamp_val(val64, S16_MIN, S16_MAX);
 851 }
 852
 853 static u16 pmbus_data2reg_vid(struct pmbus_data *data,
 854                               struct pmbus_sensor *sensor, long val)
 855 {
 856         val = clamp_val(val, 500, 1600);
 857
 858         return 2 + DIV_ROUND_CLOSEST((1600 - val) * 100, 625);
 859 }
 860
 861 static u16 pmbus_data2reg(struct pmbus_data *data,
 862                           struct pmbus_sensor *sensor, long val)
 863 {
 864         u16 regval;
 865
 866         if (!sensor->convert)
 867                 return val;
 868
 869         switch (data->info->format[sensor->class]) {
 870         case direct:
 871                 regval = pmbus_data2reg_direct(data, sensor, val);
 872                 break;
 873         case vid:
 874                 regval = pmbus_data2reg_vid(data, sensor, val);
 875                 break;
 876         case linear:
 877         default:
 878                 regval = pmbus_data2reg_linear(data, sensor, val);
 879                 break;
 880         }
 881         return regval;
 882 }
 883
 884 /*
 885  * Return boolean calculated from converted data.
 886  * <index> defines a status register index and mask.
 887  * The mask is in the lower 8 bits, the register index is in bits 8..23.
 888  *
 889  * The associated pmbus_boolean structure contains optional pointers to two
 890  * sensor attributes. If specified, those attributes are compared against each
 891  * other to determine if a limit has been exceeded.
 892  *
 893  * If the sensor attribute pointers are NULL, the function returns true if
 894  * (status[reg] & mask) is true.
 895  *
 896  * If sensor attribute pointers are provided, a comparison against a specified
 897  * limit has to be performed to determine the boolean result.
 898  * In this case, the function returns true if v1 >= v2 (where v1 and v2 are
 899  * sensor values referenced by sensor attribute pointers s1 and s2).
 900  *
 901  * To determine if an object exceeds upper limits, specify <s1,s2> = <v,limit>.
 902  * To determine if an object exceeds lower limits, specify <s1,s2> = <limit,v>.
 903  *
 904  * If a negative value is stored in any of the referenced registers, this value
 905  * reflects an error code which will be returned.
 906  */
 907 static int pmbus_get_boolean(struct pmbus_data *data, struct pmbus_boolean *b,
 908                              int index)
 909 {
 910         struct pmbus_sensor *s1 = b->s1;
 911         struct pmbus_sensor *s2 = b->s2;
 912         u16 reg = (index >> 16) & 0xffff;
 913         u16 mask = index & 0xffff;
 914         int ret, status;
 915         u16 regval;
 916
 917         status = data->status[reg];
 918         if (status < 0)
 919                 return status;
 920
 921         regval = status & mask;
 922         if (!s1 && !s2) {
 923                 ret = !!regval;
 924         } else if (!s1 || !s2) {
 925                 WARN(1, "Bad boolean descriptor %p: s1=%p, s2=%p\n", b, s1, s2);
 926                 return 0;
 927         } else {
 928                 long v1, v2;
 929
 930                 if (s1->data < 0)
 931                         return s1->data;
 932                 if (s2->data < 0)
 933                         return s2->data;
 934
 935                 v1 = pmbus_reg2data(data, s1);
 936                 v2 = pmbus_reg2data(data, s2);
 937                 ret = !!(regval && v1 >= v2);
 938         }
 939         return ret;
 940 }
 941
 942 static ssize_t pmbus_show_boolean(struct device *dev,
 943                                   struct device_attribute *da, char *buf)
 944 {
 945         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 946         struct pmbus_boolean *boolean = to_pmbus_boolean(attr);
 947         struct pmbus_data *data = pmbus_update_device(dev);
 948         int val;
 949
 950         val = pmbus_get_boolean(data, boolean, attr->index);
 951         if (val < 0)
 952                 return val;
 953         return snprintf(buf, PAGE_SIZE, "%d\n", val);
 954 }
 955
 956 static ssize_t pmbus_show_sensor(struct device *dev,
 957                                  struct device_attribute *devattr, char *buf)
 958 {
 959         struct pmbus_data *data = pmbus_update_device(dev);
 960         struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
 961
 962         if (sensor->data < 0)
 963                 return sensor->data;
 964
 965         return snprintf(buf, PAGE_SIZE, "%ld\n", pmbus_reg2data(data, sensor));
 966 }
 967
 968 static ssize_t pmbus_set_sensor(struct device *dev,
 969                                 struct device_attribute *devattr,
 970                                 const char *buf, size_t count)
 971 {
 972         struct i2c_client *client = to_i2c_client(dev->parent);
 973         struct pmbus_data *data = i2c_get_clientdata(client);
 974         struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
 975         ssize_t rv = count;
 976         long val = 0;
 977         int ret;
 978         u16 regval;
 979
 980         if (kstrtol(buf, 10, &val) < 0)
 981                 return -EINVAL;
 982
 983         mutex_lock(&data->update_lock);
 984         regval = pmbus_data2reg(data, sensor, val);
 985         ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
 986         if (ret < 0)
 987                 rv = ret;
 988         else
 989                 sensor->data = regval;
 990         mutex_unlock(&data->update_lock);
 991         return rv;
 992 }
 993
 994 static ssize_t pmbus_show_label(struct device *dev,
 995                                 struct device_attribute *da, char *buf)
 996 {
 997         struct pmbus_label *label = to_pmbus_label(da);
 998
 999         return snprintf(buf, PAGE_SIZE, "%s\n", label->label);
1000 }
1001
1002 static int pmbus_add_attribute(struct pmbus_data *data, struct attribute *attr)
1003 {
1004         if (data->num_attributes >= data->max_attributes - 1) {
1005                 int new_max_attrs = data->max_attributes + PMBUS_ATTR_ALLOC_SIZE;
1006                 void *new_attrs = krealloc(data->group.attrs,
1007                                            new_max_attrs * sizeof(void *),
1008                                            GFP_KERNEL);
1009                 if (!new_attrs)
1010                         return -ENOMEM;
1011                 data->group.attrs = new_attrs;
1012                 data->max_attributes = new_max_attrs;
1013         }
1014
1015         data->group.attrs[data->num_attributes++] = attr;
1016         data->group.attrs[data->num_attributes] = NULL;
1017         return 0;
1018 }
1019
1020 static void pmbus_dev_attr_init(struct device_attribute *dev_attr,
1021                                 const char *name,
1022                                 umode_t mode,
1023                                 ssize_t (*show)(struct device *dev,
1024                                                 struct device_attribute *attr,
1025                                                 char *buf),
1026                                 ssize_t (*store)(struct device *dev,
1027                                                  struct device_attribute *attr,
1028                                                  const char *buf, size_t count))
1029 {
1030         sysfs_attr_init(&dev_attr->attr);
1031         dev_attr->attr.name = name;
1032         dev_attr->attr.mode = mode;
1033         dev_attr->show = show;
1034         dev_attr->store = store;
1035 }
1036
1037 static void pmbus_attr_init(struct sensor_device_attribute *a,
1038                             const char *name,
1039                             umode_t mode,
1040                             ssize_t (*show)(struct device *dev,
1041                                             struct device_attribute *attr,
1042                                             char *buf),
1043                             ssize_t (*store)(struct device *dev,
1044                                              struct device_attribute *attr,
1045                                              const char *buf, size_t count),
1046                             int idx)
1047 {
1048         pmbus_dev_attr_init(&a->dev_attr, name, mode, show, store);
1049         a->index = idx;
1050 }
1051
1052 static int pmbus_add_boolean(struct pmbus_data *data,
1053                              const char *name, const char *type, int seq,
1054                              struct pmbus_sensor *s1,
1055                              struct pmbus_sensor *s2,
1056                              u16 reg, u16 mask)
1057 {
1058         struct pmbus_boolean *boolean;
1059         struct sensor_device_attribute *a;
1060
1061         boolean = devm_kzalloc(data->dev, sizeof(*boolean), GFP_KERNEL);
1062         if (!boolean)
1063                 return -ENOMEM;
1064
1065         a = &boolean->attribute;
1066
1067         snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
1068                  name, seq, type);
1069         boolean->s1 = s1;
1070         boolean->s2 = s2;
1071         pmbus_attr_init(a, boolean->name, 0444, pmbus_show_boolean, NULL,
1072                         (reg << 16) | mask);
1073
1074         return pmbus_add_attribute(data, &a->dev_attr.attr);
1075 }
1076
1077 static struct pmbus_sensor *pmbus_add_sensor(struct pmbus_data *data,
1078                                              const char *name, const char *type,
1079                                              int seq, int page, int reg,
1080                                              enum pmbus_sensor_classes class,
1081                                              bool update, bool readonly,
1082                                              bool convert)
1083 {
1084         struct pmbus_sensor *sensor;
1085         struct device_attribute *a;
1086
1087         sensor = devm_kzalloc(data->dev, sizeof(*sensor), GFP_KERNEL);
1088         if (!sensor)
1089                 return NULL;
1090         a = &sensor->attribute;
1091
1092         if (type)
1093                 snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
1094                          name, seq, type);
1095         else
1096                 snprintf(sensor->name, sizeof(sensor->name), "%s%d",
1097                          name, seq);
1098
1099         if (data->flags & PMBUS_WRITE_PROTECTED)
1100                 readonly = true;
1101
1102         sensor->page = page;
1103         sensor->reg = reg;
1104         sensor->class = class;
1105         sensor->update = update;
1106         sensor->convert = convert;
1107         pmbus_dev_attr_init(a, sensor->name,
1108                             readonly ? 0444 : 0644,
1109                             pmbus_show_sensor, pmbus_set_sensor);
1110
1111         if (pmbus_add_attribute(data, &a->attr))
1112                 return NULL;
1113
1114         sensor->next = data->sensors;
1115         data->sensors = sensor;
1116
1117         return sensor;
1118 }
1119
1120 static int pmbus_add_label(struct pmbus_data *data,
1121                            const char *name, int seq,
1122                            const char *lstring, int index)
1123 {
1124         struct pmbus_label *label;
1125         struct device_attribute *a;
1126
1127         label = devm_kzalloc(data->dev, sizeof(*label), GFP_KERNEL);
1128         if (!label)
1129                 return -ENOMEM;
1130
1131         a = &label->attribute;
1132
1133         snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
1134         if (!index)
1135                 strncpy(label->label, lstring, sizeof(label->label) - 1);
1136         else
1137                 snprintf(label->label, sizeof(label->label), "%s%d", lstring,
1138                          index);
1139
1140         pmbus_dev_attr_init(a, label->name, 0444, pmbus_show_label, NULL);
1141         return pmbus_add_attribute(data, &a->attr);
1142 }
1143
1144 /*
1145  * Search for attributes. Allocate sensors, booleans, and labels as needed.
1146  */
1147
1148 /*
1149  * The pmbus_limit_attr structure describes a single limit attribute
1150  * and its associated alarm attribute.
1151  */
1152 struct pmbus_limit_attr {
1153         u16 reg;                /* Limit register */
1154         u16 sbit;               /* Alarm attribute status bit */
1155         bool update;            /* True if register needs updates */
1156         bool low;               /* True if low limit; for limits with compare
1157                                    functions only */
1158         const char *attr;       /* Attribute name */
1159         const char *alarm;      /* Alarm attribute name */
1160 };
1161
1162 /*
1163  * The pmbus_sensor_attr structure describes one sensor attribute. This
1164  * description includes a reference to the associated limit attributes.
1165  */
1166 struct pmbus_sensor_attr {
1167         u16 reg;                        /* sensor register */
1168         u16 gbit;                       /* generic status bit */
1169         u8 nlimit;                      /* # of limit registers */
1170         enum pmbus_sensor_classes class;/* sensor class */
1171         const char *label;              /* sensor label */
1172         bool paged;                     /* true if paged sensor */
1173         bool update;                    /* true if update needed */
1174         bool compare;                   /* true if compare function needed */
1175         u32 func;                       /* sensor mask */
1176         u32 sfunc;                      /* sensor status mask */
1177         int sbase;                      /* status base register */
1178         const struct pmbus_limit_attr *limit;/* limit registers */
1179 };
1180
1181 /*
1182  * Add a set of limit attributes and, if supported, the associated
1183  * alarm attributes.
1184  * returns 0 if no alarm register found, 1 if an alarm register was found,
1185  * < 0 on errors.
1186  */
1187 static int pmbus_add_limit_attrs(struct i2c_client *client,
1188                                  struct pmbus_data *data,
1189                                  const struct pmbus_driver_info *info,
1190                                  const char *name, int index, int page,
1191                                  struct pmbus_sensor *base,
1192                                  const struct pmbus_sensor_attr *attr)
1193 {
1194         const struct pmbus_limit_attr *l = attr->limit;
1195         int nlimit = attr->nlimit;
1196         int have_alarm = 0;
1197         int i, ret;
1198         struct pmbus_sensor *curr;
1199
1200         for (i = 0; i < nlimit; i++) {
1201                 if (pmbus_check_word_register(client, page, l->reg)) {
1202                         curr = pmbus_add_sensor(data, name, l->attr, index,
1203                                                 page, l->reg, attr->class,
1204                                                 attr->update || l->update,
1205                                                 false, true);
1206                         if (!curr)
1207                                 return -ENOMEM;
1208                         if (l->sbit && (info->func[page] & attr->sfunc)) {
1209                                 ret = pmbus_add_boolean(data, name,
1210                                         l->alarm, index,
1211                                         attr->compare ?  l->low ? curr : base
1212                                                       : NULL,
1213                                         attr->compare ? l->low ? base : curr
1214                                                       : NULL,
1215                                         attr->sbase + page, l->sbit);
1216                                 if (ret)
1217                                         return ret;
1218                                 have_alarm = 1;
1219                         }
1220                 }
1221                 l++;
1222         }
1223         return have_alarm;
1224 }
1225
1226 static int pmbus_add_sensor_attrs_one(struct i2c_client *client,
1227                                       struct pmbus_data *data,
1228                                       const struct pmbus_driver_info *info,
1229                                       const char *name,
1230                                       int index, int page,
1231                                       const struct pmbus_sensor_attr *attr,
1232                                       bool paged)
1233 {
1234         struct pmbus_sensor *base;
1235         bool upper = !!(attr->gbit & 0xff00);   /* need to check STATUS_WORD */
1236         int ret;
1237
1238         if (attr->label) {
1239                 ret = pmbus_add_label(data, name, index, attr->label,
1240                                       paged ? page + 1 : 0);
1241                 if (ret)
1242                         return ret;
1243         }
1244         base = pmbus_add_sensor(data, name, "input", index, page, attr->reg,
1245                                 attr->class, true, true, true);
1246         if (!base)
1247                 return -ENOMEM;
1248         if (attr->sfunc) {
1249                 ret = pmbus_add_limit_attrs(client, data, info, name,
1250                                             index, page, base, attr);
1251                 if (ret < 0)
1252                         return ret;
1253                 /*
1254                  * Add generic alarm attribute only if there are no individual
1255                  * alarm attributes, if there is a global alarm bit, and if
1256                  * the generic status register (word or byte, depending on
1257                  * which global bit is set) for this page is accessible.
1258                  */
1259                 if (!ret && attr->gbit &&
1260                     (!upper || (upper && data->has_status_word)) &&
1261                     pmbus_check_status_register(client, page)) {
1262                         ret = pmbus_add_boolean(data, name, "alarm", index,
1263                                                 NULL, NULL,
1264                                                 PB_STATUS_BASE + page,
1265                                                 attr->gbit);
1266                         if (ret)
1267                                 return ret;
1268                 }
1269         }
1270         return 0;
1271 }
1272
1273 static bool pmbus_sensor_is_paged(const struct pmbus_driver_info *info,
1274                                   const struct pmbus_sensor_attr *attr)
1275 {
1276         int p;
1277
1278         if (attr->paged)
1279                 return true;
1280
1281         /*
1282          * Some attributes may be present on more than one page despite
1283          * not being marked with the paged attribute. If that is the case,
1284          * then treat the sensor as being paged and add the page suffix to the
1285          * attribute name.
1286          * We don't just add the paged attribute to all such attributes, in
1287          * order to maintain the un-suffixed labels in the case where the
1288          * attribute is only on page 0.
1289          */
1290         for (p = 1; p < info->pages; p++) {
1291                 if (info->func[p] & attr->func)
1292                         return true;
1293         }
1294         return false;
1295 }
1296
1297 static int pmbus_add_sensor_attrs(struct i2c_client *client,
1298                                   struct pmbus_data *data,
1299                                   const char *name,
1300                                   const struct pmbus_sensor_attr *attrs,
1301                                   int nattrs)
1302 {
1303         const struct pmbus_driver_info *info = data->info;
1304         int index, i;
1305         int ret;
1306
1307         index = 1;
1308         for (i = 0; i < nattrs; i++) {
1309                 int page, pages;
1310                 bool paged = pmbus_sensor_is_paged(info, attrs);
1311
1312                 pages = paged ? info->pages : 1;
1313                 for (page = 0; page < pages; page++) {
1314                         if (!(info->func[page] & attrs->func))
1315                                 continue;
1316                         ret = pmbus_add_sensor_attrs_one(client, data, info,
1317                                                          name, index, page,
1318                                                          attrs, paged);
1319                         if (ret)
1320                                 return ret;
1321                         index++;
1322                 }
1323                 attrs++;
1324         }
1325         return 0;
1326 }
1327
1328 static const struct pmbus_limit_attr vin_limit_attrs[] = {
1329         {
1330                 .reg = PMBUS_VIN_UV_WARN_LIMIT,
1331                 .attr = "min",
1332                 .alarm = "min_alarm",
1333                 .sbit = PB_VOLTAGE_UV_WARNING,
1334         }, {
1335                 .reg = PMBUS_VIN_UV_FAULT_LIMIT,
1336                 .attr = "lcrit",
1337                 .alarm = "lcrit_alarm",
1338                 .sbit = PB_VOLTAGE_UV_FAULT,
1339         }, {
1340                 .reg = PMBUS_VIN_OV_WARN_LIMIT,
1341                 .attr = "max",
1342                 .alarm = "max_alarm",
1343                 .sbit = PB_VOLTAGE_OV_WARNING,
1344         }, {
1345                 .reg = PMBUS_VIN_OV_FAULT_LIMIT,
1346                 .attr = "crit",
1347                 .alarm = "crit_alarm",
1348                 .sbit = PB_VOLTAGE_OV_FAULT,
1349         }, {
1350                 .reg = PMBUS_VIRT_READ_VIN_AVG,
1351                 .update = true,
1352                 .attr = "average",
1353         }, {
1354                 .reg = PMBUS_VIRT_READ_VIN_MIN,
1355                 .update = true,
1356                 .attr = "lowest",
1357         }, {
1358                 .reg = PMBUS_VIRT_READ_VIN_MAX,
1359                 .update = true,
1360                 .attr = "highest",
1361         }, {
1362                 .reg = PMBUS_VIRT_RESET_VIN_HISTORY,
1363                 .attr = "reset_history",
1364         },
1365 };
1366
1367 static const struct pmbus_limit_attr vmon_limit_attrs[] = {
1368         {
1369                 .reg = PMBUS_VIRT_VMON_UV_WARN_LIMIT,
1370                 .attr = "min",
1371                 .alarm = "min_alarm",
1372                 .sbit = PB_VOLTAGE_UV_WARNING,
1373         }, {
1374                 .reg = PMBUS_VIRT_VMON_UV_FAULT_LIMIT,
1375                 .attr = "lcrit",
1376                 .alarm = "lcrit_alarm",
1377                 .sbit = PB_VOLTAGE_UV_FAULT,
1378         }, {
1379                 .reg = PMBUS_VIRT_VMON_OV_WARN_LIMIT,
1380                 .attr = "max",
1381                 .alarm = "max_alarm",
1382                 .sbit = PB_VOLTAGE_OV_WARNING,
1383         }, {
1384                 .reg = PMBUS_VIRT_VMON_OV_FAULT_LIMIT,
1385                 .attr = "crit",
1386                 .alarm = "crit_alarm",
1387                 .sbit = PB_VOLTAGE_OV_FAULT,
1388         }
1389 };
1390
1391 static const struct pmbus_limit_attr vout_limit_attrs[] = {
1392         {
1393                 .reg = PMBUS_VOUT_UV_WARN_LIMIT,
1394                 .attr = "min",
1395                 .alarm = "min_alarm",
1396                 .sbit = PB_VOLTAGE_UV_WARNING,
1397         }, {
1398                 .reg = PMBUS_VOUT_UV_FAULT_LIMIT,
1399                 .attr = "lcrit",
1400                 .alarm = "lcrit_alarm",
1401                 .sbit = PB_VOLTAGE_UV_FAULT,
1402         }, {
1403                 .reg = PMBUS_VOUT_OV_WARN_LIMIT,
1404                 .attr = "max",
1405                 .alarm = "max_alarm",
1406                 .sbit = PB_VOLTAGE_OV_WARNING,
1407         }, {
1408                 .reg = PMBUS_VOUT_OV_FAULT_LIMIT,
1409                 .attr = "crit",
1410                 .alarm = "crit_alarm",
1411                 .sbit = PB_VOLTAGE_OV_FAULT,
1412         }, {
1413                 .reg = PMBUS_VIRT_READ_VOUT_AVG,
1414                 .update = true,
1415                 .attr = "average",
1416         }, {
1417                 .reg = PMBUS_VIRT_READ_VOUT_MIN,
1418                 .update = true,
1419                 .attr = "lowest",
1420         }, {
1421                 .reg = PMBUS_VIRT_READ_VOUT_MAX,
1422                 .update = true,
1423                 .attr = "highest",
1424         }, {
1425                 .reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
1426                 .attr = "reset_history",
1427         }
1428 };
1429
1430 static const struct pmbus_sensor_attr voltage_attributes[] = {
1431         {
1432                 .reg = PMBUS_READ_VIN,
1433                 .class = PSC_VOLTAGE_IN,
1434                 .label = "vin",
1435                 .func = PMBUS_HAVE_VIN,
1436                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1437                 .sbase = PB_STATUS_INPUT_BASE,
1438                 .gbit = PB_STATUS_VIN_UV,
1439                 .limit = vin_limit_attrs,
1440                 .nlimit = ARRAY_SIZE(vin_limit_attrs),
1441         }, {
1442                 .reg = PMBUS_VIRT_READ_VMON,
1443                 .class = PSC_VOLTAGE_IN,
1444                 .label = "vmon",
1445                 .func = PMBUS_HAVE_VMON,
1446                 .sfunc = PMBUS_HAVE_STATUS_VMON,
1447                 .sbase = PB_STATUS_VMON_BASE,
1448                 .limit = vmon_limit_attrs,
1449                 .nlimit = ARRAY_SIZE(vmon_limit_attrs),
1450         }, {
1451                 .reg = PMBUS_READ_VCAP,
1452                 .class = PSC_VOLTAGE_IN,
1453                 .label = "vcap",
1454                 .func = PMBUS_HAVE_VCAP,
1455         }, {
1456                 .reg = PMBUS_READ_VOUT,
1457                 .class = PSC_VOLTAGE_OUT,
1458                 .label = "vout",
1459                 .paged = true,
1460                 .func = PMBUS_HAVE_VOUT,
1461                 .sfunc = PMBUS_HAVE_STATUS_VOUT,
1462                 .sbase = PB_STATUS_VOUT_BASE,
1463                 .gbit = PB_STATUS_VOUT_OV,
1464                 .limit = vout_limit_attrs,
1465                 .nlimit = ARRAY_SIZE(vout_limit_attrs),
1466         }
1467 };
1468
1469 /* Current attributes */
1470
1471 static const struct pmbus_limit_attr iin_limit_attrs[] = {
1472         {
1473                 .reg = PMBUS_IIN_OC_WARN_LIMIT,
1474                 .attr = "max",
1475                 .alarm = "max_alarm",
1476                 .sbit = PB_IIN_OC_WARNING,
1477         }, {
1478                 .reg = PMBUS_IIN_OC_FAULT_LIMIT,
1479                 .attr = "crit",
1480                 .alarm = "crit_alarm",
1481                 .sbit = PB_IIN_OC_FAULT,
1482         }, {
1483                 .reg = PMBUS_VIRT_READ_IIN_AVG,
1484                 .update = true,
1485                 .attr = "average",
1486         }, {
1487                 .reg = PMBUS_VIRT_READ_IIN_MIN,
1488                 .update = true,
1489                 .attr = "lowest",
1490         }, {
1491                 .reg = PMBUS_VIRT_READ_IIN_MAX,
1492                 .update = true,
1493                 .attr = "highest",
1494         }, {
1495                 .reg = PMBUS_VIRT_RESET_IIN_HISTORY,
1496                 .attr = "reset_history",
1497         }
1498 };
1499
1500 static const struct pmbus_limit_attr iout_limit_attrs[] = {
1501         {
1502                 .reg = PMBUS_IOUT_OC_WARN_LIMIT,
1503                 .attr = "max",
1504                 .alarm = "max_alarm",
1505                 .sbit = PB_IOUT_OC_WARNING,
1506         }, {
1507                 .reg = PMBUS_IOUT_UC_FAULT_LIMIT,
1508                 .attr = "lcrit",
1509                 .alarm = "lcrit_alarm",
1510                 .sbit = PB_IOUT_UC_FAULT,
1511         }, {
1512                 .reg = PMBUS_IOUT_OC_FAULT_LIMIT,
1513                 .attr = "crit",
1514                 .alarm = "crit_alarm",
1515                 .sbit = PB_IOUT_OC_FAULT,
1516         }, {
1517                 .reg = PMBUS_VIRT_READ_IOUT_AVG,
1518                 .update = true,
1519                 .attr = "average",
1520         }, {
1521                 .reg = PMBUS_VIRT_READ_IOUT_MIN,
1522                 .update = true,
1523                 .attr = "lowest",
1524         }, {
1525                 .reg = PMBUS_VIRT_READ_IOUT_MAX,
1526                 .update = true,
1527                 .attr = "highest",
1528         }, {
1529                 .reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
1530                 .attr = "reset_history",
1531         }
1532 };
1533
1534 static const struct pmbus_sensor_attr current_attributes[] = {
1535         {
1536                 .reg = PMBUS_READ_IIN,
1537                 .class = PSC_CURRENT_IN,
1538                 .label = "iin",
1539                 .func = PMBUS_HAVE_IIN,
1540                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1541                 .sbase = PB_STATUS_INPUT_BASE,
1542                 .gbit = PB_STATUS_INPUT,
1543                 .limit = iin_limit_attrs,
1544                 .nlimit = ARRAY_SIZE(iin_limit_attrs),
1545         }, {
1546                 .reg = PMBUS_READ_IOUT,
1547                 .class = PSC_CURRENT_OUT,
1548                 .label = "iout",
1549                 .paged = true,
1550                 .func = PMBUS_HAVE_IOUT,
1551                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1552                 .sbase = PB_STATUS_IOUT_BASE,
1553                 .gbit = PB_STATUS_IOUT_OC,
1554                 .limit = iout_limit_attrs,
1555                 .nlimit = ARRAY_SIZE(iout_limit_attrs),
1556         }
1557 };
1558
1559 /* Power attributes */
1560
1561 static const struct pmbus_limit_attr pin_limit_attrs[] = {
1562         {
1563                 .reg = PMBUS_PIN_OP_WARN_LIMIT,
1564                 .attr = "max",
1565                 .alarm = "alarm",
1566                 .sbit = PB_PIN_OP_WARNING,
1567         }, {
1568                 .reg = PMBUS_VIRT_READ_PIN_AVG,
1569                 .update = true,
1570                 .attr = "average",
1571         }, {
1572                 .reg = PMBUS_VIRT_READ_PIN_MIN,
1573                 .update = true,
1574                 .attr = "input_lowest",
1575         }, {
1576                 .reg = PMBUS_VIRT_READ_PIN_MAX,
1577                 .update = true,
1578                 .attr = "input_highest",
1579         }, {
1580                 .reg = PMBUS_VIRT_RESET_PIN_HISTORY,
1581                 .attr = "reset_history",
1582         }
1583 };
1584
1585 static const struct pmbus_limit_attr pout_limit_attrs[] = {
1586         {
1587                 .reg = PMBUS_POUT_MAX,
1588                 .attr = "cap",
1589                 .alarm = "cap_alarm",
1590                 .sbit = PB_POWER_LIMITING,
1591         }, {
1592                 .reg = PMBUS_POUT_OP_WARN_LIMIT,
1593                 .attr = "max",
1594                 .alarm = "max_alarm",
1595                 .sbit = PB_POUT_OP_WARNING,
1596         }, {
1597                 .reg = PMBUS_POUT_OP_FAULT_LIMIT,
1598                 .attr = "crit",
1599                 .alarm = "crit_alarm",
1600                 .sbit = PB_POUT_OP_FAULT,
1601         }, {
1602                 .reg = PMBUS_VIRT_READ_POUT_AVG,
1603                 .update = true,
1604                 .attr = "average",
1605         }, {
1606                 .reg = PMBUS_VIRT_READ_POUT_MIN,
1607                 .update = true,
1608                 .attr = "input_lowest",
1609         }, {
1610                 .reg = PMBUS_VIRT_READ_POUT_MAX,
1611                 .update = true,
1612                 .attr = "input_highest",
1613         }, {
1614                 .reg = PMBUS_VIRT_RESET_POUT_HISTORY,
1615                 .attr = "reset_history",
1616         }
1617 };
1618
1619 static const struct pmbus_sensor_attr power_attributes[] = {
1620         {
1621                 .reg = PMBUS_READ_PIN,
1622                 .class = PSC_POWER,
1623                 .label = "pin",
1624                 .func = PMBUS_HAVE_PIN,
1625                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1626                 .sbase = PB_STATUS_INPUT_BASE,
1627                 .gbit = PB_STATUS_INPUT,
1628                 .limit = pin_limit_attrs,
1629                 .nlimit = ARRAY_SIZE(pin_limit_attrs),
1630         }, {
1631                 .reg = PMBUS_READ_POUT,
1632                 .class = PSC_POWER,
1633                 .label = "pout",
1634                 .paged = true,
1635                 .func = PMBUS_HAVE_POUT,
1636                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1637                 .sbase = PB_STATUS_IOUT_BASE,
1638                 .limit = pout_limit_attrs,
1639                 .nlimit = ARRAY_SIZE(pout_limit_attrs),
1640         }
1641 };
1642
1643 /* Temperature atributes */
1644
1645 static const struct pmbus_limit_attr temp_limit_attrs[] = {
1646         {
1647                 .reg = PMBUS_UT_WARN_LIMIT,
1648                 .low = true,
1649                 .attr = "min",
1650                 .alarm = "min_alarm",
1651                 .sbit = PB_TEMP_UT_WARNING,
1652         }, {
1653                 .reg = PMBUS_UT_FAULT_LIMIT,
1654                 .low = true,
1655                 .attr = "lcrit",
1656                 .alarm = "lcrit_alarm",
1657                 .sbit = PB_TEMP_UT_FAULT,
1658         }, {
1659                 .reg = PMBUS_OT_WARN_LIMIT,
1660                 .attr = "max",
1661                 .alarm = "max_alarm",
1662                 .sbit = PB_TEMP_OT_WARNING,
1663         }, {
1664                 .reg = PMBUS_OT_FAULT_LIMIT,
1665                 .attr = "crit",
1666                 .alarm = "crit_alarm",
1667                 .sbit = PB_TEMP_OT_FAULT,
1668         }, {
1669                 .reg = PMBUS_VIRT_READ_TEMP_MIN,
1670                 .attr = "lowest",
1671         }, {
1672                 .reg = PMBUS_VIRT_READ_TEMP_AVG,
1673                 .attr = "average",
1674         }, {
1675                 .reg = PMBUS_VIRT_READ_TEMP_MAX,
1676                 .attr = "highest",
1677         }, {
1678                 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
1679                 .attr = "reset_history",
1680         }
1681 };
1682
1683 static const struct pmbus_limit_attr temp_limit_attrs2[] = {
1684         {
1685                 .reg = PMBUS_UT_WARN_LIMIT,
1686                 .low = true,
1687                 .attr = "min",
1688                 .alarm = "min_alarm",
1689                 .sbit = PB_TEMP_UT_WARNING,
1690         }, {
1691                 .reg = PMBUS_UT_FAULT_LIMIT,
1692                 .low = true,
1693                 .attr = "lcrit",
1694                 .alarm = "lcrit_alarm",
1695                 .sbit = PB_TEMP_UT_FAULT,
1696         }, {
1697                 .reg = PMBUS_OT_WARN_LIMIT,
1698                 .attr = "max",
1699                 .alarm = "max_alarm",
1700                 .sbit = PB_TEMP_OT_WARNING,
1701         }, {
1702                 .reg = PMBUS_OT_FAULT_LIMIT,
1703                 .attr = "crit",
1704                 .alarm = "crit_alarm",
1705                 .sbit = PB_TEMP_OT_FAULT,
1706         }, {
1707                 .reg = PMBUS_VIRT_READ_TEMP2_MIN,
1708                 .attr = "lowest",
1709         }, {
1710                 .reg = PMBUS_VIRT_READ_TEMP2_AVG,
1711                 .attr = "average",
1712         }, {
1713                 .reg = PMBUS_VIRT_READ_TEMP2_MAX,
1714                 .attr = "highest",
1715         }, {
1716                 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
1717                 .attr = "reset_history",
1718         }
1719 };
1720
1721 static const struct pmbus_limit_attr temp_limit_attrs3[] = {
1722         {
1723                 .reg = PMBUS_UT_WARN_LIMIT,
1724                 .low = true,
1725                 .attr = "min",
1726                 .alarm = "min_alarm",
1727                 .sbit = PB_TEMP_UT_WARNING,
1728         }, {
1729                 .reg = PMBUS_UT_FAULT_LIMIT,
1730                 .low = true,
1731                 .attr = "lcrit",
1732                 .alarm = "lcrit_alarm",
1733                 .sbit = PB_TEMP_UT_FAULT,
1734         }, {
1735                 .reg = PMBUS_OT_WARN_LIMIT,
1736                 .attr = "max",
1737                 .alarm = "max_alarm",
1738                 .sbit = PB_TEMP_OT_WARNING,
1739         }, {
1740                 .reg = PMBUS_OT_FAULT_LIMIT,
1741                 .attr = "crit",
1742                 .alarm = "crit_alarm",
1743                 .sbit = PB_TEMP_OT_FAULT,
1744         }
1745 };
1746
1747 static const struct pmbus_sensor_attr temp_attributes[] = {
1748         {
1749                 .reg = PMBUS_READ_TEMPERATURE_1,
1750                 .class = PSC_TEMPERATURE,
1751                 .paged = true,
1752                 .update = true,
1753                 .compare = true,
1754                 .func = PMBUS_HAVE_TEMP,
1755                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1756                 .sbase = PB_STATUS_TEMP_BASE,
1757                 .gbit = PB_STATUS_TEMPERATURE,
1758                 .limit = temp_limit_attrs,
1759                 .nlimit = ARRAY_SIZE(temp_limit_attrs),
1760         }, {
1761                 .reg = PMBUS_READ_TEMPERATURE_2,
1762                 .class = PSC_TEMPERATURE,
1763                 .paged = true,
1764                 .update = true,
1765                 .compare = true,
1766                 .func = PMBUS_HAVE_TEMP2,
1767                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1768                 .sbase = PB_STATUS_TEMP_BASE,
1769                 .gbit = PB_STATUS_TEMPERATURE,
1770                 .limit = temp_limit_attrs2,
1771                 .nlimit = ARRAY_SIZE(temp_limit_attrs2),
1772         }, {
1773                 .reg = PMBUS_READ_TEMPERATURE_3,
1774                 .class = PSC_TEMPERATURE,
1775                 .paged = true,
1776                 .update = true,
1777                 .compare = true,
1778                 .func = PMBUS_HAVE_TEMP3,
1779                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1780                 .sbase = PB_STATUS_TEMP_BASE,
1781                 .gbit = PB_STATUS_TEMPERATURE,
1782                 .limit = temp_limit_attrs3,
1783                 .nlimit = ARRAY_SIZE(temp_limit_attrs3),
1784         }
1785 };
1786
1787 static const int pmbus_fan_registers[] = {
1788         PMBUS_READ_FAN_SPEED_1,
1789         PMBUS_READ_FAN_SPEED_2,
1790         PMBUS_READ_FAN_SPEED_3,
1791         PMBUS_READ_FAN_SPEED_4
1792 };
1793
1794 static const int pmbus_fan_status_registers[] = {
1795         PMBUS_STATUS_FAN_12,
1796         PMBUS_STATUS_FAN_12,
1797         PMBUS_STATUS_FAN_34,
1798         PMBUS_STATUS_FAN_34
1799 };
1800
1801 static const u32 pmbus_fan_flags[] = {
1802         PMBUS_HAVE_FAN12,
1803         PMBUS_HAVE_FAN12,
1804         PMBUS_HAVE_FAN34,
1805         PMBUS_HAVE_FAN34
1806 };
1807
1808 static const u32 pmbus_fan_status_flags[] = {
1809         PMBUS_HAVE_STATUS_FAN12,
1810         PMBUS_HAVE_STATUS_FAN12,
1811         PMBUS_HAVE_STATUS_FAN34,
1812         PMBUS_HAVE_STATUS_FAN34
1813 };
1814
1815 /* Fans */
1816
1817 /* Precondition: FAN_CONFIG_x_y and FAN_COMMAND_x must exist for the fan ID */
1818 static int pmbus_add_fan_ctrl(struct i2c_client *client,
1819                 struct pmbus_data *data, int index, int page, int id,
1820                 u8 config)
1821 {
1822         struct pmbus_sensor *sensor;
1823
1824         sensor = pmbus_add_sensor(data, "fan", "target", index, page,
1825                                   PMBUS_VIRT_FAN_TARGET_1 + id, PSC_FAN,
1826                                   false, false, true);
1827
1828         if (!sensor)
1829                 return -ENOMEM;
1830
1831         if (!((data->info->func[page] & PMBUS_HAVE_PWM12) ||
1832                         (data->info->func[page] & PMBUS_HAVE_PWM34)))
1833                 return 0;
1834
1835         sensor = pmbus_add_sensor(data, "pwm", NULL, index, page,
1836                                   PMBUS_VIRT_PWM_1 + id, PSC_PWM,
1837                                   false, false, true);
1838
1839         if (!sensor)
1840                 return -ENOMEM;
1841
1842         sensor = pmbus_add_sensor(data, "pwm", "enable", index, page,
1843                                   PMBUS_VIRT_PWM_ENABLE_1 + id, PSC_PWM,
1844                                   true, false, false);
1845
1846         if (!sensor)
1847                 return -ENOMEM;
1848
1849         return 0;
1850 }
1851
1852 static int pmbus_add_fan_attributes(struct i2c_client *client,
1853                                     struct pmbus_data *data)
1854 {
1855         const struct pmbus_driver_info *info = data->info;
1856         int index = 1;
1857         int page;
1858         int ret;
1859
1860         for (page = 0; page < info->pages; page++) {
1861                 int f;
1862
1863                 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) {
1864                         int regval;
1865
1866                         if (!(info->func[page] & pmbus_fan_flags[f]))
1867                                 break;
1868
1869                         if (!pmbus_check_word_register(client, page,
1870                                                        pmbus_fan_registers[f]))
1871                                 break;
1872
1873                         /*
1874                          * Skip fan if not installed.
1875                          * Each fan configuration register covers multiple fans,
1876                          * so we have to do some magic.
1877                          */
1878                         regval = _pmbus_read_byte_data(client, page,
1879                                 pmbus_fan_config_registers[f]);
1880                         if (regval < 0 ||
1881                             (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
1882                                 continue;
1883
1884                         if (pmbus_add_sensor(data, "fan", "input", index,
1885                                              page, pmbus_fan_registers[f],
1886                                              PSC_FAN, true, true, true) == NULL)
1887                                 return -ENOMEM;
1888
1889                         /* Fan control */
1890                         if (pmbus_check_word_register(client, page,
1891                                         pmbus_fan_command_registers[f])) {
1892                                 ret = pmbus_add_fan_ctrl(client, data, index,
1893                                                          page, f, regval);
1894                                 if (ret < 0)
1895                                         return ret;
1896                         }
1897
1898                         /*
1899                          * Each fan status register covers multiple fans,
1900                          * so we have to do some magic.
1901                          */
1902                         if ((info->func[page] & pmbus_fan_status_flags[f]) &&
1903                             pmbus_check_byte_register(client,
1904                                         page, pmbus_fan_status_registers[f])) {
1905                                 int base;
1906
1907                                 if (f > 1)      /* fan 3, 4 */
1908                                         base = PB_STATUS_FAN34_BASE + page;
1909                                 else
1910                                         base = PB_STATUS_FAN_BASE + page;
1911                                 ret = pmbus_add_boolean(data, "fan",
1912                                         "alarm", index, NULL, NULL, base,
1913                                         PB_FAN_FAN1_WARNING >> (f & 1));
1914                                 if (ret)
1915                                         return ret;
1916                                 ret = pmbus_add_boolean(data, "fan",
1917                                         "fault", index, NULL, NULL, base,
1918                                         PB_FAN_FAN1_FAULT >> (f & 1));
1919                                 if (ret)
1920                                         return ret;
1921                         }
1922                         index++;
1923                 }
1924         }
1925         return 0;
1926 }
1927
1928 struct pmbus_samples_attr {
1929         int reg;
1930         char *name;
1931 };
1932
1933 struct pmbus_samples_reg {
1934         int page;
1935         struct pmbus_samples_attr *attr;
1936         struct device_attribute dev_attr;
1937 };
1938
1939 static struct pmbus_samples_attr pmbus_samples_registers[] = {
1940         {
1941                 .reg = PMBUS_VIRT_SAMPLES,
1942                 .name = "samples",
1943         }, {
1944                 .reg = PMBUS_VIRT_IN_SAMPLES,
1945                 .name = "in_samples",
1946         }, {
1947                 .reg = PMBUS_VIRT_CURR_SAMPLES,
1948                 .name = "curr_samples",
1949         }, {
1950                 .reg = PMBUS_VIRT_POWER_SAMPLES,
1951                 .name = "power_samples",
1952         }, {
1953                 .reg = PMBUS_VIRT_TEMP_SAMPLES,
1954                 .name = "temp_samples",
1955         }
1956 };
1957
1958 #define to_samples_reg(x) container_of(x, struct pmbus_samples_reg, dev_attr)
1959
1960 static ssize_t pmbus_show_samples(struct device *dev,
1961                                   struct device_attribute *devattr, char *buf)
1962 {
1963         int val;
1964         struct i2c_client *client = to_i2c_client(dev->parent);
1965         struct pmbus_samples_reg *reg = to_samples_reg(devattr);
1966
1967         val = _pmbus_read_word_data(client, reg->page, reg->attr->reg);
1968         if (val < 0)
1969                 return val;
1970
1971         return snprintf(buf, PAGE_SIZE, "%d\n", val);
1972 }
1973
1974 static ssize_t pmbus_set_samples(struct device *dev,
1975                                  struct device_attribute *devattr,
1976                                  const char *buf, size_t count)
1977 {
1978         int ret;
1979         long val;
1980         struct i2c_client *client = to_i2c_client(dev->parent);
1981         struct pmbus_samples_reg *reg = to_samples_reg(devattr);
1982         struct pmbus_data *data = i2c_get_clientdata(client);
1983
1984         if (kstrtol(buf, 0, &val) < 0)
1985                 return -EINVAL;
1986
1987         mutex_lock(&data->update_lock);
1988         ret = _pmbus_write_word_data(client, reg->page, reg->attr->reg, val);
1989         mutex_unlock(&data->update_lock);
1990
1991         return ret ? : count;
1992 }
1993
1994 static int pmbus_add_samples_attr(struct pmbus_data *data, int page,
1995                                   struct pmbus_samples_attr *attr)
1996 {
1997         struct pmbus_samples_reg *reg;
1998
1999         reg = devm_kzalloc(data->dev, sizeof(*reg), GFP_KERNEL);
2000         if (!reg)
2001                 return -ENOMEM;
2002
2003         reg->attr = attr;
2004         reg->page = page;
2005
2006         pmbus_dev_attr_init(&reg->dev_attr, attr->name, 0644,
2007                             pmbus_show_samples, pmbus_set_samples);
2008
2009         return pmbus_add_attribute(data, &reg->dev_attr.attr);
2010 }
2011
2012 static int pmbus_add_samples_attributes(struct i2c_client *client,
2013                                         struct pmbus_data *data)
2014 {
2015         const struct pmbus_driver_info *info = data->info;
2016         int s;
2017
2018         if (!(info->func[0] & PMBUS_HAVE_SAMPLES))
2019                 return 0;
2020
2021         for (s = 0; s < ARRAY_SIZE(pmbus_samples_registers); s++) {
2022                 struct pmbus_samples_attr *attr;
2023                 int ret;
2024
2025                 attr = &pmbus_samples_registers[s];
2026                 if (!pmbus_check_word_register(client, 0, attr->reg))
2027                         continue;
2028
2029                 ret = pmbus_add_samples_attr(data, 0, attr);
2030                 if (ret)
2031                         return ret;
2032         }
2033
2034         return 0;
2035 }
2036
2037 static int pmbus_find_attributes(struct i2c_client *client,
2038                                  struct pmbus_data *data)
2039 {
2040         int ret;
2041
2042         /* Voltage sensors */
2043         ret = pmbus_add_sensor_attrs(client, data, "in", voltage_attributes,
2044                                      ARRAY_SIZE(voltage_attributes));
2045         if (ret)
2046                 return ret;
2047
2048         /* Current sensors */
2049         ret = pmbus_add_sensor_attrs(client, data, "curr", current_attributes,
2050                                      ARRAY_SIZE(current_attributes));
2051         if (ret)
2052                 return ret;
2053
2054         /* Power sensors */
2055         ret = pmbus_add_sensor_attrs(client, data, "power", power_attributes,
2056                                      ARRAY_SIZE(power_attributes));
2057         if (ret)
2058                 return ret;
2059
2060         /* Temperature sensors */
2061         ret = pmbus_add_sensor_attrs(client, data, "temp", temp_attributes,
2062                                      ARRAY_SIZE(temp_attributes));
2063         if (ret)
2064                 return ret;
2065
2066         /* Fans */
2067         ret = pmbus_add_fan_attributes(client, data);
2068         if (ret)
2069                 return ret;
2070
2071         ret = pmbus_add_samples_attributes(client, data);
2072         return ret;
2073 }
2074
2075 /*
2076  * Identify chip parameters.
2077  * This function is called for all chips.
2078  */
2079 static int pmbus_identify_common(struct i2c_client *client,
2080                                  struct pmbus_data *data, int page)
2081 {
2082         int vout_mode = -1;
2083
2084         if (pmbus_check_byte_register(client, page, PMBUS_VOUT_MODE))
2085                 vout_mode = _pmbus_read_byte_data(client, page,
2086                                                   PMBUS_VOUT_MODE);
2087         if (vout_mode >= 0 && vout_mode != 0xff) {
2088                 /*
2089                  * Not all chips support the VOUT_MODE command,
2090                  * so a failure to read it is not an error.
2091                  */
2092                 switch (vout_mode >> 5) {
2093                 case 0: /* linear mode      */
2094                         if (data->info->format[PSC_VOLTAGE_OUT] != linear)
2095                                 return -ENODEV;
2096
2097                         data->exponent[page] = ((s8)(vout_mode << 3)) >> 3;
2098                         break;
2099                 case 1: /* VID mode         */
2100                         if (data->info->format[PSC_VOLTAGE_OUT] != vid)
2101                                 return -ENODEV;
2102                         break;
2103                 case 2: /* direct mode      */
2104                         if (data->info->format[PSC_VOLTAGE_OUT] != direct)
2105                                 return -ENODEV;
2106                         break;
2107                 default:
2108                         return -ENODEV;
2109                 }
2110         }
2111
2112         pmbus_clear_fault_page(client, page);
2113         return 0;
2114 }
2115
2116 static int pmbus_read_status_byte(struct i2c_client *client, int page)
2117 {
2118         return _pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
2119 }
2120
2121 static int pmbus_read_status_word(struct i2c_client *client, int page)
2122 {
2123         return _pmbus_read_word_data(client, page, PMBUS_STATUS_WORD);
2124 }
2125
2126 static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data,
2127                              struct pmbus_driver_info *info)
2128 {
2129         struct device *dev = &client->dev;
2130         int page, ret;
2131
2132         /*
2133          * Some PMBus chips don't support PMBUS_STATUS_WORD, so try
2134          * to use PMBUS_STATUS_BYTE instead if that is the case.
2135          * Bail out if both registers are not supported.
2136          */
2137         data->read_status = pmbus_read_status_word;
2138         ret = i2c_smbus_read_word_data(client, PMBUS_STATUS_WORD);
2139         if (ret < 0 || ret == 0xffff) {
2140                 data->read_status = pmbus_read_status_byte;
2141                 ret = i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE);
2142                 if (ret < 0 || ret == 0xff) {
2143                         dev_err(dev, "PMBus status register not found\n");
2144                         return -ENODEV;
2145                 }
2146         } else {
2147                 data->has_status_word = true;
2148         }
2149
2150         /* Enable PEC if the controller supports it */
2151         ret = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY);
2152         if (ret >= 0 && (ret & PB_CAPABILITY_ERROR_CHECK))
2153                 client->flags |= I2C_CLIENT_PEC;
2154
2155         /*
2156          * Check if the chip is write protected. If it is, we can not clear
2157          * faults, and we should not try it. Also, in that case, writes into
2158          * limit registers need to be disabled.
2159          */
2160         ret = i2c_smbus_read_byte_data(client, PMBUS_WRITE_PROTECT);
2161         if (ret > 0 && (ret & PB_WP_ANY))
2162                 data->flags |= PMBUS_WRITE_PROTECTED | PMBUS_SKIP_STATUS_CHECK;
2163
2164         if (data->info->pages)
2165                 pmbus_clear_faults(client);
2166         else
2167                 pmbus_clear_fault_page(client, -1);
2168
2169         if (info->identify) {
2170                 ret = (*info->identify)(client, info);
2171                 if (ret < 0) {
2172                         dev_err(dev, "Chip identification failed\n");
2173                         return ret;
2174                 }
2175         }
2176
2177         if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
2178                 dev_err(dev, "Bad number of PMBus pages: %d\n", info->pages);
2179                 return -ENODEV;
2180         }
2181
2182         for (page = 0; page < info->pages; page++) {
2183                 ret = pmbus_identify_common(client, data, page);
2184                 if (ret < 0) {
2185                         dev_err(dev, "Failed to identify chip capabilities\n");
2186                         return ret;
2187                 }
2188         }
2189         return 0;
2190 }
2191
2192 #if IS_ENABLED(CONFIG_REGULATOR)
2193 static int pmbus_regulator_is_enabled(struct regulator_dev *rdev)
2194 {
2195         struct device *dev = rdev_get_dev(rdev);
2196         struct i2c_client *client = to_i2c_client(dev->parent);
2197         u8 page = rdev_get_id(rdev);
2198         int ret;
2199
2200         ret = pmbus_read_byte_data(client, page, PMBUS_OPERATION);
2201         if (ret < 0)
2202                 return ret;
2203
2204         return !!(ret & PB_OPERATION_CONTROL_ON);
2205 }
2206
2207 static int _pmbus_regulator_on_off(struct regulator_dev *rdev, bool enable)
2208 {
2209         struct device *dev = rdev_get_dev(rdev);
2210         struct i2c_client *client = to_i2c_client(dev->parent);
2211         u8 page = rdev_get_id(rdev);
2212
2213         return pmbus_update_byte_data(client, page, PMBUS_OPERATION,
2214                                       PB_OPERATION_CONTROL_ON,
2215                                       enable ? PB_OPERATION_CONTROL_ON : 0);
2216 }
2217
2218 static int pmbus_regulator_enable(struct regulator_dev *rdev)
2219 {
2220         return _pmbus_regulator_on_off(rdev, 1);
2221 }
2222
2223 static int pmbus_regulator_disable(struct regulator_dev *rdev)
2224 {
2225         return _pmbus_regulator_on_off(rdev, 0);
2226 }
2227
2228 const struct regulator_ops pmbus_regulator_ops = {
2229         .enable = pmbus_regulator_enable,
2230         .disable = pmbus_regulator_disable,
2231         .is_enabled = pmbus_regulator_is_enabled,
2232 };
2233 EXPORT_SYMBOL_GPL(pmbus_regulator_ops);
2234
2235 static int pmbus_regulator_register(struct pmbus_data *data)
2236 {
2237         struct device *dev = data->dev;
2238         const struct pmbus_driver_info *info = data->info;
2239         const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
2240         struct regulator_dev *rdev;
2241         int i;
2242
2243         for (i = 0; i < info->num_regulators; i++) {
2244                 struct regulator_config config = { };
2245
2246                 config.dev = dev;
2247                 config.driver_data = data;
2248
2249                 if (pdata && pdata->reg_init_data)
2250                         config.init_data = &pdata->reg_init_data[i];
2251
2252                 rdev = devm_regulator_register(dev, &info->reg_desc[i],
2253                                                &config);
2254                 if (IS_ERR(rdev)) {
2255                         dev_err(dev, "Failed to register %s regulator\n",
2256                                 info->reg_desc[i].name);
2257                         return PTR_ERR(rdev);
2258                 }
2259         }
2260
2261         return 0;
2262 }
2263 #else
2264 static int pmbus_regulator_register(struct pmbus_data *data)
2265 {
2266         return 0;
2267 }
2268 #endif
2269
2270 static struct dentry *pmbus_debugfs_dir;        /* pmbus debugfs directory */
2271
2272 #if IS_ENABLED(CONFIG_DEBUG_FS)
2273 static int pmbus_debugfs_get(void *data, u64 *val)
2274 {
2275         int rc;
2276         struct pmbus_debugfs_entry *entry = data;
2277
2278         rc = _pmbus_read_byte_data(entry->client, entry->page, entry->reg);
2279         if (rc < 0)
2280                 return rc;
2281
2282         *val = rc;
2283
2284         return 0;
2285 }
2286 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops, pmbus_debugfs_get, NULL,
2287                          "0x%02llx\n");
2288
2289 static int pmbus_debugfs_get_status(void *data, u64 *val)
2290 {
2291         int rc;
2292         struct pmbus_debugfs_entry *entry = data;
2293         struct pmbus_data *pdata = i2c_get_clientdata(entry->client);
2294
2295         rc = pdata->read_status(entry->client, entry->page);
2296         if (rc < 0)
2297                 return rc;
2298
2299         *val = rc;
2300
2301         return 0;
2302 }
2303 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_status, pmbus_debugfs_get_status,
2304                          NULL, "0x%04llx\n");
2305
2306 static int pmbus_init_debugfs(struct i2c_client *client,
2307                               struct pmbus_data *data)
2308 {
2309         int i, idx = 0;
2310         char name[PMBUS_NAME_SIZE];
2311         struct pmbus_debugfs_entry *entries;
2312
2313         if (!pmbus_debugfs_dir)
2314                 return -ENODEV;
2315
2316         /*
2317          * Create the debugfs directory for this device. Use the hwmon device
2318          * name to avoid conflicts (hwmon numbers are globally unique).
2319          */
2320         data->debugfs = debugfs_create_dir(dev_name(data->hwmon_dev),
2321                                            pmbus_debugfs_dir);
2322         if (IS_ERR_OR_NULL(data->debugfs)) {
2323                 data->debugfs = NULL;
2324                 return -ENODEV;
2325         }
2326
2327         /* Allocate the max possible entries we need. */
2328         entries = devm_kcalloc(data->dev,
2329                                data->info->pages * 10, sizeof(*entries),
2330                                GFP_KERNEL);
2331         if (!entries)
2332                 return -ENOMEM;
2333
2334         for (i = 0; i < data->info->pages; ++i) {
2335                 /* Check accessibility of status register if it's not page 0 */
2336                 if (!i || pmbus_check_status_register(client, i)) {
2337                         /* No need to set reg as we have special read op. */
2338                         entries[idx].client = client;
2339                         entries[idx].page = i;
2340                         scnprintf(name, PMBUS_NAME_SIZE, "status%d", i);
2341                         debugfs_create_file(name, 0444, data->debugfs,
2342                                             &entries[idx++],
2343                                             &pmbus_debugfs_ops_status);
2344                 }
2345
2346                 if (data->info->func[i] & PMBUS_HAVE_STATUS_VOUT) {
2347                         entries[idx].client = client;
2348                         entries[idx].page = i;
2349                         entries[idx].reg = PMBUS_STATUS_VOUT;
2350                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_vout", i);
2351                         debugfs_create_file(name, 0444, data->debugfs,
2352                                             &entries[idx++],
2353                                             &pmbus_debugfs_ops);
2354                 }
2355
2356                 if (data->info->func[i] & PMBUS_HAVE_STATUS_IOUT) {
2357                         entries[idx].client = client;
2358                         entries[idx].page = i;
2359                         entries[idx].reg = PMBUS_STATUS_IOUT;
2360                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_iout", i);
2361                         debugfs_create_file(name, 0444, data->debugfs,
2362                                             &entries[idx++],
2363                                             &pmbus_debugfs_ops);
2364                 }
2365
2366                 if (data->info->func[i] & PMBUS_HAVE_STATUS_INPUT) {
2367                         entries[idx].client = client;
2368                         entries[idx].page = i;
2369                         entries[idx].reg = PMBUS_STATUS_INPUT;
2370                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_input", i);
2371                         debugfs_create_file(name, 0444, data->debugfs,
2372                                             &entries[idx++],
2373                                             &pmbus_debugfs_ops);
2374                 }
2375
2376                 if (data->info->func[i] & PMBUS_HAVE_STATUS_TEMP) {
2377                         entries[idx].client = client;
2378                         entries[idx].page = i;
2379                         entries[idx].reg = PMBUS_STATUS_TEMPERATURE;
2380                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_temp", i);
2381                         debugfs_create_file(name, 0444, data->debugfs,
2382                                             &entries[idx++],
2383                                             &pmbus_debugfs_ops);
2384                 }
2385
2386                 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_CML)) {
2387                         entries[idx].client = client;
2388                         entries[idx].page = i;
2389                         entries[idx].reg = PMBUS_STATUS_CML;
2390                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_cml", i);
2391                         debugfs_create_file(name, 0444, data->debugfs,
2392                                             &entries[idx++],
2393                                             &pmbus_debugfs_ops);
2394                 }
2395
2396                 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_OTHER)) {
2397                         entries[idx].client = client;
2398                         entries[idx].page = i;
2399                         entries[idx].reg = PMBUS_STATUS_OTHER;
2400                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_other", i);
2401                         debugfs_create_file(name, 0444, data->debugfs,
2402                                             &entries[idx++],
2403                                             &pmbus_debugfs_ops);
2404                 }
2405
2406                 if (pmbus_check_byte_register(client, i,
2407                                               PMBUS_STATUS_MFR_SPECIFIC)) {
2408                         entries[idx].client = client;
2409                         entries[idx].page = i;
2410                         entries[idx].reg = PMBUS_STATUS_MFR_SPECIFIC;
2411                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_mfr", i);
2412                         debugfs_create_file(name, 0444, data->debugfs,
2413                                             &entries[idx++],
2414                                             &pmbus_debugfs_ops);
2415                 }
2416
2417                 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN12) {
2418                         entries[idx].client = client;
2419                         entries[idx].page = i;
2420                         entries[idx].reg = PMBUS_STATUS_FAN_12;
2421                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan12", i);
2422                         debugfs_create_file(name, 0444, data->debugfs,
2423                                             &entries[idx++],
2424                                             &pmbus_debugfs_ops);
2425                 }
2426
2427                 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN34) {
2428                         entries[idx].client = client;
2429                         entries[idx].page = i;
2430                         entries[idx].reg = PMBUS_STATUS_FAN_34;
2431                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan34", i);
2432                         debugfs_create_file(name, 0444, data->debugfs,
2433                                             &entries[idx++],
2434                                             &pmbus_debugfs_ops);
2435                 }
2436         }
2437
2438         return 0;
2439 }
2440 #else
2441 static int pmbus_init_debugfs(struct i2c_client *client,
2442                               struct pmbus_data *data)
2443 {
2444         return 0;
2445 }
2446 #endif  /* IS_ENABLED(CONFIG_DEBUG_FS) */
2447
2448 int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
2449                    struct pmbus_driver_info *info)
2450 {
2451         struct device *dev = &client->dev;
2452         const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
2453         struct pmbus_data *data;
2454         size_t groups_num = 0;
2455         int ret;
2456
2457         if (!info)
2458                 return -ENODEV;
2459
2460         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
2461                                      | I2C_FUNC_SMBUS_BYTE_DATA
2462                                      | I2C_FUNC_SMBUS_WORD_DATA))
2463                 return -ENODEV;
2464
2465         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
2466         if (!data)
2467                 return -ENOMEM;
2468
2469         if (info->groups)
2470                 while (info->groups[groups_num])
2471                         groups_num++;
2472
2473         data->groups = devm_kcalloc(dev, groups_num + 2, sizeof(void *),
2474                                     GFP_KERNEL);
2475         if (!data->groups)
2476                 return -ENOMEM;
2477
2478         i2c_set_clientdata(client, data);
2479         mutex_init(&data->update_lock);
2480         data->dev = dev;
2481
2482         if (pdata)
2483                 data->flags = pdata->flags;
2484         data->info = info;
2485
2486         ret = pmbus_init_common(client, data, info);
2487         if (ret < 0)
2488                 return ret;
2489
2490         ret = pmbus_find_attributes(client, data);
2491         if (ret)
2492                 goto out_kfree;
2493
2494         /*
2495          * If there are no attributes, something is wrong.
2496          * Bail out instead of trying to register nothing.
2497          */
2498         if (!data->num_attributes) {
2499                 dev_err(dev, "No attributes found\n");
2500                 ret = -ENODEV;
2501                 goto out_kfree;
2502         }
2503
2504         data->groups[0] = &data->group;
2505         memcpy(data->groups + 1, info->groups, sizeof(void *) * groups_num);
2506         data->hwmon_dev = hwmon_device_register_with_groups(dev, client->name,
2507                                                             data, data->groups);
2508         if (IS_ERR(data->hwmon_dev)) {
2509                 ret = PTR_ERR(data->hwmon_dev);
2510                 dev_err(dev, "Failed to register hwmon device\n");
2511                 goto out_kfree;
2512         }
2513
2514         ret = pmbus_regulator_register(data);
2515         if (ret)
2516                 goto out_unregister;
2517
2518         ret = pmbus_init_debugfs(client, data);
2519         if (ret)
2520                 dev_warn(dev, "Failed to register debugfs\n");
2521
2522         return 0;
2523
2524 out_unregister:
2525         hwmon_device_unregister(data->hwmon_dev);
2526 out_kfree:
2527         kfree(data->group.attrs);
2528         return ret;
2529 }
2530 EXPORT_SYMBOL_GPL(pmbus_do_probe);
2531
2532 int pmbus_do_remove(struct i2c_client *client)
2533 {
2534         struct pmbus_data *data = i2c_get_clientdata(client);
2535
2536         debugfs_remove_recursive(data->debugfs);
2537
2538         hwmon_device_unregister(data->hwmon_dev);
2539         kfree(data->group.attrs);
2540         return 0;
2541 }
2542 EXPORT_SYMBOL_GPL(pmbus_do_remove);
2543
2544 struct dentry *pmbus_get_debugfs_dir(struct i2c_client *client)
2545 {
2546         struct pmbus_data *data = i2c_get_clientdata(client);
2547
2548         return data->debugfs;
2549 }
2550 EXPORT_SYMBOL_GPL(pmbus_get_debugfs_dir);
2551
2552 static int __init pmbus_core_init(void)
2553 {
2554         pmbus_debugfs_dir = debugfs_create_dir("pmbus", NULL);
2555         if (IS_ERR(pmbus_debugfs_dir))
2556                 pmbus_debugfs_dir = NULL;
2557
2558         return 0;
2559 }
2560
2561 static void __exit pmbus_core_exit(void)
2562 {
2563         debugfs_remove_recursive(pmbus_debugfs_dir);
2564 }
2565
2566 module_init(pmbus_core_init);
2567 module_exit(pmbus_core_exit);
2568
2569 MODULE_AUTHOR("Guenter Roeck");
2570 MODULE_DESCRIPTION("PMBus core driver");
2571 MODULE_LICENSE("GPL");