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, 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, and LTM4676 */
  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 and LTC7880 only */
  54 #define LTC3883_MFR_IIN_PEAK            0xe1
  55
  56
  57 /* LTC2975 only */
  58 #define LTC2975_MFR_IIN_PEAK            0xc4
  59 #define LTC2975_MFR_IIN_MIN             0xc5
  60 #define LTC2975_MFR_PIN_PEAK            0xc6
  61 #define LTC2975_MFR_PIN_MIN             0xc7
  62
  63 #define LTC2978_ID_MASK                 0xfff0
  64
  65 #define LTC2972_ID                      0x0310
  66 #define LTC2974_ID                      0x0210
  67 #define LTC2975_ID                      0x0220
  68 #define LTC2977_ID                      0x0130
  69 #define LTC2978_ID_REV1                 0x0110  /* Early revision */
  70 #define LTC2978_ID_REV2                 0x0120
  71 #define LTC2979_ID_A                    0x8060
  72 #define LTC2979_ID_B                    0x8070
  73 #define LTC2980_ID_A                    0x8030  /* A/B for two die IDs */
  74 #define LTC2980_ID_B                    0x8040
  75 #define LTC3880_ID                      0x4020
  76 #define LTC3882_ID                      0x4200
  77 #define LTC3882_ID_D1                   0x4240  /* Dash 1 */
  78 #define LTC3883_ID                      0x4300
  79 #define LTC3884_ID                      0x4C00
  80 #define LTC3886_ID                      0x4600
  81 #define LTC3887_ID                      0x4700
  82 #define LTM2987_ID_A                    0x8010  /* A/B for two die IDs */
  83 #define LTM2987_ID_B                    0x8020
  84 #define LTC3889_ID                      0x4900
  85 #define LTC7880_ID                      0x49E0
  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(struct i2c_client *client, int page, u8 byte)
 200 {
 201         int ret;
 202
 203         ret = ltc_wait_ready(client);
 204         if (ret < 0)
 205                 return ret;
 206
 207         return pmbus_write_byte(client, page, byte);
 208 }
 209
 210 static inline int lin11_to_val(int data)
 211 {
 212         s16 e = ((s16)data) >> 11;
 213         s32 m = (((s16)(data << 5)) >> 5);
 214
 215         /*
 216          * mantissa is 10 bit + sign, exponent adds up to 15 bit.
 217          * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31).
 218          */
 219         e += 6;
 220         return (e < 0 ? m >> -e : m << e);
 221 }
 222
 223 static int ltc_get_max(struct ltc2978_data *data, struct i2c_client *client,
 224                        int page, int reg, u16 *pmax)
 225 {
 226         int ret;
 227
 228         ret = ltc_read_word_data(client, page, 0xff, reg);
 229         if (ret >= 0) {
 230                 if (lin11_to_val(ret) > lin11_to_val(*pmax))
 231                         *pmax = ret;
 232                 ret = *pmax;
 233         }
 234         return ret;
 235 }
 236
 237 static int ltc_get_min(struct ltc2978_data *data, struct i2c_client *client,
 238                        int page, int reg, u16 *pmin)
 239 {
 240         int ret;
 241
 242         ret = ltc_read_word_data(client, page, 0xff, reg);
 243         if (ret >= 0) {
 244                 if (lin11_to_val(ret) < lin11_to_val(*pmin))
 245                         *pmin = ret;
 246                 ret = *pmin;
 247         }
 248         return ret;
 249 }
 250
 251 static int ltc2978_read_word_data_common(struct i2c_client *client, int page,
 252                                          int reg)
 253 {
 254         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 255         struct ltc2978_data *data = to_ltc2978_data(info);
 256         int ret;
 257
 258         switch (reg) {
 259         case PMBUS_VIRT_READ_VIN_MAX:
 260                 ret = ltc_get_max(data, client, page, LTC2978_MFR_VIN_PEAK,
 261                                   &data->vin_max);
 262                 break;
 263         case PMBUS_VIRT_READ_VOUT_MAX:
 264                 ret = ltc_read_word_data(client, page, 0xff,
 265                                          LTC2978_MFR_VOUT_PEAK);
 266                 if (ret >= 0) {
 267                         /*
 268                          * VOUT is 16 bit unsigned with fixed exponent,
 269                          * so we can compare it directly
 270                          */
 271                         if (ret > data->vout_max[page])
 272                                 data->vout_max[page] = ret;
 273                         ret = data->vout_max[page];
 274                 }
 275                 break;
 276         case PMBUS_VIRT_READ_TEMP_MAX:
 277                 ret = ltc_get_max(data, client, page,
 278                                   LTC2978_MFR_TEMPERATURE_PEAK,
 279                                   &data->temp_max[page]);
 280                 break;
 281         case PMBUS_VIRT_RESET_VOUT_HISTORY:
 282         case PMBUS_VIRT_RESET_VIN_HISTORY:
 283         case PMBUS_VIRT_RESET_TEMP_HISTORY:
 284                 ret = 0;
 285                 break;
 286         default:
 287                 ret = ltc_wait_ready(client);
 288                 if (ret < 0)
 289                         return ret;
 290                 ret = -ENODATA;
 291                 break;
 292         }
 293         return ret;
 294 }
 295
 296 static int ltc2978_read_word_data(struct i2c_client *client, int page,
 297                                   int phase, int reg)
 298 {
 299         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 300         struct ltc2978_data *data = to_ltc2978_data(info);
 301         int ret;
 302
 303         switch (reg) {
 304         case PMBUS_VIRT_READ_VIN_MIN:
 305                 ret = ltc_get_min(data, client, page, LTC2978_MFR_VIN_MIN,
 306                                   &data->vin_min);
 307                 break;
 308         case PMBUS_VIRT_READ_VOUT_MIN:
 309                 ret = ltc_read_word_data(client, page, phase,
 310                                          LTC2978_MFR_VOUT_MIN);
 311                 if (ret >= 0) {
 312                         /*
 313                          * VOUT_MIN is known to not be supported on some lots
 314                          * of LTC2978 revision 1, and will return the maximum
 315                          * possible voltage if read. If VOUT_MAX is valid and
 316                          * lower than the reading of VOUT_MIN, use it instead.
 317                          */
 318                         if (data->vout_max[page] && ret > data->vout_max[page])
 319                                 ret = data->vout_max[page];
 320                         if (ret < data->vout_min[page])
 321                                 data->vout_min[page] = ret;
 322                         ret = data->vout_min[page];
 323                 }
 324                 break;
 325         case PMBUS_VIRT_READ_TEMP_MIN:
 326                 ret = ltc_get_min(data, client, page,
 327                                   LTC2978_MFR_TEMPERATURE_MIN,
 328                                   &data->temp_min[page]);
 329                 break;
 330         case PMBUS_VIRT_READ_IOUT_MAX:
 331         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 332         case PMBUS_VIRT_READ_TEMP2_MAX:
 333         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 334                 ret = -ENXIO;
 335                 break;
 336         default:
 337                 ret = ltc2978_read_word_data_common(client, page, reg);
 338                 break;
 339         }
 340         return ret;
 341 }
 342
 343 static int ltc2974_read_word_data(struct i2c_client *client, int page,
 344                                   int phase, int reg)
 345 {
 346         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 347         struct ltc2978_data *data = to_ltc2978_data(info);
 348         int ret;
 349
 350         switch (reg) {
 351         case PMBUS_VIRT_READ_IOUT_MAX:
 352                 ret = ltc_get_max(data, client, page, LTC2974_MFR_IOUT_PEAK,
 353                                   &data->iout_max[page]);
 354                 break;
 355         case PMBUS_VIRT_READ_IOUT_MIN:
 356                 ret = ltc_get_min(data, client, page, LTC2974_MFR_IOUT_MIN,
 357                                   &data->iout_min[page]);
 358                 break;
 359         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 360                 ret = 0;
 361                 break;
 362         default:
 363                 ret = ltc2978_read_word_data(client, page, phase, reg);
 364                 break;
 365         }
 366         return ret;
 367 }
 368
 369 static int ltc2975_read_word_data(struct i2c_client *client, int page,
 370                                   int phase, int reg)
 371 {
 372         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 373         struct ltc2978_data *data = to_ltc2978_data(info);
 374         int ret;
 375
 376         switch (reg) {
 377         case PMBUS_VIRT_READ_IIN_MAX:
 378                 ret = ltc_get_max(data, client, page, LTC2975_MFR_IIN_PEAK,
 379                                   &data->iin_max);
 380                 break;
 381         case PMBUS_VIRT_READ_IIN_MIN:
 382                 ret = ltc_get_min(data, client, page, LTC2975_MFR_IIN_MIN,
 383                                   &data->iin_min);
 384                 break;
 385         case PMBUS_VIRT_READ_PIN_MAX:
 386                 ret = ltc_get_max(data, client, page, LTC2975_MFR_PIN_PEAK,
 387                                   &data->pin_max);
 388                 break;
 389         case PMBUS_VIRT_READ_PIN_MIN:
 390                 ret = ltc_get_min(data, client, page, LTC2975_MFR_PIN_MIN,
 391                                   &data->pin_min);
 392                 break;
 393         case PMBUS_VIRT_RESET_IIN_HISTORY:
 394         case PMBUS_VIRT_RESET_PIN_HISTORY:
 395                 ret = 0;
 396                 break;
 397         default:
 398                 ret = ltc2978_read_word_data(client, page, phase, reg);
 399                 break;
 400         }
 401         return ret;
 402 }
 403
 404 static int ltc3880_read_word_data(struct i2c_client *client, int page,
 405                                   int phase, int reg)
 406 {
 407         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 408         struct ltc2978_data *data = to_ltc2978_data(info);
 409         int ret;
 410
 411         switch (reg) {
 412         case PMBUS_VIRT_READ_IOUT_MAX:
 413                 ret = ltc_get_max(data, client, page, LTC3880_MFR_IOUT_PEAK,
 414                                   &data->iout_max[page]);
 415                 break;
 416         case PMBUS_VIRT_READ_TEMP2_MAX:
 417                 ret = ltc_get_max(data, client, page,
 418                                   LTC3880_MFR_TEMPERATURE2_PEAK,
 419                                   &data->temp2_max);
 420                 break;
 421         case PMBUS_VIRT_READ_VIN_MIN:
 422         case PMBUS_VIRT_READ_VOUT_MIN:
 423         case PMBUS_VIRT_READ_TEMP_MIN:
 424                 ret = -ENXIO;
 425                 break;
 426         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 427         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 428                 ret = 0;
 429                 break;
 430         default:
 431                 ret = ltc2978_read_word_data_common(client, page, reg);
 432                 break;
 433         }
 434         return ret;
 435 }
 436
 437 static int ltc3883_read_word_data(struct i2c_client *client, int page,
 438                                   int phase, int reg)
 439 {
 440         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 441         struct ltc2978_data *data = to_ltc2978_data(info);
 442         int ret;
 443
 444         switch (reg) {
 445         case PMBUS_VIRT_READ_IIN_MAX:
 446                 ret = ltc_get_max(data, client, page, LTC3883_MFR_IIN_PEAK,
 447                                   &data->iin_max);
 448                 break;
 449         case PMBUS_VIRT_RESET_IIN_HISTORY:
 450                 ret = 0;
 451                 break;
 452         default:
 453                 ret = ltc3880_read_word_data(client, page, phase, reg);
 454                 break;
 455         }
 456         return ret;
 457 }
 458
 459 static int ltc2978_clear_peaks(struct ltc2978_data *data,
 460                                struct i2c_client *client, int page)
 461 {
 462         int ret;
 463
 464         if (has_clear_peaks(data))
 465                 ret = ltc_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS);
 466         else
 467                 ret = ltc_write_byte(client, page, PMBUS_CLEAR_FAULTS);
 468
 469         return ret;
 470 }
 471
 472 static int ltc2978_write_word_data(struct i2c_client *client, int page,
 473                                     int reg, u16 word)
 474 {
 475         const struct pmbus_driver_info *info = pmbus_get_driver_info(client);
 476         struct ltc2978_data *data = to_ltc2978_data(info);
 477         int ret;
 478
 479         switch (reg) {
 480         case PMBUS_VIRT_RESET_IIN_HISTORY:
 481                 data->iin_max = 0x7c00;
 482                 data->iin_min = 0x7bff;
 483                 ret = ltc2978_clear_peaks(data, client, 0);
 484                 break;
 485         case PMBUS_VIRT_RESET_PIN_HISTORY:
 486                 data->pin_max = 0x7c00;
 487                 data->pin_min = 0x7bff;
 488                 ret = ltc2978_clear_peaks(data, client, 0);
 489                 break;
 490         case PMBUS_VIRT_RESET_IOUT_HISTORY:
 491                 data->iout_max[page] = 0x7c00;
 492                 data->iout_min[page] = 0xfbff;
 493                 ret = ltc2978_clear_peaks(data, client, page);
 494                 break;
 495         case PMBUS_VIRT_RESET_TEMP2_HISTORY:
 496                 data->temp2_max = 0x7c00;
 497                 ret = ltc2978_clear_peaks(data, client, page);
 498                 break;
 499         case PMBUS_VIRT_RESET_VOUT_HISTORY:
 500                 data->vout_min[page] = 0xffff;
 501                 data->vout_max[page] = 0;
 502                 ret = ltc2978_clear_peaks(data, client, page);
 503                 break;
 504         case PMBUS_VIRT_RESET_VIN_HISTORY:
 505                 data->vin_min = 0x7bff;
 506                 data->vin_max = 0x7c00;
 507                 ret = ltc2978_clear_peaks(data, client, page);
 508                 break;
 509         case PMBUS_VIRT_RESET_TEMP_HISTORY:
 510                 data->temp_min[page] = 0x7bff;
 511                 data->temp_max[page] = 0x7c00;
 512                 ret = ltc2978_clear_peaks(data, client, page);
 513                 break;
 514         default:
 515                 ret = ltc_wait_ready(client);
 516                 if (ret < 0)
 517                         return ret;
 518                 ret = -ENODATA;
 519                 break;
 520         }
 521         return ret;
 522 }
 523
 524 static const struct i2c_device_id ltc2978_id[] = {
 525         {"ltc2972", ltc2972},
 526         {"ltc2974", ltc2974},
 527         {"ltc2975", ltc2975},
 528         {"ltc2977", ltc2977},
 529         {"ltc2978", ltc2978},
 530         {"ltc2979", ltc2979},
 531         {"ltc2980", ltc2980},
 532         {"ltc3880", ltc3880},
 533         {"ltc3882", ltc3882},
 534         {"ltc3883", ltc3883},
 535         {"ltc3884", ltc3884},
 536         {"ltc3886", ltc3886},
 537         {"ltc3887", ltc3887},
 538         {"ltc3889", ltc3889},
 539         {"ltc7880", ltc7880},
 540         {"ltm2987", ltm2987},
 541         {"ltm4664", ltm4664},
 542         {"ltm4675", ltm4675},
 543         {"ltm4676", ltm4676},
 544         {"ltm4677", ltm4677},
 545         {"ltm4678", ltm4678},
 546         {"ltm4680", ltm4680},
 547         {"ltm4686", ltm4686},
 548         {"ltm4700", ltm4700},
 549         {}
 550 };
 551 MODULE_DEVICE_TABLE(i2c, ltc2978_id);
 552
 553 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
 554 static const struct regulator_desc ltc2978_reg_desc[] = {
 555         PMBUS_REGULATOR("vout", 0),
 556         PMBUS_REGULATOR("vout", 1),
 557         PMBUS_REGULATOR("vout", 2),
 558         PMBUS_REGULATOR("vout", 3),
 559         PMBUS_REGULATOR("vout", 4),
 560         PMBUS_REGULATOR("vout", 5),
 561         PMBUS_REGULATOR("vout", 6),
 562         PMBUS_REGULATOR("vout", 7),
 563 };
 564 #endif /* CONFIG_SENSORS_LTC2978_REGULATOR */
 565
 566 static int ltc2978_get_id(struct i2c_client *client)
 567 {
 568         int chip_id;
 569
 570         chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID);
 571         if (chip_id < 0) {
 572                 const struct i2c_device_id *id;
 573                 u8 buf[I2C_SMBUS_BLOCK_MAX];
 574                 int ret;
 575
 576                 if (!i2c_check_functionality(client->adapter,
 577                                              I2C_FUNC_SMBUS_READ_BLOCK_DATA))
 578                         return -ENODEV;
 579
 580                 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_ID, buf);
 581                 if (ret < 0)
 582                         return ret;
 583                 if (ret < 3 || strncmp(buf, "LTC", 3))
 584                         return -ENODEV;
 585
 586                 ret = i2c_smbus_read_block_data(client, PMBUS_MFR_MODEL, buf);
 587                 if (ret < 0)
 588                         return ret;
 589                 for (id = &ltc2978_id[0]; strlen(id->name); id++) {
 590                         if (!strncasecmp(id->name, buf, strlen(id->name)))
 591                                 return (int)id->driver_data;
 592                 }
 593                 return -ENODEV;
 594         }
 595
 596         chip_id &= LTC2978_ID_MASK;
 597
 598         if (chip_id == LTC2972_ID)
 599                 return ltc2972;
 600         else if (chip_id == LTC2974_ID)
 601                 return ltc2974;
 602         else if (chip_id == LTC2975_ID)
 603                 return ltc2975;
 604         else if (chip_id == LTC2977_ID)
 605                 return ltc2977;
 606         else if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2)
 607                 return ltc2978;
 608         else if (chip_id == LTC2979_ID_A || chip_id == LTC2979_ID_B)
 609                 return ltc2979;
 610         else if (chip_id == LTC2980_ID_A || chip_id == LTC2980_ID_B)
 611                 return ltc2980;
 612         else if (chip_id == LTC3880_ID)
 613                 return ltc3880;
 614         else if (chip_id == LTC3882_ID || chip_id == LTC3882_ID_D1)
 615                 return ltc3882;
 616         else if (chip_id == LTC3883_ID)
 617                 return ltc3883;
 618         else if (chip_id == LTC3884_ID)
 619                 return ltc3884;
 620         else if (chip_id == LTC3886_ID)
 621                 return ltc3886;
 622         else if (chip_id == LTC3887_ID)
 623                 return ltc3887;
 624         else if (chip_id == LTC3889_ID)
 625                 return ltc3889;
 626         else if (chip_id == LTC7880_ID)
 627                 return ltc7880;
 628         else if (chip_id == LTM2987_ID_A || chip_id == LTM2987_ID_B)
 629                 return ltm2987;
 630         else if (chip_id == LTM4664_ID)
 631                 return ltm4664;
 632         else if (chip_id == LTM4675_ID)
 633                 return ltm4675;
 634         else if (chip_id == LTM4676_ID_REV1 || chip_id == LTM4676_ID_REV2 ||
 635                  chip_id == LTM4676A_ID)
 636                 return ltm4676;
 637         else if (chip_id == LTM4677_ID_REV1 || chip_id == LTM4677_ID_REV2)
 638                 return ltm4677;
 639         else if (chip_id == LTM4678_ID_REV1 || chip_id == LTM4678_ID_REV2)
 640                 return ltm4678;
 641         else if (chip_id == LTM4680_ID)
 642                 return ltm4680;
 643         else if (chip_id == LTM4686_ID)
 644                 return ltm4686;
 645         else if (chip_id == LTM4700_ID)
 646                 return ltm4700;
 647
 648         dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id);
 649         return -ENODEV;
 650 }
 651
 652 static int ltc2978_probe(struct i2c_client *client)
 653 {
 654         int i, chip_id;
 655         struct ltc2978_data *data;
 656         struct pmbus_driver_info *info;
 657         const struct i2c_device_id *id;
 658
 659         if (!i2c_check_functionality(client->adapter,
 660                                      I2C_FUNC_SMBUS_READ_WORD_DATA))
 661                 return -ENODEV;
 662
 663         data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data),
 664                             GFP_KERNEL);
 665         if (!data)
 666                 return -ENOMEM;
 667
 668         chip_id = ltc2978_get_id(client);
 669         if (chip_id < 0)
 670                 return chip_id;
 671
 672         data->id = chip_id;
 673         id = i2c_match_id(ltc2978_id, client);
 674         if (data->id != id->driver_data)
 675                 dev_warn(&client->dev,
 676                          "Device mismatch: Configured %s (%d), detected %d\n",
 677                          id->name,
 678                          (int) id->driver_data,
 679                          chip_id);
 680
 681         info = &data->info;
 682         info->write_word_data = ltc2978_write_word_data;
 683         info->write_byte = ltc_write_byte;
 684         info->read_word_data = ltc_read_word_data;
 685         info->read_byte_data = ltc_read_byte_data;
 686
 687         data->vin_min = 0x7bff;
 688         data->vin_max = 0x7c00;
 689         for (i = 0; i < ARRAY_SIZE(data->vout_min); i++)
 690                 data->vout_min[i] = 0xffff;
 691         for (i = 0; i < ARRAY_SIZE(data->iout_min); i++)
 692                 data->iout_min[i] = 0xfbff;
 693         for (i = 0; i < ARRAY_SIZE(data->iout_max); i++)
 694                 data->iout_max[i] = 0x7c00;
 695         for (i = 0; i < ARRAY_SIZE(data->temp_min); i++)
 696                 data->temp_min[i] = 0x7bff;
 697         for (i = 0; i < ARRAY_SIZE(data->temp_max); i++)
 698                 data->temp_max[i] = 0x7c00;
 699         data->temp2_max = 0x7c00;
 700
 701         switch (data->id) {
 702         case ltc2972:
 703                 info->read_word_data = ltc2975_read_word_data;
 704                 info->pages = LTC2972_NUM_PAGES;
 705                 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
 706                   | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 707                   | PMBUS_HAVE_TEMP2;
 708                 for (i = 0; i < info->pages; i++) {
 709                         info->func[i] |= PMBUS_HAVE_VOUT
 710                           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
 711                           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
 712                           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 713                 }
 714                 break;
 715         case ltc2974:
 716                 info->read_word_data = ltc2974_read_word_data;
 717                 info->pages = LTC2974_NUM_PAGES;
 718                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 719                   | PMBUS_HAVE_TEMP2;
 720                 for (i = 0; i < info->pages; i++) {
 721                         info->func[i] |= PMBUS_HAVE_VOUT
 722                           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
 723                           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
 724                           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 725                 }
 726                 break;
 727         case ltc2975:
 728                 info->read_word_data = ltc2975_read_word_data;
 729                 info->pages = LTC2974_NUM_PAGES;
 730                 info->func[0] = PMBUS_HAVE_IIN | PMBUS_HAVE_PIN
 731                   | PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 732                   | PMBUS_HAVE_TEMP2;
 733                 for (i = 0; i < info->pages; i++) {
 734                         info->func[i] |= PMBUS_HAVE_VOUT
 735                           | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT
 736                           | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP
 737                           | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT;
 738                 }
 739                 break;
 740
 741         case ltc2977:
 742         case ltc2978:
 743         case ltc2979:
 744         case ltc2980:
 745         case ltm2987:
 746                 info->read_word_data = ltc2978_read_word_data;
 747                 info->pages = LTC2978_NUM_PAGES;
 748                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT
 749                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 750                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 751                 for (i = 1; i < LTC2978_NUM_PAGES; i++) {
 752                         info->func[i] = PMBUS_HAVE_VOUT
 753                           | PMBUS_HAVE_STATUS_VOUT;
 754                 }
 755                 break;
 756         case ltc3880:
 757         case ltc3887:
 758         case ltm4675:
 759         case ltm4676:
 760         case ltm4677:
 761         case ltm4686:
 762                 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
 763                 info->read_word_data = ltc3880_read_word_data;
 764                 info->pages = LTC3880_NUM_PAGES;
 765                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
 766                   | PMBUS_HAVE_STATUS_INPUT
 767                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 768                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 769                   | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 770                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 771                 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 772                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 773                   | PMBUS_HAVE_POUT
 774                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 775                 break;
 776         case ltc3882:
 777                 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
 778                 info->read_word_data = ltc3880_read_word_data;
 779                 info->pages = LTC3880_NUM_PAGES;
 780                 info->func[0] = PMBUS_HAVE_VIN
 781                   | PMBUS_HAVE_STATUS_INPUT
 782                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 783                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 784                   | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 785                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 786                 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 787                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 788                   | PMBUS_HAVE_POUT
 789                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 790                 break;
 791         case ltc3883:
 792                 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
 793                 info->read_word_data = ltc3883_read_word_data;
 794                 info->pages = LTC3883_NUM_PAGES;
 795                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
 796                   | PMBUS_HAVE_STATUS_INPUT
 797                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 798                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 799                   | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 800                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 801                 break;
 802         case ltc3884:
 803         case ltc3886:
 804         case ltc3889:
 805         case ltc7880:
 806         case ltm4664:
 807         case ltm4678:
 808         case ltm4680:
 809         case ltm4700:
 810                 data->features |= FEAT_CLEAR_PEAKS | FEAT_NEEDS_POLLING;
 811                 info->read_word_data = ltc3883_read_word_data;
 812                 info->pages = LTC3880_NUM_PAGES;
 813                 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN
 814                   | PMBUS_HAVE_STATUS_INPUT
 815                   | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 816                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 817                   | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP
 818                   | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP;
 819                 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT
 820                   | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
 821                   | PMBUS_HAVE_POUT
 822                   | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP;
 823                 break;
 824         default:
 825                 return -ENODEV;
 826         }
 827
 828 #if IS_ENABLED(CONFIG_SENSORS_LTC2978_REGULATOR)
 829         info->num_regulators = info->pages;
 830         info->reg_desc = ltc2978_reg_desc;
 831         if (info->num_regulators > ARRAY_SIZE(ltc2978_reg_desc)) {
 832                 dev_err(&client->dev, "num_regulators too large!");
 833                 info->num_regulators = ARRAY_SIZE(ltc2978_reg_desc);
 834         }
 835 #endif
 836
 837         return pmbus_do_probe(client, info);
 838 }
 839
 840
 841 #ifdef CONFIG_OF
 842 static const struct of_device_id ltc2978_of_match[] = {
 843         { .compatible = "lltc,ltc2972" },
 844         { .compatible = "lltc,ltc2974" },
 845         { .compatible = "lltc,ltc2975" },
 846         { .compatible = "lltc,ltc2977" },
 847         { .compatible = "lltc,ltc2978" },
 848         { .compatible = "lltc,ltc2979" },
 849         { .compatible = "lltc,ltc2980" },
 850         { .compatible = "lltc,ltc3880" },
 851         { .compatible = "lltc,ltc3882" },
 852         { .compatible = "lltc,ltc3883" },
 853         { .compatible = "lltc,ltc3884" },
 854         { .compatible = "lltc,ltc3886" },
 855         { .compatible = "lltc,ltc3887" },
 856         { .compatible = "lltc,ltc3889" },
 857         { .compatible = "lltc,ltc7880" },
 858         { .compatible = "lltc,ltm2987" },
 859         { .compatible = "lltc,ltm4664" },
 860         { .compatible = "lltc,ltm4675" },
 861         { .compatible = "lltc,ltm4676" },
 862         { .compatible = "lltc,ltm4677" },
 863         { .compatible = "lltc,ltm4678" },
 864         { .compatible = "lltc,ltm4680" },
 865         { .compatible = "lltc,ltm4686" },
 866         { .compatible = "lltc,ltm4700" },
 867         { }
 868 };
 869 MODULE_DEVICE_TABLE(of, ltc2978_of_match);
 870 #endif
 871
 872 static struct i2c_driver ltc2978_driver = {
 873         .driver = {
 874                    .name = "ltc2978",
 875                    .of_match_table = of_match_ptr(ltc2978_of_match),
 876                    },
 877         .probe_new = ltc2978_probe,
 878         .id_table = ltc2978_id,
 879 };
 880
 881 module_i2c_driver(ltc2978_driver);
 882
 883 MODULE_AUTHOR("Guenter Roeck");
 884 MODULE_DESCRIPTION("PMBus driver for LTC2978 and compatible chips");
 885 MODULE_LICENSE("GPL");