1 /* 2 * Hardware monitoring driver for LTC2974, LTC2977, LTC2978, LTC3880, 3 * and LTC3883 4 * 5 * Copyright (c) 2011 Ericsson AB. 6 * Copyright (c) 2013 Guenter Roeck 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23 #include <linux/kernel.h> 24 #include <linux/module.h> 25 #include <linux/init.h> 26 #include <linux/err.h> 27 #include <linux/slab.h> 28 #include <linux/i2c.h> 29 #include "pmbus.h" 30 31 enum chips { ltc2974, ltc2977, ltc2978, ltc3880, ltc3883 }; 32 33 /* Common for all chips */ 34 #define LTC2978_MFR_VOUT_PEAK 0xdd 35 #define LTC2978_MFR_VIN_PEAK 0xde 36 #define LTC2978_MFR_TEMPERATURE_PEAK 0xdf 37 #define LTC2978_MFR_SPECIAL_ID 0xe7 38 39 /* LTC2974, LCT2977, and LTC2978 */ 40 #define LTC2978_MFR_VOUT_MIN 0xfb 41 #define LTC2978_MFR_VIN_MIN 0xfc 42 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd 43 44 /* LTC2974 only */ 45 #define LTC2974_MFR_IOUT_PEAK 0xd7 46 #define LTC2974_MFR_IOUT_MIN 0xd8 47 48 /* LTC3880 and LTC3883 */ 49 #define LTC3880_MFR_IOUT_PEAK 0xd7 50 #define LTC3880_MFR_CLEAR_PEAKS 0xe3 51 #define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4 52 53 /* LTC3883 only */ 54 #define LTC3883_MFR_IIN_PEAK 0xe1 55 56 #define LTC2974_ID 0x0212 57 #define LTC2977_ID 0x0130 58 #define LTC2978_ID_REV1 0x0121 59 #define LTC2978_ID_REV2 0x0122 60 #define LTC2978A_ID 0x0124 61 #define LTC3880_ID 0x4000 62 #define LTC3880_ID_MASK 0xff00 63 #define LTC3883_ID 0x4300 64 #define LTC3883_ID_MASK 0xff00 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 {} 374 }; 375 MODULE_DEVICE_TABLE(i2c, ltc2978_id); 376 377 static 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) { 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 { 409 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id); 410 return -ENODEV; 411 } 412 if (data->id != id->driver_data) 413 dev_warn(&client->dev, 414 "Device mismatch: Configured %s, detected %s\n", 415 id->name, 416 ltc2978_id[data->id].name); 417 418 info = &data->info; 419 info->write_word_data = ltc2978_write_word_data; 420 421 data->vin_min = 0x7bff; 422 data->vin_max = 0x7c00; 423 for (i = 0; i < ARRAY_SIZE(data->vout_min); i++) 424 data->vout_min[i] = 0xffff; 425 for (i = 0; i < ARRAY_SIZE(data->iout_min); i++) 426 data->iout_min[i] = 0xfbff; 427 for (i = 0; i < ARRAY_SIZE(data->iout_max); i++) 428 data->iout_max[i] = 0x7c00; 429 for (i = 0; i < ARRAY_SIZE(data->temp_min); i++) 430 data->temp_min[i] = 0x7bff; 431 for (i = 0; i < ARRAY_SIZE(data->temp_max); i++) 432 data->temp_max[i] = 0x7c00; 433 data->temp2_max = 0x7c00; 434 435 switch (data->id) { 436 case ltc2974: 437 info->read_word_data = ltc2974_read_word_data; 438 info->pages = LTC2974_NUM_PAGES; 439 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 440 | PMBUS_HAVE_TEMP2; 441 for (i = 0; i < info->pages; i++) { 442 info->func[i] |= PMBUS_HAVE_VOUT 443 | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_POUT 444 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP 445 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT; 446 } 447 break; 448 case ltc2977: 449 case ltc2978: 450 info->read_word_data = ltc2978_read_word_data; 451 info->pages = LTC2978_NUM_PAGES; 452 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 453 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 454 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 455 for (i = 1; i < LTC2978_NUM_PAGES; i++) { 456 info->func[i] = PMBUS_HAVE_VOUT 457 | PMBUS_HAVE_STATUS_VOUT; 458 } 459 break; 460 case ltc3880: 461 info->read_word_data = ltc3880_read_word_data; 462 info->pages = LTC3880_NUM_PAGES; 463 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 464 | PMBUS_HAVE_STATUS_INPUT 465 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 466 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 467 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 468 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 469 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 470 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 471 | PMBUS_HAVE_POUT 472 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 473 break; 474 case ltc3883: 475 info->read_word_data = ltc3883_read_word_data; 476 info->pages = LTC3883_NUM_PAGES; 477 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 478 | PMBUS_HAVE_STATUS_INPUT 479 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 480 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 481 | PMBUS_HAVE_PIN | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 482 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 483 break; 484 default: 485 return -ENODEV; 486 } 487 return pmbus_do_probe(client, id, info); 488 } 489 490 /* This is the driver that will be inserted */ 491 static struct i2c_driver ltc2978_driver = { 492 .driver = { 493 .name = "ltc2978", 494 }, 495 .probe = ltc2978_probe, 496 .remove = pmbus_do_remove, 497 .id_table = ltc2978_id, 498 }; 499 500 module_i2c_driver(ltc2978_driver); 501 502 MODULE_AUTHOR("Guenter Roeck"); 503 MODULE_DESCRIPTION("PMBus driver for LTC2974, LTC2978, LTC3880, and LTC3883"); 504 MODULE_LICENSE("GPL"); 505