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