drivers/hwmon/pmbus/ltc2978.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Hardware monitoring driver for LTC2978 and compatible chips.
   4  *
   5  * Copyright (c) 2011 Ericsson AB.
   6  * Copyright (c) 2013, 2014, 2015 Guenter Roeck
   7  * Copyright (c) 2015 Linear Technology
   8  * Copyright (c) 2018 Analog Devices Inc.
   9  */
  10
  11 #include <linux/delay.h>
  12 #include <linux/jiffies.h>
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/init.h>
  16 #include <linux/err.h>
  17 #include <linux/slab.h>
  18 #include <linux/i2c.h>
  19 #include <linux/regulator/driver.h>
  20 #include "pmbus.h"
  21
  22 enum chips {
  23         /* Managers */
  24         ltc2972, ltc2974, ltc2975, ltc2977, ltc2978, ltc2979, ltc2980,
  25         /* Controllers */
  26         ltc3880, ltc3882, ltc3883, ltc3884, ltc3886, ltc3887, ltc3889, ltc7132, ltc7880,
  27         /* Modules */
  28         ltm2987, ltm4664, ltm4675, ltm4676, ltm4677, ltm4678, ltm4680, ltm4686,
  29         ltm4700,
  30 };
  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    /* Undocumented on LTC3882 */
  37 #define LTC2978_MFR_COMMON              0xef
  38
  39 /* LTC2974, LTC2975, LCT2977, LTC2980, LTC2978, and LTM2987 */
  40 #define LTC2978_MFR_VOUT_MIN            0xfb
  41 #define LTC2978_MFR_VIN_MIN             0xfc
  42 #define LTC2978_MFR_TEMPERATURE_MIN     0xfd
  43
  44 /* LTC2974, LTC2975 */
  45 #define LTC2974_MFR_IOUT_PEAK           0xd7
  46 #define LTC2974_MFR_IOUT_MIN            0xd8
  47
  48 /* LTC3880, LTC3882, LTC3883, LTC3887, LTM4675, LTM4676, LTC7132 */
  49 #define LTC3880_MFR_IOUT_PEAK           0xd7
  50 #define LTC3880_MFR_CLEAR_PEAKS         0xe3
  51 #define LTC3880_MFR_TEMPERATURE2_PEAK   0xf4
  52
  53 /* LTC3883, LTC3884, LTC3886, LTC3889, LTC7132, LTC7880 */
  54 #define LTC3883_MFR_IIN_PEAK            0xe1
  55
  56 /* LTC2975 only */
  57 #define LTC2975_MFR_IIN_PEAK            0xc4
  58 #define LTC2975_MFR_IIN_MIN             0xc5
  59 #define LTC2975_MFR_PIN_PEAK            0xc6
  60 #define LTC2975_MFR_PIN_MIN             0xc7
  61
  62 #define LTC2978_ID_MASK                 0xfff0
  63
  64 #define LTC2972_ID                      0x0310
  65 #define LTC2974_ID                      0x0210
  66 #define LTC2975_ID                      0x0220
  67 #define LTC2977_ID                      0x0130
  68 #define LTC2978_ID_REV1                 0x0110  /* Early revision */
  69 #define LTC2978_ID_REV2                 0x0120
  70 #define LTC2979_ID_A                    0x8060
  71 #define LTC2979_ID_B                    0x8070
  72 #define LTC2980_ID_A                    0x8030  /* A/B for two die IDs */
  73 #define LTC2980_ID_B                    0x8040
  74 #define LTC3880_ID                      0x4020
  75 #define LTC3882_ID                      0x4200
  76 #define LTC3882_ID_D1                   0x4240  /* Dash 1 */
  77 #define LTC3883_ID                      0x4300
  78 #define LTC3884_ID                      0x4C00
  79 #define LTC3886_ID                      0x4600
  80 #define LTC3887_ID                      0x4700
  81 #define LTC3889_ID                      0x4900
  82 #define LTC7132_ID                      0x4CE0
  83 #define LTC7880_ID                      0x49E0
  84 #define LTM2987_ID_A                    0x8010  /* A/B for two die IDs */
  85 #define LTM2987_ID_B                    0x8020
  86 #define LTM4664_ID                      0x4120
  87 #define LTM4675_ID                      0x47a0
  88 #define LTM4676_ID_REV1                 0x4400
  89 #define LTM4676_ID_REV2                 0x4480
  90 #define LTM4676A_ID                     0x47e0
  91 #define LTM4677_ID_REV1                 0x47B0
  92 #define LTM4677_ID_REV2                 0x47D0
  93 #define LTM4678_ID_REV1                 0x4100
  94 #define LTM4678_ID_REV2                 0x4110
  95 #define LTM4680_ID                      0x4140
  96 #define LTM4686_ID                      0x4770
  97 #define LTM4700_ID                      0x4130
  98
  99 #define LTC2972_NUM_PAGES               2
 100 #define LTC2974_NUM_PAGES               4
 101 #define LTC2978_NUM_PAGES               8
 102 #define LTC3880_NUM_PAGES               2
 103 #define LTC3883_NUM_PAGES               1
 104
 105 #define LTC_POLL_TIMEOUT                100     /* in milli-seconds */
 106
 107 #define LTC_NOT_BUSY                    BIT(6)
 108 #define LTC_NOT_PENDING                 BIT(5)
 109
 110 /*
 111  * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which
 112  * happens pretty much each time chip data is updated. Raw peak data therefore
 113  * does not provide much value. To be able to provide useful peak data, keep an
 114  * internal cache of measured peak data, which is only cleared if an explicit
 115  * "clear peak" command is executed for the sensor in question.
 116  */
 117
 118 struct ltc2978_data {
 119         enum chips id;
 120         u16 vin_min, vin_max;
 121         u16 temp_min[LTC2974_NUM_PAGES], temp_max[LTC2974_NUM_PAGES];
 122         u16 vout_min[LTC2978_NUM_PAGES], vout_max[LTC2978_NUM_PAGES];
 123         u16 iout_min[LTC2974_NUM_PAGES], iout_max[LTC2974_NUM_PAGES];
 124         u16 iin_min, iin_max;
 125         u16 pin_min, pin_max;
 126         u16 temp2_max;
 127         struct pmbus_driver_info info;
 128         u32 features;
 129 };
 130 #define to_ltc2978_data(x)  container_of(x, struct ltc2978_data, info)
 131
 132 #define FEAT_CLEAR_PEAKS        BIT(0)
 133 #define FEAT_NEEDS_POLLING      BIT(1)
 134
 135 #define has_clear_peaks(d)      ((d)->features & FEAT_CLEAR_PEAKS)
 136 #define needs_polling(d)        ((d)->features & FEAT_NEEDS_POLLING)
 137
 138 static int ltc_wait_ready(struct i2c_client *client)
 139 {
 140         unsigned long timeout = jiffies + msecs_to_jiffies(LTC_POLL_TIMEOUT);
 141         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 142         struct ltc2978_data *data = to_ltc2978_data(info);
 143         int status;
 144         u8 mask;
 145
 146         if (!needs_polling(data))
 147                 return 0;
 148
 149         /*
 150          * LTC3883 does not support LTC_NOT_PENDING, even though
 151          * the datasheet claims that it does.
 152          */
 153         mask = LTC_NOT_BUSY;
 154         if (data->id != ltc3883)
 155                 mask |= LTC_NOT_PENDING;
 156
 157         do {
 158                 status = pmbus_read_byte_data(client, 0, LTC2978_MFR_COMMON);
 159                 if (status == -EBADMSG || status == -ENXIO) {
 160                         /* PEC error or NACK: chip may be busy, try again */
 161                         usleep_range(50, 100);
 162                         continue;
 163                 }
 164                 if (status < 0)
 165                         return status;
 166
 167                 if ((status & mask) == mask)
 168                         return 0;
 169
 170                 usleep_range(50, 100);
 171         } while (time_before(jiffies, timeout));
 172
 173         return -ETIMEDOUT;
 174 }
 175
 176 static int ltc_read_word_data(struct i2c_client *client, int page, int phase,
 177                               int reg)
 178 {
 179         int ret;
 180
 181         ret = ltc_wait_ready(client);
 182         if (ret < 0)
 183                 return ret;
 184
 185         return pmbus_read_word_data(client, page, 0xff, reg);
 186 }
 187
 188 static int ltc_read_byte_data(struct i2c_client *client, int page, int reg)
 189 {
 190         int ret;
 191
 192         ret = ltc_wait_ready(client);
 193         if (ret < 0)
 194                 return ret;
 195
 196         return pmbus_read_byte_data(client, page, reg);
 197 }
 198
 199 static int ltc_write_byte_data(struct i2c_client *client, int page, int reg, u8 value)
 200 {
 201         int ret;
 202
 203         ret = ltc_wait_ready(client);
 204         if (ret < 0)
 205                 return ret;
 206
 207         return pmbus_write_byte_data(client, page, reg, value);
 208 }
 209
 210 static int ltc_write_byte(struct i2c_client *client, int page, u8 byte)
 211 {
 212         int ret;
 213
 214         ret = ltc_wait_ready(client);
 215         if (ret < 0)
 216                 return ret;
 217
 218         return pmbus_write_byte(client, page, byte);
 219 }
 220
 221 static inline int lin11_to_val(int data)
 222 {
 223         s16 e = ((s16)data) >> 11;
 224         s32 m = (((s16)(data << 5)) >> 5);
 225
 226         /*
 227          * mantissa is 10 bit + sign, exponent adds up to 15 bit.
 228          * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
 229          */
 230         e += 6;
 231         return (e < 0 ? m >> -e : m << e);
 232 }
 233
 234 static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client,
 235                        int page, int reg, u16 *pmax)
 236 {
 237         int ret;
 238
 239         ret = ltc_read_word_data(client, page, 0xff, reg);
 240         if (ret >= 0) {
 241                 if (lin11_to_val(ret) > lin11_to_val(*pmax))
 242                         *pmax = ret;
 243                 ret = *pmax;
 244         }
 245         return ret;
 246 }
 247
 248 static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client,
 249                        int page, int reg, u16 *pmin)
 250 {
 251         int ret;
 252
 253         ret = ltc_read_word_data(client, page, 0xff, reg);
 254         if (ret >= 0) {
 255                 if (lin11_to_val(ret) < lin11_to_val(*pmin))
 256                         *pmin = ret;
 257                 ret = *pmin;
 258         }
 259         return ret;
 260 }
 261
 262 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
 263                                          int reg)
 264 {
 265         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 266         struct ltc2978_data *data = to_ltc2978_data(info);
 267         int ret;
 268
 269         switch (reg) {
 270         case PMBUS_VIRT_READ_VIN_MAX:
 271                 ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK,
 272                                   &data->vin_max);
 273                 break;
 274         case PMBUS_VIRT_READ_VOUT_MAX:
 275                 ret = ltc_read_word_data(client, page, 0xff,
 276                                          LTC2978_MFR_VOUT_PEAK);
 277                 if (ret >= 0) {
 278                         /*
 279                          * VOUT is 16 bit unsigned with fixed exponent,
 280                          * so we can compare it directly
 281                          */
 282                         if (ret > data->vout_max[page])
 283                                 data->vout_max[page] = ret;
 284                         ret = data->vout_max[page];
 285                 }
 286                 break;
 287         case PMBUS_VIRT_READ_TEMP_MAX:
 288                 ret = ltc_get_max(data, client, page,
 289                                   LTC2978_MFR_TEMPERATURE_PEAK,
 290                                   &data->temp_max[page]);
 291                 break;
 292         case PMBUS_VIRT_RESET_VOUT_HISTORY:
 293         case PMBUS_VIRT_RESET_VIN_HISTORY:
 294         case PMBUS_VIRT_RESET_TEMP_HISTORY:
 295                 ret = 0;
 296                 break;
 297         default:
 298                 ret = ltc_wait_ready(client);
 299                 if (ret < 0)
 300                         return ret;
 301                 ret = -ENODATA;
 302                 break;
 303         }
 304         return ret;
 305 }
 306
 307 static int ltc2978_read_word_data(struct i2c_client *client, int page,
 308                                   int phase, int reg)
 309 {
 310         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 311         struct ltc2978_data *data = to_ltc2978_data(info);
 312         int ret;
 313
 314         switch (reg) {
 315         case PMBUS_VIRT_READ_VIN_MIN:
 316                 ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN,
 317                                   &data->vin_min);
 318                 break;
 319         case PMBUS_VIRT_READ_VOUT_MIN:
 320                 ret = ltc_read_word_data(client, page, phase,
 321                                          LTC2978_MFR_VOUT_MIN);
 322                 if (ret >= 0) {
 323                         /*
 324                          * VOUT_MIN is known to not be supported on some lots
 325                          * of LTC2978 revision 1, and will return the maximum
 326                          * possible voltage if read. If VOUT_MAX is valid and
 327                          * lower than the reading of VOUT_MIN, use it instead.
 328                          */
 329                         if (data->vout_max[page] && ret > data->vout_max[page])
 330                                 ret = data->vout_max[page];
 331                         if (ret < data->vout_min[page])
 332                                 data->vout_min[page] = ret;
 333                         ret = data->vout_min[page];
 334                 }
 335                 break;
 336         case PMBUS_VIRT_READ_TEMP_MIN:
 337                 ret = ltc_get_min(data, client, page,
 338                                   LTC2978_MFR_TEMPERATURE_MIN,
 339                                   &data->temp_min[page]);
 340                 break;
 341         case PMBUS_VIRT_READ_IOUT_MAX:
 342         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 343         case PMBUS_VIRT_READ_TEMP2_MAX:
 344         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 345                 ret = -ENXIO;
 346                 break;
 347         default:
 348                 ret = ltc2978_read_word_data_common(client, page, reg);
 349                 break;
 350         }
 351         return ret;
 352 }
 353
 354 static int ltc2974_read_word_data(struct i2c_client *client, int page,
 355                                   int phase, int reg)
 356 {
 357         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 358         struct ltc2978_data *data = to_ltc2978_data(info);
 359         int ret;
 360
 361         switch (reg) {
 362         case PMBUS_VIRT_READ_IOUT_MAX:
 363                 ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK,
 364                                   &data->iout_max[page]);
 365                 break;
 366         case PMBUS_VIRT_READ_IOUT_MIN:
 367                 ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN,
 368                                   &data->iout_min[page]);
 369                 break;
 370         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 371                 ret = 0;
 372                 break;
 373         default:
 374                 ret = ltc2978_read_word_data(client, page, phase, reg);
 375                 break;
 376         }
 377         return ret;
 378 }
 379
 380 static int ltc2975_read_word_data(struct i2c_client *client, int page,
 381                                   int phase, int reg)
 382 {
 383         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 384         struct ltc2978_data *data = to_ltc2978_data(info);
 385         int ret;
 386
 387         switch (reg) {
 388         case PMBUS_VIRT_READ_IIN_MAX:
 389                 ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK,
 390                                   &data->iin_max);
 391                 break;
 392         case PMBUS_VIRT_READ_IIN_MIN:
 393                 ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN,
 394                                   &data->iin_min);
 395                 break;
 396         case PMBUS_VIRT_READ_PIN_MAX:
 397                 ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK,
 398                                   &data->pin_max);
 399                 break;
 400         case PMBUS_VIRT_READ_PIN_MIN:
 401                 ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN,
 402                                   &data->pin_min);
 403                 break;
 404         case PMBUS_VIRT_RESET_IIN_HISTORY:
 405         case PMBUS_VIRT_RESET_PIN_HISTORY:
 406                 ret = 0;
 407                 break;
 408         default:
 409                 ret = ltc2978_read_word_data(client, page, phase, reg);
 410                 break;
 411         }
 412         return ret;
 413 }
 414
 415 static int ltc3880_read_word_data(struct i2c_client *client, int page,
 416                                   int phase, int reg)
 417 {
 418         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 419         struct ltc2978_data *data = to_ltc2978_data(info);
 420         int ret;
 421
 422         switch (reg) {
 423         case PMBUS_VIRT_READ_IOUT_MAX:
 424                 ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK,
 425                                   &data->iout_max[page]);
 426                 break;
 427         case PMBUS_VIRT_READ_TEMP2_MAX:
 428                 ret = ltc_get_max(data, client, page,
 429                                   LTC3880_MFR_TEMPERATURE2_PEAK,
 430                                   &data->temp2_max);
 431                 break;
 432         case PMBUS_VIRT_READ_VIN_MIN:
 433         case PMBUS_VIRT_READ_VOUT_MIN:
 434         case PMBUS_VIRT_READ_TEMP_MIN:
 435                 ret = -ENXIO;
 436                 break;
 437         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 438         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 439                 ret = 0;
 440                 break;
 441         default:
 442                 ret = ltc2978_read_word_data_common(client, page, reg);
 443                 break;
 444         }
 445         return ret;
 446 }
 447
 448 static int ltc3883_read_word_data(struct i2c_client *client, int page,
 449                                   int phase, int reg)
 450 {
 451         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 452         struct ltc2978_data *data = to_ltc2978_data(info);
 453         int ret;
 454
 455         switch (reg) {
 456         case PMBUS_VIRT_READ_IIN_MAX:
 457                 ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK,
 458                                   &data->iin_max);
 459                 break;
 460         case PMBUS_VIRT_RESET_IIN_HISTORY:
 461                 ret = 0;
 462                 break;
 463         default:
 464                 ret = ltc3880_read_word_data(client, page, phase, reg);
 465                 break;
 466         }
 467         return ret;
 468 }
 469
 470 static int ltc2978_clear_peaks(struct ltc2978_data *data,
 471                                struct i2c_client *client, int page)
 472 {
 473         int ret;
 474
 475         if (has_clear_peaks(data))
 476                 ret = ltc_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
 477         else
 478                 ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS);
 479
 480         return ret;
 481 }
 482
 483 static int ltc2978_write_word_data(struct i2c_client *client, int page,
 484                                     int reg, u16 word)
 485 {
 486         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 487         struct ltc2978_data *data = to_ltc2978_data(info);
 488         int ret;
 489
 490         switch (reg) {
 491         case PMBUS_VIRT_RESET_IIN_HISTORY:
 492                 data->iin_max = 0x7c00;
 493                 data->iin_min = 0x7bff;
 494                 ret = ltc2978_clear_peaks(data, client, 0);
 495                 break;
 496         case PMBUS_VIRT_RESET_PIN_HISTORY:
 497                 data->pin_max = 0x7c00;
 498                 data->pin_min = 0x7bff;
 499                 ret = ltc2978_clear_peaks(data, client, 0);
 500                 break;
 501         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 502                 data->iout_max[page] = 0x7c00;
 503                 data->iout_min[page] = 0xfbff;
 504                 ret = ltc2978_clear_peaks(data, client, page);
 505                 break;
 506         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 507                 data->temp2_max = 0x7c00;
 508                 ret = ltc2978_clear_peaks(data, client, page);
 509                 break;
 510         case PMBUS_VIRT_RESET_VOUT_HISTORY:
 511                 data->vout_min[page] = 0xffff;
 512                 data->vout_max[page] = 0;
 513                 ret = ltc2978_clear_peaks(data, client, page);
 514                 break;
 515         case PMBUS_VIRT_RESET_VIN_HISTORY:
 516                 data->vin_min = 0x7bff;
 517                 data->vin_max = 0x7c00;
 518                 ret = ltc2978_clear_peaks(data, client, page);
 519                 break;
 520         case PMBUS_VIRT_RESET_TEMP_HISTORY:
 521                 data->temp_min[page] = 0x7bff;
 522                 data->temp_max[page] = 0x7c00;
 523                 ret = ltc2978_clear_peaks(data, client, page);
 524                 break;
 525         default:
 526                 ret = ltc_wait_ready(client);
 527                 if (ret < 0)
 528                         return ret;
 529                 ret = -ENODATA;
 530                 break;
 531         }
 532         return ret;
 533 }
 534
 535 static const struct i2c_device_id ltc2978_id[] = {
 536         {"ltc2972", ltc2972},
 537         {"ltc2974", ltc2974},
 538         {"ltc2975", ltc2975},
 539         {"ltc2977", ltc2977},
 540         {"ltc2978", ltc2978},
 541         {"ltc2979", ltc2979},
 542         {"ltc2980", ltc2980},
 543         {"ltc3880", ltc3880},
 544         {"ltc3882", ltc3882},
 545         {"ltc3883", ltc3883},
 546         {"ltc3884", ltc3884},
 547         {"ltc3886", ltc3886},
 548         {"ltc3887", ltc3887},
 549         {"ltc3889", ltc3889},
 550         {"ltc7132", ltc7132},
 551         {"ltc7880", ltc7880},
 552         {"ltm2987", ltm2987},
 553         {"ltm4664", ltm4664},
 554         {"ltm4675", ltm4675},
 555         {"ltm4676", ltm4676},
 556         {"ltm4677", ltm4677},
 557         {"ltm4678", ltm4678},
 558         {"ltm4680", ltm4680},
 559         {"ltm4686", ltm4686},
 560         {"ltm4700", ltm4700},
 561         {}
 562 };
 563 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
 564
 565 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
 566 #define LTC2978_ADC_RES 0xFFFF
 567 #define LTC2978_N_ADC   122
 568 #define LTC2978_MAX_UV  (LTC2978_ADC_RES * LTC2978_N_ADC)
 569 #define LTC2978_UV_STEP 1000
 570 #define LTC2978_N_VOLTAGES      ((LTC2978_MAX_UV / LTC2978_UV_STEP) + 1)
 571
 572 static const struct regulator_desc ltc2978_reg_desc[] = {
 573         PMBUS_REGULATOR_STEP("vout", 0, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0),
 574         PMBUS_REGULATOR_STEP("vout", 1, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0),
 575         PMBUS_REGULATOR_STEP("vout", 2, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0),
 576         PMBUS_REGULATOR_STEP("vout", 3, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0),
 577         PMBUS_REGULATOR_STEP("vout", 4, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0),
 578         PMBUS_REGULATOR_STEP("vout", 5, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0),
 579         PMBUS_REGULATOR_STEP("vout", 6, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0),
 580         PMBUS_REGULATOR_STEP("vout", 7, LTC2978_N_VOLTAGES, LTC2978_UV_STEP, 0),
 581 };
 582
 583 static const struct regulator_desc ltc2978_reg_desc_default[] = {
 584         PMBUS_REGULATOR("vout", 0),
 585         PMBUS_REGULATOR("vout", 1),
 586         PMBUS_REGULATOR("vout", 2),
 587         PMBUS_REGULATOR("vout", 3),
 588         PMBUS_REGULATOR("vout", 4),
 589         PMBUS_REGULATOR("vout", 5),
 590         PMBUS_REGULATOR("vout", 6),
 591         PMBUS_REGULATOR("vout", 7),
 592 };
 593 #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
 594
 595 static int ltc2978_get_id(struct i2c_client *client)
 596 {
 597         int chip_id;
 598
 599         chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
 600         if (chip_id < 0) {
 601                 const struct i2c_device_id *id;
 602                 u8 buf[I2C_SMBUS_BLOCK_MAX];
 603                 int ret;
 604
 605                 if (!i2c_check_functionality(client->adapter,
 606                                              I2C_FUNC_SMBUS_READ_BLOCK_DATA))
 607                         return -ENODEV;
 608
 609                 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf);
 610                 if (ret < 0)
 611                         return ret;
 612                 if (ret < 3 || strncmp(buf, "LTC", 3))
 613                         return -ENODEV;
 614
 615                 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf);
 616                 if (ret < 0)
 617                         return ret;
 618                 for (id = &ltc2978_id[0]; strlen(id->name); id++) {
 619                         if (!strncasecmp(id->name, buf, strlen(id->name)))
 620                                 return (int)id->driver_data;
 621                 }
 622                 return -ENODEV;
 623         }
 624
 625         chip_id &= LTC2978_ID_MASK;
 626
 627         if (chip_id == LTC2972_ID)
 628                 return ltc2972;
 629         else if (chip_id == LTC2974_ID)
 630                 return ltc2974;
 631         else if (chip_id == LTC2975_ID)
 632                 return ltc2975;
 633         else if (chip_id == LTC2977_ID)
 634                 return ltc2977;
 635         else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2)
 636                 return ltc2978;
 637         else if (chip_id == LTC2979_ID_A || chip_id == LTC2979_ID_B)
 638                 return ltc2979;
 639         else if (chip_id == LTC2980_ID_A || chip_id == LTC2980_ID_B)
 640                 return ltc2980;
 641         else if (chip_id == LTC3880_ID)
 642                 return ltc3880;
 643         else if (chip_id == LTC3882_ID || chip_id == LTC3882_ID_D1)
 644                 return ltc3882;
 645         else if (chip_id == LTC3883_ID)
 646                 return ltc3883;
 647         else if (chip_id == LTC3884_ID)
 648                 return ltc3884;
 649         else if (chip_id == LTC3886_ID)
 650                 return ltc3886;
 651         else if (chip_id == LTC3887_ID)
 652                 return ltc3887;
 653         else if (chip_id == LTC3889_ID)
 654                 return ltc3889;
 655         else if (chip_id == LTC7132_ID)
 656                 return ltc7132;
 657         else if (chip_id == LTC7880_ID)
 658                 return ltc7880;
 659         else if (chip_id == LTM2987_ID_A || chip_id == LTM2987_ID_B)
 660                 return ltm2987;
 661         else if (chip_id == LTM4664_ID)
 662                 return ltm4664;
 663         else if (chip_id == LTM4675_ID)
 664                 return ltm4675;
 665         else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 ||
 666                  chip_id == LTM4676A_ID)
 667                 return ltm4676;
 668         else if (chip_id == LTM4677_ID_REV1 || chip_id == LTM4677_ID_REV2)
 669                 return ltm4677;
 670         else if (chip_id == LTM4678_ID_REV1 || chip_id == LTM4678_ID_REV2)
 671                 return ltm4678;
 672         else if (chip_id == LTM4680_ID)
 673                 return ltm4680;
 674         else if (chip_id == LTM4686_ID)
 675                 return ltm4686;
 676         else if (chip_id == LTM4700_ID)
 677                 return ltm4700;
 678
 679         dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
 680         return -ENODEV;
 681 }
 682
 683 static int ltc2978_probe(struct i2c_client *client)
 684 {
 685         int i, chip_id;
 686         struct ltc2978_data *data;
 687         struct pmbus_driver_info *info;
 688         const struct i2c_device_id *id;
 689
 690         if (!i2c_check_functionality(client->adapter,
 691                                      I2C_FUNC_SMBUS_READ_WORD_DATA))
 692                 return -ENODEV;
 693
 694         data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
 695                             GFP_KERNEL);
 696         if (!data)
 697                 return -ENOMEM;
 698
 699         chip_id = ltc2978_get_id(client);
 700         if (chip_id < 0)
 701                 return chip_id;
 702
 703         data->id = chip_id;
 704         id = i2c_match_id(ltc2978_id, client);
 705         if (data->id != id->driver_data)
 706                 dev_warn(&client->dev,
 707                          "Device mismatch: Configured %s (%d), detected %d\n",
 708                          id->name,
 709                          (int) id->driver_data,
 710                          chip_id);
 711
 712         info = &data->info;
 713         info->write_word_data = ltc2978_write_word_data;
 714         info->write_byte = ltc_write_byte;
 715         info->write_byte_data = ltc_write_byte_data;
 716         info->read_word_data = ltc_read_word_data;
 717         info->read_byte_data = ltc_read_byte_data;
 718
 719         data->vin_min = 0x7bff;
 720         data->vin_max = 0x7c00;
 721         for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
 722                 data->vout_min[i] = 0xffff;
 723         for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
 724                 data->iout_min[i] = 0xfbff;
 725         for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
 726                 data->iout_max[i] = 0x7c00;
 727         for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
 728                 data->temp_min[i] = 0x7bff;
 729         for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
 730                 data->temp_max[i] = 0x7c00;
 731         data->temp2_max = 0x7c00;
 732
 733         switch (data->id) {
 734         case ltc2972:
 735                 info->read_word_data = ltc2975_read_word_data;
 736                 info->pages = LTC2972_NUM_PAGES;
 737                 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
 738                   | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 739                   | PMBUS_HAVE_TEMP2;
 740                 for (i = 0; i < info->pages; i++) {
 741                         info->func[i] |= PMBUS_HAVE_VOUT
 742                           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
 743                           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
 744                           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 745                 }
 746                 break;
 747         case ltc2974:
 748                 info->read_word_data = ltc2974_read_word_data;
 749                 info->pages = LTC2974_NUM_PAGES;
 750                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 751                   | PMBUS_HAVE_TEMP2;
 752                 for (i = 0; i < info->pages; i++) {
 753                         info->func[i] |= PMBUS_HAVE_VOUT
 754                           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
 755                           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
 756                           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 757                 }
 758                 break;
 759         case ltc2975:
 760                 info->read_word_data = ltc2975_read_word_data;
 761                 info->pages = LTC2974_NUM_PAGES;
 762                 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
 763                   | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 764                   | PMBUS_HAVE_TEMP2;
 765                 for (i = 0; i < info->pages; i++) {
 766                         info->func[i] |= PMBUS_HAVE_VOUT
 767                           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
 768                           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
 769                           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 770                 }
 771                 break;
 772
 773         case ltc2977:
 774         case ltc2978:
 775         case ltc2979:
 776         case ltc2980:
 777         case ltm2987:
 778                 info->read_word_data = ltc2978_read_word_data;
 779                 info->pages = LTC2978_NUM_PAGES;
 780                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 781                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 782                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 783                 for (i = 1; i < LTC2978_NUM_PAGES; i++) {
 784                         info->func[i] = PMBUS_HAVE_VOUT
 785                           | PMBUS_HAVE_STATUS_VOUT;
 786                 }
 787                 break;
 788         case ltc3880:
 789         case ltc3887:
 790         case ltm4675:
 791         case ltm4676:
 792         case ltm4677:
 793         case ltm4686:
 794                 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
 795                 info->read_word_data = ltc3880_read_word_data;
 796                 info->pages = LTC3880_NUM_PAGES;
 797                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
 798                   | PMBUS_HAVE_STATUS_INPUT
 799                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 800                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 801                   | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 802                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 803                 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 804                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 805                   | PMBUS_HAVE_POUT
 806                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 807                 break;
 808         case ltc3882:
 809                 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
 810                 info->read_word_data = ltc3880_read_word_data;
 811                 info->pages = LTC3880_NUM_PAGES;
 812                 info->func[0] = PMBUS_HAVE_VIN
 813                   | PMBUS_HAVE_STATUS_INPUT
 814                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 815                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 816                   | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 817                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 818                 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 819                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 820                   | PMBUS_HAVE_POUT
 821                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 822                 break;
 823         case ltc3883:
 824                 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
 825                 info->read_word_data = ltc3883_read_word_data;
 826                 info->pages = LTC3883_NUM_PAGES;
 827                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
 828                   | PMBUS_HAVE_STATUS_INPUT
 829                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 830                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 831                   | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 832                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 833                 break;
 834         case ltc3884:
 835         case ltc3886:
 836         case ltc3889:
 837         case ltc7132:
 838         case ltc7880:
 839         case ltm4664:
 840         case ltm4678:
 841         case ltm4680:
 842         case ltm4700:
 843                 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
 844                 info->read_word_data = ltc3883_read_word_data;
 845                 info->pages = LTC3880_NUM_PAGES;
 846                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
 847                   | PMBUS_HAVE_STATUS_INPUT
 848                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 849                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 850                   | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 851                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 852                 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 853                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 854                   | PMBUS_HAVE_POUT
 855                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 856                 break;
 857         default:
 858                 return -ENODEV;
 859         }
 860
 861 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
 862         info->num_regulators = info->pages;
 863         switch (data->id) {
 864         case ltc2972:
 865         case ltc2974:
 866         case ltc2975:
 867         case ltc2977:
 868         case ltc2978:
 869         case ltc2979:
 870         case ltc2980:
 871         case ltm2987:
 872                 info->reg_desc = ltc2978_reg_desc;
 873                 if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
 874                         dev_warn(&client->dev, "num_regulators too large!");
 875                         info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
 876                 }
 877                 break;
 878         default:
 879                 info->reg_desc = ltc2978_reg_desc_default;
 880                 if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc_default)) {
 881                         dev_warn(&client->dev, "num_regulators too large!");
 882                         info->num_regulators =
 883                             ARRAY_SIZE(ltc2978_reg_desc_default);
 884                 }
 885                 break;
 886         }
 887 #endif
 888
 889         return pmbus_do_probe(client, info);
 890 }
 891
 892
 893 #ifdef CONFIG_OF
 894 static const struct of_device_id ltc2978_of_match[] = {
 895         { .compatible = "lltc,ltc2972" },
 896         { .compatible = "lltc,ltc2974" },
 897         { .compatible = "lltc,ltc2975" },
 898         { .compatible = "lltc,ltc2977" },
 899         { .compatible = "lltc,ltc2978" },
 900         { .compatible = "lltc,ltc2979" },
 901         { .compatible = "lltc,ltc2980" },
 902         { .compatible = "lltc,ltc3880" },
 903         { .compatible = "lltc,ltc3882" },
 904         { .compatible = "lltc,ltc3883" },
 905         { .compatible = "lltc,ltc3884" },
 906         { .compatible = "lltc,ltc3886" },
 907         { .compatible = "lltc,ltc3887" },
 908         { .compatible = "lltc,ltc3889" },
 909         { .compatible = "lltc,ltc7132" },
 910         { .compatible = "lltc,ltc7880" },
 911         { .compatible = "lltc,ltm2987" },
 912         { .compatible = "lltc,ltm4664" },
 913         { .compatible = "lltc,ltm4675" },
 914         { .compatible = "lltc,ltm4676" },
 915         { .compatible = "lltc,ltm4677" },
 916         { .compatible = "lltc,ltm4678" },
 917         { .compatible = "lltc,ltm4680" },
 918         { .compatible = "lltc,ltm4686" },
 919         { .compatible = "lltc,ltm4700" },
 920         { }
 921 };
 922 MODULE_DEVICE_TABLE(of, ltc2978_of_match);
 923 #endif
 924
 925 static struct i2c_driver ltc2978_driver = {
 926         .driver = {
 927                    .name = "ltc2978",
 928                    .of_match_table = of_match_ptr(ltc2978_of_match),
 929                    },
 930         .probe = ltc2978_probe,
 931         .id_table = ltc2978_id,
 932 };
 933
 934 module_i2c_driver(ltc2978_driver);
 935
 936 MODULE_AUTHOR("Guenter Roeck");
 937 MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips");
 938 MODULE_LICENSE("GPL");
 939 MODULE_IMPORT_NS(PMBUS);