drivers/hwmon/pmbus/pmbus_core.c

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