drivers/hwmon/pmbus/pmbus_core.c

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