hwmon/pmbus/pmbus.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Hardware monitoring driver for PMBus devices
0004  *
0005  * Copyright (c) 2010, 2011 Ericsson AB.
0006  */
0007
0008 #include <linux/kernel.h>
0009 #include <linux/module.h>
0010 #include <linux/init.h>
0011 #include <linux/err.h>
0012 #include <linux/slab.h>
0013 #include <linux/mutex.h>
0014 #include <linux/i2c.h>
0015 #include <linux/pmbus.h>
0016 #include "pmbus.h"
0017
0018 struct pmbus_device_info {
0019     int pages;
0020     u32 flags;
0021 };
0022
0023 static const struct i2c_device_id pmbus_id[];
0024
0025 /*
0026  * Find sensor groups and status registers on each page.
0027  */
0028 static void pmbus_find_sensor_groups(struct i2c_client *client,
0029                      struct pmbus_driver_info *info)
0030 {
0031     int page;
0032
0033     /* Sensors detected on page 0 only */
0034     if (pmbus_check_word_register(client, 0, PMBUS_READ_VIN))
0035         info->func[0] |= PMBUS_HAVE_VIN;
0036     if (pmbus_check_word_register(client, 0, PMBUS_READ_VCAP))
0037         info->func[0] |= PMBUS_HAVE_VCAP;
0038     if (pmbus_check_word_register(client, 0, PMBUS_READ_IIN))
0039         info->func[0] |= PMBUS_HAVE_IIN;
0040     if (pmbus_check_word_register(client, 0, PMBUS_READ_PIN))
0041         info->func[0] |= PMBUS_HAVE_PIN;
0042     if (info->func[0]
0043         && pmbus_check_byte_register(client, 0, PMBUS_STATUS_INPUT))
0044         info->func[0] |= PMBUS_HAVE_STATUS_INPUT;
0045     if (pmbus_check_byte_register(client, 0, PMBUS_FAN_CONFIG_12) &&
0046         pmbus_check_word_register(client, 0, PMBUS_READ_FAN_SPEED_1)) {
0047         info->func[0] |= PMBUS_HAVE_FAN12;
0048         if (pmbus_check_byte_register(client, 0, PMBUS_STATUS_FAN_12))
0049             info->func[0] |= PMBUS_HAVE_STATUS_FAN12;
0050     }
0051     if (pmbus_check_byte_register(client, 0, PMBUS_FAN_CONFIG_34) &&
0052         pmbus_check_word_register(client, 0, PMBUS_READ_FAN_SPEED_3)) {
0053         info->func[0] |= PMBUS_HAVE_FAN34;
0054         if (pmbus_check_byte_register(client, 0, PMBUS_STATUS_FAN_34))
0055             info->func[0] |= PMBUS_HAVE_STATUS_FAN34;
0056     }
0057     if (pmbus_check_word_register(client, 0, PMBUS_READ_TEMPERATURE_1))
0058         info->func[0] |= PMBUS_HAVE_TEMP;
0059     if (pmbus_check_word_register(client, 0, PMBUS_READ_TEMPERATURE_2))
0060         info->func[0] |= PMBUS_HAVE_TEMP2;
0061     if (pmbus_check_word_register(client, 0, PMBUS_READ_TEMPERATURE_3))
0062         info->func[0] |= PMBUS_HAVE_TEMP3;
0063     if (info->func[0] & (PMBUS_HAVE_TEMP | PMBUS_HAVE_TEMP2
0064                  | PMBUS_HAVE_TEMP3)
0065         && pmbus_check_byte_register(client, 0,
0066                      PMBUS_STATUS_TEMPERATURE))
0067             info->func[0] |= PMBUS_HAVE_STATUS_TEMP;
0068
0069     /* Sensors detected on all pages */
0070     for (page = 0; page < info->pages; page++) {
0071         if (pmbus_check_word_register(client, page, PMBUS_READ_VOUT)) {
0072             info->func[page] |= PMBUS_HAVE_VOUT;
0073             if (pmbus_check_byte_register(client, page,
0074                               PMBUS_STATUS_VOUT))
0075                 info->func[page] |= PMBUS_HAVE_STATUS_VOUT;
0076         }
0077         if (pmbus_check_word_register(client, page, PMBUS_READ_IOUT)) {
0078             info->func[page] |= PMBUS_HAVE_IOUT;
0079             if (pmbus_check_byte_register(client, 0,
0080                               PMBUS_STATUS_IOUT))
0081                 info->func[page] |= PMBUS_HAVE_STATUS_IOUT;
0082         }
0083         if (pmbus_check_word_register(client, page, PMBUS_READ_POUT))
0084             info->func[page] |= PMBUS_HAVE_POUT;
0085     }
0086 }
0087
0088 /*
0089  * Identify chip parameters.
0090  */
0091 static int pmbus_identify(struct i2c_client *client,
0092               struct pmbus_driver_info *info)
0093 {
0094     int ret = 0;
0095
0096     if (!info->pages) {
0097         /*
0098          * Check if the PAGE command is supported. If it is,
0099          * keep setting the page number until it fails or until the
0100          * maximum number of pages has been reached. Assume that
0101          * this is the number of pages supported by the chip.
0102          */
0103         if (pmbus_check_byte_register(client, 0, PMBUS_PAGE)) {
0104             int page;
0105
0106             for (page = 1; page < PMBUS_PAGES; page++) {
0107                 if (pmbus_set_page(client, page, 0xff) < 0)
0108                     break;
0109             }
0110             pmbus_set_page(client, 0, 0xff);
0111             info->pages = page;
0112         } else {
0113             info->pages = 1;
0114         }
0115
0116         pmbus_clear_faults(client);
0117     }
0118
0119     if (pmbus_check_byte_register(client, 0, PMBUS_VOUT_MODE)) {
0120         int vout_mode, i;
0121
0122         vout_mode = pmbus_read_byte_data(client, 0, PMBUS_VOUT_MODE);
0123         if (vout_mode >= 0 && vout_mode != 0xff) {
0124             switch (vout_mode >> 5) {
0125             case 0:
0126                 break;
0127             case 1:
0128                 info->format[PSC_VOLTAGE_OUT] = vid;
0129                 for (i = 0; i < info->pages; i++)
0130                     info->vrm_version[i] = vr11;
0131                 break;
0132             case 2:
0133                 info->format[PSC_VOLTAGE_OUT] = direct;
0134                 break;
0135             default:
0136                 ret = -ENODEV;
0137                 goto abort;
0138             }
0139         }
0140     }
0141
0142     /*
0143      * We should check if the COEFFICIENTS register is supported.
0144      * If it is, and the chip is configured for direct mode, we can read
0145      * the coefficients from the chip, one set per group of sensor
0146      * registers.
0147      *
0148      * To do this, we will need access to a chip which actually supports the
0149      * COEFFICIENTS command, since the command is too complex to implement
0150      * without testing it. Until then, abort if a chip configured for direct
0151      * mode was detected.
0152      */
0153     if (info->format[PSC_VOLTAGE_OUT] == direct) {
0154         ret = -ENODEV;
0155         goto abort;
0156     }
0157
0158     /* Try to find sensor groups  */
0159     pmbus_find_sensor_groups(client, info);
0160 abort:
0161     return ret;
0162 }
0163
0164 static int pmbus_probe(struct i2c_client *client)
0165 {
0166     struct pmbus_driver_info *info;
0167     struct pmbus_platform_data *pdata = NULL;
0168     struct device *dev = &client->dev;
0169     struct pmbus_device_info *device_info;
0170
0171     info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL);
0172     if (!info)
0173         return -ENOMEM;
0174
0175     device_info = (struct pmbus_device_info *)i2c_match_id(pmbus_id, client)->driver_data;
0176     if (device_info->flags) {
0177         pdata = devm_kzalloc(dev, sizeof(struct pmbus_platform_data),
0178                      GFP_KERNEL);
0179         if (!pdata)
0180             return -ENOMEM;
0181
0182         pdata->flags = device_info->flags;
0183     }
0184
0185     info->pages = device_info->pages;
0186     info->identify = pmbus_identify;
0187     dev->platform_data = pdata;
0188
0189     return pmbus_do_probe(client, info);
0190 }
0191
0192 static const struct pmbus_device_info pmbus_info_one = {
0193     .pages = 1,
0194     .flags = 0
0195 };
0196
0197 static const struct pmbus_device_info pmbus_info_zero = {
0198     .pages = 0,
0199     .flags = 0
0200 };
0201
0202 static const struct pmbus_device_info pmbus_info_one_skip = {
0203     .pages = 1,
0204     .flags = PMBUS_SKIP_STATUS_CHECK
0205 };
0206
0207 static const struct pmbus_device_info pmbus_info_one_status = {
0208     .pages = 1,
0209     .flags = PMBUS_READ_STATUS_AFTER_FAILED_CHECK
0210 };
0211
0212 /*
0213  * Use driver_data to set the number of pages supported by the chip.
0214  */
0215 static const struct i2c_device_id pmbus_id[] = {
0216     {"adp4000", (kernel_ulong_t)&pmbus_info_one},
0217     {"bmr310", (kernel_ulong_t)&pmbus_info_one_status},
0218     {"bmr453", (kernel_ulong_t)&pmbus_info_one},
0219     {"bmr454", (kernel_ulong_t)&pmbus_info_one},
0220     {"bmr456", (kernel_ulong_t)&pmbus_info_one},
0221     {"bmr457", (kernel_ulong_t)&pmbus_info_one},
0222     {"bmr458", (kernel_ulong_t)&pmbus_info_one_status},
0223     {"bmr480", (kernel_ulong_t)&pmbus_info_one_status},
0224     {"bmr490", (kernel_ulong_t)&pmbus_info_one_status},
0225     {"bmr491", (kernel_ulong_t)&pmbus_info_one_status},
0226     {"bmr492", (kernel_ulong_t)&pmbus_info_one},
0227     {"dps460", (kernel_ulong_t)&pmbus_info_one_skip},
0228     {"dps650ab", (kernel_ulong_t)&pmbus_info_one_skip},
0229     {"dps800", (kernel_ulong_t)&pmbus_info_one_skip},
0230     {"max20796", (kernel_ulong_t)&pmbus_info_one},
0231     {"mdt040", (kernel_ulong_t)&pmbus_info_one},
0232     {"ncp4200", (kernel_ulong_t)&pmbus_info_one},
0233     {"ncp4208", (kernel_ulong_t)&pmbus_info_one},
0234     {"pdt003", (kernel_ulong_t)&pmbus_info_one},
0235     {"pdt006", (kernel_ulong_t)&pmbus_info_one},
0236     {"pdt012", (kernel_ulong_t)&pmbus_info_one},
0237     {"pmbus", (kernel_ulong_t)&pmbus_info_zero},
0238     {"sgd009", (kernel_ulong_t)&pmbus_info_one_skip},
0239     {"tps40400", (kernel_ulong_t)&pmbus_info_one},
0240     {"tps544b20", (kernel_ulong_t)&pmbus_info_one},
0241     {"tps544b25", (kernel_ulong_t)&pmbus_info_one},
0242     {"tps544c20", (kernel_ulong_t)&pmbus_info_one},
0243     {"tps544c25", (kernel_ulong_t)&pmbus_info_one},
0244     {"udt020", (kernel_ulong_t)&pmbus_info_one},
0245     {}
0246 };
0247
0248 MODULE_DEVICE_TABLE(i2c, pmbus_id);
0249
0250 /* This is the driver that will be inserted */
0251 static struct i2c_driver pmbus_driver = {
0252     .driver = {
0253            .name = "pmbus",
0254            },
0255     .probe_new = pmbus_probe,
0256     .id_table = pmbus_id,
0257 };
0258
0259 module_i2c_driver(pmbus_driver);
0260
0261 MODULE_AUTHOR("Guenter Roeck");
0262 MODULE_DESCRIPTION("Generic PMBus driver");
0263 MODULE_LICENSE("GPL");
0264 MODULE_IMPORT_NS(PMBUS);