drivers/hwmon/pmbus/pmbus_core.c

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