1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Hardware monitoring driver for Maxim MAX34440/MAX34441 4 * 5 * Copyright (c) 2011 Ericsson AB. 6 * Copyright (c) 2012 Guenter Roeck 7 */ 8 9 #include <linux/bitops.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/err.h> 14 #include <linux/i2c.h> 15 #include <linux/delay.h> 16 #include "pmbus.h" 17 18 enum chips { 19 adpm12160, 20 adpm12200, 21 adpm12250, 22 max34440, 23 max34441, 24 max34446, 25 max34451, 26 max34452, 27 max34460, 28 max34461, 29 }; 30 31 /* 32 * Firmware is sometimes not ready if we try and read the 33 * data from the page immediately after setting. Maxim 34 * recommends 50us delay due to the chip failing to clock 35 * stretch long enough here. 36 */ 37 #define MAX34440_PAGE_CHANGE_DELAY 50 38 39 #define MAX34440_MFR_VOUT_PEAK 0xd4 40 #define MAX34440_MFR_IOUT_PEAK 0xd5 41 #define MAX34440_MFR_TEMPERATURE_PEAK 0xd6 42 #define MAX34440_MFR_VOUT_MIN 0xd7 43 44 #define MAX34446_MFR_POUT_PEAK 0xe0 45 #define MAX34446_MFR_POUT_AVG 0xe1 46 #define MAX34446_MFR_IOUT_AVG 0xe2 47 #define MAX34446_MFR_TEMPERATURE_AVG 0xe3 48 49 #define MAX34440_STATUS_OC_WARN BIT(0) 50 #define MAX34440_STATUS_OC_FAULT BIT(1) 51 #define MAX34440_STATUS_OT_FAULT BIT(5) 52 #define MAX34440_STATUS_OT_WARN BIT(6) 53 54 /* 55 * The whole max344* family have IOUT_OC_WARN_LIMIT and IOUT_OC_FAULT_LIMIT 56 * swapped from the standard pmbus spec addresses. 57 * For max34451, version MAX34451ETNA6+ and later has this issue fixed. 58 */ 59 #define MAX34440_IOUT_OC_WARN_LIMIT 0x46 60 #define MAX34440_IOUT_OC_FAULT_LIMIT 0x4A 61 62 #define MAX34451ETNA6_MFR_REV 0x0012 63 #define MAX34451ETNA8_MFR_REV 0x0014 64 65 #define MAX34451_MFR_CHANNEL_CONFIG 0xe4 66 #define MAX34451_MFR_CHANNEL_CONFIG_SEL_MASK 0x3f 67 68 struct max34440_data { 69 int id; 70 struct pmbus_driver_info info; 71 u8 iout_oc_warn_limit; 72 u8 iout_oc_fault_limit; 73 }; 74 75 #define to_max34440_data(x) container_of(x, struct max34440_data, info) 76 77 static int max34440_read_word_data(struct i2c_client *client, int page, 78 int phase, int reg) 79 { 80 int ret; 81 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 82 const struct max34440_data *data = to_max34440_data(info); 83 84 switch (reg) { 85 case PMBUS_IOUT_OC_FAULT_LIMIT: 86 ret = pmbus_read_word_data(client, page, phase, 87 data->iout_oc_fault_limit); 88 break; 89 case PMBUS_IOUT_OC_WARN_LIMIT: 90 ret = pmbus_read_word_data(client, page, phase, 91 data->iout_oc_warn_limit); 92 break; 93 case PMBUS_VIN_OV_FAULT_LIMIT: 94 case PMBUS_VIN_OV_WARN_LIMIT: 95 case PMBUS_VIN_UV_WARN_LIMIT: 96 case PMBUS_VIN_UV_FAULT_LIMIT: 97 case PMBUS_MFR_VIN_MIN: 98 case PMBUS_MFR_VIN_MAX: 99 case PMBUS_IIN_OC_WARN_LIMIT: 100 case PMBUS_IIN_OC_FAULT_LIMIT: 101 case PMBUS_MFR_IIN_MAX: 102 case PMBUS_MFR_VOUT_MIN: 103 case PMBUS_MFR_VOUT_MAX: 104 case PMBUS_IOUT_UC_FAULT_LIMIT: 105 case PMBUS_MFR_IOUT_MAX: 106 case PMBUS_UT_WARN_LIMIT: 107 case PMBUS_UT_FAULT_LIMIT: 108 case PMBUS_MFR_MAX_TEMP_1: 109 /* 110 * MAX34451/MAX34452/ADPM family do not support VIN/IIN limit 111 * registers, manufacturer-specific min/max registers, or 112 * undercurrent/undertemperature fault limits. Accessing these 113 * triggers CML error and asserts ALERT. 114 */ 115 if (data->id == max34451 || data->id == max34452 || 116 data->id == adpm12160 || data->id == adpm12200 || 117 data->id == adpm12250) 118 return -ENXIO; 119 ret = -ENODATA; 120 break; 121 case PMBUS_VOUT_OV_WARN_LIMIT: 122 if (data->id == max34452) 123 return -ENXIO; 124 return -ENODATA; 125 case PMBUS_VIRT_READ_VOUT_MIN: 126 ret = pmbus_read_word_data(client, page, phase, 127 MAX34440_MFR_VOUT_MIN); 128 break; 129 case PMBUS_VIRT_READ_VOUT_MAX: 130 ret = pmbus_read_word_data(client, page, phase, 131 MAX34440_MFR_VOUT_PEAK); 132 break; 133 case PMBUS_VIRT_READ_IOUT_AVG: 134 if (data->id != max34446 && data->id != max34451 && 135 data->id != max34452 && data->id != adpm12160 && 136 data->id != adpm12200 && data->id != adpm12250) 137 return -ENXIO; 138 ret = pmbus_read_word_data(client, page, phase, 139 MAX34446_MFR_IOUT_AVG); 140 break; 141 case PMBUS_VIRT_READ_IOUT_MAX: 142 ret = pmbus_read_word_data(client, page, phase, 143 MAX34440_MFR_IOUT_PEAK); 144 break; 145 case PMBUS_VIRT_READ_POUT_AVG: 146 if (data->id != max34446) 147 return -ENXIO; 148 ret = pmbus_read_word_data(client, page, phase, 149 MAX34446_MFR_POUT_AVG); 150 break; 151 case PMBUS_VIRT_READ_POUT_MAX: 152 if (data->id != max34446) 153 return -ENXIO; 154 ret = pmbus_read_word_data(client, page, phase, 155 MAX34446_MFR_POUT_PEAK); 156 break; 157 case PMBUS_VIRT_READ_TEMP_AVG: 158 if (data->id != max34446 && data->id != max34460 && 159 data->id != max34461) 160 return -ENXIO; 161 ret = pmbus_read_word_data(client, page, phase, 162 MAX34446_MFR_TEMPERATURE_AVG); 163 break; 164 case PMBUS_VIRT_READ_TEMP_MAX: 165 ret = pmbus_read_word_data(client, page, phase, 166 MAX34440_MFR_TEMPERATURE_PEAK); 167 break; 168 case PMBUS_VIRT_RESET_POUT_HISTORY: 169 if (data->id != max34446) 170 return -ENXIO; 171 ret = 0; 172 break; 173 case PMBUS_VIRT_RESET_VOUT_HISTORY: 174 case PMBUS_VIRT_RESET_IOUT_HISTORY: 175 case PMBUS_VIRT_RESET_TEMP_HISTORY: 176 ret = 0; 177 break; 178 default: 179 ret = -ENODATA; 180 break; 181 } 182 return ret; 183 } 184 185 static int max34440_write_word_data(struct i2c_client *client, int page, 186 int reg, u16 word) 187 { 188 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 189 const struct max34440_data *data = to_max34440_data(info); 190 int ret; 191 192 switch (reg) { 193 case PMBUS_IOUT_OC_FAULT_LIMIT: 194 ret = pmbus_write_word_data(client, page, data->iout_oc_fault_limit, 195 word); 196 break; 197 case PMBUS_IOUT_OC_WARN_LIMIT: 198 ret = pmbus_write_word_data(client, page, data->iout_oc_warn_limit, 199 word); 200 break; 201 case PMBUS_VOUT_OV_WARN_LIMIT: 202 if (data->id == max34452) 203 return -ENXIO; 204 return -ENODATA; 205 case PMBUS_VIRT_RESET_POUT_HISTORY: 206 ret = pmbus_write_word_data(client, page, 207 MAX34446_MFR_POUT_PEAK, 0); 208 if (ret) 209 break; 210 ret = pmbus_write_word_data(client, page, 211 MAX34446_MFR_POUT_AVG, 0); 212 break; 213 case PMBUS_VIRT_RESET_VOUT_HISTORY: 214 ret = pmbus_write_word_data(client, page, 215 MAX34440_MFR_VOUT_MIN, 0x7fff); 216 if (ret) 217 break; 218 ret = pmbus_write_word_data(client, page, 219 MAX34440_MFR_VOUT_PEAK, 0); 220 break; 221 case PMBUS_VIRT_RESET_IOUT_HISTORY: 222 ret = pmbus_write_word_data(client, page, 223 MAX34440_MFR_IOUT_PEAK, 0); 224 if (!ret && (data->id == max34446 || data->id == max34451 || 225 data->id == max34452 || data->id == adpm12160 || 226 data->id == adpm12200 || data->id == adpm12250)) 227 ret = pmbus_write_word_data(client, page, 228 MAX34446_MFR_IOUT_AVG, 0); 229 230 break; 231 case PMBUS_VIRT_RESET_TEMP_HISTORY: 232 ret = pmbus_write_word_data(client, page, 233 MAX34440_MFR_TEMPERATURE_PEAK, 234 0x8000); 235 if (!ret && data->id == max34446) 236 ret = pmbus_write_word_data(client, page, 237 MAX34446_MFR_TEMPERATURE_AVG, 0); 238 break; 239 default: 240 ret = -ENODATA; 241 break; 242 } 243 return ret; 244 } 245 246 static int max34440_read_byte_data(struct i2c_client *client, int page, int reg) 247 { 248 int ret = 0; 249 int mfg_status; 250 251 if (page >= 0) { 252 ret = pmbus_set_page(client, page, 0xff); 253 if (ret < 0) 254 return ret; 255 } 256 257 switch (reg) { 258 case PMBUS_STATUS_IOUT: 259 mfg_status = pmbus_read_word_data(client, 0, 0xff, 260 PMBUS_STATUS_MFR_SPECIFIC); 261 if (mfg_status < 0) 262 return mfg_status; 263 if (mfg_status & MAX34440_STATUS_OC_WARN) 264 ret |= PB_IOUT_OC_WARNING; 265 if (mfg_status & MAX34440_STATUS_OC_FAULT) 266 ret |= PB_IOUT_OC_FAULT; 267 break; 268 case PMBUS_STATUS_TEMPERATURE: 269 mfg_status = pmbus_read_word_data(client, 0, 0xff, 270 PMBUS_STATUS_MFR_SPECIFIC); 271 if (mfg_status < 0) 272 return mfg_status; 273 if (mfg_status & MAX34440_STATUS_OT_WARN) 274 ret |= PB_TEMP_OT_WARNING; 275 if (mfg_status & MAX34440_STATUS_OT_FAULT) 276 ret |= PB_TEMP_OT_FAULT; 277 break; 278 default: 279 ret = -ENODATA; 280 break; 281 } 282 return ret; 283 } 284 285 static int max34451_read_byte_data(struct i2c_client *client, int page, int reg) 286 { 287 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 288 const struct max34440_data *data = to_max34440_data(info); 289 290 switch (reg) { 291 case PMBUS_STATUS_BYTE: 292 case PMBUS_STATUS_OTHER: 293 /* 294 * MAX34451/MAX34452/ADPM family do not support STATUS_BYTE or 295 * STATUS_OTHER registers. Accessing them triggers CML 296 * error and asserts ALERT. 297 */ 298 if (data->id == max34451 || data->id == max34452 || 299 data->id == adpm12160 || data->id == adpm12200 || 300 data->id == adpm12250) 301 return -ENXIO; 302 return -ENODATA; 303 default: 304 return -ENODATA; 305 } 306 } 307 308 static int max34451_write_byte_data(struct i2c_client *client, int page, 309 int reg, u8 byte) 310 { 311 const struct pmbus_driver_info *info = pmbus_get_driver_info(client); 312 const struct max34440_data *data = to_max34440_data(info); 313 314 switch (reg) { 315 case PMBUS_STATUS_BYTE: 316 case PMBUS_STATUS_OTHER: 317 /* 318 * MAX34451/MAX34452/ADPM family do not support STATUS_BYTE or 319 * STATUS_OTHER registers. Writing to them triggers CML 320 * error and asserts ALERT. 321 */ 322 if (data->id == max34451 || data->id == max34452 || 323 data->id == adpm12160 || data->id == adpm12200 || 324 data->id == adpm12250) 325 return -ENXIO; 326 return -ENODATA; 327 default: 328 return -ENODATA; 329 } 330 } 331 332 static int max34451_set_supported_funcs(struct i2c_client *client, 333 struct max34440_data *data) 334 { 335 /* 336 * Each of the channel 0-15 can be configured to monitor the following 337 * functions based on MFR_CHANNEL_CONFIG[5:0] 338 * 0x10: Sequencing + voltage monitoring (only valid for PAGES 0–11) 339 * 0x20: Voltage monitoring (no sequencing) 340 * 0x21: Voltage read only 341 * 0x22: Current monitoring 342 * 0x23: Current read only 343 * 0x30: General-purpose input active low 344 * 0x34: General-purpose input active high 345 * 0x00: Disabled 346 */ 347 348 int page, rv; 349 bool max34451_na6 = false; 350 351 rv = i2c_smbus_read_word_data(client, PMBUS_MFR_REVISION); 352 if (rv < 0) 353 return rv; 354 355 if (data->id == max34451 && rv >= MAX34451ETNA6_MFR_REV) { 356 max34451_na6 = true; 357 data->info.format[PSC_VOLTAGE_IN] = direct; 358 data->info.format[PSC_CURRENT_IN] = direct; 359 360 data->info.b[PSC_VOLTAGE_IN] = 0; 361 data->info.b[PSC_CURRENT_IN] = 0; 362 if (rv >= MAX34451ETNA8_MFR_REV) { 363 data->info.m[PSC_VOLTAGE_IN] = 125; 364 data->info.R[PSC_VOLTAGE_IN] = 0; 365 data->info.m[PSC_VOLTAGE_OUT] = 125; 366 data->info.R[PSC_VOLTAGE_OUT] = 0; 367 data->info.m[PSC_CURRENT_IN] = 250; 368 data->info.R[PSC_CURRENT_IN] = -1; 369 data->info.m[PSC_CURRENT_OUT] = 250; 370 data->info.R[PSC_CURRENT_OUT] = -1; 371 } else { 372 data->info.m[PSC_VOLTAGE_IN] = 1; 373 data->info.R[PSC_VOLTAGE_IN] = 3; 374 data->info.m[PSC_CURRENT_IN] = 1; 375 data->info.R[PSC_CURRENT_IN] = 2; 376 } 377 data->iout_oc_fault_limit = PMBUS_IOUT_OC_FAULT_LIMIT; 378 data->iout_oc_warn_limit = PMBUS_IOUT_OC_WARN_LIMIT; 379 } 380 381 for (page = 0; page < 16; page++) { 382 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page); 383 fsleep(MAX34440_PAGE_CHANGE_DELAY); 384 if (rv < 0) 385 return rv; 386 387 rv = i2c_smbus_read_word_data(client, 388 MAX34451_MFR_CHANNEL_CONFIG); 389 if (rv < 0) 390 return rv; 391 392 switch (rv & MAX34451_MFR_CHANNEL_CONFIG_SEL_MASK) { 393 case 0x10: 394 case 0x20: 395 data->info.func[page] = PMBUS_HAVE_VOUT | 396 PMBUS_HAVE_STATUS_VOUT; 397 398 if (max34451_na6) 399 data->info.func[page] |= PMBUS_HAVE_VIN | 400 PMBUS_HAVE_STATUS_INPUT; 401 break; 402 case 0x21: 403 data->info.func[page] = PMBUS_HAVE_VOUT; 404 405 if (max34451_na6) 406 data->info.func[page] |= PMBUS_HAVE_VIN; 407 break; 408 case 0x22: 409 data->info.func[page] = PMBUS_HAVE_IOUT | 410 PMBUS_HAVE_STATUS_IOUT; 411 412 if (max34451_na6) 413 data->info.func[page] |= PMBUS_HAVE_IIN | 414 PMBUS_HAVE_STATUS_INPUT; 415 break; 416 case 0x23: 417 data->info.func[page] = PMBUS_HAVE_IOUT; 418 419 if (max34451_na6) 420 data->info.func[page] |= PMBUS_HAVE_IIN; 421 break; 422 default: 423 break; 424 } 425 } 426 427 return 0; 428 } 429 430 static struct pmbus_driver_info max34440_info[] = { 431 [adpm12160] = { 432 .pages = 19, 433 .format[PSC_VOLTAGE_IN] = direct, 434 .format[PSC_VOLTAGE_OUT] = direct, 435 .format[PSC_CURRENT_IN] = direct, 436 .format[PSC_CURRENT_OUT] = direct, 437 .format[PSC_TEMPERATURE] = direct, 438 .m[PSC_VOLTAGE_IN] = 125, 439 .b[PSC_VOLTAGE_IN] = 0, 440 .R[PSC_VOLTAGE_IN] = 0, 441 .m[PSC_VOLTAGE_OUT] = 125, 442 .b[PSC_VOLTAGE_OUT] = 0, 443 .R[PSC_VOLTAGE_OUT] = 0, 444 .m[PSC_CURRENT_IN] = 250, 445 .b[PSC_CURRENT_IN] = 0, 446 .R[PSC_CURRENT_IN] = -1, 447 .m[PSC_CURRENT_OUT] = 250, 448 .b[PSC_CURRENT_OUT] = 0, 449 .R[PSC_CURRENT_OUT] = -1, 450 .m[PSC_TEMPERATURE] = 1, 451 .b[PSC_TEMPERATURE] = 0, 452 .R[PSC_TEMPERATURE] = 2, 453 /* absent func below [18] are not for monitoring */ 454 .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 455 .func[4] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 456 .func[5] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 457 .func[6] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 458 .func[7] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 459 .func[8] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 460 .func[9] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT, 461 .func[10] = PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT, 462 .func[18] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 463 .read_byte_data = max34451_read_byte_data, 464 .read_word_data = max34440_read_word_data, 465 .write_byte_data = max34451_write_byte_data, 466 .write_word_data = max34440_write_word_data, 467 }, 468 [adpm12200] = { 469 .pages = 19, 470 .format[PSC_VOLTAGE_IN] = direct, 471 .format[PSC_VOLTAGE_OUT] = direct, 472 .format[PSC_CURRENT_IN] = direct, 473 .format[PSC_CURRENT_OUT] = direct, 474 .format[PSC_TEMPERATURE] = direct, 475 .m[PSC_VOLTAGE_IN] = 125, 476 .b[PSC_VOLTAGE_IN] = 0, 477 .R[PSC_VOLTAGE_IN] = 0, 478 .m[PSC_VOLTAGE_OUT] = 125, 479 .b[PSC_VOLTAGE_OUT] = 0, 480 .R[PSC_VOLTAGE_OUT] = 0, 481 .m[PSC_CURRENT_IN] = 250, 482 .b[PSC_CURRENT_IN] = 0, 483 .R[PSC_CURRENT_IN] = -1, 484 .m[PSC_CURRENT_OUT] = 250, 485 .b[PSC_CURRENT_OUT] = 0, 486 .R[PSC_CURRENT_OUT] = -1, 487 .m[PSC_TEMPERATURE] = 1, 488 .b[PSC_TEMPERATURE] = 0, 489 .R[PSC_TEMPERATURE] = 2, 490 /* absent func below [18] are not for monitoring */ 491 .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 492 .func[4] = PMBUS_HAVE_STATUS_IOUT, 493 .func[5] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 494 .func[6] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 495 .func[7] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 496 .func[8] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 497 .func[9] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT, 498 .func[10] = PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT, 499 .func[14] = PMBUS_HAVE_IOUT, 500 .func[18] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 501 .read_byte_data = max34451_read_byte_data, 502 .read_word_data = max34440_read_word_data, 503 .write_byte_data = max34451_write_byte_data, 504 .write_word_data = max34440_write_word_data, 505 }, 506 [adpm12250] = { 507 .pages = 19, 508 .format[PSC_VOLTAGE_IN] = direct, 509 .format[PSC_VOLTAGE_OUT] = direct, 510 .format[PSC_CURRENT_IN] = direct, 511 .format[PSC_CURRENT_OUT] = direct, 512 .format[PSC_TEMPERATURE] = direct, 513 .m[PSC_VOLTAGE_IN] = 125, 514 .b[PSC_VOLTAGE_IN] = 0, 515 .R[PSC_VOLTAGE_IN] = 0, 516 .m[PSC_VOLTAGE_OUT] = 125, 517 .b[PSC_VOLTAGE_OUT] = 0, 518 .R[PSC_VOLTAGE_OUT] = 0, 519 .m[PSC_CURRENT_IN] = 250, 520 .b[PSC_CURRENT_IN] = 0, 521 .R[PSC_CURRENT_IN] = -1, 522 .m[PSC_CURRENT_OUT] = 250, 523 .b[PSC_CURRENT_OUT] = 0, 524 .R[PSC_CURRENT_OUT] = -1, 525 .m[PSC_TEMPERATURE] = 1, 526 .b[PSC_TEMPERATURE] = 0, 527 .R[PSC_TEMPERATURE] = 2, 528 /* absent func below [18] are not for monitoring */ 529 .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 530 .func[4] = PMBUS_HAVE_STATUS_IOUT, 531 .func[5] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 532 .func[6] = PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 533 .func[9] = PMBUS_HAVE_VIN | PMBUS_HAVE_STATUS_INPUT, 534 .func[10] = PMBUS_HAVE_IIN | PMBUS_HAVE_STATUS_INPUT, 535 .func[14] = PMBUS_HAVE_IOUT, 536 .func[18] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 537 .read_byte_data = max34451_read_byte_data, 538 .read_word_data = max34440_read_word_data, 539 .write_byte_data = max34451_write_byte_data, 540 .write_word_data = max34440_write_word_data, 541 }, 542 [max34440] = { 543 .pages = 14, 544 .format[PSC_VOLTAGE_IN] = direct, 545 .format[PSC_VOLTAGE_OUT] = direct, 546 .format[PSC_TEMPERATURE] = direct, 547 .format[PSC_CURRENT_OUT] = direct, 548 .m[PSC_VOLTAGE_IN] = 1, 549 .b[PSC_VOLTAGE_IN] = 0, 550 .R[PSC_VOLTAGE_IN] = 3, /* R = 0 in datasheet reflects mV */ 551 .m[PSC_VOLTAGE_OUT] = 1, 552 .b[PSC_VOLTAGE_OUT] = 0, 553 .R[PSC_VOLTAGE_OUT] = 3, /* R = 0 in datasheet reflects mV */ 554 .m[PSC_CURRENT_OUT] = 1, 555 .b[PSC_CURRENT_OUT] = 0, 556 .R[PSC_CURRENT_OUT] = 3, /* R = 0 in datasheet reflects mA */ 557 .m[PSC_TEMPERATURE] = 1, 558 .b[PSC_TEMPERATURE] = 0, 559 .R[PSC_TEMPERATURE] = 2, 560 .func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 561 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 562 .func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 563 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 564 .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 565 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 566 .func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 567 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 568 .func[4] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 569 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 570 .func[5] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 571 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 572 .func[6] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 573 .func[7] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 574 .func[8] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 575 .func[9] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 576 .func[10] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 577 .func[11] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 578 .func[12] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 579 .func[13] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 580 .read_byte_data = max34440_read_byte_data, 581 .read_word_data = max34440_read_word_data, 582 .write_word_data = max34440_write_word_data, 583 .page_change_delay = MAX34440_PAGE_CHANGE_DELAY, 584 }, 585 [max34441] = { 586 .pages = 12, 587 .format[PSC_VOLTAGE_IN] = direct, 588 .format[PSC_VOLTAGE_OUT] = direct, 589 .format[PSC_TEMPERATURE] = direct, 590 .format[PSC_CURRENT_OUT] = direct, 591 .format[PSC_FAN] = direct, 592 .m[PSC_VOLTAGE_IN] = 1, 593 .b[PSC_VOLTAGE_IN] = 0, 594 .R[PSC_VOLTAGE_IN] = 3, 595 .m[PSC_VOLTAGE_OUT] = 1, 596 .b[PSC_VOLTAGE_OUT] = 0, 597 .R[PSC_VOLTAGE_OUT] = 3, 598 .m[PSC_CURRENT_OUT] = 1, 599 .b[PSC_CURRENT_OUT] = 0, 600 .R[PSC_CURRENT_OUT] = 3, 601 .m[PSC_TEMPERATURE] = 1, 602 .b[PSC_TEMPERATURE] = 0, 603 .R[PSC_TEMPERATURE] = 2, 604 .m[PSC_FAN] = 1, 605 .b[PSC_FAN] = 0, 606 .R[PSC_FAN] = 0, 607 .func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 608 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 609 .func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 610 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 611 .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 612 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 613 .func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 614 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 615 .func[4] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 616 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 617 .func[5] = PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12, 618 .func[6] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 619 .func[7] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 620 .func[8] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 621 .func[9] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 622 .func[10] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 623 .func[11] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 624 .read_byte_data = max34440_read_byte_data, 625 .read_word_data = max34440_read_word_data, 626 .write_word_data = max34440_write_word_data, 627 .page_change_delay = MAX34440_PAGE_CHANGE_DELAY, 628 }, 629 [max34446] = { 630 .pages = 7, 631 .format[PSC_VOLTAGE_IN] = direct, 632 .format[PSC_VOLTAGE_OUT] = direct, 633 .format[PSC_TEMPERATURE] = direct, 634 .format[PSC_CURRENT_OUT] = direct, 635 .format[PSC_POWER] = direct, 636 .m[PSC_VOLTAGE_IN] = 1, 637 .b[PSC_VOLTAGE_IN] = 0, 638 .R[PSC_VOLTAGE_IN] = 3, 639 .m[PSC_VOLTAGE_OUT] = 1, 640 .b[PSC_VOLTAGE_OUT] = 0, 641 .R[PSC_VOLTAGE_OUT] = 3, 642 .m[PSC_CURRENT_OUT] = 1, 643 .b[PSC_CURRENT_OUT] = 0, 644 .R[PSC_CURRENT_OUT] = 3, 645 .m[PSC_POWER] = 1, 646 .b[PSC_POWER] = 0, 647 .R[PSC_POWER] = 3, 648 .m[PSC_TEMPERATURE] = 1, 649 .b[PSC_TEMPERATURE] = 0, 650 .R[PSC_TEMPERATURE] = 2, 651 .func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 652 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT, 653 .func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 654 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 655 .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 656 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_POUT, 657 .func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT 658 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT, 659 .func[4] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 660 .func[5] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 661 .func[6] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 662 .read_byte_data = max34440_read_byte_data, 663 .read_word_data = max34440_read_word_data, 664 .write_word_data = max34440_write_word_data, 665 .page_change_delay = MAX34440_PAGE_CHANGE_DELAY, 666 }, 667 [max34451] = { 668 .pages = 21, 669 .format[PSC_VOLTAGE_OUT] = direct, 670 .format[PSC_TEMPERATURE] = direct, 671 .format[PSC_CURRENT_OUT] = direct, 672 .m[PSC_VOLTAGE_OUT] = 1, 673 .b[PSC_VOLTAGE_OUT] = 0, 674 .R[PSC_VOLTAGE_OUT] = 3, 675 .m[PSC_CURRENT_OUT] = 1, 676 .b[PSC_CURRENT_OUT] = 0, 677 .R[PSC_CURRENT_OUT] = 2, 678 .m[PSC_TEMPERATURE] = 1, 679 .b[PSC_TEMPERATURE] = 0, 680 .R[PSC_TEMPERATURE] = 2, 681 /* func 0-15 is set dynamically before probing */ 682 .func[16] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 683 .func[17] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 684 .func[18] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 685 .func[19] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 686 .func[20] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 687 .read_byte_data = max34451_read_byte_data, 688 .read_word_data = max34440_read_word_data, 689 .write_byte_data = max34451_write_byte_data, 690 .write_word_data = max34440_write_word_data, 691 .page_change_delay = MAX34440_PAGE_CHANGE_DELAY, 692 }, 693 [max34452] = { 694 .pages = 21, 695 .format[PSC_VOLTAGE_OUT] = direct, 696 .format[PSC_TEMPERATURE] = direct, 697 .format[PSC_CURRENT_OUT] = direct, 698 .m[PSC_VOLTAGE_OUT] = 1, 699 .b[PSC_VOLTAGE_OUT] = 0, 700 .R[PSC_VOLTAGE_OUT] = 3, 701 .m[PSC_CURRENT_OUT] = 1, 702 .b[PSC_CURRENT_OUT] = 0, 703 .R[PSC_CURRENT_OUT] = 2, 704 .m[PSC_TEMPERATURE] = 1, 705 .b[PSC_TEMPERATURE] = 0, 706 .R[PSC_TEMPERATURE] = 2, 707 /* func 0-15 is set dynamically before probing */ 708 .func[16] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 709 .func[17] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 710 .func[18] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 711 .func[19] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 712 .func[20] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 713 .read_byte_data = max34451_read_byte_data, 714 .read_word_data = max34440_read_word_data, 715 .write_byte_data = max34451_write_byte_data, 716 .write_word_data = max34440_write_word_data, 717 .page_change_delay = MAX34440_PAGE_CHANGE_DELAY, 718 }, 719 [max34460] = { 720 .pages = 18, 721 .format[PSC_VOLTAGE_OUT] = direct, 722 .format[PSC_TEMPERATURE] = direct, 723 .m[PSC_VOLTAGE_OUT] = 1, 724 .b[PSC_VOLTAGE_OUT] = 0, 725 .R[PSC_VOLTAGE_OUT] = 3, 726 .m[PSC_TEMPERATURE] = 1, 727 .b[PSC_TEMPERATURE] = 0, 728 .R[PSC_TEMPERATURE] = 2, 729 .func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 730 .func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 731 .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 732 .func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 733 .func[4] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 734 .func[5] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 735 .func[6] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 736 .func[7] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 737 .func[8] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 738 .func[9] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 739 .func[10] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 740 .func[11] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 741 .func[13] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 742 .func[14] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 743 .func[15] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 744 .func[16] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 745 .func[17] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 746 .read_word_data = max34440_read_word_data, 747 .write_word_data = max34440_write_word_data, 748 .page_change_delay = MAX34440_PAGE_CHANGE_DELAY, 749 }, 750 [max34461] = { 751 .pages = 23, 752 .format[PSC_VOLTAGE_OUT] = direct, 753 .format[PSC_TEMPERATURE] = direct, 754 .m[PSC_VOLTAGE_OUT] = 1, 755 .b[PSC_VOLTAGE_OUT] = 0, 756 .R[PSC_VOLTAGE_OUT] = 3, 757 .m[PSC_TEMPERATURE] = 1, 758 .b[PSC_TEMPERATURE] = 0, 759 .R[PSC_TEMPERATURE] = 2, 760 .func[0] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 761 .func[1] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 762 .func[2] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 763 .func[3] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 764 .func[4] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 765 .func[5] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 766 .func[6] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 767 .func[7] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 768 .func[8] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 769 .func[9] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 770 .func[10] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 771 .func[11] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 772 .func[12] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 773 .func[13] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 774 .func[14] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 775 .func[15] = PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT, 776 /* page 16 is reserved */ 777 .func[17] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 778 .func[18] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 779 .func[19] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 780 .func[20] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 781 .func[21] = PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP, 782 .read_word_data = max34440_read_word_data, 783 .write_word_data = max34440_write_word_data, 784 .page_change_delay = MAX34440_PAGE_CHANGE_DELAY, 785 }, 786 }; 787 788 static int max34440_probe(struct i2c_client *client) 789 { 790 struct max34440_data *data; 791 int rv; 792 793 data = devm_kzalloc(&client->dev, sizeof(struct max34440_data), 794 GFP_KERNEL); 795 if (!data) 796 return -ENOMEM; 797 data->id = (uintptr_t)i2c_get_match_data(client); 798 data->info = max34440_info[data->id]; 799 data->iout_oc_fault_limit = MAX34440_IOUT_OC_FAULT_LIMIT; 800 data->iout_oc_warn_limit = MAX34440_IOUT_OC_WARN_LIMIT; 801 802 if (data->id == max34451 || data->id == max34452) { 803 rv = max34451_set_supported_funcs(client, data); 804 if (rv) 805 return rv; 806 } else if (data->id == adpm12160 || data->id == adpm12200 || 807 data->id == adpm12250) { 808 data->iout_oc_fault_limit = PMBUS_IOUT_OC_FAULT_LIMIT; 809 data->iout_oc_warn_limit = PMBUS_IOUT_OC_WARN_LIMIT; 810 } 811 812 return pmbus_do_probe(client, &data->info); 813 } 814 815 static const struct i2c_device_id max34440_id[] = { 816 { .name = "adpm12160", .driver_data = adpm12160 }, 817 { .name = "adpm12200", .driver_data = adpm12200 }, 818 { .name = "adpm12250", .driver_data = adpm12250 }, 819 { .name = "max34440", .driver_data = max34440 }, 820 { .name = "max34441", .driver_data = max34441 }, 821 { .name = "max34446", .driver_data = max34446 }, 822 { .name = "max34451", .driver_data = max34451 }, 823 { .name = "max34452", .driver_data = max34452 }, 824 { .name = "max34460", .driver_data = max34460 }, 825 { .name = "max34461", .driver_data = max34461 }, 826 { } 827 }; 828 MODULE_DEVICE_TABLE(i2c, max34440_id); 829 830 /* This is the driver that will be inserted */ 831 static struct i2c_driver max34440_driver = { 832 .driver = { 833 .name = "max34440", 834 }, 835 .probe = max34440_probe, 836 .id_table = max34440_id, 837 }; 838 839 module_i2c_driver(max34440_driver); 840 841 MODULE_AUTHOR("Guenter Roeck"); 842 MODULE_DESCRIPTION("PMBus driver for Maxim MAX34440/MAX34441"); 843 MODULE_LICENSE("GPL"); 844 MODULE_IMPORT_NS("PMBUS"); 845