drivers/hwmon/pmbus/ltc2978.c

   1 /*
   2  * Hardware monitoring driver for LTC2974, LTC2978, LTC3880, and LTC3883
   3  *
   4  * Copyright (c) 2011 Ericsson AB.
   5  * Copyright (c) 2013 Guenter Roeck
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/err.h>
  26 #include <linux/slab.h>
  27 #include <linux/i2c.h>
  28 #include "pmbus.h"
  29
  30 enum chips { ltc2974, ltc2978, ltc3880, ltc3883 };
  31
  32 /* Common for all chips */
  33 #define LTC2978_MFR_VOUT_PEAK           0xdd
  34 #define LTC2978_MFR_VIN_PEAK            0xde
  35 #define LTC2978_MFR_TEMPERATURE_PEAK    0xdf
  36 #define LTC2978_MFR_SPECIAL_ID          0xe7
  37
  38 /* LTC2974 and LTC2978 */
  39 #define LTC2978_MFR_VOUT_MIN            0xfb
  40 #define LTC2978_MFR_VIN_MIN             0xfc
  41 #define LTC2978_MFR_TEMPERATURE_MIN     0xfd
  42
  43 /* LTC2974 only */
  44 #define LTC2974_MFR_IOUT_PEAK           0xd7
  45 #define LTC2974_MFR_IOUT_MIN            0xd8
  46
  47 /* LTC3880 and LTC3883 */
  48 #define LTC3880_MFR_IOUT_PEAK           0xd7
  49 #define LTC3880_MFR_CLEAR_PEAKS         0xe3
  50 #define LTC3880_MFR_TEMPERATURE2_PEAK   0xf4
  51
  52 /* LTC3883 only */
  53 #define LTC3883_MFR_IIN_PEAK            0xe1
  54
  55 #define LTC2974_ID                      0x0212
  56 #define LTC2978_ID_REV1                 0x0121
  57 #define LTC2978_ID_REV2                 0x0122
  58 #define LTC3880_ID                      0x4000
  59 #define LTC3880_ID_MASK                 0xff00
  60 #define LTC3883_ID                      0x4300
  61 #define LTC3883_ID_MASK                 0xff00
  62
  63 #define LTC2974_NUM_PAGES               4
  64 #define LTC2978_NUM_PAGES               8
  65 #define LTC3880_NUM_PAGES               2
  66 #define LTC3883_NUM_PAGES               1
  67
  68 /*
  69  * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
  70  * happens pretty much each time chip data is updated. Raw peak data therefore
  71  * does not provide much value. To be able to provide useful peak data, keep an
  72  * internal cache of measured peak data, which is only cleared if an explicit
  73  * "clear peak" command is executed for the sensor in question.
  74  */
  75
  76 struct ltc2978_data {
  77         enum chips id;
  78         u16 vin_min, vin_max;
  79         u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
  80         u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
  81         u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
  82         u16 iin_max;
  83         u16 temp2_max;
  84         struct pmbus_driver_info info;
  85 };
  86
  87 #define to_ltc2978_data(x)  container_of(x, struct ltc2978_data, info)
  88
  89 static inline int lin11_to_val(int data)
  90 {
  91         s16 e = ((s16)data) >> 11;
  92         s32 m = (((s16)(data << 5)) >> 5);
  93
  94         /*
  95          * mantissa is 10 bit + sign, exponent adds up to 15 bit.
  96          * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
  97          */
  98         e += 6;
  99         return (e < 0 ? m >> -e : m << e);
 100 }
 101
 102 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
 103                                          int reg)
 104 {
 105         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 106         struct ltc2978_data *data = to_ltc2978_data(info);
 107         int ret;
 108
 109         switch (reg) {
 110         case PMBUS_VIRT_READ_VIN_MAX:
 111                 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_PEAK);
 112                 if (ret >= 0) {
 113                         if (lin11_to_val(ret) > lin11_to_val(data->vin_max))
 114                                 data->vin_max = ret;
 115                         ret = data->vin_max;
 116                 }
 117                 break;
 118         case PMBUS_VIRT_READ_VOUT_MAX:
 119                 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK);
 120                 if (ret >= 0) {
 121                         /*
 122                          * VOUT is 16 bit unsigned with fixed exponent,
 123                          * so we can compare it directly
 124                          */
 125                         if (ret > data->vout_max[page])
 126                                 data->vout_max[page] = ret;
 127                         ret = data->vout_max[page];
 128                 }
 129                 break;
 130         case PMBUS_VIRT_READ_TEMP_MAX:
 131                 ret = pmbus_read_word_data(client, page,
 132                                            LTC2978_MFR_TEMPERATURE_PEAK);
 133                 if (ret >= 0) {
 134                         if (lin11_to_val(ret)
 135                             > lin11_to_val(data->temp_max[page]))
 136                                 data->temp_max[page] = ret;
 137                         ret = data->temp_max[page];
 138                 }
 139                 break;
 140         case PMBUS_VIRT_RESET_VOUT_HISTORY:
 141         case PMBUS_VIRT_RESET_VIN_HISTORY:
 142         case PMBUS_VIRT_RESET_TEMP_HISTORY:
 143                 ret = 0;
 144                 break;
 145         default:
 146                 ret = -ENODATA;
 147                 break;
 148         }
 149         return ret;
 150 }
 151
 152 static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg)
 153 {
 154         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 155         struct ltc2978_data *data = to_ltc2978_data(info);
 156         int ret;
 157
 158         switch (reg) {
 159         case PMBUS_VIRT_READ_VIN_MIN:
 160                 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_MIN);
 161                 if (ret >= 0) {
 162                         if (lin11_to_val(ret) < lin11_to_val(data->vin_min))
 163                                 data->vin_min = ret;
 164                         ret = data->vin_min;
 165                 }
 166                 break;
 167         case PMBUS_VIRT_READ_VOUT_MIN:
 168                 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN);
 169                 if (ret >= 0) {
 170                         /*
 171                          * VOUT_MIN is known to not be supported on some lots
 172                          * of LTC2978 revision 1, and will return the maximum
 173                          * possible voltage if read. If VOUT_MAX is valid and
 174                          * lower than the reading of VOUT_MIN, use it instead.
 175                          */
 176                         if (data->vout_max[page] && ret > data->vout_max[page])
 177                                 ret = data->vout_max[page];
 178                         if (ret < data->vout_min[page])
 179                                 data->vout_min[page] = ret;
 180                         ret = data->vout_min[page];
 181                 }
 182                 break;
 183         case PMBUS_VIRT_READ_TEMP_MIN:
 184                 ret = pmbus_read_word_data(client, page,
 185                                            LTC2978_MFR_TEMPERATURE_MIN);
 186                 if (ret >= 0) {
 187                         if (lin11_to_val(ret)
 188                             < lin11_to_val(data->temp_min[page]))
 189                                 data->temp_min[page] = ret;
 190                         ret = data->temp_min[page];
 191                 }
 192                 break;
 193         case PMBUS_VIRT_READ_IOUT_MAX:
 194         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 195         case PMBUS_VIRT_READ_TEMP2_MAX:
 196         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 197                 ret = -ENXIO;
 198                 break;
 199         default:
 200                 ret = ltc2978_read_word_data_common(client, page, reg);
 201                 break;
 202         }
 203         return ret;
 204 }
 205
 206 static int ltc2974_read_word_data(struct i2c_client *client, int page, int reg)
 207 {
 208         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 209         struct ltc2978_data *data = to_ltc2978_data(info);
 210         int ret;
 211
 212         switch (reg) {
 213         case PMBUS_VIRT_READ_IOUT_MAX:
 214                 ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_PEAK);
 215                 if (ret >= 0) {
 216                         if (lin11_to_val(ret)
 217                             > lin11_to_val(data->iout_max[page]))
 218                                 data->iout_max[page] = ret;
 219                         ret = data->iout_max[page];
 220                 }
 221                 break;
 222         case PMBUS_VIRT_READ_IOUT_MIN:
 223                 ret = pmbus_read_word_data(client, page, LTC2974_MFR_IOUT_MIN);
 224                 if (ret >= 0) {
 225                         if (lin11_to_val(ret)
 226                             < lin11_to_val(data->iout_min[page]))
 227                                 data->iout_min[page] = ret;
 228                         ret = data->iout_min[page];
 229                 }
 230                 break;
 231         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 232                 ret = 0;
 233                 break;
 234         default:
 235                 ret = ltc2978_read_word_data(client, page, reg);
 236                 break;
 237         }
 238         return ret;
 239 }
 240
 241 static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg)
 242 {
 243         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 244         struct ltc2978_data *data = to_ltc2978_data(info);
 245         int ret;
 246
 247         switch (reg) {
 248         case PMBUS_VIRT_READ_IOUT_MAX:
 249                 ret = pmbus_read_word_data(client, page, LTC3880_MFR_IOUT_PEAK);
 250                 if (ret >= 0) {
 251                         if (lin11_to_val(ret)
 252                             > lin11_to_val(data->iout_max[page]))
 253                                 data->iout_max[page] = ret;
 254                         ret = data->iout_max[page];
 255                 }
 256                 break;
 257         case PMBUS_VIRT_READ_TEMP2_MAX:
 258                 ret = pmbus_read_word_data(client, page,
 259                                            LTC3880_MFR_TEMPERATURE2_PEAK);
 260                 if (ret >= 0) {
 261                         if (lin11_to_val(ret) > lin11_to_val(data->temp2_max))
 262                                 data->temp2_max = ret;
 263                         ret = data->temp2_max;
 264                 }
 265                 break;
 266         case PMBUS_VIRT_READ_VIN_MIN:
 267         case PMBUS_VIRT_READ_VOUT_MIN:
 268         case PMBUS_VIRT_READ_TEMP_MIN:
 269                 ret = -ENXIO;
 270                 break;
 271         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 272         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 273                 ret = 0;
 274                 break;
 275         default:
 276                 ret = ltc2978_read_word_data_common(client, page, reg);
 277                 break;
 278         }
 279         return ret;
 280 }
 281
 282 static int ltc3883_read_word_data(struct i2c_client *client, int page, int reg)
 283 {
 284         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 285         struct ltc2978_data *data = to_ltc2978_data(info);
 286         int ret;
 287
 288         switch (reg) {
 289         case PMBUS_VIRT_READ_IIN_MAX:
 290                 ret = pmbus_read_word_data(client, page, LTC3883_MFR_IIN_PEAK);
 291                 if (ret >= 0) {
 292                         if (lin11_to_val(ret)
 293                             > lin11_to_val(data->iin_max))
 294                                 data->iin_max = ret;
 295                         ret = data->iin_max;
 296                 }
 297                 break;
 298         case PMBUS_VIRT_RESET_IIN_HISTORY:
 299                 ret = 0;
 300                 break;
 301         default:
 302                 ret = ltc3880_read_word_data(client, page, reg);
 303                 break;
 304         }
 305         return ret;
 306 }
 307
 308 static int ltc2978_clear_peaks(struct i2c_client *client, int page,
 309                                enum chips id)
 310 {
 311         int ret;
 312
 313         if (id == ltc3880 || id == ltc3883)
 314                 ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
 315         else
 316                 ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS);
 317
 318         return ret;
 319 }
 320
 321 static int ltc2978_write_word_data(struct i2c_client *client, int page,
 322                                     int reg, u16 word)
 323 {
 324         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 325         struct ltc2978_data *data = to_ltc2978_data(info);
 326         int ret;
 327
 328         switch (reg) {
 329         case PMBUS_VIRT_RESET_IIN_HISTORY:
 330                 data->iin_max = 0x7c00;
 331                 ret = ltc2978_clear_peaks(client, page, data->id);
 332                 break;
 333         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 334                 data->iout_max[page] = 0x7c00;
 335                 data->iout_min[page] = 0xfbff;
 336                 ret = ltc2978_clear_peaks(client, page, data->id);
 337                 break;
 338         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 339                 data->temp2_max = 0x7c00;
 340                 ret = ltc2978_clear_peaks(client, page, data->id);
 341                 break;
 342         case PMBUS_VIRT_RESET_VOUT_HISTORY:
 343                 data->vout_min[page] = 0xffff;
 344                 data->vout_max[page] = 0;
 345                 ret = ltc2978_clear_peaks(client, page, data->id);
 346                 break;
 347         case PMBUS_VIRT_RESET_VIN_HISTORY:
 348                 data->vin_min = 0x7bff;
 349                 data->vin_max = 0x7c00;
 350                 ret = ltc2978_clear_peaks(client, page, data->id);
 351                 break;
 352         case PMBUS_VIRT_RESET_TEMP_HISTORY:
 353                 data->temp_min[page] = 0x7bff;
 354                 data->temp_max[page] = 0x7c00;
 355                 ret = ltc2978_clear_peaks(client, page, data->id);
 356                 break;
 357         default:
 358                 ret = -ENODATA;
 359                 break;
 360         }
 361         return ret;
 362 }
 363
 364 static const struct i2c_device_id ltc2978_id[] = {
 365         {"ltc2974", ltc2974},
 366         {"ltc2978", ltc2978},
 367         {"ltc3880", ltc3880},
 368         {"ltc3883", ltc3883},
 369         {}
 370 };
 371 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
 372
 373 static int ltc2978_probe(struct i2c_client *client,
 374                          const struct i2c_device_id *id)
 375 {
 376         int chip_id, i;
 377         struct ltc2978_data *data;
 378         struct pmbus_driver_info *info;
 379
 380         if (!i2c_check_functionality(client->adapter,
 381                                      I2C_FUNC_SMBUS_READ_WORD_DATA))
 382                 return -ENODEV;
 383
 384         data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
 385                             GFP_KERNEL);
 386         if (!data)
 387                 return -ENOMEM;
 388
 389         chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
 390         if (chip_id < 0)
 391                 return chip_id;
 392
 393         if (chip_id == LTC2974_ID) {
 394                 data->id = ltc2974;
 395         } else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2) {
 396                 data->id = ltc2978;
 397         } else if ((chip_id & LTC3880_ID_MASK) == LTC3880_ID) {
 398                 data->id = ltc3880;
 399         } else if ((chip_id & LTC3883_ID_MASK) == LTC3883_ID) {
 400                 data->id = ltc3883;
 401         } else {
 402                 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
 403                 return -ENODEV;
 404         }
 405         if (data->id != id->driver_data)
 406                 dev_warn(&client->dev,
 407                          "Device mismatch: Configured %s, detected %s\n",
 408                          id->name,
 409                          ltc2978_id[data->id].name);
 410
 411         info = &data->info;
 412         info->write_word_data = ltc2978_write_word_data;
 413
 414         data->vin_min = 0x7bff;
 415         data->vin_max = 0x7c00;
 416         for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
 417                 data->vout_min[i] = 0xffff;
 418         for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
 419                 data->iout_min[i] = 0xfbff;
 420         for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
 421                 data->iout_max[i] = 0x7c00;
 422         for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
 423                 data->temp_min[i] = 0x7bff;
 424         for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
 425                 data->temp_max[i] = 0x7c00;
 426         data->temp2_max = 0x7c00;
 427
 428         switch (data->id) {
 429         case ltc2974:
 430                 info->read_word_data = ltc2974_read_word_data;
 431                 info->pages = LTC2974_NUM_PAGES;
 432                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 433                   | PMBUS_HAVE_TEMP2;
 434                 for (i = 0; i < info->pages; i++) {
 435                         info->func[i] |= PMBUS_HAVE_VOUT
 436                           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
 437                           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
 438                           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 439                 }
 440                 break;
 441         case ltc2978:
 442                 info->read_word_data = ltc2978_read_word_data;
 443                 info->pages = LTC2978_NUM_PAGES;
 444                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 445                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 446                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 447                 for (i = 1; i < LTC2978_NUM_PAGES; i++) {
 448                         info->func[i] = PMBUS_HAVE_VOUT
 449                           | PMBUS_HAVE_STATUS_VOUT;
 450                 }
 451                 break;
 452         case ltc3880:
 453                 info->read_word_data = ltc3880_read_word_data;
 454                 info->pages = LTC3880_NUM_PAGES;
 455                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
 456                   | PMBUS_HAVE_STATUS_INPUT
 457                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 458                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 459                   | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 460                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 461                 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 462                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 463                   | PMBUS_HAVE_POUT
 464                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 465                 break;
 466         case ltc3883:
 467                 info->read_word_data = ltc3883_read_word_data;
 468                 info->pages = LTC3883_NUM_PAGES;
 469                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
 470                   | PMBUS_HAVE_STATUS_INPUT
 471                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 472                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 473                   | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 474                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 475                 break;
 476         default:
 477                 return -ENODEV;
 478         }
 479         return pmbus_do_probe(client, id, info);
 480 }
 481
 482 /* This is the driver that will be inserted */
 483 static struct i2c_driver ltc2978_driver = {
 484         .driver = {
 485                    .name = "ltc2978",
 486                    },
 487         .probe = ltc2978_probe,
 488         .remove = pmbus_do_remove,
 489         .id_table = ltc2978_id,
 490 };
 491
 492 module_i2c_driver(ltc2978_driver);
 493
 494 MODULE_AUTHOR("Guenter Roeck");
 495 MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, and LTC3883");
 496 MODULE_LICENSE("GPL");