drivers/hwmon/pmbus/ltc2978.c

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