drivers/hwmon/pmbus/pmbus_core.c

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