drivers/hwmon/lineage-pem.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Driver for Lineage Compact Power Line series of power entry modules.
0004  *
0005  * Copyright (C) 2010, 2011 Ericsson AB.
0006  *
0007  * Documentation:
0008  *  http://www.lineagepower.com/oem/pdf/CPLI2C.pdf
0009  */
0010
0011 #include <linux/kernel.h>
0012 #include <linux/module.h>
0013 #include <linux/init.h>
0014 #include <linux/err.h>
0015 #include <linux/slab.h>
0016 #include <linux/i2c.h>
0017 #include <linux/hwmon.h>
0018 #include <linux/hwmon-sysfs.h>
0019 #include <linux/jiffies.h>
0020
0021 /*
0022  * This driver supports various Lineage Compact Power Line DC/DC and AC/DC
0023  * converters such as CP1800, CP2000AC, CP2000DC, CP2100DC, and others.
0024  *
0025  * The devices are nominally PMBus compliant. However, most standard PMBus
0026  * commands are not supported. Specifically, all hardware monitoring and
0027  * status reporting commands are non-standard. For this reason, a standard
0028  * PMBus driver can not be used.
0029  *
0030  * All Lineage CPL devices have a built-in I2C bus master selector (PCA9541).
0031  * To ensure device access, this driver should only be used as client driver
0032  * to the pca9541 I2C master selector driver.
0033  */
0034
0035 /* Command codes */
0036 #define PEM_OPERATION       0x01
0037 #define PEM_CLEAR_INFO_FLAGS    0x03
0038 #define PEM_VOUT_COMMAND    0x21
0039 #define PEM_VOUT_OV_FAULT_LIMIT 0x40
0040 #define PEM_READ_DATA_STRING    0xd0
0041 #define PEM_READ_INPUT_STRING   0xdc
0042 #define PEM_READ_FIRMWARE_REV   0xdd
0043 #define PEM_READ_RUN_TIMER  0xde
0044 #define PEM_FAN_HI_SPEED    0xdf
0045 #define PEM_FAN_NORMAL_SPEED    0xe0
0046 #define PEM_READ_FAN_SPEED  0xe1
0047
0048 /* offsets in data string */
0049 #define PEM_DATA_STATUS_2   0
0050 #define PEM_DATA_STATUS_1   1
0051 #define PEM_DATA_ALARM_2    2
0052 #define PEM_DATA_ALARM_1    3
0053 #define PEM_DATA_VOUT_LSB   4
0054 #define PEM_DATA_VOUT_MSB   5
0055 #define PEM_DATA_CURRENT    6
0056 #define PEM_DATA_TEMP       7
0057
0058 /* Virtual entries, to report constants */
0059 #define PEM_DATA_TEMP_MAX   10
0060 #define PEM_DATA_TEMP_CRIT  11
0061
0062 /* offsets in input string */
0063 #define PEM_INPUT_VOLTAGE   0
0064 #define PEM_INPUT_POWER_LSB 1
0065 #define PEM_INPUT_POWER_MSB 2
0066
0067 /* offsets in fan data */
0068 #define PEM_FAN_ADJUSTMENT  0
0069 #define PEM_FAN_FAN1        1
0070 #define PEM_FAN_FAN2        2
0071 #define PEM_FAN_FAN3        3
0072
0073 /* Status register bits */
0074 #define STS1_OUTPUT_ON      (1 << 0)
0075 #define STS1_LEDS_FLASHING  (1 << 1)
0076 #define STS1_EXT_FAULT      (1 << 2)
0077 #define STS1_SERVICE_LED_ON (1 << 3)
0078 #define STS1_SHUTDOWN_OCCURRED  (1 << 4)
0079 #define STS1_INT_FAULT      (1 << 5)
0080 #define STS1_ISOLATION_TEST_OK  (1 << 6)
0081
0082 #define STS2_ENABLE_PIN_HI  (1 << 0)
0083 #define STS2_DATA_OUT_RANGE (1 << 1)
0084 #define STS2_RESTARTED_OK   (1 << 1)
0085 #define STS2_ISOLATION_TEST_FAIL (1 << 3)
0086 #define STS2_HIGH_POWER_CAP (1 << 4)
0087 #define STS2_INVALID_INSTR  (1 << 5)
0088 #define STS2_WILL_RESTART   (1 << 6)
0089 #define STS2_PEC_ERR        (1 << 7)
0090
0091 /* Alarm register bits */
0092 #define ALRM1_VIN_OUT_LIMIT (1 << 0)
0093 #define ALRM1_VOUT_OUT_LIMIT    (1 << 1)
0094 #define ALRM1_OV_VOLT_SHUTDOWN  (1 << 2)
0095 #define ALRM1_VIN_OVERCURRENT   (1 << 3)
0096 #define ALRM1_TEMP_WARNING  (1 << 4)
0097 #define ALRM1_TEMP_SHUTDOWN (1 << 5)
0098 #define ALRM1_PRIMARY_FAULT (1 << 6)
0099 #define ALRM1_POWER_LIMIT   (1 << 7)
0100
0101 #define ALRM2_5V_OUT_LIMIT  (1 << 1)
0102 #define ALRM2_TEMP_FAULT    (1 << 2)
0103 #define ALRM2_OV_LOW        (1 << 3)
0104 #define ALRM2_DCDC_TEMP_HIGH    (1 << 4)
0105 #define ALRM2_PRI_TEMP_HIGH (1 << 5)
0106 #define ALRM2_NO_PRIMARY    (1 << 6)
0107 #define ALRM2_FAN_FAULT     (1 << 7)
0108
0109 #define FIRMWARE_REV_LEN    4
0110 #define DATA_STRING_LEN     9
0111 #define INPUT_STRING_LEN    5   /* 4 for most devices   */
0112 #define FAN_SPEED_LEN       5
0113
0114 struct pem_data {
0115     struct i2c_client *client;
0116     const struct attribute_group *groups[4];
0117
0118     struct mutex update_lock;
0119     bool valid;
0120     bool fans_supported;
0121     int input_length;
0122     unsigned long last_updated; /* in jiffies */
0123
0124     u8 firmware_rev[FIRMWARE_REV_LEN];
0125     u8 data_string[DATA_STRING_LEN];
0126     u8 input_string[INPUT_STRING_LEN];
0127     u8 fan_speed[FAN_SPEED_LEN];
0128 };
0129
0130 static int pem_read_block(struct i2c_client *client, u8 command, u8 *data,
0131               int data_len)
0132 {
0133     u8 block_buffer[I2C_SMBUS_BLOCK_MAX];
0134     int result;
0135
0136     result = i2c_smbus_read_block_data(client, command, block_buffer);
0137     if (unlikely(result < 0))
0138         goto abort;
0139     if (unlikely(result == 0xff || result != data_len)) {
0140         result = -EIO;
0141         goto abort;
0142     }
0143     memcpy(data, block_buffer, data_len);
0144     result = 0;
0145 abort:
0146     return result;
0147 }
0148
0149 static struct pem_data *pem_update_device(struct device *dev)
0150 {
0151     struct pem_data *data = dev_get_drvdata(dev);
0152     struct i2c_client *client = data->client;
0153     struct pem_data *ret = data;
0154
0155     mutex_lock(&data->update_lock);
0156
0157     if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
0158         int result;
0159
0160         /* Read data string */
0161         result = pem_read_block(client, PEM_READ_DATA_STRING,
0162                     data->data_string,
0163                     sizeof(data->data_string));
0164         if (unlikely(result < 0)) {
0165             ret = ERR_PTR(result);
0166             goto abort;
0167         }
0168
0169         /* Read input string */
0170         if (data->input_length) {
0171             result = pem_read_block(client, PEM_READ_INPUT_STRING,
0172                         data->input_string,
0173                         data->input_length);
0174             if (unlikely(result < 0)) {
0175                 ret = ERR_PTR(result);
0176                 goto abort;
0177             }
0178         }
0179
0180         /* Read fan speeds */
0181         if (data->fans_supported) {
0182             result = pem_read_block(client, PEM_READ_FAN_SPEED,
0183                         data->fan_speed,
0184                         sizeof(data->fan_speed));
0185             if (unlikely(result < 0)) {
0186                 ret = ERR_PTR(result);
0187                 goto abort;
0188             }
0189         }
0190
0191         i2c_smbus_write_byte(client, PEM_CLEAR_INFO_FLAGS);
0192
0193         data->last_updated = jiffies;
0194         data->valid = true;
0195     }
0196 abort:
0197     mutex_unlock(&data->update_lock);
0198     return ret;
0199 }
0200
0201 static long pem_get_data(u8 *data, int len, int index)
0202 {
0203     long val;
0204
0205     switch (index) {
0206     case PEM_DATA_VOUT_LSB:
0207         val = (data[index] + (data[index+1] << 8)) * 5 / 2;
0208         break;
0209     case PEM_DATA_CURRENT:
0210         val = data[index] * 200;
0211         break;
0212     case PEM_DATA_TEMP:
0213         val = data[index] * 1000;
0214         break;
0215     case PEM_DATA_TEMP_MAX:
0216         val = 97 * 1000;    /* 97 degrees C per datasheet */
0217         break;
0218     case PEM_DATA_TEMP_CRIT:
0219         val = 107 * 1000;   /* 107 degrees C per datasheet */
0220         break;
0221     default:
0222         WARN_ON_ONCE(1);
0223         val = 0;
0224     }
0225     return val;
0226 }
0227
0228 static long pem_get_input(u8 *data, int len, int index)
0229 {
0230     long val;
0231
0232     switch (index) {
0233     case PEM_INPUT_VOLTAGE:
0234         if (len == INPUT_STRING_LEN)
0235             val = (data[index] + (data[index+1] << 8) - 75) * 1000;
0236         else
0237             val = (data[index] - 75) * 1000;
0238         break;
0239     case PEM_INPUT_POWER_LSB:
0240         if (len == INPUT_STRING_LEN)
0241             index++;
0242         val = (data[index] + (data[index+1] << 8)) * 1000000L;
0243         break;
0244     default:
0245         WARN_ON_ONCE(1);
0246         val = 0;
0247     }
0248     return val;
0249 }
0250
0251 static long pem_get_fan(u8 *data, int len, int index)
0252 {
0253     long val;
0254
0255     switch (index) {
0256     case PEM_FAN_FAN1:
0257     case PEM_FAN_FAN2:
0258     case PEM_FAN_FAN3:
0259         val = data[index] * 100;
0260         break;
0261     default:
0262         WARN_ON_ONCE(1);
0263         val = 0;
0264     }
0265     return val;
0266 }
0267
0268 /*
0269  * Show boolean, either a fault or an alarm.
0270  * .nr points to the register, .index is the bit mask to check
0271  */
0272 static ssize_t pem_bool_show(struct device *dev, struct device_attribute *da,
0273                  char *buf)
0274 {
0275     struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da);
0276     struct pem_data *data = pem_update_device(dev);
0277     u8 status;
0278
0279     if (IS_ERR(data))
0280         return PTR_ERR(data);
0281
0282     status = data->data_string[attr->nr] & attr->index;
0283     return sysfs_emit(buf, "%d\n", !!status);
0284 }
0285
0286 static ssize_t pem_data_show(struct device *dev, struct device_attribute *da,
0287                  char *buf)
0288 {
0289     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0290     struct pem_data *data = pem_update_device(dev);
0291     long value;
0292
0293     if (IS_ERR(data))
0294         return PTR_ERR(data);
0295
0296     value = pem_get_data(data->data_string, sizeof(data->data_string),
0297                  attr->index);
0298
0299     return sysfs_emit(buf, "%ld\n", value);
0300 }
0301
0302 static ssize_t pem_input_show(struct device *dev, struct device_attribute *da,
0303                   char *buf)
0304 {
0305     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0306     struct pem_data *data = pem_update_device(dev);
0307     long value;
0308
0309     if (IS_ERR(data))
0310         return PTR_ERR(data);
0311
0312     value = pem_get_input(data->input_string, sizeof(data->input_string),
0313                   attr->index);
0314
0315     return sysfs_emit(buf, "%ld\n", value);
0316 }
0317
0318 static ssize_t pem_fan_show(struct device *dev, struct device_attribute *da,
0319                 char *buf)
0320 {
0321     struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
0322     struct pem_data *data = pem_update_device(dev);
0323     long value;
0324
0325     if (IS_ERR(data))
0326         return PTR_ERR(data);
0327
0328     value = pem_get_fan(data->fan_speed, sizeof(data->fan_speed),
0329                 attr->index);
0330
0331     return sysfs_emit(buf, "%ld\n", value);
0332 }
0333
0334 /* Voltages */
0335 static SENSOR_DEVICE_ATTR_RO(in1_input, pem_data, PEM_DATA_VOUT_LSB);
0336 static SENSOR_DEVICE_ATTR_2_RO(in1_alarm, pem_bool, PEM_DATA_ALARM_1,
0337                    ALRM1_VOUT_OUT_LIMIT);
0338 static SENSOR_DEVICE_ATTR_2_RO(in1_crit_alarm, pem_bool, PEM_DATA_ALARM_1,
0339                    ALRM1_OV_VOLT_SHUTDOWN);
0340 static SENSOR_DEVICE_ATTR_RO(in2_input, pem_input, PEM_INPUT_VOLTAGE);
0341 static SENSOR_DEVICE_ATTR_2_RO(in2_alarm, pem_bool, PEM_DATA_ALARM_1,
0342                    ALRM1_VIN_OUT_LIMIT | ALRM1_PRIMARY_FAULT);
0343
0344 /* Currents */
0345 static SENSOR_DEVICE_ATTR_RO(curr1_input, pem_data, PEM_DATA_CURRENT);
0346 static SENSOR_DEVICE_ATTR_2_RO(curr1_alarm, pem_bool, PEM_DATA_ALARM_1,
0347                    ALRM1_VIN_OVERCURRENT);
0348
0349 /* Power */
0350 static SENSOR_DEVICE_ATTR_RO(power1_input, pem_input, PEM_INPUT_POWER_LSB);
0351 static SENSOR_DEVICE_ATTR_2_RO(power1_alarm, pem_bool, PEM_DATA_ALARM_1,
0352                    ALRM1_POWER_LIMIT);
0353
0354 /* Fans */
0355 static SENSOR_DEVICE_ATTR_RO(fan1_input, pem_fan, PEM_FAN_FAN1);
0356 static SENSOR_DEVICE_ATTR_RO(fan2_input, pem_fan, PEM_FAN_FAN2);
0357 static SENSOR_DEVICE_ATTR_RO(fan3_input, pem_fan, PEM_FAN_FAN3);
0358 static SENSOR_DEVICE_ATTR_2_RO(fan1_alarm, pem_bool, PEM_DATA_ALARM_2,
0359                    ALRM2_FAN_FAULT);
0360
0361 /* Temperatures */
0362 static SENSOR_DEVICE_ATTR_RO(temp1_input, pem_data, PEM_DATA_TEMP);
0363 static SENSOR_DEVICE_ATTR_RO(temp1_max, pem_data, PEM_DATA_TEMP_MAX);
0364 static SENSOR_DEVICE_ATTR_RO(temp1_crit, pem_data, PEM_DATA_TEMP_CRIT);
0365 static SENSOR_DEVICE_ATTR_2_RO(temp1_alarm, pem_bool, PEM_DATA_ALARM_1,
0366                    ALRM1_TEMP_WARNING);
0367 static SENSOR_DEVICE_ATTR_2_RO(temp1_crit_alarm, pem_bool, PEM_DATA_ALARM_1,
0368                    ALRM1_TEMP_SHUTDOWN);
0369 static SENSOR_DEVICE_ATTR_2_RO(temp1_fault, pem_bool, PEM_DATA_ALARM_2,
0370                    ALRM2_TEMP_FAULT);
0371
0372 static struct attribute *pem_attributes[] = {
0373     &sensor_dev_attr_in1_input.dev_attr.attr,
0374     &sensor_dev_attr_in1_alarm.dev_attr.attr,
0375     &sensor_dev_attr_in1_crit_alarm.dev_attr.attr,
0376     &sensor_dev_attr_in2_alarm.dev_attr.attr,
0377
0378     &sensor_dev_attr_curr1_alarm.dev_attr.attr,
0379
0380     &sensor_dev_attr_power1_alarm.dev_attr.attr,
0381
0382     &sensor_dev_attr_fan1_alarm.dev_attr.attr,
0383
0384     &sensor_dev_attr_temp1_input.dev_attr.attr,
0385     &sensor_dev_attr_temp1_max.dev_attr.attr,
0386     &sensor_dev_attr_temp1_crit.dev_attr.attr,
0387     &sensor_dev_attr_temp1_alarm.dev_attr.attr,
0388     &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
0389     &sensor_dev_attr_temp1_fault.dev_attr.attr,
0390
0391     NULL,
0392 };
0393
0394 static const struct attribute_group pem_group = {
0395     .attrs = pem_attributes,
0396 };
0397
0398 static struct attribute *pem_input_attributes[] = {
0399     &sensor_dev_attr_in2_input.dev_attr.attr,
0400     &sensor_dev_attr_curr1_input.dev_attr.attr,
0401     &sensor_dev_attr_power1_input.dev_attr.attr,
0402     NULL
0403 };
0404
0405 static const struct attribute_group pem_input_group = {
0406     .attrs = pem_input_attributes,
0407 };
0408
0409 static struct attribute *pem_fan_attributes[] = {
0410     &sensor_dev_attr_fan1_input.dev_attr.attr,
0411     &sensor_dev_attr_fan2_input.dev_attr.attr,
0412     &sensor_dev_attr_fan3_input.dev_attr.attr,
0413     NULL
0414 };
0415
0416 static const struct attribute_group pem_fan_group = {
0417     .attrs = pem_fan_attributes,
0418 };
0419
0420 static int pem_probe(struct i2c_client *client)
0421 {
0422     struct i2c_adapter *adapter = client->adapter;
0423     struct device *dev = &client->dev;
0424     struct device *hwmon_dev;
0425     struct pem_data *data;
0426     int ret, idx = 0;
0427
0428     if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BLOCK_DATA
0429                      | I2C_FUNC_SMBUS_WRITE_BYTE))
0430         return -ENODEV;
0431
0432     data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
0433     if (!data)
0434         return -ENOMEM;
0435
0436     data->client = client;
0437     mutex_init(&data->update_lock);
0438
0439     /*
0440      * We use the next two commands to determine if the device is really
0441      * there.
0442      */
0443     ret = pem_read_block(client, PEM_READ_FIRMWARE_REV,
0444                  data->firmware_rev, sizeof(data->firmware_rev));
0445     if (ret < 0)
0446         return ret;
0447
0448     ret = i2c_smbus_write_byte(client, PEM_CLEAR_INFO_FLAGS);
0449     if (ret < 0)
0450         return ret;
0451
0452     dev_info(dev, "Firmware revision %d.%d.%d\n",
0453          data->firmware_rev[0], data->firmware_rev[1],
0454          data->firmware_rev[2]);
0455
0456     /* sysfs hooks */
0457     data->groups[idx++] = &pem_group;
0458
0459     /*
0460      * Check if input readings are supported.
0461      * This is the case if we can read input data,
0462      * and if the returned data is not all zeros.
0463      * Note that input alarms are always supported.
0464      */
0465     ret = pem_read_block(client, PEM_READ_INPUT_STRING,
0466                  data->input_string,
0467                  sizeof(data->input_string) - 1);
0468     if (!ret && (data->input_string[0] || data->input_string[1] ||
0469              data->input_string[2]))
0470         data->input_length = sizeof(data->input_string) - 1;
0471     else if (ret < 0) {
0472         /* Input string is one byte longer for some devices */
0473         ret = pem_read_block(client, PEM_READ_INPUT_STRING,
0474                     data->input_string,
0475                     sizeof(data->input_string));
0476         if (!ret && (data->input_string[0] || data->input_string[1] ||
0477                 data->input_string[2] || data->input_string[3]))
0478             data->input_length = sizeof(data->input_string);
0479     }
0480
0481     if (data->input_length)
0482         data->groups[idx++] = &pem_input_group;
0483
0484     /*
0485      * Check if fan speed readings are supported.
0486      * This is the case if we can read fan speed data,
0487      * and if the returned data is not all zeros.
0488      * Note that the fan alarm is always supported.
0489      */
0490     ret = pem_read_block(client, PEM_READ_FAN_SPEED,
0491                  data->fan_speed,
0492                  sizeof(data->fan_speed));
0493     if (!ret && (data->fan_speed[0] || data->fan_speed[1] ||
0494              data->fan_speed[2] || data->fan_speed[3])) {
0495         data->fans_supported = true;
0496         data->groups[idx++] = &pem_fan_group;
0497     }
0498
0499     hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
0500                                data, data->groups);
0501     return PTR_ERR_OR_ZERO(hwmon_dev);
0502 }
0503
0504 static const struct i2c_device_id pem_id[] = {
0505     {"lineage_pem", 0},
0506     {}
0507 };
0508 MODULE_DEVICE_TABLE(i2c, pem_id);
0509
0510 static struct i2c_driver pem_driver = {
0511     .driver = {
0512            .name = "lineage_pem",
0513            },
0514     .probe_new = pem_probe,
0515     .id_table = pem_id,
0516 };
0517
0518 module_i2c_driver(pem_driver);
0519
0520 MODULE_AUTHOR("Guenter Roeck <linux@roeck-us.net>");
0521 MODULE_DESCRIPTION("Lineage CPL PEM hardware monitoring driver");
0522 MODULE_LICENSE("GPL");