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/math64.h>
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/err.h>
  26 #include <linux/slab.h>
  27 #include <linux/i2c.h>
  28 #include <linux/hwmon.h>
  29 #include <linux/hwmon-sysfs.h>
  30 #include <linux/delay.h>
  31 #include <linux/i2c/pmbus.h>
  32 #include "pmbus.h"
  33
  34 /*
  35  * Constants needed to determine number of sensors, booleans, and labels.
  36  */
  37 #define PMBUS_MAX_INPUT_SENSORS         22      /* 10*volt, 7*curr, 5*power */
  38 #define PMBUS_VOUT_SENSORS_PER_PAGE     9       /* input, min, max, lcrit,
  39                                                    crit, lowest, highest, avg,
  40                                                    reset */
  41 #define PMBUS_IOUT_SENSORS_PER_PAGE     8       /* input, min, max, crit,
  42                                                    lowest, highest, avg,
  43                                                    reset */
  44 #define PMBUS_POUT_SENSORS_PER_PAGE     4       /* input, cap, max, crit */
  45 #define PMBUS_MAX_SENSORS_PER_FAN       1       /* input */
  46 #define PMBUS_MAX_SENSORS_PER_TEMP      8       /* input, min, max, lcrit,
  47                                                    crit, lowest, highest,
  48                                                    reset */
  49
  50 #define PMBUS_MAX_INPUT_BOOLEANS        7       /* v: min_alarm, max_alarm,
  51                                                    lcrit_alarm, crit_alarm;
  52                                                    c: alarm, crit_alarm;
  53                                                    p: crit_alarm */
  54 #define PMBUS_VOUT_BOOLEANS_PER_PAGE    4       /* min_alarm, max_alarm,
  55                                                    lcrit_alarm, crit_alarm */
  56 #define PMBUS_IOUT_BOOLEANS_PER_PAGE    3       /* alarm, lcrit_alarm,
  57                                                    crit_alarm */
  58 #define PMBUS_POUT_BOOLEANS_PER_PAGE    3       /* cap_alarm, alarm, crit_alarm
  59                                                  */
  60 #define PMBUS_MAX_BOOLEANS_PER_FAN      2       /* alarm, fault */
  61 #define PMBUS_MAX_BOOLEANS_PER_TEMP     4       /* min_alarm, max_alarm,
  62                                                    lcrit_alarm, crit_alarm */
  63
  64 #define PMBUS_MAX_INPUT_LABELS          4       /* vin, vcap, iin, pin */
  65
  66 /*
  67  * status, status_vout, status_iout, status_fans, status_fan34, and status_temp
  68  * are paged. status_input is unpaged.
  69  */
  70 #define PB_NUM_STATUS_REG       (PMBUS_PAGES * 6 + 1)
  71
  72 /*
  73  * Index into status register array, per status register group
  74  */
  75 #define PB_STATUS_BASE          0
  76 #define PB_STATUS_VOUT_BASE     (PB_STATUS_BASE + PMBUS_PAGES)
  77 #define PB_STATUS_IOUT_BASE     (PB_STATUS_VOUT_BASE + PMBUS_PAGES)
  78 #define PB_STATUS_FAN_BASE      (PB_STATUS_IOUT_BASE + PMBUS_PAGES)
  79 #define PB_STATUS_FAN34_BASE    (PB_STATUS_FAN_BASE + PMBUS_PAGES)
  80 #define PB_STATUS_INPUT_BASE    (PB_STATUS_FAN34_BASE + PMBUS_PAGES)
  81 #define PB_STATUS_TEMP_BASE     (PB_STATUS_INPUT_BASE + 1)
  82
  83 #define PMBUS_NAME_SIZE         24
  84
  85 struct pmbus_sensor {
  86         char name[PMBUS_NAME_SIZE];     /* sysfs sensor name */
  87         struct sensor_device_attribute attribute;
  88         u8 page;                /* page number */
  89         u16 reg;                /* register */
  90         enum pmbus_sensor_classes class;        /* sensor class */
  91         bool update;            /* runtime sensor update needed */
  92         int data;               /* Sensor data.
  93                                    Negative if there was a read error */
  94 };
  95
  96 struct pmbus_boolean {
  97         char name[PMBUS_NAME_SIZE];     /* sysfs boolean name */
  98         struct sensor_device_attribute attribute;
  99 };
 100
 101 struct pmbus_label {
 102         char name[PMBUS_NAME_SIZE];     /* sysfs label name */
 103         struct sensor_device_attribute attribute;
 104         char label[PMBUS_NAME_SIZE];    /* label */
 105 };
 106
 107 struct pmbus_data {
 108         struct device *hwmon_dev;
 109
 110         u32 flags;              /* from platform data */
 111
 112         int exponent;           /* linear mode: exponent for output voltages */
 113
 114         const struct pmbus_driver_info *info;
 115
 116         int max_attributes;
 117         int num_attributes;
 118         struct attribute **attributes;
 119         struct attribute_group group;
 120
 121         /*
 122          * Sensors cover both sensor and limit registers.
 123          */
 124         int max_sensors;
 125         int num_sensors;
 126         struct pmbus_sensor *sensors;
 127         /*
 128          * Booleans are used for alarms.
 129          * Values are determined from status registers.
 130          */
 131         int max_booleans;
 132         int num_booleans;
 133         struct pmbus_boolean *booleans;
 134         /*
 135          * Labels are used to map generic names (e.g., "in1")
 136          * to PMBus specific names (e.g., "vin" or "vout1").
 137          */
 138         int max_labels;
 139         int num_labels;
 140         struct pmbus_label *labels;
 141
 142         struct mutex update_lock;
 143         bool valid;
 144         unsigned long last_updated;     /* in jiffies */
 145
 146         /*
 147          * A single status register covers multiple attributes,
 148          * so we keep them all together.
 149          */
 150         u8 status[PB_NUM_STATUS_REG];
 151
 152         u8 currpage;
 153 };
 154
 155 int pmbus_set_page(struct i2c_client *client, u8 page)
 156 {
 157         struct pmbus_data *data = i2c_get_clientdata(client);
 158         int rv = 0;
 159         int newpage;
 160
 161         if (page != data->currpage) {
 162                 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page);
 163                 newpage = i2c_smbus_read_byte_data(client, PMBUS_PAGE);
 164                 if (newpage != page)
 165                         rv = -EIO;
 166                 else
 167                         data->currpage = page;
 168         }
 169         return rv;
 170 }
 171 EXPORT_SYMBOL_GPL(pmbus_set_page);
 172
 173 int pmbus_write_byte(struct i2c_client *client, int page, u8 value)
 174 {
 175         int rv;
 176
 177         if (page >= 0) {
 178                 rv = pmbus_set_page(client, page);
 179                 if (rv < 0)
 180                         return rv;
 181         }
 182
 183         return i2c_smbus_write_byte(client, value);
 184 }
 185 EXPORT_SYMBOL_GPL(pmbus_write_byte);
 186
 187 /*
 188  * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if
 189  * a device specific mapping funcion exists and calls it if necessary.
 190  */
 191 static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value)
 192 {
 193         struct pmbus_data *data = i2c_get_clientdata(client);
 194         const struct pmbus_driver_info *info = data->info;
 195         int status;
 196
 197         if (info->write_byte) {
 198                 status = info->write_byte(client, page, value);
 199                 if (status != -ENODATA)
 200                         return status;
 201         }
 202         return pmbus_write_byte(client, page, value);
 203 }
 204
 205 int pmbus_write_word_data(struct i2c_client *client, u8 page, u8 reg, u16 word)
 206 {
 207         int rv;
 208
 209         rv = pmbus_set_page(client, page);
 210         if (rv < 0)
 211                 return rv;
 212
 213         return i2c_smbus_write_word_data(client, reg, word);
 214 }
 215 EXPORT_SYMBOL_GPL(pmbus_write_word_data);
 216
 217 /*
 218  * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if
 219  * a device specific mapping function exists and calls it if necessary.
 220  */
 221 static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg,
 222                                   u16 word)
 223 {
 224         struct pmbus_data *data = i2c_get_clientdata(client);
 225         const struct pmbus_driver_info *info = data->info;
 226         int status;
 227
 228         if (info->write_word_data) {
 229                 status = info->write_word_data(client, page, reg, word);
 230                 if (status != -ENODATA)
 231                         return status;
 232         }
 233         if (reg >= PMBUS_VIRT_BASE)
 234                 return -ENXIO;
 235         return pmbus_write_word_data(client, page, reg, word);
 236 }
 237
 238 int pmbus_read_word_data(struct i2c_client *client, u8 page, u8 reg)
 239 {
 240         int rv;
 241
 242         rv = pmbus_set_page(client, page);
 243         if (rv < 0)
 244                 return rv;
 245
 246         return i2c_smbus_read_word_data(client, reg);
 247 }
 248 EXPORT_SYMBOL_GPL(pmbus_read_word_data);
 249
 250 /*
 251  * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if
 252  * a device specific mapping function exists and calls it if necessary.
 253  */
 254 static int _pmbus_read_word_data(struct i2c_client *client, int page, int reg)
 255 {
 256         struct pmbus_data *data = i2c_get_clientdata(client);
 257         const struct pmbus_driver_info *info = data->info;
 258         int status;
 259
 260         if (info->read_word_data) {
 261                 status = info->read_word_data(client, page, reg);
 262                 if (status != -ENODATA)
 263                         return status;
 264         }
 265         if (reg >= PMBUS_VIRT_BASE)
 266                 return -ENXIO;
 267         return pmbus_read_word_data(client, page, reg);
 268 }
 269
 270 int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg)
 271 {
 272         int rv;
 273
 274         if (page >= 0) {
 275                 rv = pmbus_set_page(client, page);
 276                 if (rv < 0)
 277                         return rv;
 278         }
 279
 280         return i2c_smbus_read_byte_data(client, reg);
 281 }
 282 EXPORT_SYMBOL_GPL(pmbus_read_byte_data);
 283
 284 /*
 285  * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if
 286  * a device specific mapping function exists and calls it if necessary.
 287  */
 288 static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg)
 289 {
 290         struct pmbus_data *data = i2c_get_clientdata(client);
 291         const struct pmbus_driver_info *info = data->info;
 292         int status;
 293
 294         if (info->read_byte_data) {
 295                 status = info->read_byte_data(client, page, reg);
 296                 if (status != -ENODATA)
 297                         return status;
 298         }
 299         return pmbus_read_byte_data(client, page, reg);
 300 }
 301
 302 static void pmbus_clear_fault_page(struct i2c_client *client, int page)
 303 {
 304         _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
 305 }
 306
 307 void pmbus_clear_faults(struct i2c_client *client)
 308 {
 309         struct pmbus_data *data = i2c_get_clientdata(client);
 310         int i;
 311
 312         for (i = 0; i < data->info->pages; i++)
 313                 pmbus_clear_fault_page(client, i);
 314 }
 315 EXPORT_SYMBOL_GPL(pmbus_clear_faults);
 316
 317 static int pmbus_check_status_cml(struct i2c_client *client)
 318 {
 319         int status, status2;
 320
 321         status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_BYTE);
 322         if (status < 0 || (status & PB_STATUS_CML)) {
 323                 status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML);
 324                 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND))
 325                         return -EIO;
 326         }
 327         return 0;
 328 }
 329
 330 bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg)
 331 {
 332         int rv;
 333         struct pmbus_data *data = i2c_get_clientdata(client);
 334
 335         rv = _pmbus_read_byte_data(client, page, reg);
 336         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
 337                 rv = pmbus_check_status_cml(client);
 338         pmbus_clear_fault_page(client, -1);
 339         return rv >= 0;
 340 }
 341 EXPORT_SYMBOL_GPL(pmbus_check_byte_register);
 342
 343 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg)
 344 {
 345         int rv;
 346         struct pmbus_data *data = i2c_get_clientdata(client);
 347
 348         rv = _pmbus_read_word_data(client, page, reg);
 349         if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK))
 350                 rv = pmbus_check_status_cml(client);
 351         pmbus_clear_fault_page(client, -1);
 352         return rv >= 0;
 353 }
 354 EXPORT_SYMBOL_GPL(pmbus_check_word_register);
 355
 356 const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client *client)
 357 {
 358         struct pmbus_data *data = i2c_get_clientdata(client);
 359
 360         return data->info;
 361 }
 362 EXPORT_SYMBOL_GPL(pmbus_get_driver_info);
 363
 364 static struct pmbus_data *pmbus_update_device(struct device *dev)
 365 {
 366         struct i2c_client *client = to_i2c_client(dev);
 367         struct pmbus_data *data = i2c_get_clientdata(client);
 368         const struct pmbus_driver_info *info = data->info;
 369
 370         mutex_lock(&data->update_lock);
 371         if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
 372                 int i;
 373
 374                 for (i = 0; i < info->pages; i++)
 375                         data->status[PB_STATUS_BASE + i]
 376                             = _pmbus_read_byte_data(client, i,
 377                                                     PMBUS_STATUS_BYTE);
 378                 for (i = 0; i < info->pages; i++) {
 379                         if (!(info->func[i] & PMBUS_HAVE_STATUS_VOUT))
 380                                 continue;
 381                         data->status[PB_STATUS_VOUT_BASE + i]
 382                           = _pmbus_read_byte_data(client, i, PMBUS_STATUS_VOUT);
 383                 }
 384                 for (i = 0; i < info->pages; i++) {
 385                         if (!(info->func[i] & PMBUS_HAVE_STATUS_IOUT))
 386                                 continue;
 387                         data->status[PB_STATUS_IOUT_BASE + i]
 388                           = _pmbus_read_byte_data(client, i, PMBUS_STATUS_IOUT);
 389                 }
 390                 for (i = 0; i < info->pages; i++) {
 391                         if (!(info->func[i] & PMBUS_HAVE_STATUS_TEMP))
 392                                 continue;
 393                         data->status[PB_STATUS_TEMP_BASE + i]
 394                           = _pmbus_read_byte_data(client, i,
 395                                                   PMBUS_STATUS_TEMPERATURE);
 396                 }
 397                 for (i = 0; i < info->pages; i++) {
 398                         if (!(info->func[i] & PMBUS_HAVE_STATUS_FAN12))
 399                                 continue;
 400                         data->status[PB_STATUS_FAN_BASE + i]
 401                           = _pmbus_read_byte_data(client, i,
 402                                                   PMBUS_STATUS_FAN_12);
 403                 }
 404
 405                 for (i = 0; i < info->pages; i++) {
 406                         if (!(info->func[i] & PMBUS_HAVE_STATUS_FAN34))
 407                                 continue;
 408                         data->status[PB_STATUS_FAN34_BASE + i]
 409                           = _pmbus_read_byte_data(client, i,
 410                                                   PMBUS_STATUS_FAN_34);
 411                 }
 412
 413                 if (info->func[0] & PMBUS_HAVE_STATUS_INPUT)
 414                         data->status[PB_STATUS_INPUT_BASE]
 415                           = _pmbus_read_byte_data(client, 0,
 416                                                   PMBUS_STATUS_INPUT);
 417
 418                 for (i = 0; i < data->num_sensors; i++) {
 419                         struct pmbus_sensor *sensor = &data->sensors[i];
 420
 421                         if (!data->valid || sensor->update)
 422                                 sensor->data
 423                                     = _pmbus_read_word_data(client,
 424                                                             sensor->page,
 425                                                             sensor->reg);
 426                 }
 427                 pmbus_clear_faults(client);
 428                 data->last_updated = jiffies;
 429                 data->valid = 1;
 430         }
 431         mutex_unlock(&data->update_lock);
 432         return data;
 433 }
 434
 435 /*
 436  * Convert linear sensor values to milli- or micro-units
 437  * depending on sensor type.
 438  */
 439 static long pmbus_reg2data_linear(struct pmbus_data *data,
 440                                   struct pmbus_sensor *sensor)
 441 {
 442         s16 exponent;
 443         s32 mantissa;
 444         long val;
 445
 446         if (sensor->class == PSC_VOLTAGE_OUT) { /* LINEAR16 */
 447                 exponent = data->exponent;
 448                 mantissa = (u16) sensor->data;
 449         } else {                                /* LINEAR11 */
 450                 exponent = ((s16)sensor->data) >> 11;
 451                 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5;
 452         }
 453
 454         val = mantissa;
 455
 456         /* scale result to milli-units for all sensors except fans */
 457         if (sensor->class != PSC_FAN)
 458                 val = val * 1000L;
 459
 460         /* scale result to micro-units for power sensors */
 461         if (sensor->class == PSC_POWER)
 462                 val = val * 1000L;
 463
 464         if (exponent >= 0)
 465                 val <<= exponent;
 466         else
 467                 val >>= -exponent;
 468
 469         return val;
 470 }
 471
 472 /*
 473  * Convert direct sensor values to milli- or micro-units
 474  * depending on sensor type.
 475  */
 476 static long pmbus_reg2data_direct(struct pmbus_data *data,
 477                                   struct pmbus_sensor *sensor)
 478 {
 479         s64 b, val = (s16)sensor->data;
 480         s32 m, R;
 481
 482         m = data->info->m[sensor->class];
 483         b = data->info->b[sensor->class];
 484         R = data->info->R[sensor->class];
 485
 486         if (m == 0)
 487                 return 0;
 488
 489         /* X = 1/m * (Y * 10^-R - b) */
 490         R = -R;
 491         /* scale result to milli-units for everything but fans */
 492         if (sensor->class != PSC_FAN) {
 493                 R += 3;
 494                 b *= 1000;
 495         }
 496
 497         /* scale result to micro-units for power sensors */
 498         if (sensor->class == PSC_POWER) {
 499                 R += 3;
 500                 b *= 1000;
 501         }
 502
 503         while (R > 0) {
 504                 val *= 10;
 505                 R--;
 506         }
 507         while (R < 0) {
 508                 val = div_s64(val + 5LL, 10L);  /* round closest */
 509                 R++;
 510         }
 511
 512         val = div_s64(val - b, m);
 513         return clamp_val(val, LONG_MIN, LONG_MAX);
 514 }
 515
 516 /*
 517  * Convert VID sensor values to milli- or micro-units
 518  * depending on sensor type.
 519  * We currently only support VR11.
 520  */
 521 static long pmbus_reg2data_vid(struct pmbus_data *data,
 522                                struct pmbus_sensor *sensor)
 523 {
 524         long val = sensor->data;
 525
 526         if (val < 0x02 || val > 0xb2)
 527                 return 0;
 528         return DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100);
 529 }
 530
 531 static long pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor)
 532 {
 533         long val;
 534
 535         switch (data->info->format[sensor->class]) {
 536         case direct:
 537                 val = pmbus_reg2data_direct(data, sensor);
 538                 break;
 539         case vid:
 540                 val = pmbus_reg2data_vid(data, sensor);
 541                 break;
 542         case linear:
 543         default:
 544                 val = pmbus_reg2data_linear(data, sensor);
 545                 break;
 546         }
 547         return val;
 548 }
 549
 550 #define MAX_MANTISSA    (1023 * 1000)
 551 #define MIN_MANTISSA    (511 * 1000)
 552
 553 static u16 pmbus_data2reg_linear(struct pmbus_data *data,
 554                                  enum pmbus_sensor_classes class, long val)
 555 {
 556         s16 exponent = 0, mantissa;
 557         bool negative = false;
 558
 559         /* simple case */
 560         if (val == 0)
 561                 return 0;
 562
 563         if (class == PSC_VOLTAGE_OUT) {
 564                 /* LINEAR16 does not support negative voltages */
 565                 if (val < 0)
 566                         return 0;
 567
 568                 /*
 569                  * For a static exponents, we don't have a choice
 570                  * but to adjust the value to it.
 571                  */
 572                 if (data->exponent < 0)
 573                         val <<= -data->exponent;
 574                 else
 575                         val >>= data->exponent;
 576                 val = DIV_ROUND_CLOSEST(val, 1000);
 577                 return val & 0xffff;
 578         }
 579
 580         if (val < 0) {
 581                 negative = true;
 582                 val = -val;
 583         }
 584
 585         /* Power is in uW. Convert to mW before converting. */
 586         if (class == PSC_POWER)
 587                 val = DIV_ROUND_CLOSEST(val, 1000L);
 588
 589         /*
 590          * For simplicity, convert fan data to milli-units
 591          * before calculating the exponent.
 592          */
 593         if (class == PSC_FAN)
 594                 val = val * 1000;
 595
 596         /* Reduce large mantissa until it fits into 10 bit */
 597         while (val >= MAX_MANTISSA && exponent < 15) {
 598                 exponent++;
 599                 val >>= 1;
 600         }
 601         /* Increase small mantissa to improve precision */
 602         while (val < MIN_MANTISSA && exponent > -15) {
 603                 exponent--;
 604                 val <<= 1;
 605         }
 606
 607         /* Convert mantissa from milli-units to units */
 608         mantissa = DIV_ROUND_CLOSEST(val, 1000);
 609
 610         /* Ensure that resulting number is within range */
 611         if (mantissa > 0x3ff)
 612                 mantissa = 0x3ff;
 613
 614         /* restore sign */
 615         if (negative)
 616                 mantissa = -mantissa;
 617
 618         /* Convert to 5 bit exponent, 11 bit mantissa */
 619         return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800);
 620 }
 621
 622 static u16 pmbus_data2reg_direct(struct pmbus_data *data,
 623                                  enum pmbus_sensor_classes class, long val)
 624 {
 625         s64 b, val64 = val;
 626         s32 m, 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         val64 = val64 * m + b;
 644
 645         while (R > 0) {
 646                 val64 *= 10;
 647                 R--;
 648         }
 649         while (R < 0) {
 650                 val64 = div_s64(val64 + 5LL, 10L);  /* round closest */
 651                 R++;
 652         }
 653
 654         return (u16)clamp_val(val64, -32768, 32767);
 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 (strict_strtol(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 };
1342
1343 static const struct pmbus_sensor_attr power_attributes[] = {
1344         {
1345                 .reg = PMBUS_READ_PIN,
1346                 .class = PSC_POWER,
1347                 .label = "pin",
1348                 .func = PMBUS_HAVE_PIN,
1349                 .sfunc = PMBUS_HAVE_STATUS_INPUT,
1350                 .sbase = PB_STATUS_INPUT_BASE,
1351                 .limit = pin_limit_attrs,
1352                 .nlimit = ARRAY_SIZE(pin_limit_attrs),
1353         }, {
1354                 .reg = PMBUS_READ_POUT,
1355                 .class = PSC_POWER,
1356                 .label = "pout",
1357                 .paged = true,
1358                 .func = PMBUS_HAVE_POUT,
1359                 .sfunc = PMBUS_HAVE_STATUS_IOUT,
1360                 .sbase = PB_STATUS_IOUT_BASE,
1361                 .limit = pout_limit_attrs,
1362                 .nlimit = ARRAY_SIZE(pout_limit_attrs),
1363         }
1364 };
1365
1366 /* Temperature atributes */
1367
1368 static const struct pmbus_limit_attr temp_limit_attrs[] = {
1369         {
1370                 .reg = PMBUS_UT_WARN_LIMIT,
1371                 .low = true,
1372                 .attr = "min",
1373                 .alarm = "min_alarm",
1374                 .sbit = PB_TEMP_UT_WARNING,
1375         }, {
1376                 .reg = PMBUS_UT_FAULT_LIMIT,
1377                 .low = true,
1378                 .attr = "lcrit",
1379                 .alarm = "lcrit_alarm",
1380                 .sbit = PB_TEMP_UT_FAULT,
1381         }, {
1382                 .reg = PMBUS_OT_WARN_LIMIT,
1383                 .attr = "max",
1384                 .alarm = "max_alarm",
1385                 .sbit = PB_TEMP_OT_WARNING,
1386         }, {
1387                 .reg = PMBUS_OT_FAULT_LIMIT,
1388                 .attr = "crit",
1389                 .alarm = "crit_alarm",
1390                 .sbit = PB_TEMP_OT_FAULT,
1391         }, {
1392                 .reg = PMBUS_VIRT_READ_TEMP_MIN,
1393                 .attr = "lowest",
1394         }, {
1395                 .reg = PMBUS_VIRT_READ_TEMP_MAX,
1396                 .attr = "highest",
1397         }, {
1398                 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY,
1399                 .attr = "reset_history",
1400         }
1401 };
1402
1403 static const struct pmbus_limit_attr temp_limit_attrs2[] = {
1404         {
1405                 .reg = PMBUS_UT_WARN_LIMIT,
1406                 .low = true,
1407                 .attr = "min",
1408                 .alarm = "min_alarm",
1409                 .sbit = PB_TEMP_UT_WARNING,
1410         }, {
1411                 .reg = PMBUS_UT_FAULT_LIMIT,
1412                 .low = true,
1413                 .attr = "lcrit",
1414                 .alarm = "lcrit_alarm",
1415                 .sbit = PB_TEMP_UT_FAULT,
1416         }, {
1417                 .reg = PMBUS_OT_WARN_LIMIT,
1418                 .attr = "max",
1419                 .alarm = "max_alarm",
1420                 .sbit = PB_TEMP_OT_WARNING,
1421         }, {
1422                 .reg = PMBUS_OT_FAULT_LIMIT,
1423                 .attr = "crit",
1424                 .alarm = "crit_alarm",
1425                 .sbit = PB_TEMP_OT_FAULT,
1426         }, {
1427                 .reg = PMBUS_VIRT_READ_TEMP2_MIN,
1428                 .attr = "lowest",
1429         }, {
1430                 .reg = PMBUS_VIRT_READ_TEMP2_MAX,
1431                 .attr = "highest",
1432         }, {
1433                 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY,
1434                 .attr = "reset_history",
1435         }
1436 };
1437
1438 static const struct pmbus_limit_attr temp_limit_attrs3[] = {
1439         {
1440                 .reg = PMBUS_UT_WARN_LIMIT,
1441                 .low = true,
1442                 .attr = "min",
1443                 .alarm = "min_alarm",
1444                 .sbit = PB_TEMP_UT_WARNING,
1445         }, {
1446                 .reg = PMBUS_UT_FAULT_LIMIT,
1447                 .low = true,
1448                 .attr = "lcrit",
1449                 .alarm = "lcrit_alarm",
1450                 .sbit = PB_TEMP_UT_FAULT,
1451         }, {
1452                 .reg = PMBUS_OT_WARN_LIMIT,
1453                 .attr = "max",
1454                 .alarm = "max_alarm",
1455                 .sbit = PB_TEMP_OT_WARNING,
1456         }, {
1457                 .reg = PMBUS_OT_FAULT_LIMIT,
1458                 .attr = "crit",
1459                 .alarm = "crit_alarm",
1460                 .sbit = PB_TEMP_OT_FAULT,
1461         }
1462 };
1463
1464 static const struct pmbus_sensor_attr temp_attributes[] = {
1465         {
1466                 .reg = PMBUS_READ_TEMPERATURE_1,
1467                 .class = PSC_TEMPERATURE,
1468                 .paged = true,
1469                 .update = true,
1470                 .compare = true,
1471                 .func = PMBUS_HAVE_TEMP,
1472                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1473                 .sbase = PB_STATUS_TEMP_BASE,
1474                 .gbit = PB_STATUS_TEMPERATURE,
1475                 .limit = temp_limit_attrs,
1476                 .nlimit = ARRAY_SIZE(temp_limit_attrs),
1477         }, {
1478                 .reg = PMBUS_READ_TEMPERATURE_2,
1479                 .class = PSC_TEMPERATURE,
1480                 .paged = true,
1481                 .update = true,
1482                 .compare = true,
1483                 .func = PMBUS_HAVE_TEMP2,
1484                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1485                 .sbase = PB_STATUS_TEMP_BASE,
1486                 .gbit = PB_STATUS_TEMPERATURE,
1487                 .limit = temp_limit_attrs2,
1488                 .nlimit = ARRAY_SIZE(temp_limit_attrs2),
1489         }, {
1490                 .reg = PMBUS_READ_TEMPERATURE_3,
1491                 .class = PSC_TEMPERATURE,
1492                 .paged = true,
1493                 .update = true,
1494                 .compare = true,
1495                 .func = PMBUS_HAVE_TEMP3,
1496                 .sfunc = PMBUS_HAVE_STATUS_TEMP,
1497                 .sbase = PB_STATUS_TEMP_BASE,
1498                 .gbit = PB_STATUS_TEMPERATURE,
1499                 .limit = temp_limit_attrs3,
1500                 .nlimit = ARRAY_SIZE(temp_limit_attrs3),
1501         }
1502 };
1503
1504 static const int pmbus_fan_registers[] = {
1505         PMBUS_READ_FAN_SPEED_1,
1506         PMBUS_READ_FAN_SPEED_2,
1507         PMBUS_READ_FAN_SPEED_3,
1508         PMBUS_READ_FAN_SPEED_4
1509 };
1510
1511 static const int pmbus_fan_config_registers[] = {
1512         PMBUS_FAN_CONFIG_12,
1513         PMBUS_FAN_CONFIG_12,
1514         PMBUS_FAN_CONFIG_34,
1515         PMBUS_FAN_CONFIG_34
1516 };
1517
1518 static const int pmbus_fan_status_registers[] = {
1519         PMBUS_STATUS_FAN_12,
1520         PMBUS_STATUS_FAN_12,
1521         PMBUS_STATUS_FAN_34,
1522         PMBUS_STATUS_FAN_34
1523 };
1524
1525 static const u32 pmbus_fan_flags[] = {
1526         PMBUS_HAVE_FAN12,
1527         PMBUS_HAVE_FAN12,
1528         PMBUS_HAVE_FAN34,
1529         PMBUS_HAVE_FAN34
1530 };
1531
1532 static const u32 pmbus_fan_status_flags[] = {
1533         PMBUS_HAVE_STATUS_FAN12,
1534         PMBUS_HAVE_STATUS_FAN12,
1535         PMBUS_HAVE_STATUS_FAN34,
1536         PMBUS_HAVE_STATUS_FAN34
1537 };
1538
1539 /* Fans */
1540 static void pmbus_add_fan_attributes(struct i2c_client *client,
1541                                      struct pmbus_data *data)
1542 {
1543         const struct pmbus_driver_info *info = data->info;
1544         int index = 1;
1545         int page;
1546
1547         for (page = 0; page < info->pages; page++) {
1548                 int f;
1549
1550                 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) {
1551                         int regval;
1552
1553                         if (!(info->func[page] & pmbus_fan_flags[f]))
1554                                 break;
1555
1556                         if (!pmbus_check_word_register(client, page,
1557                                                        pmbus_fan_registers[f]))
1558                                 break;
1559
1560                         /*
1561                          * Skip fan if not installed.
1562                          * Each fan configuration register covers multiple fans,
1563                          * so we have to do some magic.
1564                          */
1565                         regval = _pmbus_read_byte_data(client, page,
1566                                 pmbus_fan_config_registers[f]);
1567                         if (regval < 0 ||
1568                             (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4)))))
1569                                 continue;
1570
1571                         pmbus_add_sensor(data, "fan", "input", index, page,
1572                                          pmbus_fan_registers[f], PSC_FAN, true,
1573                                          true);
1574
1575                         /*
1576                          * Each fan status register covers multiple fans,
1577                          * so we have to do some magic.
1578                          */
1579                         if ((info->func[page] & pmbus_fan_status_flags[f]) &&
1580                             pmbus_check_byte_register(client,
1581                                         page, pmbus_fan_status_registers[f])) {
1582                                 int base;
1583
1584                                 if (f > 1)      /* fan 3, 4 */
1585                                         base = PB_STATUS_FAN34_BASE + page;
1586                                 else
1587                                         base = PB_STATUS_FAN_BASE + page;
1588                                 pmbus_add_boolean_reg(data, "fan", "alarm",
1589                                         index, base,
1590                                         PB_FAN_FAN1_WARNING >> (f & 1));
1591                                 pmbus_add_boolean_reg(data, "fan", "fault",
1592                                         index, base,
1593                                         PB_FAN_FAN1_FAULT >> (f & 1));
1594                         }
1595                         index++;
1596                 }
1597         }
1598 }
1599
1600 static void pmbus_find_attributes(struct i2c_client *client,
1601                                   struct pmbus_data *data)
1602 {
1603         /* Voltage sensors */
1604         pmbus_add_sensor_attrs(client, data, "in", voltage_attributes,
1605                                ARRAY_SIZE(voltage_attributes));
1606
1607         /* Current sensors */
1608         pmbus_add_sensor_attrs(client, data, "curr", current_attributes,
1609                                ARRAY_SIZE(current_attributes));
1610
1611         /* Power sensors */
1612         pmbus_add_sensor_attrs(client, data, "power", power_attributes,
1613                                ARRAY_SIZE(power_attributes));
1614
1615         /* Temperature sensors */
1616         pmbus_add_sensor_attrs(client, data, "temp", temp_attributes,
1617                                ARRAY_SIZE(temp_attributes));
1618
1619         /* Fans */
1620         pmbus_add_fan_attributes(client, data);
1621 }
1622
1623 /*
1624  * Identify chip parameters.
1625  * This function is called for all chips.
1626  */
1627 static int pmbus_identify_common(struct i2c_client *client,
1628                                  struct pmbus_data *data)
1629 {
1630         int vout_mode = -1;
1631
1632         if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE))
1633                 vout_mode = _pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
1634         if (vout_mode >= 0 && vout_mode != 0xff) {
1635                 /*
1636                  * Not all chips support the VOUT_MODE command,
1637                  * so a failure to read it is not an error.
1638                  */
1639                 switch (vout_mode >> 5) {
1640                 case 0: /* linear mode      */
1641                         if (data->info->format[PSC_VOLTAGE_OUT] != linear)
1642                                 return -ENODEV;
1643
1644                         data->exponent = ((s8)(vout_mode << 3)) >> 3;
1645                         break;
1646                 case 1: /* VID mode         */
1647                         if (data->info->format[PSC_VOLTAGE_OUT] != vid)
1648                                 return -ENODEV;
1649                         break;
1650                 case 2: /* direct mode      */
1651                         if (data->info->format[PSC_VOLTAGE_OUT] != direct)
1652                                 return -ENODEV;
1653                         break;
1654                 default:
1655                         return -ENODEV;
1656                 }
1657         }
1658
1659         /* Determine maximum number of sensors, booleans, and labels */
1660         pmbus_find_max_attr(client, data);
1661         pmbus_clear_fault_page(client, 0);
1662         return 0;
1663 }
1664
1665 int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id,
1666                    struct pmbus_driver_info *info)
1667 {
1668         const struct pmbus_platform_data *pdata = client->dev.platform_data;
1669         struct pmbus_data *data;
1670         int ret;
1671
1672         if (!info) {
1673                 dev_err(&client->dev, "Missing chip information");
1674                 return -ENODEV;
1675         }
1676
1677         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE
1678                                      | I2C_FUNC_SMBUS_BYTE_DATA
1679                                      | I2C_FUNC_SMBUS_WORD_DATA))
1680                 return -ENODEV;
1681
1682         data = kzalloc(sizeof(*data), GFP_KERNEL);
1683         if (!data) {
1684                 dev_err(&client->dev, "No memory to allocate driver data\n");
1685                 return -ENOMEM;
1686         }
1687
1688         i2c_set_clientdata(client, data);
1689         mutex_init(&data->update_lock);
1690
1691         /* Bail out if PMBus status register does not exist. */
1692         if (i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE) < 0) {
1693                 dev_err(&client->dev, "PMBus status register not found\n");
1694                 ret = -ENODEV;
1695                 goto out_data;
1696         }
1697
1698         if (pdata)
1699                 data->flags = pdata->flags;
1700         data->info = info;
1701
1702         pmbus_clear_faults(client);
1703
1704         if (info->identify) {
1705                 ret = (*info->identify)(client, info);
1706                 if (ret < 0) {
1707                         dev_err(&client->dev, "Chip identification failed\n");
1708                         goto out_data;
1709                 }
1710         }
1711
1712         if (info->pages <= 0 || info->pages > PMBUS_PAGES) {
1713                 dev_err(&client->dev, "Bad number of PMBus pages: %d\n",
1714                         info->pages);
1715                 ret = -ENODEV;
1716                 goto out_data;
1717         }
1718
1719         ret = pmbus_identify_common(client, data);
1720         if (ret < 0) {
1721                 dev_err(&client->dev, "Failed to identify chip capabilities\n");
1722                 goto out_data;
1723         }
1724
1725         ret = -ENOMEM;
1726         data->sensors = kzalloc(sizeof(struct pmbus_sensor) * data->max_sensors,
1727                                 GFP_KERNEL);
1728         if (!data->sensors) {
1729                 dev_err(&client->dev, "No memory to allocate sensor data\n");
1730                 goto out_data;
1731         }
1732
1733         data->booleans = kzalloc(sizeof(struct pmbus_boolean)
1734                                  * data->max_booleans, GFP_KERNEL);
1735         if (!data->booleans) {
1736                 dev_err(&client->dev, "No memory to allocate boolean data\n");
1737                 goto out_sensors;
1738         }
1739
1740         data->labels = kzalloc(sizeof(struct pmbus_label) * data->max_labels,
1741                                GFP_KERNEL);
1742         if (!data->labels) {
1743                 dev_err(&client->dev, "No memory to allocate label data\n");
1744                 goto out_booleans;
1745         }
1746
1747         data->attributes = kzalloc(sizeof(struct attribute *)
1748                                    * data->max_attributes, GFP_KERNEL);
1749         if (!data->attributes) {
1750                 dev_err(&client->dev, "No memory to allocate attribute data\n");
1751                 goto out_labels;
1752         }
1753
1754         pmbus_find_attributes(client, data);
1755
1756         /*
1757          * If there are no attributes, something is wrong.
1758          * Bail out instead of trying to register nothing.
1759          */
1760         if (!data->num_attributes) {
1761                 dev_err(&client->dev, "No attributes found\n");
1762                 ret = -ENODEV;
1763                 goto out_attributes;
1764         }
1765
1766         /* Register sysfs hooks */
1767         data->group.attrs = data->attributes;
1768         ret = sysfs_create_group(&client->dev.kobj, &data->group);
1769         if (ret) {
1770                 dev_err(&client->dev, "Failed to create sysfs entries\n");
1771                 goto out_attributes;
1772         }
1773         data->hwmon_dev = hwmon_device_register(&client->dev);
1774         if (IS_ERR(data->hwmon_dev)) {
1775                 ret = PTR_ERR(data->hwmon_dev);
1776                 dev_err(&client->dev, "Failed to register hwmon device\n");
1777                 goto out_hwmon_device_register;
1778         }
1779         return 0;
1780
1781 out_hwmon_device_register:
1782         sysfs_remove_group(&client->dev.kobj, &data->group);
1783 out_attributes:
1784         kfree(data->attributes);
1785 out_labels:
1786         kfree(data->labels);
1787 out_booleans:
1788         kfree(data->booleans);
1789 out_sensors:
1790         kfree(data->sensors);
1791 out_data:
1792         kfree(data);
1793         return ret;
1794 }
1795 EXPORT_SYMBOL_GPL(pmbus_do_probe);
1796
1797 void pmbus_do_remove(struct i2c_client *client)
1798 {
1799         struct pmbus_data *data = i2c_get_clientdata(client);
1800         hwmon_device_unregister(data->hwmon_dev);
1801         sysfs_remove_group(&client->dev.kobj, &data->group);
1802         kfree(data->attributes);
1803         kfree(data->labels);
1804         kfree(data->booleans);
1805         kfree(data->sensors);
1806         kfree(data);
1807 }
1808 EXPORT_SYMBOL_GPL(pmbus_do_remove);
1809
1810 MODULE_AUTHOR("Guenter Roeck");
1811 MODULE_DESCRIPTION("PMBus core driver");
1812 MODULE_LICENSE("GPL");