drivers/hwmon/pmbus/pmbus_core.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Hardware monitoring driver for PMBus devices
   4  *
   5  * Copyright (c) 2010, 2011 Ericsson AB.
   6  * Copyright (c) 2012 Guenter Roeck
   7  */
   8
   9 #include <linux/debugfs.h>
  10 #include <linux/delay.h>
  11 #include <linux/kernel.h>
  12 #include <linux/math64.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/err.h>
  16 #include <linux/slab.h>
  17 #include <linux/i2c.h>
  18 #include <linux/hwmon.h>
  19 #include <linux/hwmon-sysfs.h>
  20 #include <linux/pmbus.h>
  21 #include <linux/regulator/driver.h>
  22 #include <linux/regulator/machine.h>
  23 #include <linux/of.h>
  24 #include <linux/thermal.h>
  25 #include "pmbus.h"
  26
  27 /*
  28  * Number of additional attribute pointers to allocate
  29  * with each call to krealloc
  30  */
  31 #define PMBUS_ATTR_ALLOC_SIZE   32
  32 #define PMBUS_NAME_SIZE         24
  33
  34 static int wp = -1;
  35 module_param(wp, int, 0444);
  36
  37 struct pmbus_sensor {
  38         struct pmbus_sensor *next;
  39         char name[PMBUS_NAME_SIZE];     /* sysfs sensor name */
  40         struct device_attribute attribute;
  41         u8 page;                /* page number */
  42         u8 phase;               /* phase number, 0xff for all phases */
  43         u16 reg;                /* register */
  44         enum pmbus_sensor_classes class;        /* sensor class */
  45         bool update;            /* runtime sensor update needed */
  46         bool convert;           /* Whether or not to apply linear/vid/direct */
  47         int data;               /* Sensor data.
  48                                    Negative if there was a read error */
  49 };
  50 #define to_pmbus_sensor(_attr) \
  51         container_of(_attr, struct pmbus_sensor, attribute)
  52
  53 struct pmbus_boolean {
  54         char name[PMBUS_NAME_SIZE];     /* sysfs boolean name */
  55         struct sensor_device_attribute attribute;
  56         struct pmbus_sensor *s1;
  57         struct pmbus_sensor *s2;
  58 };
  59 #define to_pmbus_boolean(_attr) \
  60         container_of(_attr, struct pmbus_boolean, attribute)
  61
  62 struct pmbus_label {
  63         char name[PMBUS_NAME_SIZE];     /* sysfs label name */
  64         struct device_attribute attribute;
  65         char label[PMBUS_NAME_SIZE];    /* label */
  66 };
  67 #define to_pmbus_label(_attr) \
  68         container_of(_attr, struct pmbus_label, attribute)
  69
  70 /* Macros for converting between sensor index and register/page/status mask */
  71
  72 #define PB_STATUS_MASK  0xffff
  73 #define PB_REG_SHIFT    16
  74 #define PB_REG_MASK     0x3ff
  75 #define PB_PAGE_SHIFT   26
  76 #define PB_PAGE_MASK    0x3f
  77
  78 #define pb_reg_to_index(page, reg, mask)        (((page) << PB_PAGE_SHIFT) | \
  79                                                  ((reg) << PB_REG_SHIFT) | (mask))
  80
  81 #define pb_index_to_page(index)                 (((index) >> PB_PAGE_SHIFT) & PB_PAGE_MASK)
  82 #define pb_index_to_reg(index)                  (((index) >> PB_REG_SHIFT) & PB_REG_MASK)
  83 #define pb_index_to_mask(index)                 ((index) & PB_STATUS_MASK)
  84
  85 struct pmbus_data {
  86         struct device *dev;
  87         struct device *hwmon_dev;
  88         struct regulator_dev **rdevs;
  89
  90         u32 flags;              /* from platform data */
  91
  92         u8 revision;    /* The PMBus revision the device is compliant with */
  93
  94         int exponent[PMBUS_PAGES];
  95                                 /* linear mode: exponent for output voltages */
  96
  97         const struct pmbus_driver_info *info;
  98
  99         int max_attributes;
 100         int num_attributes;
 101         struct attribute_group group;
 102         const struct attribute_group **groups;
 103         struct dentry *debugfs;         /* debugfs device directory */
 104
 105         struct pmbus_sensor *sensors;
 106
 107         struct mutex update_lock;
 108
 109         bool has_status_word;           /* device uses STATUS_WORD register */
 110         int (*read_status)(struct i2c_client *client, int page);
 111
 112         s16 currpage;   /* current page, -1 for unknown/unset */
 113         s16 currphase;  /* current phase, 0xff for all, -1 for unknown/unset */
 114
 115         int vout_low[PMBUS_PAGES];      /* voltage low margin */
 116         int vout_high[PMBUS_PAGES];     /* voltage high margin */
 117         ktime_t write_time;             /* Last SMBUS write timestamp */
 118         ktime_t access_time;            /* Last SMBUS access timestamp */
 119 };
 120
 121 struct pmbus_debugfs_entry {
 122         struct i2c_client *client;
 123         u8 page;
 124         u8 reg;
 125 };
 126
 127 static const int pmbus_fan_rpm_mask[] = {
 128         PB_FAN_1_RPM,
 129         PB_FAN_2_RPM,
 130         PB_FAN_1_RPM,
 131         PB_FAN_2_RPM,
 132 };
 133
 134 static const int pmbus_fan_config_registers[] = {
 135         PMBUS_FAN_CONFIG_12,
 136         PMBUS_FAN_CONFIG_12,
 137         PMBUS_FAN_CONFIG_34,
 138         PMBUS_FAN_CONFIG_34
 139 };
 140
 141 static const int pmbus_fan_command_registers[] = {
 142         PMBUS_FAN_COMMAND_1,
 143         PMBUS_FAN_COMMAND_2,
 144         PMBUS_FAN_COMMAND_3,
 145         PMBUS_FAN_COMMAND_4,
 146 };
 147
 148 void pmbus_clear_cache(struct i2c_client *client)
 149 {
 150         struct pmbus_data *data = i2c_get_clientdata(client);
 151         struct pmbus_sensor *sensor;
 152
 153         for (sensor = data->sensors; sensor; sensor = sensor->next)
 154                 sensor->data = -ENODATA;
 155 }
 156 EXPORT_SYMBOL_NS_GPL(pmbus_clear_cache, "PMBUS");
 157
 158 void pmbus_set_update(struct i2c_client *client, u8 reg, bool update)
 159 {
 160         struct pmbus_data *data = i2c_get_clientdata(client);
 161         struct pmbus_sensor *sensor;
 162
 163         for (sensor = data->sensors; sensor; sensor = sensor->next)
 164                 if (sensor->reg == reg)
 165                         sensor->update = update;
 166 }
 167 EXPORT_SYMBOL_NS_GPL(pmbus_set_update, "PMBUS");
 168
 169 /* Some chips need a delay between accesses. */
 170 static void pmbus_wait(struct i2c_client *client)
 171 {
 172         struct pmbus_data *data = i2c_get_clientdata(client);
 173         const struct pmbus_driver_info *info = data->info;
 174         s64 delta;
 175
 176         if (info->access_delay) {
 177                 delta = ktime_us_delta(ktime_get(), data->access_time);
 178
 179                 if (delta < info->access_delay)
 180                         fsleep(info->access_delay - delta);
 181         } else if (info->write_delay) {
 182                 delta = ktime_us_delta(ktime_get(), data->write_time);
 183
 184                 if (delta < info->write_delay)
 185                         fsleep(info->write_delay - delta);
 186         }
 187 }
 188
 189 /* Sets the last accessed timestamp for pmbus_wait */
 190 static void pmbus_update_ts(struct i2c_client *client, bool write_op)
 191 {
 192         struct pmbus_data *data = i2c_get_clientdata(client);
 193         const struct pmbus_driver_info *info = data->info;
 194
 195         if (info->access_delay) {
 196                 data->access_time = ktime_get();
 197         } else if (info->write_delay && write_op) {
 198                 data->write_time = ktime_get();
 199         }
 200 }
 201
 202 int pmbus_set_page(struct i2c_client *client, int page, int phase)
 203 {
 204         struct pmbus_data *data = i2c_get_clientdata(client);
 205         int rv;
 206
 207         if (page < 0)
 208                 return 0;
 209
 210         if (!(data->info->func[page] & PMBUS_PAGE_VIRTUAL) &&
 211             data->info->pages > 1 && page != data->currpage) {
 212                 pmbus_wait(client);
 213                 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
 214                 pmbus_update_ts(client, true);
 215                 if (rv < 0)
 216                         return rv;
 217
 218                 pmbus_wait(client);
 219                 rv = i2c_smbus_read_byte_data(client, PMBUS_PAGE);
 220                 pmbus_update_ts(client, false);
 221                 if (rv < 0)
 222                         return rv;
 223
 224                 if (rv != page)
 225                         return -EIO;
 226         }
 227         data->currpage = page;
 228
 229         if (data->info->phases[page] && data->currphase != phase &&
 230             !(data->info->func[page] & PMBUS_PHASE_VIRTUAL)) {
 231                 pmbus_wait(client);
 232                 rv = i2c_smbus_write_byte_data(client, PMBUS_PHASE,
 233                                                phase);
 234                 pmbus_update_ts(client, true);
 235                 if (rv)
 236                         return rv;
 237         }
 238         data->currphase = phase;
 239
 240         return 0;
 241 }
 242 EXPORT_SYMBOL_NS_GPL(pmbus_set_page, "PMBUS");
 243
 244 int pmbus_write_byte(struct i2c_client *client, int page, u8 value)
 245 {
 246         int rv;
 247
 248         rv = pmbus_set_page(client, page, 0xff);
 249         if (rv < 0)
 250                 return rv;
 251
 252         pmbus_wait(client);
 253         rv = i2c_smbus_write_byte(client, value);
 254         pmbus_update_ts(client, true);
 255
 256         return rv;
 257 }
 258 EXPORT_SYMBOL_NS_GPL(pmbus_write_byte, "PMBUS");
 259
 260 /*
 261  * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if
 262  * a device specific mapping function exists and calls it if necessary.
 263  */
 264 static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value)
 265 {
 266         struct pmbus_data *data = i2c_get_clientdata(client);
 267         const struct pmbus_driver_info *info = data->info;
 268         int status;
 269
 270         if (info->write_byte) {
 271                 status = info->write_byte(client, page, value);
 272                 if (status != -ENODATA)
 273                         return status;
 274         }
 275         return pmbus_write_byte(client, page, value);
 276 }
 277
 278 int pmbus_write_word_data(struct i2c_client *client, int page, u8 reg,
 279                           u16 word)
 280 {
 281         int rv;
 282
 283         rv = pmbus_set_page(client, page, 0xff);
 284         if (rv < 0)
 285                 return rv;
 286
 287         pmbus_wait(client);
 288         rv = i2c_smbus_write_word_data(client, reg, word);
 289         pmbus_update_ts(client, true);
 290
 291         return rv;
 292 }
 293 EXPORT_SYMBOL_NS_GPL(pmbus_write_word_data, "PMBUS");
 294
 295
 296 static int pmbus_write_virt_reg(struct i2c_client *client, int page, int reg,
 297                                 u16 word)
 298 {
 299         int bit;
 300         int id;
 301         int rv;
 302
 303         switch (reg) {
 304         case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4:
 305                 id = reg - PMBUS_VIRT_FAN_TARGET_1;
 306                 bit = pmbus_fan_rpm_mask[id];
 307                 rv = pmbus_update_fan(client, page, id, bit, bit, word);
 308                 break;
 309         default:
 310                 rv = -ENXIO;
 311                 break;
 312         }
 313
 314         return rv;
 315 }
 316
 317 /*
 318  * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if
 319  * a device specific mapping function exists and calls it if necessary.
 320  */
 321 static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg,
 322                                   u16 word)
 323 {
 324         struct pmbus_data *data = i2c_get_clientdata(client);
 325         const struct pmbus_driver_info *info = data->info;
 326         int status;
 327
 328         if (info->write_word_data) {
 329                 status = info->write_word_data(client, page, reg, word);
 330                 if (status != -ENODATA)
 331                         return status;
 332         }
 333
 334         if (reg >= PMBUS_VIRT_BASE)
 335                 return pmbus_write_virt_reg(client, page, reg, word);
 336
 337         return pmbus_write_word_data(client, page, reg, word);
 338 }
 339
 340 /*
 341  * _pmbus_write_byte_data() is similar to pmbus_write_byte_data(), but checks if
 342  * a device specific mapping function exists and calls it if necessary.
 343  */
 344 static int _pmbus_write_byte_data(struct i2c_client *client, int page, int reg, u8 value)
 345 {
 346         struct pmbus_data *data = i2c_get_clientdata(client);
 347         const struct pmbus_driver_info *info = data->info;
 348         int status;
 349
 350         if (info->write_byte_data) {
 351                 status = info->write_byte_data(client, page, reg, value);
 352                 if (status != -ENODATA)
 353                         return status;
 354         }
 355         return pmbus_write_byte_data(client, page, reg, value);
 356 }
 357
 358 /*
 359  * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
 360  * a device specific mapping function exists and calls it if necessary.
 361  */
 362 static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg)
 363 {
 364         struct pmbus_data *data = i2c_get_clientdata(client);
 365         const struct pmbus_driver_info *info = data->info;
 366         int status;
 367
 368         if (info->read_byte_data) {
 369                 status = info->read_byte_data(client, page, reg);
 370                 if (status != -ENODATA)
 371                         return status;
 372         }
 373         return pmbus_read_byte_data(client, page, reg);
 374 }
 375
 376 int pmbus_update_fan(struct i2c_client *client, int page, int id,
 377                      u8 config, u8 mask, u16 command)
 378 {
 379         int from;
 380         int rv;
 381         u8 to;
 382
 383         from = _pmbus_read_byte_data(client, page,
 384                                     pmbus_fan_config_registers[id]);
 385         if (from < 0)
 386                 return from;
 387
 388         to = (from & ~mask) | (config & mask);
 389         if (to != from) {
 390                 rv = _pmbus_write_byte_data(client, page,
 391                                            pmbus_fan_config_registers[id], to);
 392                 if (rv < 0)
 393                         return rv;
 394         }
 395
 396         return _pmbus_write_word_data(client, page,
 397                                       pmbus_fan_command_registers[id], command);
 398 }
 399 EXPORT_SYMBOL_NS_GPL(pmbus_update_fan, "PMBUS");
 400
 401 int pmbus_read_word_data(struct i2c_client *client, int page, int phase, u8 reg)
 402 {
 403         int rv;
 404
 405         rv = pmbus_set_page(client, page, phase);
 406         if (rv < 0)
 407                 return rv;
 408
 409         pmbus_wait(client);
 410         rv = i2c_smbus_read_word_data(client, reg);
 411         pmbus_update_ts(client, false);
 412
 413         return rv;
 414 }
 415 EXPORT_SYMBOL_NS_GPL(pmbus_read_word_data, "PMBUS");
 416
 417 static int pmbus_read_virt_reg(struct i2c_client *client, int page, int reg)
 418 {
 419         int rv;
 420         int id;
 421
 422         switch (reg) {
 423         case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4:
 424                 id = reg - PMBUS_VIRT_FAN_TARGET_1;
 425                 rv = pmbus_get_fan_rate_device(client, page, id, rpm);
 426                 break;
 427         default:
 428                 rv = -ENXIO;
 429                 break;
 430         }
 431
 432         return rv;
 433 }
 434
 435 /*
 436  * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if
 437  * a device specific mapping function exists and calls it if necessary.
 438  */
 439 static int _pmbus_read_word_data(struct i2c_client *client, int page,
 440                                  int phase, int reg)
 441 {
 442         struct pmbus_data *data = i2c_get_clientdata(client);
 443         const struct pmbus_driver_info *info = data->info;
 444         int status;
 445
 446         if (info->read_word_data) {
 447                 status = info->read_word_data(client, page, phase, reg);
 448                 if (status != -ENODATA)
 449                         return status;
 450         }
 451
 452         if (reg >= PMBUS_VIRT_BASE)
 453                 return pmbus_read_virt_reg(client, page, reg);
 454
 455         return pmbus_read_word_data(client, page, phase, reg);
 456 }
 457
 458 /* Same as above, but without phase parameter, for use in check functions */
 459 static int __pmbus_read_word_data(struct i2c_client *client, int page, int reg)
 460 {
 461         return _pmbus_read_word_data(client, page, 0xff, reg);
 462 }
 463
 464 int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg)
 465 {
 466         int rv;
 467
 468         rv = pmbus_set_page(client, page, 0xff);
 469         if (rv < 0)
 470                 return rv;
 471
 472         pmbus_wait(client);
 473         rv = i2c_smbus_read_byte_data(client, reg);
 474         pmbus_update_ts(client, false);
 475
 476         return rv;
 477 }
 478 EXPORT_SYMBOL_NS_GPL(pmbus_read_byte_data, "PMBUS");
 479
 480 int pmbus_write_byte_data(struct i2c_client *client, int page, u8 reg, u8 value)
 481 {
 482         int rv;
 483
 484         rv = pmbus_set_page(client, page, 0xff);
 485         if (rv < 0)
 486                 return rv;
 487
 488         pmbus_wait(client);
 489         rv = i2c_smbus_write_byte_data(client, reg, value);
 490         pmbus_update_ts(client, true);
 491
 492         return rv;
 493 }
 494 EXPORT_SYMBOL_NS_GPL(pmbus_write_byte_data, "PMBUS");
 495
 496 int pmbus_update_byte_data(struct i2c_client *client, int page, u8 reg,
 497                            u8 mask, u8 value)
 498 {
 499         unsigned int tmp;
 500         int rv;
 501
 502         rv = _pmbus_read_byte_data(client, page, reg);
 503         if (rv < 0)
 504                 return rv;
 505
 506         tmp = (rv & ~mask) | (value & mask);
 507
 508         if (tmp != rv)
 509                 rv = _pmbus_write_byte_data(client, page, reg, tmp);
 510
 511         return rv;
 512 }
 513 EXPORT_SYMBOL_NS_GPL(pmbus_update_byte_data, "PMBUS");
 514
 515 static int pmbus_read_block_data(struct i2c_client *client, int page, u8 reg,
 516                                  char *data_buf)
 517 {
 518         int rv;
 519
 520         rv = pmbus_set_page(client, page, 0xff);
 521         if (rv < 0)
 522                 return rv;
 523
 524         pmbus_wait(client);
 525         rv = i2c_smbus_read_block_data(client, reg, data_buf);
 526         pmbus_update_ts(client, false);
 527
 528         return rv;
 529 }
 530
 531 static struct pmbus_sensor *pmbus_find_sensor(struct pmbus_data *data, int page,
 532                                               int reg)
 533 {
 534         struct pmbus_sensor *sensor;
 535
 536         for (sensor = data->sensors; sensor; sensor = sensor->next) {
 537                 if (sensor->page == page && sensor->reg == reg)
 538                         return sensor;
 539         }
 540
 541         return ERR_PTR(-EINVAL);
 542 }
 543
 544 static int pmbus_get_fan_rate(struct i2c_client *client, int page, int id,
 545                               enum pmbus_fan_mode mode,
 546                               bool from_cache)
 547 {
 548         struct pmbus_data *data = i2c_get_clientdata(client);
 549         bool want_rpm, have_rpm;
 550         struct pmbus_sensor *s;
 551         int config;
 552         int reg;
 553
 554         want_rpm = (mode == rpm);
 555
 556         if (from_cache) {
 557                 reg = want_rpm ? PMBUS_VIRT_FAN_TARGET_1 : PMBUS_VIRT_PWM_1;
 558                 s = pmbus_find_sensor(data, page, reg + id);
 559                 if (IS_ERR(s))
 560                         return PTR_ERR(s);
 561
 562                 return s->data;
 563         }
 564
 565         config = _pmbus_read_byte_data(client, page,
 566                                       pmbus_fan_config_registers[id]);
 567         if (config < 0)
 568                 return config;
 569
 570         have_rpm = !!(config & pmbus_fan_rpm_mask[id]);
 571         if (want_rpm == have_rpm)
 572                 return pmbus_read_word_data(client, page, 0xff,
 573                                             pmbus_fan_command_registers[id]);
 574
 575         /* Can't sensibly map between RPM and PWM, just return zero */
 576         return 0;
 577 }
 578
 579 int pmbus_get_fan_rate_device(struct i2c_client *client, int page, int id,
 580                               enum pmbus_fan_mode mode)
 581 {
 582         return pmbus_get_fan_rate(client, page, id, mode, false);
 583 }
 584 EXPORT_SYMBOL_NS_GPL(pmbus_get_fan_rate_device, "PMBUS");
 585
 586 int pmbus_get_fan_rate_cached(struct i2c_client *client, int page, int id,
 587                               enum pmbus_fan_mode mode)
 588 {
 589         return pmbus_get_fan_rate(client, page, id, mode, true);
 590 }
 591 EXPORT_SYMBOL_NS_GPL(pmbus_get_fan_rate_cached, "PMBUS");
 592
 593 static void pmbus_clear_fault_page(struct i2c_client *client, int page)
 594 {
 595         _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
 596 }
 597
 598 void pmbus_clear_faults(struct i2c_client *client)
 599 {
 600         struct pmbus_data *data = i2c_get_clientdata(client);
 601         int i;
 602
 603         for (i = 0; i < data->info->pages; i++)
 604                 pmbus_clear_fault_page(client, i);
 605 }
 606 EXPORT_SYMBOL_NS_GPL(pmbus_clear_faults, "PMBUS");
 607
 608 static int pmbus_check_status_cml(struct i2c_client *client)
 609 {
 610         struct pmbus_data *data = i2c_get_clientdata(client);
 611         int status, status2;
 612
 613         status = data->read_status(client, -1);
 614         if (status < 0 || (status & PB_STATUS_CML)) {
 615                 status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
 616                 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND))
 617                         return -EIO;
 618         }
 619         return 0;
 620 }
 621
 622 static bool pmbus_check_register(struct i2c_client *client,
 623                                  int (*func)(struct i2c_client *client,
 624                                              int page, int reg),
 625                                  int page, int reg)
 626 {
 627         int rv;
 628         struct pmbus_data *data = i2c_get_clientdata(client);
 629
 630         rv = func(client, page, reg);
 631         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
 632                 rv = pmbus_check_status_cml(client);
 633         if (rv < 0 && (data->flags & PMBUS_READ_STATUS_AFTER_FAILED_CHECK))
 634                 data->read_status(client, -1);
 635         if (reg < PMBUS_VIRT_BASE)
 636                 pmbus_clear_fault_page(client, -1);
 637         return rv >= 0;
 638 }
 639
 640 static bool pmbus_check_status_register(struct i2c_client *client, int page)
 641 {
 642         int status;
 643         struct pmbus_data *data = i2c_get_clientdata(client);
 644
 645         status = data->read_status(client, page);
 646         if (status >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK) &&
 647             (status & PB_STATUS_CML)) {
 648                 status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
 649                 if (status < 0 || (status & PB_CML_FAULT_INVALID_COMMAND))
 650                         status = -EIO;
 651         }
 652
 653         pmbus_clear_fault_page(client, -1);
 654         return status >= 0;
 655 }
 656
 657 bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg)
 658 {
 659         return pmbus_check_register(client, _pmbus_read_byte_data, page, reg);
 660 }
 661 EXPORT_SYMBOL_NS_GPL(pmbus_check_byte_register, "PMBUS");
 662
 663 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
 664 {
 665         return pmbus_check_register(client, __pmbus_read_word_data, page, reg);
 666 }
 667 EXPORT_SYMBOL_NS_GPL(pmbus_check_word_register, "PMBUS");
 668
 669 static bool __maybe_unused pmbus_check_block_register(struct i2c_client *client,
 670                                                       int page, int reg)
 671 {
 672         int rv;
 673         struct pmbus_data *data = i2c_get_clientdata(client);
 674         char data_buf[I2C_SMBUS_BLOCK_MAX + 2];
 675
 676         rv = pmbus_read_block_data(client, page, reg, data_buf);
 677         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
 678                 rv = pmbus_check_status_cml(client);
 679         if (rv < 0 && (data->flags & PMBUS_READ_STATUS_AFTER_FAILED_CHECK))
 680                 data->read_status(client, -1);
 681         pmbus_clear_fault_page(client, -1);
 682         return rv >= 0;
 683 }
 684
 685 const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client *client)
 686 {
 687         struct pmbus_data *data = i2c_get_clientdata(client);
 688
 689         return data->info;
 690 }
 691 EXPORT_SYMBOL_NS_GPL(pmbus_get_driver_info, "PMBUS");
 692
 693 static int pmbus_get_status(struct i2c_client *client, int page, int reg)
 694 {
 695         struct pmbus_data *data = i2c_get_clientdata(client);
 696         int status;
 697
 698         switch (reg) {
 699         case PMBUS_STATUS_WORD:
 700                 status = data->read_status(client, page);
 701                 break;
 702         default:
 703                 status = _pmbus_read_byte_data(client, page, reg);
 704                 break;
 705         }
 706         if (status < 0)
 707                 pmbus_clear_faults(client);
 708         return status;
 709 }
 710
 711 static void pmbus_update_sensor_data(struct i2c_client *client, struct pmbus_sensor *sensor)
 712 {
 713         if (sensor->data < 0 || sensor->update)
 714                 sensor->data = _pmbus_read_word_data(client, sensor->page,
 715                                                      sensor->phase, sensor->reg);
 716 }
 717
 718 /*
 719  * Convert ieee754 sensor values to milli- or micro-units
 720  * depending on sensor type.
 721  *
 722  * ieee754 data format:
 723  *      bit 15:         sign
 724  *      bit 10..14:     exponent
 725  *      bit 0..9:       mantissa
 726  * exponent=0:
 727  *      v=(−1)^signbit * 2^(−14) * 0.significantbits
 728  * exponent=1..30:
 729  *      v=(−1)^signbit * 2^(exponent - 15) * 1.significantbits
 730  * exponent=31:
 731  *      v=NaN
 732  *
 733  * Add the number mantissa bits into the calculations for simplicity.
 734  * To do that, add '10' to the exponent. By doing that, we can just add
 735  * 0x400 to normal values and get the expected result.
 736  */
 737 static long pmbus_reg2data_ieee754(struct pmbus_data *data,
 738                                    struct pmbus_sensor *sensor)
 739 {
 740         int exponent;
 741         bool sign;
 742         long val;
 743
 744         /* only support half precision for now */
 745         sign = sensor->data & 0x8000;
 746         exponent = (sensor->data >> 10) & 0x1f;
 747         val = sensor->data & 0x3ff;
 748
 749         if (exponent == 0) {                    /* subnormal */
 750                 exponent = -(14 + 10);
 751         } else if (exponent ==  0x1f) {         /* NaN, convert to min/max */
 752                 exponent = 0;
 753                 val = 65504;
 754         } else {
 755                 exponent -= (15 + 10);          /* normal */
 756                 val |= 0x400;
 757         }
 758
 759         /* scale result to milli-units for all sensors except fans */
 760         if (sensor->class != PSC_FAN)
 761                 val = val * 1000L;
 762
 763         /* scale result to micro-units for power sensors */
 764         if (sensor->class == PSC_POWER)
 765                 val = val * 1000L;
 766
 767         if (exponent >= 0)
 768                 val <<= exponent;
 769         else
 770                 val >>= -exponent;
 771
 772         if (sign)
 773                 val = -val;
 774
 775         return val;
 776 }
 777
 778 /*
 779  * Convert linear sensor values to milli- or micro-units
 780  * depending on sensor type.
 781  */
 782 static s64 pmbus_reg2data_linear(struct pmbus_data *data,
 783                                  struct pmbus_sensor *sensor)
 784 {
 785         s16 exponent;
 786         s32 mantissa;
 787         s64 val;
 788
 789         if (sensor->class == PSC_VOLTAGE_OUT) { /* LINEAR16 */
 790                 exponent = data->exponent[sensor->page];
 791                 mantissa = (u16) sensor->data;
 792         } else {                                /* LINEAR11 */
 793                 exponent = ((s16)sensor->data) >> 11;
 794                 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5;
 795         }
 796
 797         val = mantissa;
 798
 799         /* scale result to milli-units for all sensors except fans */
 800         if (sensor->class != PSC_FAN)
 801                 val = val * 1000LL;
 802
 803         /* scale result to micro-units for power sensors */
 804         if (sensor->class == PSC_POWER)
 805                 val = val * 1000LL;
 806
 807         if (exponent >= 0)
 808                 val <<= exponent;
 809         else
 810                 val >>= -exponent;
 811
 812         return val;
 813 }
 814
 815 /*
 816  * Convert direct sensor values to milli- or micro-units
 817  * depending on sensor type.
 818  */
 819 static s64 pmbus_reg2data_direct(struct pmbus_data *data,
 820                                  struct pmbus_sensor *sensor)
 821 {
 822         s64 b, val = (s16)sensor->data;
 823         s32 m, R;
 824
 825         m = data->info->m[sensor->class];
 826         b = data->info->b[sensor->class];
 827         R = data->info->R[sensor->class];
 828
 829         if (m == 0)
 830                 return 0;
 831
 832         /* X = 1/m * (Y * 10^-R - b) */
 833         R = -R;
 834         /* scale result to milli-units for everything but fans */
 835         if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) {
 836                 R += 3;
 837                 b *= 1000;
 838         }
 839
 840         /* scale result to micro-units for power sensors */
 841         if (sensor->class == PSC_POWER) {
 842                 R += 3;
 843                 b *= 1000;
 844         }
 845
 846         while (R > 0) {
 847                 val *= 10;
 848                 R--;
 849         }
 850         while (R < 0) {
 851                 val = div_s64(val + 5LL, 10L);  /* round closest */
 852                 R++;
 853         }
 854
 855         val = div_s64(val - b, m);
 856         return val;
 857 }
 858
 859 /*
 860  * Convert VID sensor values to milli- or micro-units
 861  * depending on sensor type.
 862  */
 863 static s64 pmbus_reg2data_vid(struct pmbus_data *data,
 864                               struct pmbus_sensor *sensor)
 865 {
 866         long val = sensor->data;
 867         long rv = 0;
 868
 869         switch (data->info->vrm_version[sensor->page]) {
 870         case vr11:
 871                 if (val >= 0x02 && val <= 0xb2)
 872                         rv = DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100);
 873                 break;
 874         case vr12:
 875                 if (val >= 0x01)
 876                         rv = 250 + (val - 1) * 5;
 877                 break;
 878         case vr13:
 879                 if (val >= 0x01)
 880                         rv = 500 + (val - 1) * 10;
 881                 break;
 882         case imvp9:
 883                 if (val >= 0x01)
 884                         rv = 200 + (val - 1) * 10;
 885                 break;
 886         case amd625mv:
 887                 if (val >= 0x0 && val <= 0xd8)
 888                         rv = DIV_ROUND_CLOSEST(155000 - val * 625, 100);
 889                 break;
 890         }
 891         return rv;
 892 }
 893
 894 static s64 pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
 895 {
 896         s64 val;
 897
 898         if (!sensor->convert)
 899                 return sensor->data;
 900
 901         switch (data->info->format[sensor->class]) {
 902         case direct:
 903                 val = pmbus_reg2data_direct(data, sensor);
 904                 break;
 905         case vid:
 906                 val = pmbus_reg2data_vid(data, sensor);
 907                 break;
 908         case ieee754:
 909                 val = pmbus_reg2data_ieee754(data, sensor);
 910                 break;
 911         case linear:
 912         default:
 913                 val = pmbus_reg2data_linear(data, sensor);
 914                 break;
 915         }
 916         return val;
 917 }
 918
 919 #define MAX_IEEE_MANTISSA       (0x7ff * 1000)
 920 #define MIN_IEEE_MANTISSA       (0x400 * 1000)
 921
 922 static u16 pmbus_data2reg_ieee754(struct pmbus_data *data,
 923                                   struct pmbus_sensor *sensor, long val)
 924 {
 925         u16 exponent = (15 + 10);
 926         long mantissa;
 927         u16 sign = 0;
 928
 929         /* simple case */
 930         if (val == 0)
 931                 return 0;
 932
 933         if (val < 0) {
 934                 sign = 0x8000;
 935                 val = -val;
 936         }
 937
 938         /* Power is in uW. Convert to mW before converting. */
 939         if (sensor->class == PSC_POWER)
 940                 val = DIV_ROUND_CLOSEST(val, 1000L);
 941
 942         /*
 943          * For simplicity, convert fan data to milli-units
 944          * before calculating the exponent.
 945          */
 946         if (sensor->class == PSC_FAN)
 947                 val = val * 1000;
 948
 949         /* Reduce large mantissa until it fits into 10 bit */
 950         while (val > MAX_IEEE_MANTISSA && exponent < 30) {
 951                 exponent++;
 952                 val >>= 1;
 953         }
 954         /*
 955          * Increase small mantissa to generate valid 'normal'
 956          * number
 957          */
 958         while (val < MIN_IEEE_MANTISSA && exponent > 1) {
 959                 exponent--;
 960                 val <<= 1;
 961         }
 962
 963         /* Convert mantissa from milli-units to units */
 964         mantissa = DIV_ROUND_CLOSEST(val, 1000);
 965
 966         /*
 967          * Ensure that the resulting number is within range.
 968          * Valid range is 0x400..0x7ff, where bit 10 reflects
 969          * the implied high bit in normalized ieee754 numbers.
 970          * Set the range to 0x400..0x7ff to reflect this.
 971          * The upper bit is then removed by the mask against
 972          * 0x3ff in the final assignment.
 973          */
 974         if (mantissa > 0x7ff)
 975                 mantissa = 0x7ff;
 976         else if (mantissa < 0x400)
 977                 mantissa = 0x400;
 978
 979         /* Convert to sign, 5 bit exponent, 10 bit mantissa */
 980         return sign | (mantissa & 0x3ff) | ((exponent << 10) & 0x7c00);
 981 }
 982
 983 #define MAX_LIN_MANTISSA        (1023 * 1000)
 984 #define MIN_LIN_MANTISSA        (511 * 1000)
 985
 986 static u16 pmbus_data2reg_linear(struct pmbus_data *data,
 987                                  struct pmbus_sensor *sensor, s64 val)
 988 {
 989         s16 exponent = 0, mantissa;
 990         bool negative = false;
 991
 992         /* simple case */
 993         if (val == 0)
 994                 return 0;
 995
 996         if (sensor->class == PSC_VOLTAGE_OUT) {
 997                 /* LINEAR16 does not support negative voltages */
 998                 if (val < 0)
 999                         return 0;
1000
1001                 /*
1002                  * For a static exponents, we don't have a choice
1003                  * but to adjust the value to it.
1004                  */
1005                 if (data->exponent[sensor->page] < 0)
1006                         val <<= -data->exponent[sensor->page];
1007                 else
1008                         val >>= data->exponent[sensor->page];
1009                 val = DIV_ROUND_CLOSEST_ULL(val, 1000);
1010                 return clamp_val(val, 0, 0xffff);
1011         }
1012
1013         if (val < 0) {
1014                 negative = true;
1015                 val = -val;
1016         }
1017
1018         /* Power is in uW. Convert to mW before converting. */
1019         if (sensor->class == PSC_POWER)
1020                 val = DIV_ROUND_CLOSEST_ULL(val, 1000);
1021
1022         /*
1023          * For simplicity, convert fan data to milli-units
1024          * before calculating the exponent.
1025          */
1026         if (sensor->class == PSC_FAN)
1027                 val = val * 1000LL;
1028
1029         /* Reduce large mantissa until it fits into 10 bit */
1030         while (val >= MAX_LIN_MANTISSA && exponent < 15) {
1031                 exponent++;
1032                 val >>= 1;
1033         }
1034         /* Increase small mantissa to improve precision */
1035         while (val < MIN_LIN_MANTISSA && exponent > -15) {
1036                 exponent--;
1037                 val <<= 1;
1038         }
1039
1040         /* Convert mantissa from milli-units to units */
1041         mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff);
1042
1043         /* restore sign */
1044         if (negative)
1045                 mantissa = -mantissa;
1046
1047         /* Convert to 5 bit exponent, 11 bit mantissa */
1048         return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
1049 }
1050
1051 static u16 pmbus_data2reg_direct(struct pmbus_data *data,
1052                                  struct pmbus_sensor *sensor, s64 val)
1053 {
1054         s64 b;
1055         s32 m, R;
1056
1057         m = data->info->m[sensor->class];
1058         b = data->info->b[sensor->class];
1059         R = data->info->R[sensor->class];
1060
1061         /* Power is in uW. Adjust R and b. */
1062         if (sensor->class == PSC_POWER) {
1063                 R -= 3;
1064                 b *= 1000;
1065         }
1066
1067         /* Calculate Y = (m * X + b) * 10^R */
1068         if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) {
1069                 R -= 3;         /* Adjust R and b for data in milli-units */
1070                 b *= 1000;
1071         }
1072         val = val * m + b;
1073
1074         while (R > 0) {
1075                 val *= 10;
1076                 R--;
1077         }
1078         while (R < 0) {
1079                 val = div_s64(val + 5LL, 10L);  /* round closest */
1080                 R++;
1081         }
1082
1083         return (u16)clamp_val(val, S16_MIN, S16_MAX);
1084 }
1085
1086 static u16 pmbus_data2reg_vid(struct pmbus_data *data,
1087                               struct pmbus_sensor *sensor, s64 val)
1088 {
1089         val = clamp_val(val, 500, 1600);
1090
1091         return 2 + DIV_ROUND_CLOSEST_ULL((1600LL - val) * 100LL, 625);
1092 }
1093
1094 static u16 pmbus_data2reg(struct pmbus_data *data,
1095                           struct pmbus_sensor *sensor, s64 val)
1096 {
1097         u16 regval;
1098
1099         if (!sensor->convert)
1100                 return val;
1101
1102         switch (data->info->format[sensor->class]) {
1103         case direct:
1104                 regval = pmbus_data2reg_direct(data, sensor, val);
1105                 break;
1106         case vid:
1107                 regval = pmbus_data2reg_vid(data, sensor, val);
1108                 break;
1109         case ieee754:
1110                 regval = pmbus_data2reg_ieee754(data, sensor, val);
1111                 break;
1112         case linear:
1113         default:
1114                 regval = pmbus_data2reg_linear(data, sensor, val);
1115                 break;
1116         }
1117         return regval;
1118 }
1119
1120 /*
1121  * Return boolean calculated from converted data.
1122  * <index> defines a status register index and mask.
1123  * The mask is in the lower 8 bits, the register index is in bits 8..23.
1124  *
1125  * The associated pmbus_boolean structure contains optional pointers to two
1126  * sensor attributes. If specified, those attributes are compared against each
1127  * other to determine if a limit has been exceeded.
1128  *
1129  * If the sensor attribute pointers are NULL, the function returns true if
1130  * (status[reg] & mask) is true.
1131  *
1132  * If sensor attribute pointers are provided, a comparison against a specified
1133  * limit has to be performed to determine the boolean result.
1134  * In this case, the function returns true if v1 >= v2 (where v1 and v2 are
1135  * sensor values referenced by sensor attribute pointers s1 and s2).
1136  *
1137  * To determine if an object exceeds upper limits, specify <s1,s2> = <v,limit>.
1138  * To determine if an object exceeds lower limits, specify <s1,s2> = <limit,v>.
1139  *
1140  * If a negative value is stored in any of the referenced registers, this value
1141  * reflects an error code which will be returned.
1142  */
1143 static int pmbus_get_boolean(struct i2c_client *client, struct pmbus_boolean *b,
1144                              int index)
1145 {
1146         struct pmbus_data *data = i2c_get_clientdata(client);
1147         struct pmbus_sensor *s1 = b->s1;
1148         struct pmbus_sensor *s2 = b->s2;
1149         u16 mask = pb_index_to_mask(index);
1150         u8 page = pb_index_to_page(index);
1151         u16 reg = pb_index_to_reg(index);
1152         int ret, status;
1153         u16 regval;
1154
1155         mutex_lock(&data->update_lock);
1156         status = pmbus_get_status(client, page, reg);
1157         if (status < 0) {
1158                 ret = status;
1159                 goto unlock;
1160         }
1161
1162         if (s1)
1163                 pmbus_update_sensor_data(client, s1);
1164         if (s2)
1165                 pmbus_update_sensor_data(client, s2);
1166
1167         regval = status & mask;
1168         if (regval) {
1169                 if (data->revision >= PMBUS_REV_12) {
1170                         ret = _pmbus_write_byte_data(client, page, reg, regval);
1171                         if (ret)
1172                                 goto unlock;
1173                 } else {
1174                         pmbus_clear_fault_page(client, page);
1175                 }
1176
1177         }
1178         if (s1 && s2) {
1179                 s64 v1, v2;
1180
1181                 if (s1->data < 0) {
1182                         ret = s1->data;
1183                         goto unlock;
1184                 }
1185                 if (s2->data < 0) {
1186                         ret = s2->data;
1187                         goto unlock;
1188                 }
1189
1190                 v1 = pmbus_reg2data(data, s1);
1191                 v2 = pmbus_reg2data(data, s2);
1192                 ret = !!(regval && v1 >= v2);
1193         } else {
1194                 ret = !!regval;
1195         }
1196 unlock:
1197         mutex_unlock(&data->update_lock);
1198         return ret;
1199 }
1200
1201 static ssize_t pmbus_show_boolean(struct device *dev,
1202                                   struct device_attribute *da, char *buf)
1203 {
1204         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
1205         struct pmbus_boolean *boolean = to_pmbus_boolean(attr);
1206         struct i2c_client *client = to_i2c_client(dev->parent);
1207         int val;
1208
1209         val = pmbus_get_boolean(client, boolean, attr->index);
1210         if (val < 0)
1211                 return val;
1212         return sysfs_emit(buf, "%d\n", val);
1213 }
1214
1215 static ssize_t pmbus_show_sensor(struct device *dev,
1216                                  struct device_attribute *devattr, char *buf)
1217 {
1218         struct i2c_client *client = to_i2c_client(dev->parent);
1219         struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
1220         struct pmbus_data *data = i2c_get_clientdata(client);
1221         ssize_t ret;
1222
1223         mutex_lock(&data->update_lock);
1224         pmbus_update_sensor_data(client, sensor);
1225         if (sensor->data < 0)
1226                 ret = sensor->data;
1227         else
1228                 ret = sysfs_emit(buf, "%lld\n", pmbus_reg2data(data, sensor));
1229         mutex_unlock(&data->update_lock);
1230         return ret;
1231 }
1232
1233 static ssize_t pmbus_set_sensor(struct device *dev,
1234                                 struct device_attribute *devattr,
1235                                 const char *buf, size_t count)
1236 {
1237         struct i2c_client *client = to_i2c_client(dev->parent);
1238         struct pmbus_data *data = i2c_get_clientdata(client);
1239         struct pmbus_sensor *sensor = to_pmbus_sensor(devattr);
1240         ssize_t rv = count;
1241         s64 val;
1242         int ret;
1243         u16 regval;
1244
1245         if (kstrtos64(buf, 10, &val) < 0)
1246                 return -EINVAL;
1247
1248         mutex_lock(&data->update_lock);
1249         regval = pmbus_data2reg(data, sensor, val);
1250         ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
1251         if (ret < 0)
1252                 rv = ret;
1253         else
1254                 sensor->data = -ENODATA;
1255         mutex_unlock(&data->update_lock);
1256         return rv;
1257 }
1258
1259 static ssize_t pmbus_show_label(struct device *dev,
1260                                 struct device_attribute *da, char *buf)
1261 {
1262         struct pmbus_label *label = to_pmbus_label(da);
1263
1264         return sysfs_emit(buf, "%s\n", label->label);
1265 }
1266
1267 static int pmbus_add_attribute(struct pmbus_data *data, struct attribute *attr)
1268 {
1269         if (data->num_attributes >= data->max_attributes - 1) {
1270                 int new_max_attrs = data->max_attributes + PMBUS_ATTR_ALLOC_SIZE;
1271                 void *new_attrs = devm_krealloc_array(data->dev, data->group.attrs,
1272                                                       new_max_attrs, sizeof(void *),
1273                                                       GFP_KERNEL);
1274                 if (!new_attrs)
1275                         return -ENOMEM;
1276                 data->group.attrs = new_attrs;
1277                 data->max_attributes = new_max_attrs;
1278         }
1279
1280         data->group.attrs[data->num_attributes++] = attr;
1281         data->group.attrs[data->num_attributes] = NULL;
1282         return 0;
1283 }
1284
1285 static void pmbus_dev_attr_init(struct device_attribute *dev_attr,
1286                                 const char *name,
1287                                 umode_t mode,
1288                                 ssize_t (*show)(struct device *dev,
1289                                                 struct device_attribute *attr,
1290                                                 char *buf),
1291                                 ssize_t (*store)(struct device *dev,
1292                                                  struct device_attribute *attr,
1293                                                  const char *buf, size_t count))
1294 {
1295         sysfs_attr_init(&dev_attr->attr);
1296         dev_attr->attr.name = name;
1297         dev_attr->attr.mode = mode;
1298         dev_attr->show = show;
1299         dev_attr->store = store;
1300 }
1301
1302 static void pmbus_attr_init(struct sensor_device_attribute *a,
1303                             const char *name,
1304                             umode_t mode,
1305                             ssize_t (*show)(struct device *dev,
1306                                             struct device_attribute *attr,
1307                                             char *buf),
1308                             ssize_t (*store)(struct device *dev,
1309                                              struct device_attribute *attr,
1310                                              const char *buf, size_t count),
1311                             int idx)
1312 {
1313         pmbus_dev_attr_init(&a->dev_attr, name, mode, show, store);
1314         a->index = idx;
1315 }
1316
1317 static int pmbus_add_boolean(struct pmbus_data *data,
1318                              const char *name, const char *type, int seq,
1319                              struct pmbus_sensor *s1,
1320                              struct pmbus_sensor *s2,
1321                              u8 page, u16 reg, u16 mask)
1322 {
1323         struct pmbus_boolean *boolean;
1324         struct sensor_device_attribute *a;
1325
1326         if (WARN((s1 && !s2) || (!s1 && s2), "Bad s1/s2 parameters\n"))
1327                 return -EINVAL;
1328
1329         boolean = devm_kzalloc(data->dev, sizeof(*boolean), GFP_KERNEL);
1330         if (!boolean)
1331                 return -ENOMEM;
1332
1333         a = &boolean->attribute;
1334
1335         snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
1336                  name, seq, type);
1337         boolean->s1 = s1;
1338         boolean->s2 = s2;
1339         pmbus_attr_init(a, boolean->name, 0444, pmbus_show_boolean, NULL,
1340                         pb_reg_to_index(page, reg, mask));
1341
1342         return pmbus_add_attribute(data, &a->dev_attr.attr);
1343 }
1344
1345 /* of thermal for pmbus temperature sensors */
1346 struct pmbus_thermal_data {
1347         struct pmbus_data *pmbus_data;
1348         struct pmbus_sensor *sensor;
1349 };
1350
1351 static int pmbus_thermal_get_temp(struct thermal_zone_device *tz, int *temp)
1352 {
1353         struct pmbus_thermal_data *tdata = thermal_zone_device_priv(tz);
1354         struct pmbus_sensor *sensor = tdata->sensor;
1355         struct pmbus_data *pmbus_data = tdata->pmbus_data;
1356         struct i2c_client *client = to_i2c_client(pmbus_data->dev);
1357         struct device *dev = pmbus_data->hwmon_dev;
1358         int ret = 0;
1359
1360         if (!dev) {
1361                 /* May not even get to hwmon yet */
1362                 *temp = 0;
1363                 return 0;
1364         }
1365
1366         mutex_lock(&pmbus_data->update_lock);
1367         pmbus_update_sensor_data(client, sensor);
1368         if (sensor->data < 0)
1369                 ret = sensor->data;
1370         else
1371                 *temp = (int)pmbus_reg2data(pmbus_data, sensor);
1372         mutex_unlock(&pmbus_data->update_lock);
1373
1374         return ret;
1375 }
1376
1377 static const struct thermal_zone_device_ops pmbus_thermal_ops = {
1378         .get_temp = pmbus_thermal_get_temp,
1379 };
1380
1381 static int pmbus_thermal_add_sensor(struct pmbus_data *pmbus_data,
1382                                     struct pmbus_sensor *sensor, int index)
1383 {
1384         struct device *dev = pmbus_data->dev;
1385         struct pmbus_thermal_data *tdata;
1386         struct thermal_zone_device *tzd;
1387
1388         tdata = devm_kzalloc(dev, sizeof(*tdata), GFP_KERNEL);
1389         if (!tdata)
1390                 return -ENOMEM;
1391
1392         tdata->sensor = sensor;
1393         tdata->pmbus_data = pmbus_data;
1394
1395         tzd = devm_thermal_of_zone_register(dev, index, tdata,
1396                                             &pmbus_thermal_ops);
1397         /*
1398          * If CONFIG_THERMAL_OF is disabled, this returns -ENODEV,
1399          * so ignore that error but forward any other error.
1400          */
1401         if (IS_ERR(tzd) && (PTR_ERR(tzd) != -ENODEV))
1402                 return PTR_ERR(tzd);
1403
1404         return 0;
1405 }
1406
1407 static struct pmbus_sensor *pmbus_add_sensor(struct pmbus_data *data,
1408                                              const char *name, const char *type,
1409                                              int seq, int page, int phase,
1410                                              int reg,
1411                                              enum pmbus_sensor_classes class,
1412                                              bool update, bool readonly,
1413                                              bool convert)
1414 {
1415         struct pmbus_sensor *sensor;
1416         struct device_attribute *a;
1417
1418         sensor = devm_kzalloc(data->dev, sizeof(*sensor), GFP_KERNEL);
1419         if (!sensor)
1420                 return NULL;
1421         a = &sensor->attribute;
1422
1423         if (type)
1424                 snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
1425                          name, seq, type);
1426         else
1427                 snprintf(sensor->name, sizeof(sensor->name), "%s%d",
1428                          name, seq);
1429
1430         if (data->flags & PMBUS_WRITE_PROTECTED)
1431                 readonly = true;
1432
1433         sensor->page = page;
1434         sensor->phase = phase;
1435         sensor->reg = reg;
1436         sensor->class = class;
1437         sensor->update = update;
1438         sensor->convert = convert;
1439         sensor->data = -ENODATA;
1440         pmbus_dev_attr_init(a, sensor->name,
1441                             readonly ? 0444 : 0644,
1442                             pmbus_show_sensor, pmbus_set_sensor);
1443
1444         if (pmbus_add_attribute(data, &a->attr))
1445                 return NULL;
1446
1447         sensor->next = data->sensors;
1448         data->sensors = sensor;
1449
1450         /* temperature sensors with _input values are registered with thermal */
1451         if (class == PSC_TEMPERATURE && strcmp(type, "input") == 0)
1452                 pmbus_thermal_add_sensor(data, sensor, seq);
1453
1454         return sensor;
1455 }
1456
1457 static int pmbus_add_label(struct pmbus_data *data,
1458                            const char *name, int seq,
1459                            const char *lstring, int index, int phase)
1460 {
1461         struct pmbus_label *label;
1462         struct device_attribute *a;
1463
1464         label = devm_kzalloc(data->dev, sizeof(*label), GFP_KERNEL);
1465         if (!label)
1466                 return -ENOMEM;
1467
1468         a = &label->attribute;
1469
1470         snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
1471         if (!index) {
1472                 if (phase == 0xff)
1473                         strncpy(label->label, lstring,
1474                                 sizeof(label->label) - 1);
1475                 else
1476                         snprintf(label->label, sizeof(label->label), "%s.%d",
1477                                  lstring, phase);
1478         } else {
1479                 if (phase == 0xff)
1480                         snprintf(label->label, sizeof(label->label), "%s%d",
1481                                  lstring, index);
1482                 else
1483                         snprintf(label->label, sizeof(label->label), "%s%d.%d",
1484                                  lstring, index, phase);
1485         }
1486
1487         pmbus_dev_attr_init(a, label->name, 0444, pmbus_show_label, NULL);
1488         return pmbus_add_attribute(data, &a->attr);
1489 }
1490
1491 /*
1492  * Search for attributes. Allocate sensors, booleans, and labels as needed.
1493  */
1494
1495 /*
1496  * The pmbus_limit_attr structure describes a single limit attribute
1497  * and its associated alarm attribute.
1498  */
1499 struct pmbus_limit_attr {
1500         u16 reg;                /* Limit register */
1501         u16 sbit;               /* Alarm attribute status bit */
1502         bool update;            /* True if register needs updates */
1503         bool low;               /* True if low limit; for limits with compare
1504                                    functions only */
1505         const char *attr;       /* Attribute name */
1506         const char *alarm;      /* Alarm attribute name */
1507 };
1508
1509 /*
1510  * The pmbus_sensor_attr structure describes one sensor attribute. This
1511  * description includes a reference to the associated limit attributes.
1512  */
1513 struct pmbus_sensor_attr {
1514         u16 reg;                        /* sensor register */
1515         u16 gbit;                       /* generic status bit */
1516         u8 nlimit;                      /* # of limit registers */
1517         enum pmbus_sensor_classes class;/* sensor class */
1518         const char *label;              /* sensor label */
1519         bool paged;                     /* true if paged sensor */
1520         bool update;                    /* true if update needed */
1521         bool compare;                   /* true if compare function needed */
1522         u32 func;                       /* sensor mask */
1523         u32 sfunc;                      /* sensor status mask */
1524         int sreg;                       /* status register */
1525         const struct pmbus_limit_attr *limit;/* limit registers */
1526 };
1527
1528 /*
1529  * Add a set of limit attributes and, if supported, the associated
1530  * alarm attributes.
1531  * returns 0 if no alarm register found, 1 if an alarm register was found,
1532  * < 0 on errors.
1533  */
1534 static int pmbus_add_limit_attrs(struct i2c_client *client,
1535                                  struct pmbus_data *data,
1536                                  const struct pmbus_driver_info *info,
1537                                  const char *name, int index, int page,
1538                                  struct pmbus_sensor *base,
1539                                  const struct pmbus_sensor_attr *attr)
1540 {
1541         const struct pmbus_limit_attr *l = attr->limit;
1542         int nlimit = attr->nlimit;
1543         int have_alarm = 0;
1544         int i, ret;
1545         struct pmbus_sensor *curr;
1546
1547         for (i = 0; i < nlimit; i++) {
1548                 if (pmbus_check_word_register(client, page, l->reg)) {
1549                         curr = pmbus_add_sensor(data, name, l->attr, index,
1550                                                 page, 0xff, l->reg, attr->class,
1551                                                 attr->update || l->update,
1552                                                 false, true);
1553                         if (!curr)
1554                                 return -ENOMEM;
1555                         if (l->sbit && (info->func[page] & attr->sfunc)) {
1556                                 ret = pmbus_add_boolean(data, name,
1557                                         l->alarm, index,
1558                                         attr->compare ?  l->low ? curr : base
1559                                                       : NULL,
1560                                         attr->compare ? l->low ? base : curr
1561                                                       : NULL,
1562                                         page, attr->sreg, l->sbit);
1563                                 if (ret)
1564                                         return ret;
1565                                 have_alarm = 1;
1566                         }
1567                 }
1568                 l++;
1569         }
1570         return have_alarm;
1571 }
1572
1573 static int pmbus_add_sensor_attrs_one(struct i2c_client *client,
1574                                       struct pmbus_data *data,
1575                                       const struct pmbus_driver_info *info,
1576                                       const char *name,
1577                                       int index, int page, int phase,
1578                                       const struct pmbus_sensor_attr *attr,
1579                                       bool paged)
1580 {
1581         struct pmbus_sensor *base;
1582         bool upper = !!(attr->gbit & 0xff00);   /* need to check STATUS_WORD */
1583         int ret;
1584
1585         if (attr->label) {
1586                 ret = pmbus_add_label(data, name, index, attr->label,
1587                                       paged ? page + 1 : 0, phase);
1588                 if (ret)
1589                         return ret;
1590         }
1591         base = pmbus_add_sensor(data, name, "input", index, page, phase,
1592                                 attr->reg, attr->class, true, true, true);
1593         if (!base)
1594                 return -ENOMEM;
1595         /* No limit and alarm attributes for phase specific sensors */
1596         if (attr->sfunc && phase == 0xff) {
1597                 ret = pmbus_add_limit_attrs(client, data, info, name,
1598                                             index, page, base, attr);
1599                 if (ret < 0)
1600                         return ret;
1601                 /*
1602                  * Add generic alarm attribute only if there are no individual
1603                  * alarm attributes, if there is a global alarm bit, and if
1604                  * the generic status register (word or byte, depending on
1605                  * which global bit is set) for this page is accessible.
1606                  */
1607                 if (!ret && attr->gbit &&
1608                     (!upper || data->has_status_word) &&
1609                     pmbus_check_status_register(client, page)) {
1610                         ret = pmbus_add_boolean(data, name, "alarm", index,
1611                                                 NULL, NULL,
1612                                                 page, PMBUS_STATUS_WORD,
1613                                                 attr->gbit);
1614                         if (ret)
1615                                 return ret;
1616                 }
1617         }
1618         return 0;
1619 }
1620
1621 static bool pmbus_sensor_is_paged(const struct pmbus_driver_info *info,
1622                                   const struct pmbus_sensor_attr *attr)
1623 {
1624         int p;
1625
1626         if (attr->paged)
1627                 return true;
1628
1629         /*
1630          * Some attributes may be present on more than one page despite
1631          * not being marked with the paged attribute. If that is the case,
1632          * then treat the sensor as being paged and add the page suffix to the
1633          * attribute name.
1634          * We don't just add the paged attribute to all such attributes, in
1635          * order to maintain the un-suffixed labels in the case where the
1636          * attribute is only on page 0.
1637          */
1638         for (p = 1; p < info->pages; p++) {
1639                 if (info->func[p] & attr->func)
1640                         return true;
1641         }
1642         return false;
1643 }
1644
1645 static int pmbus_add_sensor_attrs(struct i2c_client *client,
1646                                   struct pmbus_data *data,
1647                                   const char *name,
1648                                   const struct pmbus_sensor_attr *attrs,
1649                                   int nattrs)
1650 {
1651         const struct pmbus_driver_info *info = data->info;
1652         int index, i;
1653         int ret;
1654
1655         index = 1;
1656         for (i = 0; i < nattrs; i++) {
1657                 int page, pages;
1658                 bool paged = pmbus_sensor_is_paged(info, attrs);
1659
1660                 pages = paged ? info->pages : 1;
1661                 for (page = 0; page < pages; page++) {
1662                         if (info->func[page] & attrs->func) {
1663                                 ret = pmbus_add_sensor_attrs_one(client, data, info,
1664                                                                  name, index, page,
1665                                                                  0xff, attrs, paged);
1666                                 if (ret)
1667                                         return ret;
1668                                 index++;
1669                         }
1670                         if (info->phases[page]) {
1671                                 int phase;
1672
1673                                 for (phase = 0; phase < info->phases[page];
1674                                      phase++) {
1675                                         if (!(info->pfunc[phase] & attrs->func))
1676                                                 continue;
1677                                         ret = pmbus_add_sensor_attrs_one(client,
1678                                                 data, info, name, index, page,
1679                                                 phase, attrs, paged);
1680                                         if (ret)
1681                                                 return ret;
1682                                         index++;
1683                                 }
1684                         }
1685                 }
1686                 attrs++;
1687         }
1688         return 0;
1689 }
1690
1691 static const struct pmbus_limit_attr vin_limit_attrs[] = {
1692         {
1693                 .reg = PMBUS_VIN_UV_WARN_LIMIT,
1694                 .attr = "min",
1695                 .alarm = "min_alarm",
1696                 .sbit = PB_VOLTAGE_UV_WARNING,
1697         }, {
1698                 .reg = PMBUS_VIN_UV_FAULT_LIMIT,
1699                 .attr = "lcrit",
1700                 .alarm = "lcrit_alarm",
1701                 .sbit = PB_VOLTAGE_UV_FAULT | PB_VOLTAGE_VIN_OFF,
1702         }, {
1703                 .reg = PMBUS_VIN_OV_WARN_LIMIT,
1704                 .attr = "max",
1705                 .alarm = "max_alarm",
1706                 .sbit = PB_VOLTAGE_OV_WARNING,
1707         }, {
1708                 .reg = PMBUS_VIN_OV_FAULT_LIMIT,
1709                 .attr = "crit",
1710                 .alarm = "crit_alarm",
1711                 .sbit = PB_VOLTAGE_OV_FAULT,
1712         }, {
1713                 .reg = PMBUS_VIRT_READ_VIN_AVG,
1714                 .update = true,
1715                 .attr = "average",
1716         }, {
1717                 .reg = PMBUS_VIRT_READ_VIN_MIN,
1718                 .update = true,
1719                 .attr = "lowest",
1720         }, {
1721                 .reg = PMBUS_VIRT_READ_VIN_MAX,
1722                 .update = true,
1723                 .attr = "highest",
1724         }, {
1725                 .reg = PMBUS_VIRT_RESET_VIN_HISTORY,
1726                 .attr = "reset_history",
1727         }, {
1728                 .reg = PMBUS_MFR_VIN_MIN,
1729                 .attr = "rated_min",
1730         }, {
1731                 .reg = PMBUS_MFR_VIN_MAX,
1732                 .attr = "rated_max",
1733         },
1734 };
1735
1736 static const struct pmbus_limit_attr vmon_limit_attrs[] = {
1737         {
1738                 .reg = PMBUS_VIRT_VMON_UV_WARN_LIMIT,
1739                 .attr = "min",
1740                 .alarm = "min_alarm",
1741                 .sbit = PB_VOLTAGE_UV_WARNING,
1742         }, {
1743                 .reg = PMBUS_VIRT_VMON_UV_FAULT_LIMIT,
1744                 .attr = "lcrit",
1745                 .alarm = "lcrit_alarm",
1746                 .sbit = PB_VOLTAGE_UV_FAULT,
1747         }, {
1748                 .reg = PMBUS_VIRT_VMON_OV_WARN_LIMIT,
1749                 .attr = "max",
1750                 .alarm = "max_alarm",
1751                 .sbit = PB_VOLTAGE_OV_WARNING,
1752         }, {
1753                 .reg = PMBUS_VIRT_VMON_OV_FAULT_LIMIT,
1754                 .attr = "crit",
1755                 .alarm = "crit_alarm",
1756                 .sbit = PB_VOLTAGE_OV_FAULT,
1757         }
1758 };
1759
1760 static const struct pmbus_limit_attr vout_limit_attrs[] = {
1761         {
1762                 .reg = PMBUS_VOUT_UV_WARN_LIMIT,
1763                 .attr = "min",
1764                 .alarm = "min_alarm",
1765                 .sbit = PB_VOLTAGE_UV_WARNING,
1766         }, {
1767                 .reg = PMBUS_VOUT_UV_FAULT_LIMIT,
1768                 .attr = "lcrit",
1769                 .alarm = "lcrit_alarm",
1770                 .sbit = PB_VOLTAGE_UV_FAULT,
1771         }, {
1772                 .reg = PMBUS_VOUT_OV_WARN_LIMIT,
1773                 .attr = "max",
1774                 .alarm = "max_alarm",
1775                 .sbit = PB_VOLTAGE_OV_WARNING,
1776         }, {
1777                 .reg = PMBUS_VOUT_OV_FAULT_LIMIT,
1778                 .attr = "crit",
1779                 .alarm = "crit_alarm",
1780                 .sbit = PB_VOLTAGE_OV_FAULT,
1781         }, {
1782                 .reg = PMBUS_VIRT_READ_VOUT_AVG,
1783                 .update = true,
1784                 .attr = "average",
1785         }, {
1786                 .reg = PMBUS_VIRT_READ_VOUT_MIN,
1787                 .update = true,
1788                 .attr = "lowest",
1789         }, {
1790                 .reg = PMBUS_VIRT_READ_VOUT_MAX,
1791                 .update = true,
1792                 .attr = "highest",
1793         }, {
1794                 .reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
1795                 .attr = "reset_history",
1796         }, {
1797                 .reg = PMBUS_MFR_VOUT_MIN,
1798                 .attr = "rated_min",
1799         }, {
1800                 .reg = PMBUS_MFR_VOUT_MAX,
1801                 .attr = "rated_max",
1802         },
1803 };
1804
1805 static const struct pmbus_sensor_attr voltage_attributes[] = {
1806         {
1807                 .reg = PMBUS_READ_VIN,
1808                 .class = PSC_VOLTAGE_IN,
1809                 .label = "vin",
1810                 .func = PMBUS_HAVE_VIN,
1811                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1812                 .sreg = PMBUS_STATUS_INPUT,
1813                 .gbit = PB_STATUS_VIN_UV,
1814                 .limit = vin_limit_attrs,
1815                 .nlimit = ARRAY_SIZE(vin_limit_attrs),
1816         }, {
1817                 .reg = PMBUS_VIRT_READ_VMON,
1818                 .class = PSC_VOLTAGE_IN,
1819                 .label = "vmon",
1820                 .func = PMBUS_HAVE_VMON,
1821                 .sfunc = PMBUS_HAVE_STATUS_VMON,
1822                 .sreg = PMBUS_VIRT_STATUS_VMON,
1823                 .limit = vmon_limit_attrs,
1824                 .nlimit = ARRAY_SIZE(vmon_limit_attrs),
1825         }, {
1826                 .reg = PMBUS_READ_VCAP,
1827                 .class = PSC_VOLTAGE_IN,
1828                 .label = "vcap",
1829                 .func = PMBUS_HAVE_VCAP,
1830         }, {
1831                 .reg = PMBUS_READ_VOUT,
1832                 .class = PSC_VOLTAGE_OUT,
1833                 .label = "vout",
1834                 .paged = true,
1835                 .func = PMBUS_HAVE_VOUT,
1836                 .sfunc = PMBUS_HAVE_STATUS_VOUT,
1837                 .sreg = PMBUS_STATUS_VOUT,
1838                 .gbit = PB_STATUS_VOUT_OV,
1839                 .limit = vout_limit_attrs,
1840                 .nlimit = ARRAY_SIZE(vout_limit_attrs),
1841         }
1842 };
1843
1844 /* Current attributes */
1845
1846 static const struct pmbus_limit_attr iin_limit_attrs[] = {
1847         {
1848                 .reg = PMBUS_IIN_OC_WARN_LIMIT,
1849                 .attr = "max",
1850                 .alarm = "max_alarm",
1851                 .sbit = PB_IIN_OC_WARNING,
1852         }, {
1853                 .reg = PMBUS_IIN_OC_FAULT_LIMIT,
1854                 .attr = "crit",
1855                 .alarm = "crit_alarm",
1856                 .sbit = PB_IIN_OC_FAULT,
1857         }, {
1858                 .reg = PMBUS_VIRT_READ_IIN_AVG,
1859                 .update = true,
1860                 .attr = "average",
1861         }, {
1862                 .reg = PMBUS_VIRT_READ_IIN_MIN,
1863                 .update = true,
1864                 .attr = "lowest",
1865         }, {
1866                 .reg = PMBUS_VIRT_READ_IIN_MAX,
1867                 .update = true,
1868                 .attr = "highest",
1869         }, {
1870                 .reg = PMBUS_VIRT_RESET_IIN_HISTORY,
1871                 .attr = "reset_history",
1872         }, {
1873                 .reg = PMBUS_MFR_IIN_MAX,
1874                 .attr = "rated_max",
1875         },
1876 };
1877
1878 static const struct pmbus_limit_attr iout_limit_attrs[] = {
1879         {
1880                 .reg = PMBUS_IOUT_OC_WARN_LIMIT,
1881                 .attr = "max",
1882                 .alarm = "max_alarm",
1883                 .sbit = PB_IOUT_OC_WARNING,
1884         }, {
1885                 .reg = PMBUS_IOUT_UC_FAULT_LIMIT,
1886                 .attr = "lcrit",
1887                 .alarm = "lcrit_alarm",
1888                 .sbit = PB_IOUT_UC_FAULT,
1889         }, {
1890                 .reg = PMBUS_IOUT_OC_FAULT_LIMIT,
1891                 .attr = "crit",
1892                 .alarm = "crit_alarm",
1893                 .sbit = PB_IOUT_OC_FAULT,
1894         }, {
1895                 .reg = PMBUS_VIRT_READ_IOUT_AVG,
1896                 .update = true,
1897                 .attr = "average",
1898         }, {
1899                 .reg = PMBUS_VIRT_READ_IOUT_MIN,
1900                 .update = true,
1901                 .attr = "lowest",
1902         }, {
1903                 .reg = PMBUS_VIRT_READ_IOUT_MAX,
1904                 .update = true,
1905                 .attr = "highest",
1906         }, {
1907                 .reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
1908                 .attr = "reset_history",
1909         }, {
1910                 .reg = PMBUS_MFR_IOUT_MAX,
1911                 .attr = "rated_max",
1912         },
1913 };
1914
1915 static const struct pmbus_sensor_attr current_attributes[] = {
1916         {
1917                 .reg = PMBUS_READ_IIN,
1918                 .class = PSC_CURRENT_IN,
1919                 .label = "iin",
1920                 .func = PMBUS_HAVE_IIN,
1921                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1922                 .sreg = PMBUS_STATUS_INPUT,
1923                 .gbit = PB_STATUS_INPUT,
1924                 .limit = iin_limit_attrs,
1925                 .nlimit = ARRAY_SIZE(iin_limit_attrs),
1926         }, {
1927                 .reg = PMBUS_READ_IOUT,
1928                 .class = PSC_CURRENT_OUT,
1929                 .label = "iout",
1930                 .paged = true,
1931                 .func = PMBUS_HAVE_IOUT,
1932                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1933                 .sreg = PMBUS_STATUS_IOUT,
1934                 .gbit = PB_STATUS_IOUT_OC,
1935                 .limit = iout_limit_attrs,
1936                 .nlimit = ARRAY_SIZE(iout_limit_attrs),
1937         }
1938 };
1939
1940 /* Power attributes */
1941
1942 static const struct pmbus_limit_attr pin_limit_attrs[] = {
1943         {
1944                 .reg = PMBUS_PIN_OP_WARN_LIMIT,
1945                 .attr = "max",
1946                 .alarm = "alarm",
1947                 .sbit = PB_PIN_OP_WARNING,
1948         }, {
1949                 .reg = PMBUS_VIRT_READ_PIN_AVG,
1950                 .update = true,
1951                 .attr = "average",
1952         }, {
1953                 .reg = PMBUS_VIRT_READ_PIN_MIN,
1954                 .update = true,
1955                 .attr = "input_lowest",
1956         }, {
1957                 .reg = PMBUS_VIRT_READ_PIN_MAX,
1958                 .update = true,
1959                 .attr = "input_highest",
1960         }, {
1961                 .reg = PMBUS_VIRT_RESET_PIN_HISTORY,
1962                 .attr = "reset_history",
1963         }, {
1964                 .reg = PMBUS_MFR_PIN_MAX,
1965                 .attr = "rated_max",
1966         },
1967 };
1968
1969 static const struct pmbus_limit_attr pout_limit_attrs[] = {
1970         {
1971                 .reg = PMBUS_POUT_MAX,
1972                 .attr = "cap",
1973                 .alarm = "cap_alarm",
1974                 .sbit = PB_POWER_LIMITING,
1975         }, {
1976                 .reg = PMBUS_POUT_OP_WARN_LIMIT,
1977                 .attr = "max",
1978                 .alarm = "max_alarm",
1979                 .sbit = PB_POUT_OP_WARNING,
1980         }, {
1981                 .reg = PMBUS_POUT_OP_FAULT_LIMIT,
1982                 .attr = "crit",
1983                 .alarm = "crit_alarm",
1984                 .sbit = PB_POUT_OP_FAULT,
1985         }, {
1986                 .reg = PMBUS_VIRT_READ_POUT_AVG,
1987                 .update = true,
1988                 .attr = "average",
1989         }, {
1990                 .reg = PMBUS_VIRT_READ_POUT_MIN,
1991                 .update = true,
1992                 .attr = "input_lowest",
1993         }, {
1994                 .reg = PMBUS_VIRT_READ_POUT_MAX,
1995                 .update = true,
1996                 .attr = "input_highest",
1997         }, {
1998                 .reg = PMBUS_VIRT_RESET_POUT_HISTORY,
1999                 .attr = "reset_history",
2000         }, {
2001                 .reg = PMBUS_MFR_POUT_MAX,
2002                 .attr = "rated_max",
2003         },
2004 };
2005
2006 static const struct pmbus_sensor_attr power_attributes[] = {
2007         {
2008                 .reg = PMBUS_READ_PIN,
2009                 .class = PSC_POWER,
2010                 .label = "pin",
2011                 .func = PMBUS_HAVE_PIN,
2012                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
2013                 .sreg = PMBUS_STATUS_INPUT,
2014                 .gbit = PB_STATUS_INPUT,
2015                 .limit = pin_limit_attrs,
2016                 .nlimit = ARRAY_SIZE(pin_limit_attrs),
2017         }, {
2018                 .reg = PMBUS_READ_POUT,
2019                 .class = PSC_POWER,
2020                 .label = "pout",
2021                 .paged = true,
2022                 .func = PMBUS_HAVE_POUT,
2023                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
2024                 .sreg = PMBUS_STATUS_IOUT,
2025                 .limit = pout_limit_attrs,
2026                 .nlimit = ARRAY_SIZE(pout_limit_attrs),
2027         }
2028 };
2029
2030 /* Temperature atributes */
2031
2032 static const struct pmbus_limit_attr temp_limit_attrs[] = {
2033         {
2034                 .reg = PMBUS_UT_WARN_LIMIT,
2035                 .low = true,
2036                 .attr = "min",
2037                 .alarm = "min_alarm",
2038                 .sbit = PB_TEMP_UT_WARNING,
2039         }, {
2040                 .reg = PMBUS_UT_FAULT_LIMIT,
2041                 .low = true,
2042                 .attr = "lcrit",
2043                 .alarm = "lcrit_alarm",
2044                 .sbit = PB_TEMP_UT_FAULT,
2045         }, {
2046                 .reg = PMBUS_OT_WARN_LIMIT,
2047                 .attr = "max",
2048                 .alarm = "max_alarm",
2049                 .sbit = PB_TEMP_OT_WARNING,
2050         }, {
2051                 .reg = PMBUS_OT_FAULT_LIMIT,
2052                 .attr = "crit",
2053                 .alarm = "crit_alarm",
2054                 .sbit = PB_TEMP_OT_FAULT,
2055         }, {
2056                 .reg = PMBUS_VIRT_READ_TEMP_MIN,
2057                 .attr = "lowest",
2058         }, {
2059                 .reg = PMBUS_VIRT_READ_TEMP_AVG,
2060                 .attr = "average",
2061         }, {
2062                 .reg = PMBUS_VIRT_READ_TEMP_MAX,
2063                 .attr = "highest",
2064         }, {
2065                 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
2066                 .attr = "reset_history",
2067         }, {
2068                 .reg = PMBUS_MFR_MAX_TEMP_1,
2069                 .attr = "rated_max",
2070         },
2071 };
2072
2073 static const struct pmbus_limit_attr temp_limit_attrs2[] = {
2074         {
2075                 .reg = PMBUS_UT_WARN_LIMIT,
2076                 .low = true,
2077                 .attr = "min",
2078                 .alarm = "min_alarm",
2079                 .sbit = PB_TEMP_UT_WARNING,
2080         }, {
2081                 .reg = PMBUS_UT_FAULT_LIMIT,
2082                 .low = true,
2083                 .attr = "lcrit",
2084                 .alarm = "lcrit_alarm",
2085                 .sbit = PB_TEMP_UT_FAULT,
2086         }, {
2087                 .reg = PMBUS_OT_WARN_LIMIT,
2088                 .attr = "max",
2089                 .alarm = "max_alarm",
2090                 .sbit = PB_TEMP_OT_WARNING,
2091         }, {
2092                 .reg = PMBUS_OT_FAULT_LIMIT,
2093                 .attr = "crit",
2094                 .alarm = "crit_alarm",
2095                 .sbit = PB_TEMP_OT_FAULT,
2096         }, {
2097                 .reg = PMBUS_VIRT_READ_TEMP2_MIN,
2098                 .attr = "lowest",
2099         }, {
2100                 .reg = PMBUS_VIRT_READ_TEMP2_AVG,
2101                 .attr = "average",
2102         }, {
2103                 .reg = PMBUS_VIRT_READ_TEMP2_MAX,
2104                 .attr = "highest",
2105         }, {
2106                 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
2107                 .attr = "reset_history",
2108         }, {
2109                 .reg = PMBUS_MFR_MAX_TEMP_2,
2110                 .attr = "rated_max",
2111         },
2112 };
2113
2114 static const struct pmbus_limit_attr temp_limit_attrs3[] = {
2115         {
2116                 .reg = PMBUS_UT_WARN_LIMIT,
2117                 .low = true,
2118                 .attr = "min",
2119                 .alarm = "min_alarm",
2120                 .sbit = PB_TEMP_UT_WARNING,
2121         }, {
2122                 .reg = PMBUS_UT_FAULT_LIMIT,
2123                 .low = true,
2124                 .attr = "lcrit",
2125                 .alarm = "lcrit_alarm",
2126                 .sbit = PB_TEMP_UT_FAULT,
2127         }, {
2128                 .reg = PMBUS_OT_WARN_LIMIT,
2129                 .attr = "max",
2130                 .alarm = "max_alarm",
2131                 .sbit = PB_TEMP_OT_WARNING,
2132         }, {
2133                 .reg = PMBUS_OT_FAULT_LIMIT,
2134                 .attr = "crit",
2135                 .alarm = "crit_alarm",
2136                 .sbit = PB_TEMP_OT_FAULT,
2137         }, {
2138                 .reg = PMBUS_MFR_MAX_TEMP_3,
2139                 .attr = "rated_max",
2140         },
2141 };
2142
2143 static const struct pmbus_sensor_attr temp_attributes[] = {
2144         {
2145                 .reg = PMBUS_READ_TEMPERATURE_1,
2146                 .class = PSC_TEMPERATURE,
2147                 .paged = true,
2148                 .update = true,
2149                 .compare = true,
2150                 .func = PMBUS_HAVE_TEMP,
2151                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
2152                 .sreg = PMBUS_STATUS_TEMPERATURE,
2153                 .gbit = PB_STATUS_TEMPERATURE,
2154                 .limit = temp_limit_attrs,
2155                 .nlimit = ARRAY_SIZE(temp_limit_attrs),
2156         }, {
2157                 .reg = PMBUS_READ_TEMPERATURE_2,
2158                 .class = PSC_TEMPERATURE,
2159                 .paged = true,
2160                 .update = true,
2161                 .compare = true,
2162                 .func = PMBUS_HAVE_TEMP2,
2163                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
2164                 .sreg = PMBUS_STATUS_TEMPERATURE,
2165                 .gbit = PB_STATUS_TEMPERATURE,
2166                 .limit = temp_limit_attrs2,
2167                 .nlimit = ARRAY_SIZE(temp_limit_attrs2),
2168         }, {
2169                 .reg = PMBUS_READ_TEMPERATURE_3,
2170                 .class = PSC_TEMPERATURE,
2171                 .paged = true,
2172                 .update = true,
2173                 .compare = true,
2174                 .func = PMBUS_HAVE_TEMP3,
2175                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
2176                 .sreg = PMBUS_STATUS_TEMPERATURE,
2177                 .gbit = PB_STATUS_TEMPERATURE,
2178                 .limit = temp_limit_attrs3,
2179                 .nlimit = ARRAY_SIZE(temp_limit_attrs3),
2180         }
2181 };
2182
2183 static const int pmbus_fan_registers[] = {
2184         PMBUS_READ_FAN_SPEED_1,
2185         PMBUS_READ_FAN_SPEED_2,
2186         PMBUS_READ_FAN_SPEED_3,
2187         PMBUS_READ_FAN_SPEED_4
2188 };
2189
2190 static const int pmbus_fan_status_registers[] = {
2191         PMBUS_STATUS_FAN_12,
2192         PMBUS_STATUS_FAN_12,
2193         PMBUS_STATUS_FAN_34,
2194         PMBUS_STATUS_FAN_34
2195 };
2196
2197 static const u32 pmbus_fan_flags[] = {
2198         PMBUS_HAVE_FAN12,
2199         PMBUS_HAVE_FAN12,
2200         PMBUS_HAVE_FAN34,
2201         PMBUS_HAVE_FAN34
2202 };
2203
2204 static const u32 pmbus_fan_status_flags[] = {
2205         PMBUS_HAVE_STATUS_FAN12,
2206         PMBUS_HAVE_STATUS_FAN12,
2207         PMBUS_HAVE_STATUS_FAN34,
2208         PMBUS_HAVE_STATUS_FAN34
2209 };
2210
2211 /* Fans */
2212
2213 /* Precondition: FAN_CONFIG_x_y and FAN_COMMAND_x must exist for the fan ID */
2214 static int pmbus_add_fan_ctrl(struct i2c_client *client,
2215                 struct pmbus_data *data, int index, int page, int id,
2216                 u8 config)
2217 {
2218         struct pmbus_sensor *sensor;
2219
2220         sensor = pmbus_add_sensor(data, "fan", "target", index, page,
2221                                   0xff, PMBUS_VIRT_FAN_TARGET_1 + id, PSC_FAN,
2222                                   false, false, true);
2223
2224         if (!sensor)
2225                 return -ENOMEM;
2226
2227         if (!((data->info->func[page] & PMBUS_HAVE_PWM12) ||
2228                         (data->info->func[page] & PMBUS_HAVE_PWM34)))
2229                 return 0;
2230
2231         sensor = pmbus_add_sensor(data, "pwm", NULL, index, page,
2232                                   0xff, PMBUS_VIRT_PWM_1 + id, PSC_PWM,
2233                                   false, false, true);
2234
2235         if (!sensor)
2236                 return -ENOMEM;
2237
2238         sensor = pmbus_add_sensor(data, "pwm", "enable", index, page,
2239                                   0xff, PMBUS_VIRT_PWM_ENABLE_1 + id, PSC_PWM,
2240                                   true, false, false);
2241
2242         if (!sensor)
2243                 return -ENOMEM;
2244
2245         return 0;
2246 }
2247
2248 static int pmbus_add_fan_attributes(struct i2c_client *client,
2249                                     struct pmbus_data *data)
2250 {
2251         const struct pmbus_driver_info *info = data->info;
2252         int index = 1;
2253         int page;
2254         int ret;
2255
2256         for (page = 0; page < info->pages; page++) {
2257                 int f;
2258
2259                 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) {
2260                         int regval;
2261
2262                         if (!(info->func[page] & pmbus_fan_flags[f]))
2263                                 break;
2264
2265                         if (!pmbus_check_word_register(client, page,
2266                                                        pmbus_fan_registers[f]))
2267                                 break;
2268
2269                         /*
2270                          * Skip fan if not installed.
2271                          * Each fan configuration register covers multiple fans,
2272                          * so we have to do some magic.
2273                          */
2274                         regval = _pmbus_read_byte_data(client, page,
2275                                 pmbus_fan_config_registers[f]);
2276                         if (regval < 0 ||
2277                             (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
2278                                 continue;
2279
2280                         if (pmbus_add_sensor(data, "fan", "input", index,
2281                                              page, 0xff, pmbus_fan_registers[f],
2282                                              PSC_FAN, true, true, true) == NULL)
2283                                 return -ENOMEM;
2284
2285                         /* Fan control */
2286                         if (pmbus_check_word_register(client, page,
2287                                         pmbus_fan_command_registers[f])) {
2288                                 ret = pmbus_add_fan_ctrl(client, data, index,
2289                                                          page, f, regval);
2290                                 if (ret < 0)
2291                                         return ret;
2292                         }
2293
2294                         /*
2295                          * Each fan status register covers multiple fans,
2296                          * so we have to do some magic.
2297                          */
2298                         if ((info->func[page] & pmbus_fan_status_flags[f]) &&
2299                             pmbus_check_byte_register(client,
2300                                         page, pmbus_fan_status_registers[f])) {
2301                                 int reg;
2302
2303                                 if (f > 1)      /* fan 3, 4 */
2304                                         reg = PMBUS_STATUS_FAN_34;
2305                                 else
2306                                         reg = PMBUS_STATUS_FAN_12;
2307                                 ret = pmbus_add_boolean(data, "fan",
2308                                         "alarm", index, NULL, NULL, page, reg,
2309                                         PB_FAN_FAN1_WARNING >> (f & 1));
2310                                 if (ret)
2311                                         return ret;
2312                                 ret = pmbus_add_boolean(data, "fan",
2313                                         "fault", index, NULL, NULL, page, reg,
2314                                         PB_FAN_FAN1_FAULT >> (f & 1));
2315                                 if (ret)
2316                                         return ret;
2317                         }
2318                         index++;
2319                 }
2320         }
2321         return 0;
2322 }
2323
2324 struct pmbus_samples_attr {
2325         int reg;
2326         char *name;
2327 };
2328
2329 struct pmbus_samples_reg {
2330         int page;
2331         struct pmbus_samples_attr *attr;
2332         struct device_attribute dev_attr;
2333 };
2334
2335 static struct pmbus_samples_attr pmbus_samples_registers[] = {
2336         {
2337                 .reg = PMBUS_VIRT_SAMPLES,
2338                 .name = "samples",
2339         }, {
2340                 .reg = PMBUS_VIRT_IN_SAMPLES,
2341                 .name = "in_samples",
2342         }, {
2343                 .reg = PMBUS_VIRT_CURR_SAMPLES,
2344                 .name = "curr_samples",
2345         }, {
2346                 .reg = PMBUS_VIRT_POWER_SAMPLES,
2347                 .name = "power_samples",
2348         }, {
2349                 .reg = PMBUS_VIRT_TEMP_SAMPLES,
2350                 .name = "temp_samples",
2351         }
2352 };
2353
2354 #define to_samples_reg(x) container_of(x, struct pmbus_samples_reg, dev_attr)
2355
2356 static ssize_t pmbus_show_samples(struct device *dev,
2357                                   struct device_attribute *devattr, char *buf)
2358 {
2359         int val;
2360         struct i2c_client *client = to_i2c_client(dev->parent);
2361         struct pmbus_samples_reg *reg = to_samples_reg(devattr);
2362         struct pmbus_data *data = i2c_get_clientdata(client);
2363
2364         mutex_lock(&data->update_lock);
2365         val = _pmbus_read_word_data(client, reg->page, 0xff, reg->attr->reg);
2366         mutex_unlock(&data->update_lock);
2367         if (val < 0)
2368                 return val;
2369
2370         return sysfs_emit(buf, "%d\n", val);
2371 }
2372
2373 static ssize_t pmbus_set_samples(struct device *dev,
2374                                  struct device_attribute *devattr,
2375                                  const char *buf, size_t count)
2376 {
2377         int ret;
2378         long val;
2379         struct i2c_client *client = to_i2c_client(dev->parent);
2380         struct pmbus_samples_reg *reg = to_samples_reg(devattr);
2381         struct pmbus_data *data = i2c_get_clientdata(client);
2382
2383         if (kstrtol(buf, 0, &val) < 0)
2384                 return -EINVAL;
2385
2386         mutex_lock(&data->update_lock);
2387         ret = _pmbus_write_word_data(client, reg->page, reg->attr->reg, val);
2388         mutex_unlock(&data->update_lock);
2389
2390         return ret ? : count;
2391 }
2392
2393 static int pmbus_add_samples_attr(struct pmbus_data *data, int page,
2394                                   struct pmbus_samples_attr *attr)
2395 {
2396         struct pmbus_samples_reg *reg;
2397
2398         reg = devm_kzalloc(data->dev, sizeof(*reg), GFP_KERNEL);
2399         if (!reg)
2400                 return -ENOMEM;
2401
2402         reg->attr = attr;
2403         reg->page = page;
2404
2405         pmbus_dev_attr_init(&reg->dev_attr, attr->name, 0644,
2406                             pmbus_show_samples, pmbus_set_samples);
2407
2408         return pmbus_add_attribute(data, &reg->dev_attr.attr);
2409 }
2410
2411 static int pmbus_add_samples_attributes(struct i2c_client *client,
2412                                         struct pmbus_data *data)
2413 {
2414         const struct pmbus_driver_info *info = data->info;
2415         int s;
2416
2417         if (!(info->func[0] & PMBUS_HAVE_SAMPLES))
2418                 return 0;
2419
2420         for (s = 0; s < ARRAY_SIZE(pmbus_samples_registers); s++) {
2421                 struct pmbus_samples_attr *attr;
2422                 int ret;
2423
2424                 attr = &pmbus_samples_registers[s];
2425                 if (!pmbus_check_word_register(client, 0, attr->reg))
2426                         continue;
2427
2428                 ret = pmbus_add_samples_attr(data, 0, attr);
2429                 if (ret)
2430                         return ret;
2431         }
2432
2433         return 0;
2434 }
2435
2436 static int pmbus_find_attributes(struct i2c_client *client,
2437                                  struct pmbus_data *data)
2438 {
2439         int ret;
2440
2441         /* Voltage sensors */
2442         ret = pmbus_add_sensor_attrs(client, data, "in", voltage_attributes,
2443                                      ARRAY_SIZE(voltage_attributes));
2444         if (ret)
2445                 return ret;
2446
2447         /* Current sensors */
2448         ret = pmbus_add_sensor_attrs(client, data, "curr", current_attributes,
2449                                      ARRAY_SIZE(current_attributes));
2450         if (ret)
2451                 return ret;
2452
2453         /* Power sensors */
2454         ret = pmbus_add_sensor_attrs(client, data, "power", power_attributes,
2455                                      ARRAY_SIZE(power_attributes));
2456         if (ret)
2457                 return ret;
2458
2459         /* Temperature sensors */
2460         ret = pmbus_add_sensor_attrs(client, data, "temp", temp_attributes,
2461                                      ARRAY_SIZE(temp_attributes));
2462         if (ret)
2463                 return ret;
2464
2465         /* Fans */
2466         ret = pmbus_add_fan_attributes(client, data);
2467         if (ret)
2468                 return ret;
2469
2470         ret = pmbus_add_samples_attributes(client, data);
2471         return ret;
2472 }
2473
2474 /*
2475  * The pmbus_class_attr_map structure maps one sensor class to
2476  * it's corresponding sensor attributes array.
2477  */
2478 struct pmbus_class_attr_map {
2479         enum pmbus_sensor_classes class;
2480         int nattr;
2481         const struct pmbus_sensor_attr *attr;
2482 };
2483
2484 static const struct pmbus_class_attr_map class_attr_map[] = {
2485         {
2486                 .class = PSC_VOLTAGE_IN,
2487                 .attr = voltage_attributes,
2488                 .nattr = ARRAY_SIZE(voltage_attributes),
2489         }, {
2490                 .class = PSC_VOLTAGE_OUT,
2491                 .attr = voltage_attributes,
2492                 .nattr = ARRAY_SIZE(voltage_attributes),
2493         }, {
2494                 .class = PSC_CURRENT_IN,
2495                 .attr = current_attributes,
2496                 .nattr = ARRAY_SIZE(current_attributes),
2497         }, {
2498                 .class = PSC_CURRENT_OUT,
2499                 .attr = current_attributes,
2500                 .nattr = ARRAY_SIZE(current_attributes),
2501         }, {
2502                 .class = PSC_POWER,
2503                 .attr = power_attributes,
2504                 .nattr = ARRAY_SIZE(power_attributes),
2505         }, {
2506                 .class = PSC_TEMPERATURE,
2507                 .attr = temp_attributes,
2508                 .nattr = ARRAY_SIZE(temp_attributes),
2509         }
2510 };
2511
2512 /*
2513  * Read the coefficients for direct mode.
2514  */
2515 static int pmbus_read_coefficients(struct i2c_client *client,
2516                                    struct pmbus_driver_info *info,
2517                                    const struct pmbus_sensor_attr *attr)
2518 {
2519         int rv;
2520         union i2c_smbus_data data;
2521         enum pmbus_sensor_classes class = attr->class;
2522         s8 R;
2523         s16 m, b;
2524
2525         data.block[0] = 2;
2526         data.block[1] = attr->reg;
2527         data.block[2] = 0x01;
2528
2529         pmbus_wait(client);
2530         rv = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
2531                             I2C_SMBUS_WRITE, PMBUS_COEFFICIENTS,
2532                             I2C_SMBUS_BLOCK_PROC_CALL, &data);
2533         pmbus_update_ts(client, true);
2534
2535         if (rv < 0)
2536                 return rv;
2537
2538         if (data.block[0] != 5)
2539                 return -EIO;
2540
2541         m = data.block[1] | (data.block[2] << 8);
2542         b = data.block[3] | (data.block[4] << 8);
2543         R = data.block[5];
2544         info->m[class] = m;
2545         info->b[class] = b;
2546         info->R[class] = R;
2547
2548         return rv;
2549 }
2550
2551 static int pmbus_init_coefficients(struct i2c_client *client,
2552                                    struct pmbus_driver_info *info)
2553 {
2554         int i, n, ret = -EINVAL;
2555         const struct pmbus_class_attr_map *map;
2556         const struct pmbus_sensor_attr *attr;
2557
2558         for (i = 0; i < ARRAY_SIZE(class_attr_map); i++) {
2559                 map = &class_attr_map[i];
2560                 if (info->format[map->class] != direct)
2561                         continue;
2562                 for (n = 0; n < map->nattr; n++) {
2563                         attr = &map->attr[n];
2564                         if (map->class != attr->class)
2565                                 continue;
2566                         ret = pmbus_read_coefficients(client, info, attr);
2567                         if (ret >= 0)
2568                                 break;
2569                 }
2570                 if (ret < 0) {
2571                         dev_err(&client->dev,
2572                                 "No coefficients found for sensor class %d\n",
2573                                 map->class);
2574                         return -EINVAL;
2575                 }
2576         }
2577
2578         return 0;
2579 }
2580
2581 /*
2582  * Identify chip parameters.
2583  * This function is called for all chips.
2584  */
2585 static int pmbus_identify_common(struct i2c_client *client,
2586                                  struct pmbus_data *data, int page)
2587 {
2588         int vout_mode = -1;
2589
2590         if (pmbus_check_byte_register(client, page, PMBUS_VOUT_MODE))
2591                 vout_mode = _pmbus_read_byte_data(client, page,
2592                                                   PMBUS_VOUT_MODE);
2593         if (vout_mode >= 0 && vout_mode != 0xff) {
2594                 /*
2595                  * Not all chips support the VOUT_MODE command,
2596                  * so a failure to read it is not an error.
2597                  */
2598                 switch (vout_mode >> 5) {
2599                 case 0: /* linear mode      */
2600                         if (data->info->format[PSC_VOLTAGE_OUT] != linear)
2601                                 return -ENODEV;
2602
2603                         data->exponent[page] = ((s8)(vout_mode << 3)) >> 3;
2604                         break;
2605                 case 1: /* VID mode         */
2606                         if (data->info->format[PSC_VOLTAGE_OUT] != vid)
2607                                 return -ENODEV;
2608                         break;
2609                 case 2: /* direct mode      */
2610                         if (data->info->format[PSC_VOLTAGE_OUT] != direct)
2611                                 return -ENODEV;
2612                         break;
2613                 case 3: /* ieee 754 half precision */
2614                         if (data->info->format[PSC_VOLTAGE_OUT] != ieee754)
2615                                 return -ENODEV;
2616                         break;
2617                 default:
2618                         return -ENODEV;
2619                 }
2620         }
2621
2622         return 0;
2623 }
2624
2625 static int pmbus_read_status_byte(struct i2c_client *client, int page)
2626 {
2627         return _pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE);
2628 }
2629
2630 static int pmbus_read_status_word(struct i2c_client *client, int page)
2631 {
2632         return _pmbus_read_word_data(client, page, 0xff, PMBUS_STATUS_WORD);
2633 }
2634
2635 /* PEC attribute support */
2636
2637 static ssize_t pec_show(struct device *dev, struct device_attribute *dummy,
2638                         char *buf)
2639 {
2640         struct i2c_client *client = to_i2c_client(dev);
2641
2642         return sysfs_emit(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC));
2643 }
2644
2645 static ssize_t pec_store(struct device *dev, struct device_attribute *dummy,
2646                          const char *buf, size_t count)
2647 {
2648         struct i2c_client *client = to_i2c_client(dev);
2649         bool enable;
2650         int err;
2651
2652         err = kstrtobool(buf, &enable);
2653         if (err < 0)
2654                 return err;
2655
2656         if (enable)
2657                 client->flags |= I2C_CLIENT_PEC;
2658         else
2659                 client->flags &= ~I2C_CLIENT_PEC;
2660
2661         return count;
2662 }
2663
2664 static DEVICE_ATTR_RW(pec);
2665
2666 static void pmbus_remove_pec(void *dev)
2667 {
2668         device_remove_file(dev, &dev_attr_pec);
2669 }
2670
2671 static void pmbus_init_wp(struct i2c_client *client, struct pmbus_data *data)
2672 {
2673         int ret;
2674
2675         switch (wp) {
2676         case 0:
2677                 _pmbus_write_byte_data(client, -1,
2678                                        PMBUS_WRITE_PROTECT, 0);
2679                 break;
2680
2681         case 1:
2682                 _pmbus_write_byte_data(client, -1,
2683                                        PMBUS_WRITE_PROTECT, PB_WP_VOUT);
2684                 break;
2685
2686         case 2:
2687                 _pmbus_write_byte_data(client, -1,
2688                                        PMBUS_WRITE_PROTECT, PB_WP_OP);
2689                 break;
2690
2691         case 3:
2692                 _pmbus_write_byte_data(client, -1,
2693                                        PMBUS_WRITE_PROTECT, PB_WP_ALL);
2694                 break;
2695
2696         default:
2697                 /* Ignore the other values */
2698                 break;
2699         }
2700
2701         ret = _pmbus_read_byte_data(client, -1, PMBUS_WRITE_PROTECT);
2702         if (ret < 0)
2703                 return;
2704
2705         switch (ret & PB_WP_ANY) {
2706         case PB_WP_ALL:
2707                 data->flags |= PMBUS_OP_PROTECTED;
2708                 fallthrough;
2709         case PB_WP_OP:
2710                 data->flags |= PMBUS_VOUT_PROTECTED;
2711                 fallthrough;
2712         case PB_WP_VOUT:
2713                 data->flags |= PMBUS_WRITE_PROTECTED | PMBUS_SKIP_STATUS_CHECK;
2714                 break;
2715
2716         default:
2717                 break;
2718         }
2719 }
2720
2721 static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data,
2722                              struct pmbus_driver_info *info)
2723 {
2724         struct device *dev = &client->dev;
2725         int page, ret;
2726
2727         /*
2728          * Figure out if PEC is enabled before accessing any other register.
2729          * Make sure PEC is disabled, will be enabled later if needed.
2730          */
2731         client->flags &= ~I2C_CLIENT_PEC;
2732
2733         /* Enable PEC if the controller and bus supports it */
2734         if (!(data->flags & PMBUS_NO_CAPABILITY)) {
2735                 pmbus_wait(client);
2736                 ret = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY);
2737                 pmbus_update_ts(client, false);
2738
2739                 if (ret >= 0 && (ret & PB_CAPABILITY_ERROR_CHECK)) {
2740                         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_PEC))
2741                                 client->flags |= I2C_CLIENT_PEC;
2742                 }
2743         }
2744
2745         /*
2746          * Some PMBus chips don't support PMBUS_STATUS_WORD, so try
2747          * to use PMBUS_STATUS_BYTE instead if that is the case.
2748          * Bail out if both registers are not supported.
2749          */
2750         data->read_status = pmbus_read_status_word;
2751         pmbus_wait(client);
2752         ret = i2c_smbus_read_word_data(client, PMBUS_STATUS_WORD);
2753         pmbus_update_ts(client, false);
2754
2755         if (ret < 0 || ret == 0xffff) {
2756                 data->read_status = pmbus_read_status_byte;
2757                 pmbus_wait(client);
2758                 ret = i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE);
2759                 pmbus_update_ts(client, false);
2760
2761                 if (ret < 0 || ret == 0xff) {
2762                         dev_err(dev, "PMBus status register not found\n");
2763                         return -ENODEV;
2764                 }
2765         } else {
2766                 data->has_status_word = true;
2767         }
2768
2769         /*
2770          * Check if the chip is write protected. If it is, we can not clear
2771          * faults, and we should not try it. Also, in that case, writes into
2772          * limit registers need to be disabled.
2773          */
2774         if (!(data->flags & PMBUS_NO_WRITE_PROTECT))
2775                 pmbus_init_wp(client, data);
2776
2777         ret = i2c_smbus_read_byte_data(client, PMBUS_REVISION);
2778         if (ret >= 0)
2779                 data->revision = ret;
2780
2781         if (data->info->pages)
2782                 pmbus_clear_faults(client);
2783         else
2784                 pmbus_clear_fault_page(client, -1);
2785
2786         if (info->identify) {
2787                 ret = (*info->identify)(client, info);
2788                 if (ret < 0) {
2789                         dev_err(dev, "Chip identification failed\n");
2790                         return ret;
2791                 }
2792         }
2793
2794         if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
2795                 dev_err(dev, "Bad number of PMBus pages: %d\n", info->pages);
2796                 return -ENODEV;
2797         }
2798
2799         for (page = 0; page < info->pages; page++) {
2800                 ret = pmbus_identify_common(client, data, page);
2801                 if (ret < 0) {
2802                         dev_err(dev, "Failed to identify chip capabilities\n");
2803                         return ret;
2804                 }
2805         }
2806
2807         if (data->flags & PMBUS_USE_COEFFICIENTS_CMD) {
2808                 if (!i2c_check_functionality(client->adapter,
2809                                              I2C_FUNC_SMBUS_BLOCK_PROC_CALL))
2810                         return -ENODEV;
2811
2812                 ret = pmbus_init_coefficients(client, info);
2813                 if (ret < 0)
2814                         return ret;
2815         }
2816
2817         if (client->flags & I2C_CLIENT_PEC) {
2818                 /*
2819                  * If I2C_CLIENT_PEC is set here, both the I2C adapter and the
2820                  * chip support PEC. Add 'pec' attribute to client device to let
2821                  * the user control it.
2822                  */
2823                 ret = device_create_file(dev, &dev_attr_pec);
2824                 if (ret)
2825                         return ret;
2826                 ret = devm_add_action_or_reset(dev, pmbus_remove_pec, dev);
2827                 if (ret)
2828                         return ret;
2829         }
2830
2831         return 0;
2832 }
2833
2834 /* A PMBus status flag and the corresponding REGULATOR_ERROR_* and REGULATOR_EVENTS_* flag */
2835 struct pmbus_status_assoc {
2836         int pflag, rflag, eflag;
2837 };
2838
2839 /* PMBus->regulator bit mappings for a PMBus status register */
2840 struct pmbus_status_category {
2841         int func;
2842         int reg;
2843         const struct pmbus_status_assoc *bits; /* zero-terminated */
2844 };
2845
2846 static const struct pmbus_status_category __maybe_unused pmbus_status_flag_map[] = {
2847         {
2848                 .func = PMBUS_HAVE_STATUS_VOUT,
2849                 .reg = PMBUS_STATUS_VOUT,
2850                 .bits = (const struct pmbus_status_assoc[]) {
2851                         { PB_VOLTAGE_UV_WARNING, REGULATOR_ERROR_UNDER_VOLTAGE_WARN,
2852                         REGULATOR_EVENT_UNDER_VOLTAGE_WARN },
2853                         { PB_VOLTAGE_UV_FAULT,   REGULATOR_ERROR_UNDER_VOLTAGE,
2854                         REGULATOR_EVENT_UNDER_VOLTAGE },
2855                         { PB_VOLTAGE_OV_WARNING, REGULATOR_ERROR_OVER_VOLTAGE_WARN,
2856                         REGULATOR_EVENT_OVER_VOLTAGE_WARN },
2857                         { PB_VOLTAGE_OV_FAULT,   REGULATOR_ERROR_REGULATION_OUT,
2858                         REGULATOR_EVENT_OVER_VOLTAGE_WARN },
2859                         { },
2860                 },
2861         }, {
2862                 .func = PMBUS_HAVE_STATUS_IOUT,
2863                 .reg = PMBUS_STATUS_IOUT,
2864                 .bits = (const struct pmbus_status_assoc[]) {
2865                         { PB_IOUT_OC_WARNING,   REGULATOR_ERROR_OVER_CURRENT_WARN,
2866                         REGULATOR_EVENT_OVER_CURRENT_WARN },
2867                         { PB_IOUT_OC_FAULT,     REGULATOR_ERROR_OVER_CURRENT,
2868                         REGULATOR_EVENT_OVER_CURRENT },
2869                         { PB_IOUT_OC_LV_FAULT,  REGULATOR_ERROR_OVER_CURRENT,
2870                         REGULATOR_EVENT_OVER_CURRENT },
2871                         { },
2872                 },
2873         }, {
2874                 .func = PMBUS_HAVE_STATUS_TEMP,
2875                 .reg = PMBUS_STATUS_TEMPERATURE,
2876                 .bits = (const struct pmbus_status_assoc[]) {
2877                         { PB_TEMP_OT_WARNING,    REGULATOR_ERROR_OVER_TEMP_WARN,
2878                         REGULATOR_EVENT_OVER_TEMP_WARN },
2879                         { PB_TEMP_OT_FAULT,      REGULATOR_ERROR_OVER_TEMP,
2880                         REGULATOR_EVENT_OVER_TEMP },
2881                         { },
2882                 },
2883         },
2884 };
2885
2886 static int _pmbus_is_enabled(struct i2c_client *client, u8 page)
2887 {
2888         int ret;
2889
2890         ret = _pmbus_read_byte_data(client, page, PMBUS_OPERATION);
2891
2892         if (ret < 0)
2893                 return ret;
2894
2895         return !!(ret & PB_OPERATION_CONTROL_ON);
2896 }
2897
2898 static int __maybe_unused pmbus_is_enabled(struct i2c_client *client, u8 page)
2899 {
2900         struct pmbus_data *data = i2c_get_clientdata(client);
2901         int ret;
2902
2903         mutex_lock(&data->update_lock);
2904         ret = _pmbus_is_enabled(client, page);
2905         mutex_unlock(&data->update_lock);
2906
2907         return ret;
2908 }
2909
2910 #define to_dev_attr(_dev_attr) \
2911         container_of(_dev_attr, struct device_attribute, attr)
2912
2913 static void pmbus_notify(struct pmbus_data *data, int page, int reg, int flags)
2914 {
2915         int i;
2916
2917         for (i = 0; i < data->num_attributes; i++) {
2918                 struct device_attribute *da = to_dev_attr(data->group.attrs[i]);
2919                 struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
2920                 int index = attr->index;
2921                 u16 smask = pb_index_to_mask(index);
2922                 u8 spage = pb_index_to_page(index);
2923                 u16 sreg = pb_index_to_reg(index);
2924
2925                 if (reg == sreg && page == spage && (smask & flags)) {
2926                         dev_dbg(data->dev, "sysfs notify: %s", da->attr.name);
2927                         sysfs_notify(&data->dev->kobj, NULL, da->attr.name);
2928                         kobject_uevent(&data->dev->kobj, KOBJ_CHANGE);
2929                         flags &= ~smask;
2930                 }
2931
2932                 if (!flags)
2933                         break;
2934         }
2935 }
2936
2937 static int _pmbus_get_flags(struct pmbus_data *data, u8 page, unsigned int *flags,
2938                            unsigned int *event, bool notify)
2939 {
2940         int i, status;
2941         const struct pmbus_status_category *cat;
2942         const struct pmbus_status_assoc *bit;
2943         struct device *dev = data->dev;
2944         struct i2c_client *client = to_i2c_client(dev);
2945         int func = data->info->func[page];
2946
2947         *flags = 0;
2948         *event = 0;
2949
2950         for (i = 0; i < ARRAY_SIZE(pmbus_status_flag_map); i++) {
2951                 cat = &pmbus_status_flag_map[i];
2952                 if (!(func & cat->func))
2953                         continue;
2954
2955                 status = _pmbus_read_byte_data(client, page, cat->reg);
2956                 if (status < 0)
2957                         return status;
2958
2959                 for (bit = cat->bits; bit->pflag; bit++)
2960                         if (status & bit->pflag) {
2961                                 *flags |= bit->rflag;
2962                                 *event |= bit->eflag;
2963                         }
2964
2965                 if (notify && status)
2966                         pmbus_notify(data, page, cat->reg, status);
2967
2968         }
2969
2970         /*
2971          * Map what bits of STATUS_{WORD,BYTE} we can to REGULATOR_ERROR_*
2972          * bits.  Some of the other bits are tempting (especially for cases
2973          * where we don't have the relevant PMBUS_HAVE_STATUS_*
2974          * functionality), but there's an unfortunate ambiguity in that
2975          * they're defined as indicating a fault *or* a warning, so we can't
2976          * easily determine whether to report REGULATOR_ERROR_<foo> or
2977          * REGULATOR_ERROR_<foo>_WARN.
2978          */
2979         status = pmbus_get_status(client, page, PMBUS_STATUS_WORD);
2980         if (status < 0)
2981                 return status;
2982
2983         if (_pmbus_is_enabled(client, page)) {
2984                 if (status & PB_STATUS_OFF) {
2985                         *flags |= REGULATOR_ERROR_FAIL;
2986                         *event |= REGULATOR_EVENT_FAIL;
2987                 }
2988
2989                 if (status & PB_STATUS_POWER_GOOD_N) {
2990                         *flags |= REGULATOR_ERROR_REGULATION_OUT;
2991                         *event |= REGULATOR_EVENT_REGULATION_OUT;
2992                 }
2993         }
2994         /*
2995          * Unlike most other status bits, PB_STATUS_{IOUT_OC,VOUT_OV} are
2996          * defined strictly as fault indicators (not warnings).
2997          */
2998         if (status & PB_STATUS_IOUT_OC) {
2999                 *flags |= REGULATOR_ERROR_OVER_CURRENT;
3000                 *event |= REGULATOR_EVENT_OVER_CURRENT;
3001         }
3002         if (status & PB_STATUS_VOUT_OV) {
3003                 *flags |= REGULATOR_ERROR_REGULATION_OUT;
3004                 *event |= REGULATOR_EVENT_FAIL;
3005         }
3006
3007         /*
3008          * If we haven't discovered any thermal faults or warnings via
3009          * PMBUS_STATUS_TEMPERATURE, map PB_STATUS_TEMPERATURE to a warning as
3010          * a (conservative) best-effort interpretation.
3011          */
3012         if (!(*flags & (REGULATOR_ERROR_OVER_TEMP | REGULATOR_ERROR_OVER_TEMP_WARN)) &&
3013             (status & PB_STATUS_TEMPERATURE)) {
3014                 *flags |= REGULATOR_ERROR_OVER_TEMP_WARN;
3015                 *event |= REGULATOR_EVENT_OVER_TEMP_WARN;
3016         }
3017
3018
3019         return 0;
3020 }
3021
3022 static int __maybe_unused pmbus_get_flags(struct pmbus_data *data, u8 page, unsigned int *flags,
3023                                           unsigned int *event, bool notify)
3024 {
3025         int ret;
3026
3027         mutex_lock(&data->update_lock);
3028         ret = _pmbus_get_flags(data, page, flags, event, notify);
3029         mutex_unlock(&data->update_lock);
3030
3031         return ret;
3032 }
3033
3034 #if IS_ENABLED(CONFIG_REGULATOR)
3035 static int pmbus_regulator_is_enabled(struct regulator_dev *rdev)
3036 {
3037         struct device *dev = rdev_get_dev(rdev);
3038         struct i2c_client *client = to_i2c_client(dev->parent);
3039
3040         return pmbus_is_enabled(client, rdev_get_id(rdev));
3041 }
3042
3043 static int _pmbus_regulator_on_off(struct regulator_dev *rdev, bool enable)
3044 {
3045         struct device *dev = rdev_get_dev(rdev);
3046         struct i2c_client *client = to_i2c_client(dev->parent);
3047         struct pmbus_data *data = i2c_get_clientdata(client);
3048         u8 page = rdev_get_id(rdev);
3049         int ret;
3050
3051         mutex_lock(&data->update_lock);
3052         ret = pmbus_update_byte_data(client, page, PMBUS_OPERATION,
3053                                      PB_OPERATION_CONTROL_ON,
3054                                      enable ? PB_OPERATION_CONTROL_ON : 0);
3055         mutex_unlock(&data->update_lock);
3056
3057         return ret;
3058 }
3059
3060 static int pmbus_regulator_enable(struct regulator_dev *rdev)
3061 {
3062         return _pmbus_regulator_on_off(rdev, 1);
3063 }
3064
3065 static int pmbus_regulator_disable(struct regulator_dev *rdev)
3066 {
3067         return _pmbus_regulator_on_off(rdev, 0);
3068 }
3069
3070 static int pmbus_regulator_get_error_flags(struct regulator_dev *rdev, unsigned int *flags)
3071 {
3072         struct device *dev = rdev_get_dev(rdev);
3073         struct i2c_client *client = to_i2c_client(dev->parent);
3074         struct pmbus_data *data = i2c_get_clientdata(client);
3075         int event;
3076
3077         return pmbus_get_flags(data, rdev_get_id(rdev), flags, &event, false);
3078 }
3079
3080 static int pmbus_regulator_get_status(struct regulator_dev *rdev)
3081 {
3082         struct device *dev = rdev_get_dev(rdev);
3083         struct i2c_client *client = to_i2c_client(dev->parent);
3084         struct pmbus_data *data = i2c_get_clientdata(client);
3085         u8 page = rdev_get_id(rdev);
3086         int status, ret;
3087         int event;
3088
3089         mutex_lock(&data->update_lock);
3090         status = pmbus_get_status(client, page, PMBUS_STATUS_WORD);
3091         if (status < 0) {
3092                 ret = status;
3093                 goto unlock;
3094         }
3095
3096         if (status & PB_STATUS_OFF) {
3097                 ret = REGULATOR_STATUS_OFF;
3098                 goto unlock;
3099         }
3100
3101         /* If regulator is ON & reports power good then return ON */
3102         if (!(status & PB_STATUS_POWER_GOOD_N)) {
3103                 ret = REGULATOR_STATUS_ON;
3104                 goto unlock;
3105         }
3106
3107         ret = _pmbus_get_flags(data, rdev_get_id(rdev), &status, &event, false);
3108         if (ret)
3109                 goto unlock;
3110
3111         if (status & (REGULATOR_ERROR_UNDER_VOLTAGE | REGULATOR_ERROR_OVER_CURRENT |
3112            REGULATOR_ERROR_REGULATION_OUT | REGULATOR_ERROR_FAIL | REGULATOR_ERROR_OVER_TEMP)) {
3113                 ret = REGULATOR_STATUS_ERROR;
3114                 goto unlock;
3115         }
3116
3117         ret = REGULATOR_STATUS_UNDEFINED;
3118
3119 unlock:
3120         mutex_unlock(&data->update_lock);
3121         return ret;
3122 }
3123
3124 static int pmbus_regulator_get_low_margin(struct i2c_client *client, int page)
3125 {
3126         struct pmbus_data *data = i2c_get_clientdata(client);
3127         struct pmbus_sensor s = {
3128                 .page = page,
3129                 .class = PSC_VOLTAGE_OUT,
3130                 .convert = true,
3131                 .data = -1,
3132         };
3133
3134         if (data->vout_low[page] < 0) {
3135                 if (pmbus_check_word_register(client, page, PMBUS_MFR_VOUT_MIN))
3136                         s.data = _pmbus_read_word_data(client, page, 0xff,
3137                                                        PMBUS_MFR_VOUT_MIN);
3138                 if (s.data < 0) {
3139                         s.data = _pmbus_read_word_data(client, page, 0xff,
3140                                                        PMBUS_VOUT_MARGIN_LOW);
3141                         if (s.data < 0)
3142                                 return s.data;
3143                 }
3144                 data->vout_low[page] = pmbus_reg2data(data, &s);
3145         }
3146
3147         return data->vout_low[page];
3148 }
3149
3150 static int pmbus_regulator_get_high_margin(struct i2c_client *client, int page)
3151 {
3152         struct pmbus_data *data = i2c_get_clientdata(client);
3153         struct pmbus_sensor s = {
3154                 .page = page,
3155                 .class = PSC_VOLTAGE_OUT,
3156                 .convert = true,
3157                 .data = -1,
3158         };
3159
3160         if (data->vout_high[page] < 0) {
3161                 if (pmbus_check_word_register(client, page, PMBUS_MFR_VOUT_MAX))
3162                         s.data = _pmbus_read_word_data(client, page, 0xff,
3163                                                        PMBUS_MFR_VOUT_MAX);
3164                 if (s.data < 0) {
3165                         s.data = _pmbus_read_word_data(client, page, 0xff,
3166                                                        PMBUS_VOUT_MARGIN_HIGH);
3167                         if (s.data < 0)
3168                                 return s.data;
3169                 }
3170                 data->vout_high[page] = pmbus_reg2data(data, &s);
3171         }
3172
3173         return data->vout_high[page];
3174 }
3175
3176 static int pmbus_regulator_get_voltage(struct regulator_dev *rdev)
3177 {
3178         struct device *dev = rdev_get_dev(rdev);
3179         struct i2c_client *client = to_i2c_client(dev->parent);
3180         struct pmbus_data *data = i2c_get_clientdata(client);
3181         struct pmbus_sensor s = {
3182                 .page = rdev_get_id(rdev),
3183                 .class = PSC_VOLTAGE_OUT,
3184                 .convert = true,
3185         };
3186
3187         s.data = _pmbus_read_word_data(client, s.page, 0xff, PMBUS_READ_VOUT);
3188         if (s.data < 0)
3189                 return s.data;
3190
3191         return (int)pmbus_reg2data(data, &s) * 1000; /* unit is uV */
3192 }
3193
3194 static int pmbus_regulator_set_voltage(struct regulator_dev *rdev, int min_uv,
3195                                        int max_uv, unsigned int *selector)
3196 {
3197         struct device *dev = rdev_get_dev(rdev);
3198         struct i2c_client *client = to_i2c_client(dev->parent);
3199         struct pmbus_data *data = i2c_get_clientdata(client);
3200         struct pmbus_sensor s = {
3201                 .page = rdev_get_id(rdev),
3202                 .class = PSC_VOLTAGE_OUT,
3203                 .convert = true,
3204                 .data = -1,
3205         };
3206         int val = DIV_ROUND_CLOSEST(min_uv, 1000); /* convert to mV */
3207         int low, high;
3208
3209         *selector = 0;
3210
3211         low = pmbus_regulator_get_low_margin(client, s.page);
3212         if (low < 0)
3213                 return low;
3214
3215         high = pmbus_regulator_get_high_margin(client, s.page);
3216         if (high < 0)
3217                 return high;
3218
3219         /* Make sure we are within margins */
3220         if (low > val)
3221                 val = low;
3222         if (high < val)
3223                 val = high;
3224
3225         val = pmbus_data2reg(data, &s, val);
3226
3227         return _pmbus_write_word_data(client, s.page, PMBUS_VOUT_COMMAND, (u16)val);
3228 }
3229
3230 static int pmbus_regulator_list_voltage(struct regulator_dev *rdev,
3231                                          unsigned int selector)
3232 {
3233         struct device *dev = rdev_get_dev(rdev);
3234         struct i2c_client *client = to_i2c_client(dev->parent);
3235         struct pmbus_data *data = i2c_get_clientdata(client);
3236         int val, low, high;
3237
3238         if (data->flags & PMBUS_VOUT_PROTECTED)
3239                 return 0;
3240
3241         if (selector >= rdev->desc->n_voltages ||
3242             selector < rdev->desc->linear_min_sel)
3243                 return -EINVAL;
3244
3245         selector -= rdev->desc->linear_min_sel;
3246         val = DIV_ROUND_CLOSEST(rdev->desc->min_uV +
3247                                 (rdev->desc->uV_step * selector), 1000); /* convert to mV */
3248
3249         low = pmbus_regulator_get_low_margin(client, rdev_get_id(rdev));
3250         if (low < 0)
3251                 return low;
3252
3253         high = pmbus_regulator_get_high_margin(client, rdev_get_id(rdev));
3254         if (high < 0)
3255                 return high;
3256
3257         if (val >= low && val <= high)
3258                 return val * 1000; /* unit is uV */
3259
3260         return 0;
3261 }
3262
3263 const struct regulator_ops pmbus_regulator_ops = {
3264         .enable = pmbus_regulator_enable,
3265         .disable = pmbus_regulator_disable,
3266         .is_enabled = pmbus_regulator_is_enabled,
3267         .get_error_flags = pmbus_regulator_get_error_flags,
3268         .get_status = pmbus_regulator_get_status,
3269         .get_voltage = pmbus_regulator_get_voltage,
3270         .set_voltage = pmbus_regulator_set_voltage,
3271         .list_voltage = pmbus_regulator_list_voltage,
3272 };
3273 EXPORT_SYMBOL_NS_GPL(pmbus_regulator_ops, "PMBUS");
3274
3275 int pmbus_regulator_init_cb(struct regulator_dev *rdev,
3276                             struct regulator_config *config)
3277 {
3278         struct pmbus_data *data = config->driver_data;
3279         struct regulation_constraints *constraints = rdev->constraints;
3280
3281         if (data->flags & PMBUS_OP_PROTECTED)
3282                 constraints->valid_ops_mask &= ~REGULATOR_CHANGE_STATUS;
3283
3284         if (data->flags & PMBUS_VOUT_PROTECTED)
3285                 constraints->valid_ops_mask &= ~REGULATOR_CHANGE_VOLTAGE;
3286
3287         return 0;
3288 }
3289 EXPORT_SYMBOL_NS_GPL(pmbus_regulator_init_cb, "PMBUS");
3290
3291 static int pmbus_regulator_register(struct pmbus_data *data)
3292 {
3293         struct device *dev = data->dev;
3294         const struct pmbus_driver_info *info = data->info;
3295         const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
3296         int i;
3297
3298         data->rdevs = devm_kzalloc(dev, sizeof(struct regulator_dev *) * info->num_regulators,
3299                                    GFP_KERNEL);
3300         if (!data->rdevs)
3301                 return -ENOMEM;
3302
3303         for (i = 0; i < info->num_regulators; i++) {
3304                 struct regulator_config config = { };
3305
3306                 config.dev = dev;
3307                 config.driver_data = data;
3308
3309                 if (pdata && pdata->reg_init_data)
3310                         config.init_data = &pdata->reg_init_data[i];
3311
3312                 data->rdevs[i] = devm_regulator_register(dev, &info->reg_desc[i],
3313                                                          &config);
3314                 if (IS_ERR(data->rdevs[i]))
3315                         return dev_err_probe(dev, PTR_ERR(data->rdevs[i]),
3316                                              "Failed to register %s regulator\n",
3317                                              info->reg_desc[i].name);
3318         }
3319
3320         return 0;
3321 }
3322
3323 static int pmbus_regulator_notify(struct pmbus_data *data, int page, int event)
3324 {
3325                 int j;
3326
3327                 for (j = 0; j < data->info->num_regulators; j++) {
3328                         if (page == rdev_get_id(data->rdevs[j])) {
3329                                 regulator_notifier_call_chain(data->rdevs[j], event, NULL);
3330                                 break;
3331                         }
3332                 }
3333                 return 0;
3334 }
3335 #else
3336 static int pmbus_regulator_register(struct pmbus_data *data)
3337 {
3338         return 0;
3339 }
3340
3341 static int pmbus_regulator_notify(struct pmbus_data *data, int page, int event)
3342 {
3343                 return 0;
3344 }
3345 #endif
3346
3347 static int pmbus_write_smbalert_mask(struct i2c_client *client, u8 page, u8 reg, u8 val)
3348 {
3349         int ret;
3350
3351         ret = _pmbus_write_word_data(client, page, PMBUS_SMBALERT_MASK, reg | (val << 8));
3352
3353         /*
3354          * Clear fault systematically in case writing PMBUS_SMBALERT_MASK
3355          * is not supported by the chip.
3356          */
3357         pmbus_clear_fault_page(client, page);
3358
3359         return ret;
3360 }
3361
3362 static irqreturn_t pmbus_fault_handler(int irq, void *pdata)
3363 {
3364         struct pmbus_data *data = pdata;
3365         struct i2c_client *client = to_i2c_client(data->dev);
3366
3367         int i, status, event;
3368         mutex_lock(&data->update_lock);
3369         for (i = 0; i < data->info->pages; i++) {
3370                 _pmbus_get_flags(data, i, &status, &event, true);
3371
3372                 if (event)
3373                         pmbus_regulator_notify(data, i, event);
3374         }
3375
3376         pmbus_clear_faults(client);
3377         mutex_unlock(&data->update_lock);
3378
3379         return IRQ_HANDLED;
3380 }
3381
3382 static int pmbus_irq_setup(struct i2c_client *client, struct pmbus_data *data)
3383 {
3384         struct device *dev = &client->dev;
3385         const struct pmbus_status_category *cat;
3386         const struct pmbus_status_assoc *bit;
3387         int i, j, err, func;
3388         u8 mask;
3389
3390         static const u8 misc_status[] = {PMBUS_STATUS_CML, PMBUS_STATUS_OTHER,
3391                                          PMBUS_STATUS_MFR_SPECIFIC, PMBUS_STATUS_FAN_12,
3392                                          PMBUS_STATUS_FAN_34};
3393
3394         if (!client->irq)
3395                 return 0;
3396
3397         for (i = 0; i < data->info->pages; i++) {
3398                 func = data->info->func[i];
3399
3400                 for (j = 0; j < ARRAY_SIZE(pmbus_status_flag_map); j++) {
3401                         cat = &pmbus_status_flag_map[j];
3402                         if (!(func & cat->func))
3403                                 continue;
3404                         mask = 0;
3405                         for (bit = cat->bits; bit->pflag; bit++)
3406                                 mask |= bit->pflag;
3407
3408                         err = pmbus_write_smbalert_mask(client, i, cat->reg, ~mask);
3409                         if (err)
3410                                 dev_dbg_once(dev, "Failed to set smbalert for reg 0x%02x\n",
3411                                              cat->reg);
3412                 }
3413
3414                 for (j = 0; j < ARRAY_SIZE(misc_status); j++)
3415                         pmbus_write_smbalert_mask(client, i, misc_status[j], 0xff);
3416         }
3417
3418         /* Register notifiers */
3419         err = devm_request_threaded_irq(dev, client->irq, NULL, pmbus_fault_handler,
3420                                         IRQF_ONESHOT, "pmbus-irq", data);
3421         if (err) {
3422                 dev_err(dev, "failed to request an irq %d\n", err);
3423                 return err;
3424         }
3425
3426         return 0;
3427 }
3428
3429 static struct dentry *pmbus_debugfs_dir;        /* pmbus debugfs directory */
3430
3431 #if IS_ENABLED(CONFIG_DEBUG_FS)
3432 static int pmbus_debugfs_get(void *data, u64 *val)
3433 {
3434         int rc;
3435         struct pmbus_debugfs_entry *entry = data;
3436         struct pmbus_data *pdata = i2c_get_clientdata(entry->client);
3437
3438         rc = mutex_lock_interruptible(&pdata->update_lock);
3439         if (rc)
3440                 return rc;
3441         rc = _pmbus_read_byte_data(entry->client, entry->page, entry->reg);
3442         mutex_unlock(&pdata->update_lock);
3443         if (rc < 0)
3444                 return rc;
3445
3446         *val = rc;
3447
3448         return 0;
3449 }
3450 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops, pmbus_debugfs_get, NULL,
3451                          "0x%02llx\n");
3452
3453 static int pmbus_debugfs_get_status(void *data, u64 *val)
3454 {
3455         int rc;
3456         struct pmbus_debugfs_entry *entry = data;
3457         struct pmbus_data *pdata = i2c_get_clientdata(entry->client);
3458
3459         rc = mutex_lock_interruptible(&pdata->update_lock);
3460         if (rc)
3461                 return rc;
3462         rc = pdata->read_status(entry->client, entry->page);
3463         mutex_unlock(&pdata->update_lock);
3464         if (rc < 0)
3465                 return rc;
3466
3467         *val = rc;
3468
3469         return 0;
3470 }
3471 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_status, pmbus_debugfs_get_status,
3472                          NULL, "0x%04llx\n");
3473
3474 static ssize_t pmbus_debugfs_mfr_read(struct file *file, char __user *buf,
3475                                        size_t count, loff_t *ppos)
3476 {
3477         int rc;
3478         struct pmbus_debugfs_entry *entry = file->private_data;
3479         struct pmbus_data *pdata = i2c_get_clientdata(entry->client);
3480         char data[I2C_SMBUS_BLOCK_MAX + 2] = { 0 };
3481
3482         rc = mutex_lock_interruptible(&pdata->update_lock);
3483         if (rc)
3484                 return rc;
3485         rc = pmbus_read_block_data(entry->client, entry->page, entry->reg,
3486                                    data);
3487         mutex_unlock(&pdata->update_lock);
3488         if (rc < 0)
3489                 return rc;
3490
3491         /* Add newline at the end of a read data */
3492         data[rc] = '\n';
3493
3494         /* Include newline into the length */
3495         rc += 1;
3496
3497         return simple_read_from_buffer(buf, count, ppos, data, rc);
3498 }
3499
3500 static const struct file_operations pmbus_debugfs_ops_mfr = {
3501         .llseek = noop_llseek,
3502         .read = pmbus_debugfs_mfr_read,
3503         .write = NULL,
3504         .open = simple_open,
3505 };
3506
3507 static void pmbus_remove_debugfs(void *data)
3508 {
3509         struct dentry *entry = data;
3510
3511         debugfs_remove_recursive(entry);
3512 }
3513
3514 static int pmbus_init_debugfs(struct i2c_client *client,
3515                               struct pmbus_data *data)
3516 {
3517         int i, idx = 0;
3518         char name[PMBUS_NAME_SIZE];
3519         struct pmbus_debugfs_entry *entries;
3520
3521         if (!pmbus_debugfs_dir)
3522                 return -ENODEV;
3523
3524         /*
3525          * Create the debugfs directory for this device. Use the hwmon device
3526          * name to avoid conflicts (hwmon numbers are globally unique).
3527          */
3528         data->debugfs = debugfs_create_dir(dev_name(data->hwmon_dev),
3529                                            pmbus_debugfs_dir);
3530         if (IS_ERR_OR_NULL(data->debugfs)) {
3531                 data->debugfs = NULL;
3532                 return -ENODEV;
3533         }
3534
3535         /*
3536          * Allocate the max possible entries we need.
3537          * 7 entries device-specific
3538          * 10 entries page-specific
3539          */
3540         entries = devm_kcalloc(data->dev,
3541                                7 + data->info->pages * 10, sizeof(*entries),
3542                                GFP_KERNEL);
3543         if (!entries)
3544                 return -ENOMEM;
3545
3546         /*
3547          * Add device-specific entries.
3548          * Please note that the PMBUS standard allows all registers to be
3549          * page-specific.
3550          * To reduce the number of debugfs entries for devices with many pages
3551          * assume that values of the following registers are the same for all
3552          * pages and report values only for page 0.
3553          */
3554         if (pmbus_check_byte_register(client, 0, PMBUS_REVISION)) {
3555                 entries[idx].client = client;
3556                 entries[idx].page = 0;
3557                 entries[idx].reg = PMBUS_REVISION;
3558                 debugfs_create_file("revision", 0444, data->debugfs,
3559                                     &entries[idx++],
3560                                     &pmbus_debugfs_ops);
3561         }
3562
3563         if (pmbus_check_block_register(client, 0, PMBUS_MFR_ID)) {
3564                 entries[idx].client = client;
3565                 entries[idx].page = 0;
3566                 entries[idx].reg = PMBUS_MFR_ID;
3567                 debugfs_create_file("mfr_id", 0444, data->debugfs,
3568                                     &entries[idx++],
3569                                     &pmbus_debugfs_ops_mfr);
3570         }
3571
3572         if (pmbus_check_block_register(client, 0, PMBUS_MFR_MODEL)) {
3573                 entries[idx].client = client;
3574                 entries[idx].page = 0;
3575                 entries[idx].reg = PMBUS_MFR_MODEL;
3576                 debugfs_create_file("mfr_model", 0444, data->debugfs,
3577                                     &entries[idx++],
3578                                     &pmbus_debugfs_ops_mfr);
3579         }
3580
3581         if (pmbus_check_block_register(client, 0, PMBUS_MFR_REVISION)) {
3582                 entries[idx].client = client;
3583                 entries[idx].page = 0;
3584                 entries[idx].reg = PMBUS_MFR_REVISION;
3585                 debugfs_create_file("mfr_revision", 0444, data->debugfs,
3586                                     &entries[idx++],
3587                                     &pmbus_debugfs_ops_mfr);
3588         }
3589
3590         if (pmbus_check_block_register(client, 0, PMBUS_MFR_LOCATION)) {
3591                 entries[idx].client = client;
3592                 entries[idx].page = 0;
3593                 entries[idx].reg = PMBUS_MFR_LOCATION;
3594                 debugfs_create_file("mfr_location", 0444, data->debugfs,
3595                                     &entries[idx++],
3596                                     &pmbus_debugfs_ops_mfr);
3597         }
3598
3599         if (pmbus_check_block_register(client, 0, PMBUS_MFR_DATE)) {
3600                 entries[idx].client = client;
3601                 entries[idx].page = 0;
3602                 entries[idx].reg = PMBUS_MFR_DATE;
3603                 debugfs_create_file("mfr_date", 0444, data->debugfs,
3604                                     &entries[idx++],
3605                                     &pmbus_debugfs_ops_mfr);
3606         }
3607
3608         if (pmbus_check_block_register(client, 0, PMBUS_MFR_SERIAL)) {
3609                 entries[idx].client = client;
3610                 entries[idx].page = 0;
3611                 entries[idx].reg = PMBUS_MFR_SERIAL;
3612                 debugfs_create_file("mfr_serial", 0444, data->debugfs,
3613                                     &entries[idx++],
3614                                     &pmbus_debugfs_ops_mfr);
3615         }
3616
3617         /* Add page specific entries */
3618         for (i = 0; i < data->info->pages; ++i) {
3619                 /* Check accessibility of status register if it's not page 0 */
3620                 if (!i || pmbus_check_status_register(client, i)) {
3621                         /* No need to set reg as we have special read op. */
3622                         entries[idx].client = client;
3623                         entries[idx].page = i;
3624                         scnprintf(name, PMBUS_NAME_SIZE, "status%d", i);
3625                         debugfs_create_file(name, 0444, data->debugfs,
3626                                             &entries[idx++],
3627                                             &pmbus_debugfs_ops_status);
3628                 }
3629
3630                 if (data->info->func[i] & PMBUS_HAVE_STATUS_VOUT) {
3631                         entries[idx].client = client;
3632                         entries[idx].page = i;
3633                         entries[idx].reg = PMBUS_STATUS_VOUT;
3634                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_vout", i);
3635                         debugfs_create_file(name, 0444, data->debugfs,
3636                                             &entries[idx++],
3637                                             &pmbus_debugfs_ops);
3638                 }
3639
3640                 if (data->info->func[i] & PMBUS_HAVE_STATUS_IOUT) {
3641                         entries[idx].client = client;
3642                         entries[idx].page = i;
3643                         entries[idx].reg = PMBUS_STATUS_IOUT;
3644                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_iout", i);
3645                         debugfs_create_file(name, 0444, data->debugfs,
3646                                             &entries[idx++],
3647                                             &pmbus_debugfs_ops);
3648                 }
3649
3650                 if (data->info->func[i] & PMBUS_HAVE_STATUS_INPUT) {
3651                         entries[idx].client = client;
3652                         entries[idx].page = i;
3653                         entries[idx].reg = PMBUS_STATUS_INPUT;
3654                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_input", i);
3655                         debugfs_create_file(name, 0444, data->debugfs,
3656                                             &entries[idx++],
3657                                             &pmbus_debugfs_ops);
3658                 }
3659
3660                 if (data->info->func[i] & PMBUS_HAVE_STATUS_TEMP) {
3661                         entries[idx].client = client;
3662                         entries[idx].page = i;
3663                         entries[idx].reg = PMBUS_STATUS_TEMPERATURE;
3664                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_temp", i);
3665                         debugfs_create_file(name, 0444, data->debugfs,
3666                                             &entries[idx++],
3667                                             &pmbus_debugfs_ops);
3668                 }
3669
3670                 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_CML)) {
3671                         entries[idx].client = client;
3672                         entries[idx].page = i;
3673                         entries[idx].reg = PMBUS_STATUS_CML;
3674                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_cml", i);
3675                         debugfs_create_file(name, 0444, data->debugfs,
3676                                             &entries[idx++],
3677                                             &pmbus_debugfs_ops);
3678                 }
3679
3680                 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_OTHER)) {
3681                         entries[idx].client = client;
3682                         entries[idx].page = i;
3683                         entries[idx].reg = PMBUS_STATUS_OTHER;
3684                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_other", i);
3685                         debugfs_create_file(name, 0444, data->debugfs,
3686                                             &entries[idx++],
3687                                             &pmbus_debugfs_ops);
3688                 }
3689
3690                 if (pmbus_check_byte_register(client, i,
3691                                               PMBUS_STATUS_MFR_SPECIFIC)) {
3692                         entries[idx].client = client;
3693                         entries[idx].page = i;
3694                         entries[idx].reg = PMBUS_STATUS_MFR_SPECIFIC;
3695                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_mfr", i);
3696                         debugfs_create_file(name, 0444, data->debugfs,
3697                                             &entries[idx++],
3698                                             &pmbus_debugfs_ops);
3699                 }
3700
3701                 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN12) {
3702                         entries[idx].client = client;
3703                         entries[idx].page = i;
3704                         entries[idx].reg = PMBUS_STATUS_FAN_12;
3705                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan12", i);
3706                         debugfs_create_file(name, 0444, data->debugfs,
3707                                             &entries[idx++],
3708                                             &pmbus_debugfs_ops);
3709                 }
3710
3711                 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN34) {
3712                         entries[idx].client = client;
3713                         entries[idx].page = i;
3714                         entries[idx].reg = PMBUS_STATUS_FAN_34;
3715                         scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan34", i);
3716                         debugfs_create_file(name, 0444, data->debugfs,
3717                                             &entries[idx++],
3718                                             &pmbus_debugfs_ops);
3719                 }
3720         }
3721
3722         return devm_add_action_or_reset(data->dev,
3723                                         pmbus_remove_debugfs, data->debugfs);
3724 }
3725 #else
3726 static int pmbus_init_debugfs(struct i2c_client *client,
3727                               struct pmbus_data *data)
3728 {
3729         return 0;
3730 }
3731 #endif  /* IS_ENABLED(CONFIG_DEBUG_FS) */
3732
3733 int pmbus_do_probe(struct i2c_client *client, struct pmbus_driver_info *info)
3734 {
3735         struct device *dev = &client->dev;
3736         const struct pmbus_platform_data *pdata = dev_get_platdata(dev);
3737         struct pmbus_data *data;
3738         size_t groups_num = 0;
3739         int ret;
3740         int i;
3741         char *name;
3742
3743         if (!info)
3744                 return -ENODEV;
3745
3746         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
3747                                      | I2C_FUNC_SMBUS_BYTE_DATA
3748                                      | I2C_FUNC_SMBUS_WORD_DATA))
3749                 return -ENODEV;
3750
3751         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
3752         if (!data)
3753                 return -ENOMEM;
3754
3755         if (info->groups)
3756                 while (info->groups[groups_num])
3757                         groups_num++;
3758
3759         data->groups = devm_kcalloc(dev, groups_num + 2, sizeof(void *),
3760                                     GFP_KERNEL);
3761         if (!data->groups)
3762                 return -ENOMEM;
3763
3764         i2c_set_clientdata(client, data);
3765         mutex_init(&data->update_lock);
3766         data->dev = dev;
3767
3768         if (pdata)
3769                 data->flags = pdata->flags;
3770         data->info = info;
3771         data->currpage = -1;
3772         data->currphase = -1;
3773
3774         for (i = 0; i < ARRAY_SIZE(data->vout_low); i++) {
3775                 data->vout_low[i] = -1;
3776                 data->vout_high[i] = -1;
3777         }
3778
3779         ret = pmbus_init_common(client, data, info);
3780         if (ret < 0)
3781                 return ret;
3782
3783         ret = pmbus_find_attributes(client, data);
3784         if (ret)
3785                 return ret;
3786
3787         /*
3788          * If there are no attributes, something is wrong.
3789          * Bail out instead of trying to register nothing.
3790          */
3791         if (!data->num_attributes) {
3792                 dev_err(dev, "No attributes found\n");
3793                 return -ENODEV;
3794         }
3795
3796         name = devm_kstrdup(dev, client->name, GFP_KERNEL);
3797         if (!name)
3798                 return -ENOMEM;
3799         strreplace(name, '-', '_');
3800
3801         data->groups[0] = &data->group;
3802         memcpy(data->groups + 1, info->groups, sizeof(void *) * groups_num);
3803         data->hwmon_dev = devm_hwmon_device_register_with_groups(dev,
3804                                         name, data, data->groups);
3805         if (IS_ERR(data->hwmon_dev)) {
3806                 dev_err(dev, "Failed to register hwmon device\n");
3807                 return PTR_ERR(data->hwmon_dev);
3808         }
3809
3810         ret = pmbus_regulator_register(data);
3811         if (ret)
3812                 return ret;
3813
3814         ret = pmbus_irq_setup(client, data);
3815         if (ret)
3816                 return ret;
3817
3818         ret = pmbus_init_debugfs(client, data);
3819         if (ret)
3820                 dev_warn(dev, "Failed to register debugfs\n");
3821
3822         return 0;
3823 }
3824 EXPORT_SYMBOL_NS_GPL(pmbus_do_probe, "PMBUS");
3825
3826 struct dentry *pmbus_get_debugfs_dir(struct i2c_client *client)
3827 {
3828         struct pmbus_data *data = i2c_get_clientdata(client);
3829
3830         return data->debugfs;
3831 }
3832 EXPORT_SYMBOL_NS_GPL(pmbus_get_debugfs_dir, "PMBUS");
3833
3834 int pmbus_lock_interruptible(struct i2c_client *client)
3835 {
3836         struct pmbus_data *data = i2c_get_clientdata(client);
3837
3838         return mutex_lock_interruptible(&data->update_lock);
3839 }
3840 EXPORT_SYMBOL_NS_GPL(pmbus_lock_interruptible, "PMBUS");
3841
3842 void pmbus_unlock(struct i2c_client *client)
3843 {
3844         struct pmbus_data *data = i2c_get_clientdata(client);
3845
3846         mutex_unlock(&data->update_lock);
3847 }
3848 EXPORT_SYMBOL_NS_GPL(pmbus_unlock, "PMBUS");
3849
3850 static int __init pmbus_core_init(void)
3851 {
3852         pmbus_debugfs_dir = debugfs_create_dir("pmbus", NULL);
3853         if (IS_ERR(pmbus_debugfs_dir))
3854                 pmbus_debugfs_dir = NULL;
3855
3856         return 0;
3857 }
3858
3859 static void __exit pmbus_core_exit(void)
3860 {
3861         debugfs_remove_recursive(pmbus_debugfs_dir);
3862 }
3863
3864 module_init(pmbus_core_init);
3865 module_exit(pmbus_core_exit);
3866
3867 MODULE_AUTHOR("Guenter Roeck");
3868 MODULE_DESCRIPTION("PMBus core driver");
3869 MODULE_LICENSE("GPL");