drivers/hwmon/pmbus/ltc2978.c

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