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