1 /* 2 * Hardware monitoring driver for LTC2978 and LTC3880 3 * 4 * Copyright (c) 2011 Ericsson AB. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 */ 20 21 #include <linux/kernel.h> 22 #include <linux/module.h> 23 #include <linux/init.h> 24 #include <linux/err.h> 25 #include <linux/slab.h> 26 #include <linux/i2c.h> 27 #include "pmbus.h" 28 29 enum chips { ltc2978, ltc3880 }; 30 31 /* LTC2978 and LTC3880 */ 32 #define LTC2978_MFR_VOUT_PEAK 0xdd 33 #define LTC2978_MFR_VIN_PEAK 0xde 34 #define LTC2978_MFR_TEMPERATURE_PEAK 0xdf 35 #define LTC2978_MFR_SPECIAL_ID 0xe7 36 37 /* LTC2978 only */ 38 #define LTC2978_MFR_VOUT_MIN 0xfb 39 #define LTC2978_MFR_VIN_MIN 0xfc 40 #define LTC2978_MFR_TEMPERATURE_MIN 0xfd 41 42 /* LTC3880 only */ 43 #define LTC3880_MFR_IOUT_PEAK 0xd7 44 #define LTC3880_MFR_CLEAR_PEAKS 0xe3 45 #define LTC3880_MFR_TEMPERATURE2_PEAK 0xf4 46 47 #define LTC2978_ID_REV1 0x0121 48 #define LTC2978_ID_REV2 0x0122 49 #define LTC3880_ID 0x4000 50 #define LTC3880_ID_MASK 0xff00 51 52 /* 53 * LTC2978 clears peak data whenever the CLEAR_FAULTS command is executed, which 54 * happens pretty much each time chip data is updated. Raw peak data therefore 55 * does not provide much value. To be able to provide useful peak data, keep an 56 * internal cache of measured peak data, which is only cleared if an explicit 57 * "clear peak" command is executed for the sensor in question. 58 */ 59 struct ltc2978_data { 60 enum chips id; 61 int vin_min, vin_max; 62 int temp_min, temp_max; 63 int vout_min[8], vout_max[8]; 64 int iout_max[2]; 65 int temp2_max; 66 struct pmbus_driver_info info; 67 }; 68 69 #define to_ltc2978_data(x) container_of(x, struct ltc2978_data, info) 70 71 static inline int lin11_to_val(int data) 72 { 73 s16 e = ((s16)data) >> 11; 74 s32 m = (((s16)(data << 5)) >> 5); 75 76 /* 77 * mantissa is 10 bit + sign, exponent adds up to 15 bit. 78 * Add 6 bit to exponent for maximum accuracy (10 + 15 + 6 = 31). 79 */ 80 e += 6; 81 return (e < 0 ? m >> -e : m << e); 82 } 83 84 static int ltc2978_read_word_data_common(struct i2c_client *client, int page, 85 int reg) 86 { 87 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 88 struct ltc2978_data *data = to_ltc2978_data(info); 89 int ret; 90 91 switch (reg) { 92 case PMBUS_VIRT_READ_VIN_MAX: 93 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_PEAK); 94 if (ret >= 0) { 95 if (lin11_to_val(ret) > lin11_to_val(data->vin_max)) 96 data->vin_max = ret; 97 ret = data->vin_max; 98 } 99 break; 100 case PMBUS_VIRT_READ_VOUT_MAX: 101 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_PEAK); 102 if (ret >= 0) { 103 /* 104 * VOUT is 16 bit unsigned with fixed exponent, 105 * so we can compare it directly 106 */ 107 if (ret > data->vout_max[page]) 108 data->vout_max[page] = ret; 109 ret = data->vout_max[page]; 110 } 111 break; 112 case PMBUS_VIRT_READ_TEMP_MAX: 113 ret = pmbus_read_word_data(client, page, 114 LTC2978_MFR_TEMPERATURE_PEAK); 115 if (ret >= 0) { 116 if (lin11_to_val(ret) > lin11_to_val(data->temp_max)) 117 data->temp_max = ret; 118 ret = data->temp_max; 119 } 120 break; 121 case PMBUS_VIRT_RESET_VOUT_HISTORY: 122 case PMBUS_VIRT_RESET_VIN_HISTORY: 123 case PMBUS_VIRT_RESET_TEMP_HISTORY: 124 ret = 0; 125 break; 126 default: 127 ret = -ENODATA; 128 break; 129 } 130 return ret; 131 } 132 133 static int ltc2978_read_word_data(struct i2c_client *client, int page, int reg) 134 { 135 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 136 struct ltc2978_data *data = to_ltc2978_data(info); 137 int ret; 138 139 switch (reg) { 140 case PMBUS_VIRT_READ_VIN_MIN: 141 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VIN_MIN); 142 if (ret >= 0) { 143 if (lin11_to_val(ret) < lin11_to_val(data->vin_min)) 144 data->vin_min = ret; 145 ret = data->vin_min; 146 } 147 break; 148 case PMBUS_VIRT_READ_VOUT_MIN: 149 ret = pmbus_read_word_data(client, page, LTC2978_MFR_VOUT_MIN); 150 if (ret >= 0) { 151 /* 152 * VOUT_MIN is known to not be supported on some lots 153 * of LTC2978 revision 1, and will return the maximum 154 * possible voltage if read. If VOUT_MAX is valid and 155 * lower than the reading of VOUT_MIN, use it instead. 156 */ 157 if (data->vout_max[page] && ret > data->vout_max[page]) 158 ret = data->vout_max[page]; 159 if (ret < data->vout_min[page]) 160 data->vout_min[page] = ret; 161 ret = data->vout_min[page]; 162 } 163 break; 164 case PMBUS_VIRT_READ_TEMP_MIN: 165 ret = pmbus_read_word_data(client, page, 166 LTC2978_MFR_TEMPERATURE_MIN); 167 if (ret >= 0) { 168 if (lin11_to_val(ret) 169 < lin11_to_val(data->temp_min)) 170 data->temp_min = ret; 171 ret = data->temp_min; 172 } 173 break; 174 case PMBUS_VIRT_READ_IOUT_MAX: 175 case PMBUS_VIRT_RESET_IOUT_HISTORY: 176 case PMBUS_VIRT_READ_TEMP2_MAX: 177 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 178 ret = -ENXIO; 179 break; 180 default: 181 ret = ltc2978_read_word_data_common(client, page, reg); 182 break; 183 } 184 return ret; 185 } 186 187 static int ltc3880_read_word_data(struct i2c_client *client, int page, int reg) 188 { 189 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 190 struct ltc2978_data *data = to_ltc2978_data(info); 191 int ret; 192 193 switch (reg) { 194 case PMBUS_VIRT_READ_IOUT_MAX: 195 ret = pmbus_read_word_data(client, page, LTC3880_MFR_IOUT_PEAK); 196 if (ret >= 0) { 197 if (lin11_to_val(ret) 198 > lin11_to_val(data->iout_max[page])) 199 data->iout_max[page] = ret; 200 ret = data->iout_max[page]; 201 } 202 break; 203 case PMBUS_VIRT_READ_TEMP2_MAX: 204 ret = pmbus_read_word_data(client, page, 205 LTC3880_MFR_TEMPERATURE2_PEAK); 206 if (ret >= 0) { 207 if (lin11_to_val(ret) > lin11_to_val(data->temp2_max)) 208 data->temp2_max = ret; 209 ret = data->temp2_max; 210 } 211 break; 212 case PMBUS_VIRT_READ_VIN_MIN: 213 case PMBUS_VIRT_READ_VOUT_MIN: 214 case PMBUS_VIRT_READ_TEMP_MIN: 215 ret = -ENXIO; 216 break; 217 case PMBUS_VIRT_RESET_IOUT_HISTORY: 218 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 219 ret = 0; 220 break; 221 default: 222 ret = ltc2978_read_word_data_common(client, page, reg); 223 break; 224 } 225 return ret; 226 } 227 228 static int ltc2978_clear_peaks(struct i2c_client *client, int page, 229 enum chips id) 230 { 231 int ret; 232 233 if (id == ltc2978) 234 ret = pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS); 235 else 236 ret = pmbus_write_byte(client, 0, LTC3880_MFR_CLEAR_PEAKS); 237 238 return ret; 239 } 240 241 static int ltc2978_write_word_data(struct i2c_client *client, int page, 242 int reg, u16 word) 243 { 244 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 245 struct ltc2978_data *data = to_ltc2978_data(info); 246 int ret; 247 248 switch (reg) { 249 case PMBUS_VIRT_RESET_IOUT_HISTORY: 250 data->iout_max[page] = 0x7c00; 251 ret = ltc2978_clear_peaks(client, page, data->id); 252 break; 253 case PMBUS_VIRT_RESET_TEMP2_HISTORY: 254 data->temp2_max = 0x7c00; 255 ret = ltc2978_clear_peaks(client, page, data->id); 256 break; 257 case PMBUS_VIRT_RESET_VOUT_HISTORY: 258 data->vout_min[page] = 0xffff; 259 data->vout_max[page] = 0; 260 ret = ltc2978_clear_peaks(client, page, data->id); 261 break; 262 case PMBUS_VIRT_RESET_VIN_HISTORY: 263 data->vin_min = 0x7bff; 264 data->vin_max = 0x7c00; 265 ret = ltc2978_clear_peaks(client, page, data->id); 266 break; 267 case PMBUS_VIRT_RESET_TEMP_HISTORY: 268 data->temp_min = 0x7bff; 269 data->temp_max = 0x7c00; 270 ret = ltc2978_clear_peaks(client, page, data->id); 271 break; 272 default: 273 ret = -ENODATA; 274 break; 275 } 276 return ret; 277 } 278 279 static const struct i2c_device_id ltc2978_id[] = { 280 {"ltc2978", ltc2978}, 281 {"ltc3880", ltc3880}, 282 {} 283 }; 284 MODULE_DEVICE_TABLE(i2c, ltc2978_id); 285 286 static int ltc2978_probe(struct i2c_client *client, 287 const struct i2c_device_id *id) 288 { 289 int chip_id, i; 290 struct ltc2978_data *data; 291 struct pmbus_driver_info *info; 292 293 if (!i2c_check_functionality(client->adapter, 294 I2C_FUNC_SMBUS_READ_WORD_DATA)) 295 return -ENODEV; 296 297 data = devm_kzalloc(&client->dev, sizeof(struct ltc2978_data), 298 GFP_KERNEL); 299 if (!data) 300 return -ENOMEM; 301 302 chip_id = i2c_smbus_read_word_data(client, LTC2978_MFR_SPECIAL_ID); 303 if (chip_id < 0) 304 return chip_id; 305 306 if (chip_id == LTC2978_ID_REV1 || chip_id == LTC2978_ID_REV2) { 307 data->id = ltc2978; 308 } else if ((chip_id & LTC3880_ID_MASK) == LTC3880_ID) { 309 data->id = ltc3880; 310 } else { 311 dev_err(&client->dev, "Unsupported chip ID 0x%x\n", chip_id); 312 return -ENODEV; 313 } 314 if (data->id != id->driver_data) 315 dev_warn(&client->dev, 316 "Device mismatch: Configured %s, detected %s\n", 317 id->name, 318 ltc2978_id[data->id].name); 319 320 info = &data->info; 321 info->write_word_data = ltc2978_write_word_data; 322 323 data->vin_min = 0x7bff; 324 data->vin_max = 0x7c00; 325 data->temp_min = 0x7bff; 326 data->temp_max = 0x7c00; 327 data->temp2_max = 0x7c00; 328 329 switch (data->id) { 330 case ltc2978: 331 info->read_word_data = ltc2978_read_word_data; 332 info->pages = 8; 333 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT 334 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 335 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 336 for (i = 1; i < 8; i++) { 337 info->func[i] = PMBUS_HAVE_VOUT 338 | PMBUS_HAVE_STATUS_VOUT; 339 } 340 break; 341 case ltc3880: 342 info->read_word_data = ltc3880_read_word_data; 343 info->pages = 2; 344 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_IIN 345 | PMBUS_HAVE_STATUS_INPUT 346 | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 347 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 348 | PMBUS_HAVE_POUT | PMBUS_HAVE_TEMP 349 | PMBUS_HAVE_TEMP2 | PMBUS_HAVE_STATUS_TEMP; 350 info->func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 351 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT 352 | PMBUS_HAVE_POUT 353 | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP; 354 data->iout_max[0] = 0x7c00; 355 data->iout_max[1] = 0x7c00; 356 break; 357 default: 358 return -ENODEV; 359 } 360 for (i = 0; i < info->pages; i++) 361 data->vout_min[i] = 0xffff; 362 363 return pmbus_do_probe(client, id, info); 364 } 365 366 /* This is the driver that will be inserted */ 367 static struct i2c_driver ltc2978_driver = { 368 .driver = { 369 .name = "ltc2978", 370 }, 371 .probe = ltc2978_probe, 372 .remove = pmbus_do_remove, 373 .id_table = ltc2978_id, 374 }; 375 376 module_i2c_driver(ltc2978_driver); 377 378 MODULE_AUTHOR("Guenter Roeck"); 379 MODULE_DESCRIPTION("PMBus driver for LTC2978 and LTC3880"); 380 MODULE_LICENSE("GPL"); 381