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