drivers/hwmon/pmbus/pmbus_core.c

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