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/delay.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, int *val)
 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 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                 *val = !!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                 *val = !!(regval && v1 >= v2);
 743         }
 744         return 0;
 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         int err;
 754
 755         err = pmbus_get_boolean(data, attr->index, &val);
 756         if (err)
 757                 return err;
 758         return snprintf(buf, PAGE_SIZE, "%d\n", val);
 759 }
 760
 761 static ssize_t pmbus_show_sensor(struct device *dev,
 762                                  struct device_attribute *da, char *buf)
 763 {
 764         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 765         struct pmbus_data *data = pmbus_update_device(dev);
 766         struct pmbus_sensor *sensor;
 767
 768         sensor = &data->sensors[attr->index];
 769         if (sensor->data < 0)
 770                 return sensor->data;
 771
 772         return snprintf(buf, PAGE_SIZE, "%ld\n", pmbus_reg2data(data, sensor));
 773 }
 774
 775 static ssize_t pmbus_set_sensor(struct device *dev,
 776                                 struct device_attribute *devattr,
 777                                 const char *buf, size_t count)
 778 {
 779         struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
 780         struct i2c_client *client = to_i2c_client(dev);
 781         struct pmbus_data *data = i2c_get_clientdata(client);
 782         struct pmbus_sensor *sensor = &data->sensors[attr->index];
 783         ssize_t rv = count;
 784         long val = 0;
 785         int ret;
 786         u16 regval;
 787
 788         if (kstrtol(buf, 10, &val) < 0)
 789                 return -EINVAL;
 790
 791         mutex_lock(&data->update_lock);
 792         regval = pmbus_data2reg(data, sensor->class, val);
 793         ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval);
 794         if (ret < 0)
 795                 rv = ret;
 796         else
 797                 data->sensors[attr->index].data = regval;
 798         mutex_unlock(&data->update_lock);
 799         return rv;
 800 }
 801
 802 static ssize_t pmbus_show_label(struct device *dev,
 803                                 struct device_attribute *da, char *buf)
 804 {
 805         struct i2c_client *client = to_i2c_client(dev);
 806         struct pmbus_data *data = i2c_get_clientdata(client);
 807         struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
 808
 809         return snprintf(buf, PAGE_SIZE, "%s\n",
 810                         data->labels[attr->index].label);
 811 }
 812
 813 #define PMBUS_ADD_ATTR(data, _name, _idx, _mode, _type, _show, _set)    \
 814 do {                                                                    \
 815         struct sensor_device_attribute *a                               \
 816             = &data->_type##s[data->num_##_type##s].attribute;          \
 817         BUG_ON(data->num_attributes >= data->max_attributes);           \
 818         sysfs_attr_init(&a->dev_attr.attr);                             \
 819         a->dev_attr.attr.name = _name;                                  \
 820         a->dev_attr.attr.mode = _mode;                                  \
 821         a->dev_attr.show = _show;                                       \
 822         a->dev_attr.store = _set;                                       \
 823         a->index = _idx;                                                \
 824         data->attributes[data->num_attributes] = &a->dev_attr.attr;     \
 825         data->num_attributes++;                                         \
 826 } while (0)
 827
 828 #define PMBUS_ADD_GET_ATTR(data, _name, _type, _idx)                    \
 829         PMBUS_ADD_ATTR(data, _name, _idx, S_IRUGO, _type,               \
 830                        pmbus_show_##_type,  NULL)
 831
 832 #define PMBUS_ADD_SET_ATTR(data, _name, _type, _idx)                    \
 833         PMBUS_ADD_ATTR(data, _name, _idx, S_IWUSR | S_IRUGO, _type,     \
 834                        pmbus_show_##_type, pmbus_set_##_type)
 835
 836 static void pmbus_add_boolean(struct pmbus_data *data,
 837                               const char *name, const char *type, int seq,
 838                               int idx)
 839 {
 840         struct pmbus_boolean *boolean;
 841
 842         BUG_ON(data->num_booleans >= data->max_booleans);
 843
 844         boolean = &data->booleans[data->num_booleans];
 845
 846         snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s",
 847                  name, seq, type);
 848         PMBUS_ADD_GET_ATTR(data, boolean->name, boolean, idx);
 849         data->num_booleans++;
 850 }
 851
 852 static void pmbus_add_boolean_reg(struct pmbus_data *data,
 853                                   const char *name, const char *type,
 854                                   int seq, int reg, int bit)
 855 {
 856         pmbus_add_boolean(data, name, type, seq, (reg << 8) | bit);
 857 }
 858
 859 static void pmbus_add_boolean_cmp(struct pmbus_data *data,
 860                                   const char *name, const char *type,
 861                                   int seq, int i1, int i2, int reg, int mask)
 862 {
 863         pmbus_add_boolean(data, name, type, seq,
 864                           (i1 << 24) | (i2 << 16) | (reg << 8) | mask);
 865 }
 866
 867 static void pmbus_add_sensor(struct pmbus_data *data,
 868                              const char *name, const char *type, int seq,
 869                              int page, int reg, enum pmbus_sensor_classes class,
 870                              bool update, bool readonly)
 871 {
 872         struct pmbus_sensor *sensor;
 873
 874         BUG_ON(data->num_sensors >= data->max_sensors);
 875
 876         sensor = &data->sensors[data->num_sensors];
 877         snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s",
 878                  name, seq, type);
 879         sensor->page = page;
 880         sensor->reg = reg;
 881         sensor->class = class;
 882         sensor->update = update;
 883         if (readonly)
 884                 PMBUS_ADD_GET_ATTR(data, sensor->name, sensor,
 885                                    data->num_sensors);
 886         else
 887                 PMBUS_ADD_SET_ATTR(data, sensor->name, sensor,
 888                                    data->num_sensors);
 889         data->num_sensors++;
 890 }
 891
 892 static void pmbus_add_label(struct pmbus_data *data,
 893                             const char *name, int seq,
 894                             const char *lstring, int index)
 895 {
 896         struct pmbus_label *label;
 897
 898         BUG_ON(data->num_labels >= data->max_labels);
 899
 900         label = &data->labels[data->num_labels];
 901         snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq);
 902         if (!index)
 903                 strncpy(label->label, lstring, sizeof(label->label) - 1);
 904         else
 905                 snprintf(label->label, sizeof(label->label), "%s%d", lstring,
 906                          index);
 907
 908         PMBUS_ADD_GET_ATTR(data, label->name, label, data->num_labels);
 909         data->num_labels++;
 910 }
 911
 912 /*
 913  * Determine maximum number of sensors, booleans, and labels.
 914  * To keep things simple, only make a rough high estimate.
 915  */
 916 static void pmbus_find_max_attr(struct i2c_client *client,
 917                                 struct pmbus_data *data)
 918 {
 919         const struct pmbus_driver_info *info = data->info;
 920         int page, max_sensors, max_booleans, max_labels;
 921
 922         max_sensors = PMBUS_MAX_INPUT_SENSORS;
 923         max_booleans = PMBUS_MAX_INPUT_BOOLEANS;
 924         max_labels = PMBUS_MAX_INPUT_LABELS;
 925
 926         for (page = 0; page < info->pages; page++) {
 927                 if (info->func[page] & PMBUS_HAVE_VOUT) {
 928                         max_sensors += PMBUS_VOUT_SENSORS_PER_PAGE;
 929                         max_booleans += PMBUS_VOUT_BOOLEANS_PER_PAGE;
 930                         max_labels++;
 931                 }
 932                 if (info->func[page] & PMBUS_HAVE_IOUT) {
 933                         max_sensors += PMBUS_IOUT_SENSORS_PER_PAGE;
 934                         max_booleans += PMBUS_IOUT_BOOLEANS_PER_PAGE;
 935                         max_labels++;
 936                 }
 937                 if (info->func[page] & PMBUS_HAVE_POUT) {
 938                         max_sensors += PMBUS_POUT_SENSORS_PER_PAGE;
 939                         max_booleans += PMBUS_POUT_BOOLEANS_PER_PAGE;
 940                         max_labels++;
 941                 }
 942                 if (info->func[page] & PMBUS_HAVE_FAN12) {
 943                         max_sensors += 2 * PMBUS_MAX_SENSORS_PER_FAN;
 944                         max_booleans += 2 * PMBUS_MAX_BOOLEANS_PER_FAN;
 945                 }
 946                 if (info->func[page] & PMBUS_HAVE_FAN34) {
 947                         max_sensors += 2 * PMBUS_MAX_SENSORS_PER_FAN;
 948                         max_booleans += 2 * PMBUS_MAX_BOOLEANS_PER_FAN;
 949                 }
 950                 if (info->func[page] & PMBUS_HAVE_TEMP) {
 951                         max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
 952                         max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
 953                 }
 954                 if (info->func[page] & PMBUS_HAVE_TEMP2) {
 955                         max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
 956                         max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
 957                 }
 958                 if (info->func[page] & PMBUS_HAVE_TEMP3) {
 959                         max_sensors += PMBUS_MAX_SENSORS_PER_TEMP;
 960                         max_booleans += PMBUS_MAX_BOOLEANS_PER_TEMP;
 961                 }
 962         }
 963         data->max_sensors = max_sensors;
 964         data->max_booleans = max_booleans;
 965         data->max_labels = max_labels;
 966         data->max_attributes = max_sensors + max_booleans + max_labels;
 967 }
 968
 969 /*
 970  * Search for attributes. Allocate sensors, booleans, and labels as needed.
 971  */
 972
 973 /*
 974  * The pmbus_limit_attr structure describes a single limit attribute
 975  * and its associated alarm attribute.
 976  */
 977 struct pmbus_limit_attr {
 978         u16 reg;                /* Limit register */
 979         bool update;            /* True if register needs updates */
 980         bool low;               /* True if low limit; for limits with compare
 981                                    functions only */
 982         const char *attr;       /* Attribute name */
 983         const char *alarm;      /* Alarm attribute name */
 984         u32 sbit;               /* Alarm attribute status bit */
 985 };
 986
 987 /*
 988  * The pmbus_sensor_attr structure describes one sensor attribute. This
 989  * description includes a reference to the associated limit attributes.
 990  */
 991 struct pmbus_sensor_attr {
 992         u8 reg;                         /* sensor register */
 993         enum pmbus_sensor_classes class;/* sensor class */
 994         const char *label;              /* sensor label */
 995         bool paged;                     /* true if paged sensor */
 996         bool update;                    /* true if update needed */
 997         bool compare;                   /* true if compare function needed */
 998         u32 func;                       /* sensor mask */
 999         u32 sfunc;                      /* sensor status mask */
1000         int sbase;                      /* status base register */
1001         u32 gbit;                       /* generic status bit */
1002         const struct pmbus_limit_attr *limit;/* limit registers */
1003         int nlimit;                     /* # of limit registers */
1004 };
1005
1006 /*
1007  * Add a set of limit attributes and, if supported, the associated
1008  * alarm attributes.
1009  */
1010 static bool pmbus_add_limit_attrs(struct i2c_client *client,
1011                                   struct pmbus_data *data,
1012                                   const struct pmbus_driver_info *info,
1013                                   const char *name, int index, int page,
1014                                   int cbase,
1015                                   const struct pmbus_sensor_attr *attr)
1016 {
1017         const struct pmbus_limit_attr *l = attr->limit;
1018         int nlimit = attr->nlimit;
1019         bool have_alarm = false;
1020         int i, cindex;
1021
1022         for (i = 0; i < nlimit; i++) {
1023                 if (pmbus_check_word_register(client, page, l->reg)) {
1024                         cindex = data->num_sensors;
1025                         pmbus_add_sensor(data, name, l->attr, index, page,
1026                                          l->reg, attr->class,
1027                                          attr->update || l->update,
1028                                          false);
1029                         if (l->sbit && (info->func[page] & attr->sfunc)) {
1030                                 if (attr->compare) {
1031                                         pmbus_add_boolean_cmp(data, name,
1032                                                 l->alarm, index,
1033                                                 l->low ? cindex : cbase,
1034                                                 l->low ? cbase : cindex,
1035                                                 attr->sbase + page, l->sbit);
1036                                 } else {
1037                                         pmbus_add_boolean_reg(data, name,
1038                                                 l->alarm, index,
1039                                                 attr->sbase + page, l->sbit);
1040                                 }
1041                                 have_alarm = true;
1042                         }
1043                 }
1044                 l++;
1045         }
1046         return have_alarm;
1047 }
1048
1049 static void pmbus_add_sensor_attrs_one(struct i2c_client *client,
1050                                        struct pmbus_data *data,
1051                                        const struct pmbus_driver_info *info,
1052                                        const char *name,
1053                                        int index, int page,
1054                                        const struct pmbus_sensor_attr *attr)
1055 {
1056         bool have_alarm;
1057         int cbase = data->num_sensors;
1058
1059         if (attr->label)
1060                 pmbus_add_label(data, name, index, attr->label,
1061                                 attr->paged ? page + 1 : 0);
1062         pmbus_add_sensor(data, name, "input", index, page, attr->reg,
1063                          attr->class, true, true);
1064         if (attr->sfunc) {
1065                 have_alarm = pmbus_add_limit_attrs(client, data, info, name,
1066                                                    index, page, cbase, attr);
1067                 /*
1068                  * Add generic alarm attribute only if there are no individual
1069                  * alarm attributes, if there is a global alarm bit, and if
1070                  * the generic status register for this page is accessible.
1071                  */
1072                 if (!have_alarm && attr->gbit &&
1073                     pmbus_check_byte_register(client, page, PMBUS_STATUS_BYTE))
1074                         pmbus_add_boolean_reg(data, name, "alarm", index,
1075                                               PB_STATUS_BASE + page,
1076                                               attr->gbit);
1077         }
1078 }
1079
1080 static void pmbus_add_sensor_attrs(struct i2c_client *client,
1081                                    struct pmbus_data *data,
1082                                    const char *name,
1083                                    const struct pmbus_sensor_attr *attrs,
1084                                    int nattrs)
1085 {
1086         const struct pmbus_driver_info *info = data->info;
1087         int index, i;
1088
1089         index = 1;
1090         for (i = 0; i < nattrs; i++) {
1091                 int page, pages;
1092
1093                 pages = attrs->paged ? info->pages : 1;
1094                 for (page = 0; page < pages; page++) {
1095                         if (!(info->func[page] & attrs->func))
1096                                 continue;
1097                         pmbus_add_sensor_attrs_one(client, data, info, name,
1098                                                    index, page, attrs);
1099                         index++;
1100                 }
1101                 attrs++;
1102         }
1103 }
1104
1105 static const struct pmbus_limit_attr vin_limit_attrs[] = {
1106         {
1107                 .reg = PMBUS_VIN_UV_WARN_LIMIT,
1108                 .attr = "min",
1109                 .alarm = "min_alarm",
1110                 .sbit = PB_VOLTAGE_UV_WARNING,
1111         }, {
1112                 .reg = PMBUS_VIN_UV_FAULT_LIMIT,
1113                 .attr = "lcrit",
1114                 .alarm = "lcrit_alarm",
1115                 .sbit = PB_VOLTAGE_UV_FAULT,
1116         }, {
1117                 .reg = PMBUS_VIN_OV_WARN_LIMIT,
1118                 .attr = "max",
1119                 .alarm = "max_alarm",
1120                 .sbit = PB_VOLTAGE_OV_WARNING,
1121         }, {
1122                 .reg = PMBUS_VIN_OV_FAULT_LIMIT,
1123                 .attr = "crit",
1124                 .alarm = "crit_alarm",
1125                 .sbit = PB_VOLTAGE_OV_FAULT,
1126         }, {
1127                 .reg = PMBUS_VIRT_READ_VIN_AVG,
1128                 .update = true,
1129                 .attr = "average",
1130         }, {
1131                 .reg = PMBUS_VIRT_READ_VIN_MIN,
1132                 .update = true,
1133                 .attr = "lowest",
1134         }, {
1135                 .reg = PMBUS_VIRT_READ_VIN_MAX,
1136                 .update = true,
1137                 .attr = "highest",
1138         }, {
1139                 .reg = PMBUS_VIRT_RESET_VIN_HISTORY,
1140                 .attr = "reset_history",
1141         },
1142 };
1143
1144 static const struct pmbus_limit_attr vout_limit_attrs[] = {
1145         {
1146                 .reg = PMBUS_VOUT_UV_WARN_LIMIT,
1147                 .attr = "min",
1148                 .alarm = "min_alarm",
1149                 .sbit = PB_VOLTAGE_UV_WARNING,
1150         }, {
1151                 .reg = PMBUS_VOUT_UV_FAULT_LIMIT,
1152                 .attr = "lcrit",
1153                 .alarm = "lcrit_alarm",
1154                 .sbit = PB_VOLTAGE_UV_FAULT,
1155         }, {
1156                 .reg = PMBUS_VOUT_OV_WARN_LIMIT,
1157                 .attr = "max",
1158                 .alarm = "max_alarm",
1159                 .sbit = PB_VOLTAGE_OV_WARNING,
1160         }, {
1161                 .reg = PMBUS_VOUT_OV_FAULT_LIMIT,
1162                 .attr = "crit",
1163                 .alarm = "crit_alarm",
1164                 .sbit = PB_VOLTAGE_OV_FAULT,
1165         }, {
1166                 .reg = PMBUS_VIRT_READ_VOUT_AVG,
1167                 .update = true,
1168                 .attr = "average",
1169         }, {
1170                 .reg = PMBUS_VIRT_READ_VOUT_MIN,
1171                 .update = true,
1172                 .attr = "lowest",
1173         }, {
1174                 .reg = PMBUS_VIRT_READ_VOUT_MAX,
1175                 .update = true,
1176                 .attr = "highest",
1177         }, {
1178                 .reg = PMBUS_VIRT_RESET_VOUT_HISTORY,
1179                 .attr = "reset_history",
1180         }
1181 };
1182
1183 static const struct pmbus_sensor_attr voltage_attributes[] = {
1184         {
1185                 .reg = PMBUS_READ_VIN,
1186                 .class = PSC_VOLTAGE_IN,
1187                 .label = "vin",
1188                 .func = PMBUS_HAVE_VIN,
1189                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1190                 .sbase = PB_STATUS_INPUT_BASE,
1191                 .gbit = PB_STATUS_VIN_UV,
1192                 .limit = vin_limit_attrs,
1193                 .nlimit = ARRAY_SIZE(vin_limit_attrs),
1194         }, {
1195                 .reg = PMBUS_READ_VCAP,
1196                 .class = PSC_VOLTAGE_IN,
1197                 .label = "vcap",
1198                 .func = PMBUS_HAVE_VCAP,
1199         }, {
1200                 .reg = PMBUS_READ_VOUT,
1201                 .class = PSC_VOLTAGE_OUT,
1202                 .label = "vout",
1203                 .paged = true,
1204                 .func = PMBUS_HAVE_VOUT,
1205                 .sfunc = PMBUS_HAVE_STATUS_VOUT,
1206                 .sbase = PB_STATUS_VOUT_BASE,
1207                 .gbit = PB_STATUS_VOUT_OV,
1208                 .limit = vout_limit_attrs,
1209                 .nlimit = ARRAY_SIZE(vout_limit_attrs),
1210         }
1211 };
1212
1213 /* Current attributes */
1214
1215 static const struct pmbus_limit_attr iin_limit_attrs[] = {
1216         {
1217                 .reg = PMBUS_IIN_OC_WARN_LIMIT,
1218                 .attr = "max",
1219                 .alarm = "max_alarm",
1220                 .sbit = PB_IIN_OC_WARNING,
1221         }, {
1222                 .reg = PMBUS_IIN_OC_FAULT_LIMIT,
1223                 .attr = "crit",
1224                 .alarm = "crit_alarm",
1225                 .sbit = PB_IIN_OC_FAULT,
1226         }, {
1227                 .reg = PMBUS_VIRT_READ_IIN_AVG,
1228                 .update = true,
1229                 .attr = "average",
1230         }, {
1231                 .reg = PMBUS_VIRT_READ_IIN_MIN,
1232                 .update = true,
1233                 .attr = "lowest",
1234         }, {
1235                 .reg = PMBUS_VIRT_READ_IIN_MAX,
1236                 .update = true,
1237                 .attr = "highest",
1238         }, {
1239                 .reg = PMBUS_VIRT_RESET_IIN_HISTORY,
1240                 .attr = "reset_history",
1241         }
1242 };
1243
1244 static const struct pmbus_limit_attr iout_limit_attrs[] = {
1245         {
1246                 .reg = PMBUS_IOUT_OC_WARN_LIMIT,
1247                 .attr = "max",
1248                 .alarm = "max_alarm",
1249                 .sbit = PB_IOUT_OC_WARNING,
1250         }, {
1251                 .reg = PMBUS_IOUT_UC_FAULT_LIMIT,
1252                 .attr = "lcrit",
1253                 .alarm = "lcrit_alarm",
1254                 .sbit = PB_IOUT_UC_FAULT,
1255         }, {
1256                 .reg = PMBUS_IOUT_OC_FAULT_LIMIT,
1257                 .attr = "crit",
1258                 .alarm = "crit_alarm",
1259                 .sbit = PB_IOUT_OC_FAULT,
1260         }, {
1261                 .reg = PMBUS_VIRT_READ_IOUT_AVG,
1262                 .update = true,
1263                 .attr = "average",
1264         }, {
1265                 .reg = PMBUS_VIRT_READ_IOUT_MIN,
1266                 .update = true,
1267                 .attr = "lowest",
1268         }, {
1269                 .reg = PMBUS_VIRT_READ_IOUT_MAX,
1270                 .update = true,
1271                 .attr = "highest",
1272         }, {
1273                 .reg = PMBUS_VIRT_RESET_IOUT_HISTORY,
1274                 .attr = "reset_history",
1275         }
1276 };
1277
1278 static const struct pmbus_sensor_attr current_attributes[] = {
1279         {
1280                 .reg = PMBUS_READ_IIN,
1281                 .class = PSC_CURRENT_IN,
1282                 .label = "iin",
1283                 .func = PMBUS_HAVE_IIN,
1284                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1285                 .sbase = PB_STATUS_INPUT_BASE,
1286                 .limit = iin_limit_attrs,
1287                 .nlimit = ARRAY_SIZE(iin_limit_attrs),
1288         }, {
1289                 .reg = PMBUS_READ_IOUT,
1290                 .class = PSC_CURRENT_OUT,
1291                 .label = "iout",
1292                 .paged = true,
1293                 .func = PMBUS_HAVE_IOUT,
1294                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1295                 .sbase = PB_STATUS_IOUT_BASE,
1296                 .gbit = PB_STATUS_IOUT_OC,
1297                 .limit = iout_limit_attrs,
1298                 .nlimit = ARRAY_SIZE(iout_limit_attrs),
1299         }
1300 };
1301
1302 /* Power attributes */
1303
1304 static const struct pmbus_limit_attr pin_limit_attrs[] = {
1305         {
1306                 .reg = PMBUS_PIN_OP_WARN_LIMIT,
1307                 .attr = "max",
1308                 .alarm = "alarm",
1309                 .sbit = PB_PIN_OP_WARNING,
1310         }, {
1311                 .reg = PMBUS_VIRT_READ_PIN_AVG,
1312                 .update = true,
1313                 .attr = "average",
1314         }, {
1315                 .reg = PMBUS_VIRT_READ_PIN_MAX,
1316                 .update = true,
1317                 .attr = "input_highest",
1318         }, {
1319                 .reg = PMBUS_VIRT_RESET_PIN_HISTORY,
1320                 .attr = "reset_history",
1321         }
1322 };
1323
1324 static const struct pmbus_limit_attr pout_limit_attrs[] = {
1325         {
1326                 .reg = PMBUS_POUT_MAX,
1327                 .attr = "cap",
1328                 .alarm = "cap_alarm",
1329                 .sbit = PB_POWER_LIMITING,
1330         }, {
1331                 .reg = PMBUS_POUT_OP_WARN_LIMIT,
1332                 .attr = "max",
1333                 .alarm = "max_alarm",
1334                 .sbit = PB_POUT_OP_WARNING,
1335         }, {
1336                 .reg = PMBUS_POUT_OP_FAULT_LIMIT,
1337                 .attr = "crit",
1338                 .alarm = "crit_alarm",
1339                 .sbit = PB_POUT_OP_FAULT,
1340         }, {
1341                 .reg = PMBUS_VIRT_READ_POUT_AVG,
1342                 .update = true,
1343                 .attr = "average",
1344         }, {
1345                 .reg = PMBUS_VIRT_READ_POUT_MAX,
1346                 .update = true,
1347                 .attr = "input_highest",
1348         }, {
1349                 .reg = PMBUS_VIRT_RESET_POUT_HISTORY,
1350                 .attr = "reset_history",
1351         }
1352 };
1353
1354 static const struct pmbus_sensor_attr power_attributes[] = {
1355         {
1356                 .reg = PMBUS_READ_PIN,
1357                 .class = PSC_POWER,
1358                 .label = "pin",
1359                 .func = PMBUS_HAVE_PIN,
1360                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1361                 .sbase = PB_STATUS_INPUT_BASE,
1362                 .limit = pin_limit_attrs,
1363                 .nlimit = ARRAY_SIZE(pin_limit_attrs),
1364         }, {
1365                 .reg = PMBUS_READ_POUT,
1366                 .class = PSC_POWER,
1367                 .label = "pout",
1368                 .paged = true,
1369                 .func = PMBUS_HAVE_POUT,
1370                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1371                 .sbase = PB_STATUS_IOUT_BASE,
1372                 .limit = pout_limit_attrs,
1373                 .nlimit = ARRAY_SIZE(pout_limit_attrs),
1374         }
1375 };
1376
1377 /* Temperature atributes */
1378
1379 static const struct pmbus_limit_attr temp_limit_attrs[] = {
1380         {
1381                 .reg = PMBUS_UT_WARN_LIMIT,
1382                 .low = true,
1383                 .attr = "min",
1384                 .alarm = "min_alarm",
1385                 .sbit = PB_TEMP_UT_WARNING,
1386         }, {
1387                 .reg = PMBUS_UT_FAULT_LIMIT,
1388                 .low = true,
1389                 .attr = "lcrit",
1390                 .alarm = "lcrit_alarm",
1391                 .sbit = PB_TEMP_UT_FAULT,
1392         }, {
1393                 .reg = PMBUS_OT_WARN_LIMIT,
1394                 .attr = "max",
1395                 .alarm = "max_alarm",
1396                 .sbit = PB_TEMP_OT_WARNING,
1397         }, {
1398                 .reg = PMBUS_OT_FAULT_LIMIT,
1399                 .attr = "crit",
1400                 .alarm = "crit_alarm",
1401                 .sbit = PB_TEMP_OT_FAULT,
1402         }, {
1403                 .reg = PMBUS_VIRT_READ_TEMP_MIN,
1404                 .attr = "lowest",
1405         }, {
1406                 .reg = PMBUS_VIRT_READ_TEMP_AVG,
1407                 .attr = "average",
1408         }, {
1409                 .reg = PMBUS_VIRT_READ_TEMP_MAX,
1410                 .attr = "highest",
1411         }, {
1412                 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
1413                 .attr = "reset_history",
1414         }
1415 };
1416
1417 static const struct pmbus_limit_attr temp_limit_attrs2[] = {
1418         {
1419                 .reg = PMBUS_UT_WARN_LIMIT,
1420                 .low = true,
1421                 .attr = "min",
1422                 .alarm = "min_alarm",
1423                 .sbit = PB_TEMP_UT_WARNING,
1424         }, {
1425                 .reg = PMBUS_UT_FAULT_LIMIT,
1426                 .low = true,
1427                 .attr = "lcrit",
1428                 .alarm = "lcrit_alarm",
1429                 .sbit = PB_TEMP_UT_FAULT,
1430         }, {
1431                 .reg = PMBUS_OT_WARN_LIMIT,
1432                 .attr = "max",
1433                 .alarm = "max_alarm",
1434                 .sbit = PB_TEMP_OT_WARNING,
1435         }, {
1436                 .reg = PMBUS_OT_FAULT_LIMIT,
1437                 .attr = "crit",
1438                 .alarm = "crit_alarm",
1439                 .sbit = PB_TEMP_OT_FAULT,
1440         }, {
1441                 .reg = PMBUS_VIRT_READ_TEMP2_MIN,
1442                 .attr = "lowest",
1443         }, {
1444                 .reg = PMBUS_VIRT_READ_TEMP2_AVG,
1445                 .attr = "average",
1446         }, {
1447                 .reg = PMBUS_VIRT_READ_TEMP2_MAX,
1448                 .attr = "highest",
1449         }, {
1450                 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
1451                 .attr = "reset_history",
1452         }
1453 };
1454
1455 static const struct pmbus_limit_attr temp_limit_attrs3[] = {
1456         {
1457                 .reg = PMBUS_UT_WARN_LIMIT,
1458                 .low = true,
1459                 .attr = "min",
1460                 .alarm = "min_alarm",
1461                 .sbit = PB_TEMP_UT_WARNING,
1462         }, {
1463                 .reg = PMBUS_UT_FAULT_LIMIT,
1464                 .low = true,
1465                 .attr = "lcrit",
1466                 .alarm = "lcrit_alarm",
1467                 .sbit = PB_TEMP_UT_FAULT,
1468         }, {
1469                 .reg = PMBUS_OT_WARN_LIMIT,
1470                 .attr = "max",
1471                 .alarm = "max_alarm",
1472                 .sbit = PB_TEMP_OT_WARNING,
1473         }, {
1474                 .reg = PMBUS_OT_FAULT_LIMIT,
1475                 .attr = "crit",
1476                 .alarm = "crit_alarm",
1477                 .sbit = PB_TEMP_OT_FAULT,
1478         }
1479 };
1480
1481 static const struct pmbus_sensor_attr temp_attributes[] = {
1482         {
1483                 .reg = PMBUS_READ_TEMPERATURE_1,
1484                 .class = PSC_TEMPERATURE,
1485                 .paged = true,
1486                 .update = true,
1487                 .compare = true,
1488                 .func = PMBUS_HAVE_TEMP,
1489                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1490                 .sbase = PB_STATUS_TEMP_BASE,
1491                 .gbit = PB_STATUS_TEMPERATURE,
1492                 .limit = temp_limit_attrs,
1493                 .nlimit = ARRAY_SIZE(temp_limit_attrs),
1494         }, {
1495                 .reg = PMBUS_READ_TEMPERATURE_2,
1496                 .class = PSC_TEMPERATURE,
1497                 .paged = true,
1498                 .update = true,
1499                 .compare = true,
1500                 .func = PMBUS_HAVE_TEMP2,
1501                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1502                 .sbase = PB_STATUS_TEMP_BASE,
1503                 .gbit = PB_STATUS_TEMPERATURE,
1504                 .limit = temp_limit_attrs2,
1505                 .nlimit = ARRAY_SIZE(temp_limit_attrs2),
1506         }, {
1507                 .reg = PMBUS_READ_TEMPERATURE_3,
1508                 .class = PSC_TEMPERATURE,
1509                 .paged = true,
1510                 .update = true,
1511                 .compare = true,
1512                 .func = PMBUS_HAVE_TEMP3,
1513                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1514                 .sbase = PB_STATUS_TEMP_BASE,
1515                 .gbit = PB_STATUS_TEMPERATURE,
1516                 .limit = temp_limit_attrs3,
1517                 .nlimit = ARRAY_SIZE(temp_limit_attrs3),
1518         }
1519 };
1520
1521 static const int pmbus_fan_registers[] = {
1522         PMBUS_READ_FAN_SPEED_1,
1523         PMBUS_READ_FAN_SPEED_2,
1524         PMBUS_READ_FAN_SPEED_3,
1525         PMBUS_READ_FAN_SPEED_4
1526 };
1527
1528 static const int pmbus_fan_config_registers[] = {
1529         PMBUS_FAN_CONFIG_12,
1530         PMBUS_FAN_CONFIG_12,
1531         PMBUS_FAN_CONFIG_34,
1532         PMBUS_FAN_CONFIG_34
1533 };
1534
1535 static const int pmbus_fan_status_registers[] = {
1536         PMBUS_STATUS_FAN_12,
1537         PMBUS_STATUS_FAN_12,
1538         PMBUS_STATUS_FAN_34,
1539         PMBUS_STATUS_FAN_34
1540 };
1541
1542 static const u32 pmbus_fan_flags[] = {
1543         PMBUS_HAVE_FAN12,
1544         PMBUS_HAVE_FAN12,
1545         PMBUS_HAVE_FAN34,
1546         PMBUS_HAVE_FAN34
1547 };
1548
1549 static const u32 pmbus_fan_status_flags[] = {
1550         PMBUS_HAVE_STATUS_FAN12,
1551         PMBUS_HAVE_STATUS_FAN12,
1552         PMBUS_HAVE_STATUS_FAN34,
1553         PMBUS_HAVE_STATUS_FAN34
1554 };
1555
1556 /* Fans */
1557 static void pmbus_add_fan_attributes(struct i2c_client *client,
1558                                      struct pmbus_data *data)
1559 {
1560         const struct pmbus_driver_info *info = data->info;
1561         int index = 1;
1562         int page;
1563
1564         for (page = 0; page < info->pages; page++) {
1565                 int f;
1566
1567                 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) {
1568                         int regval;
1569
1570                         if (!(info->func[page] & pmbus_fan_flags[f]))
1571                                 break;
1572
1573                         if (!pmbus_check_word_register(client, page,
1574                                                        pmbus_fan_registers[f]))
1575                                 break;
1576
1577                         /*
1578                          * Skip fan if not installed.
1579                          * Each fan configuration register covers multiple fans,
1580                          * so we have to do some magic.
1581                          */
1582                         regval = _pmbus_read_byte_data(client, page,
1583                                 pmbus_fan_config_registers[f]);
1584                         if (regval < 0 ||
1585                             (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
1586                                 continue;
1587
1588                         pmbus_add_sensor(data, "fan", "input", index, page,
1589                                          pmbus_fan_registers[f], PSC_FAN, true,
1590                                          true);
1591
1592                         /*
1593                          * Each fan status register covers multiple fans,
1594                          * so we have to do some magic.
1595                          */
1596                         if ((info->func[page] & pmbus_fan_status_flags[f]) &&
1597                             pmbus_check_byte_register(client,
1598                                         page, pmbus_fan_status_registers[f])) {
1599                                 int base;
1600
1601                                 if (f > 1)      /* fan 3, 4 */
1602                                         base = PB_STATUS_FAN34_BASE + page;
1603                                 else
1604                                         base = PB_STATUS_FAN_BASE + page;
1605                                 pmbus_add_boolean_reg(data, "fan", "alarm",
1606                                         index, base,
1607                                         PB_FAN_FAN1_WARNING >> (f & 1));
1608                                 pmbus_add_boolean_reg(data, "fan", "fault",
1609                                         index, base,
1610                                         PB_FAN_FAN1_FAULT >> (f & 1));
1611                         }
1612                         index++;
1613                 }
1614         }
1615 }
1616
1617 static void pmbus_find_attributes(struct i2c_client *client,
1618                                   struct pmbus_data *data)
1619 {
1620         /* Voltage sensors */
1621         pmbus_add_sensor_attrs(client, data, "in", voltage_attributes,
1622                                ARRAY_SIZE(voltage_attributes));
1623
1624         /* Current sensors */
1625         pmbus_add_sensor_attrs(client, data, "curr", current_attributes,
1626                                ARRAY_SIZE(current_attributes));
1627
1628         /* Power sensors */
1629         pmbus_add_sensor_attrs(client, data, "power", power_attributes,
1630                                ARRAY_SIZE(power_attributes));
1631
1632         /* Temperature sensors */
1633         pmbus_add_sensor_attrs(client, data, "temp", temp_attributes,
1634                                ARRAY_SIZE(temp_attributes));
1635
1636         /* Fans */
1637         pmbus_add_fan_attributes(client, data);
1638 }
1639
1640 /*
1641  * Identify chip parameters.
1642  * This function is called for all chips.
1643  */
1644 static int pmbus_identify_common(struct i2c_client *client,
1645                                  struct pmbus_data *data)
1646 {
1647         int vout_mode = -1;
1648
1649         if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE))
1650                 vout_mode = _pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
1651         if (vout_mode >= 0 && vout_mode != 0xff) {
1652                 /*
1653                  * Not all chips support the VOUT_MODE command,
1654                  * so a failure to read it is not an error.
1655                  */
1656                 switch (vout_mode >> 5) {
1657                 case 0: /* linear mode      */
1658                         if (data->info->format[PSC_VOLTAGE_OUT] != linear)
1659                                 return -ENODEV;
1660
1661                         data->exponent = ((s8)(vout_mode << 3)) >> 3;
1662                         break;
1663                 case 1: /* VID mode         */
1664                         if (data->info->format[PSC_VOLTAGE_OUT] != vid)
1665                                 return -ENODEV;
1666                         break;
1667                 case 2: /* direct mode      */
1668                         if (data->info->format[PSC_VOLTAGE_OUT] != direct)
1669                                 return -ENODEV;
1670                         break;
1671                 default:
1672                         return -ENODEV;
1673                 }
1674         }
1675
1676         /* Determine maximum number of sensors, booleans, and labels */
1677         pmbus_find_max_attr(client, data);
1678         pmbus_clear_fault_page(client, 0);
1679         return 0;
1680 }
1681
1682 int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
1683                    struct pmbus_driver_info *info)
1684 {
1685         const struct pmbus_platform_data *pdata = client->dev.platform_data;
1686         struct pmbus_data *data;
1687         int ret;
1688
1689         if (!info) {
1690                 dev_err(&client->dev, "Missing chip information");
1691                 return -ENODEV;
1692         }
1693
1694         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
1695                                      | I2C_FUNC_SMBUS_BYTE_DATA
1696                                      | I2C_FUNC_SMBUS_WORD_DATA))
1697                 return -ENODEV;
1698
1699         data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1700         if (!data) {
1701                 dev_err(&client->dev, "No memory to allocate driver data\n");
1702                 return -ENOMEM;
1703         }
1704
1705         i2c_set_clientdata(client, data);
1706         mutex_init(&data->update_lock);
1707
1708         /* Bail out if PMBus status register does not exist. */
1709         if (i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE) < 0) {
1710                 dev_err(&client->dev, "PMBus status register not found\n");
1711                 return -ENODEV;
1712         }
1713
1714         if (pdata)
1715                 data->flags = pdata->flags;
1716         data->info = info;
1717
1718         pmbus_clear_faults(client);
1719
1720         if (info->identify) {
1721                 ret = (*info->identify)(client, info);
1722                 if (ret < 0) {
1723                         dev_err(&client->dev, "Chip identification failed\n");
1724                         return ret;
1725                 }
1726         }
1727
1728         if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
1729                 dev_err(&client->dev, "Bad number of PMBus pages: %d\n",
1730                         info->pages);
1731                 return -ENODEV;
1732         }
1733
1734         ret = pmbus_identify_common(client, data);
1735         if (ret < 0) {
1736                 dev_err(&client->dev, "Failed to identify chip capabilities\n");
1737                 return ret;
1738         }
1739
1740         ret = -ENOMEM;
1741         data->sensors = devm_kzalloc(&client->dev, sizeof(struct pmbus_sensor)
1742                                      * data->max_sensors, GFP_KERNEL);
1743         if (!data->sensors) {
1744                 dev_err(&client->dev, "No memory to allocate sensor data\n");
1745                 return -ENOMEM;
1746         }
1747
1748         data->booleans = devm_kzalloc(&client->dev, sizeof(struct pmbus_boolean)
1749                                  * data->max_booleans, GFP_KERNEL);
1750         if (!data->booleans) {
1751                 dev_err(&client->dev, "No memory to allocate boolean data\n");
1752                 return -ENOMEM;
1753         }
1754
1755         data->labels = devm_kzalloc(&client->dev, sizeof(struct pmbus_label)
1756                                     * data->max_labels, GFP_KERNEL);
1757         if (!data->labels) {
1758                 dev_err(&client->dev, "No memory to allocate label data\n");
1759                 return -ENOMEM;
1760         }
1761
1762         data->attributes = devm_kzalloc(&client->dev, sizeof(struct attribute *)
1763                                         * data->max_attributes, GFP_KERNEL);
1764         if (!data->attributes) {
1765                 dev_err(&client->dev, "No memory to allocate attribute data\n");
1766                 return -ENOMEM;
1767         }
1768
1769         pmbus_find_attributes(client, data);
1770
1771         /*
1772          * If there are no attributes, something is wrong.
1773          * Bail out instead of trying to register nothing.
1774          */
1775         if (!data->num_attributes) {
1776                 dev_err(&client->dev, "No attributes found\n");
1777                 return -ENODEV;
1778         }
1779
1780         /* Register sysfs hooks */
1781         data->group.attrs = data->attributes;
1782         ret = sysfs_create_group(&client->dev.kobj, &data->group);
1783         if (ret) {
1784                 dev_err(&client->dev, "Failed to create sysfs entries\n");
1785                 return ret;
1786         }
1787         data->hwmon_dev = hwmon_device_register(&client->dev);
1788         if (IS_ERR(data->hwmon_dev)) {
1789                 ret = PTR_ERR(data->hwmon_dev);
1790                 dev_err(&client->dev, "Failed to register hwmon device\n");
1791                 goto out_hwmon_device_register;
1792         }
1793         return 0;
1794
1795 out_hwmon_device_register:
1796         sysfs_remove_group(&client->dev.kobj, &data->group);
1797         return ret;
1798 }
1799 EXPORT_SYMBOL_GPL(pmbus_do_probe);
1800
1801 int pmbus_do_remove(struct i2c_client *client)
1802 {
1803         struct pmbus_data *data = i2c_get_clientdata(client);
1804         hwmon_device_unregister(data->hwmon_dev);
1805         sysfs_remove_group(&client->dev.kobj, &data->group);
1806         return 0;
1807 }
1808 EXPORT_SYMBOL_GPL(pmbus_do_remove);
1809
1810 MODULE_AUTHOR("Guenter Roeck");
1811 MODULE_DESCRIPTION("PMBus core driver");
1812 MODULE_LICENSE("GPL");