|
| 1 | +From 0a3a6f30eb6ea96a1642a3ad75d2de87a1448fb3 Mon Sep 17 00:00:00 2001 |
| 2 | +From: Arun Saravanan Balachandran < [email protected]> |
| 3 | +Date: Thu, 11 Feb 2021 09:15:41 +0000 |
| 4 | +Subject: [PATCH] Add attributes to retrieve PMBus status command codes |
| 5 | + |
| 6 | +Signed-off-by: Arun Saravanan Balachandran < [email protected]> |
| 7 | +--- |
| 8 | + drivers/hwmon/pmbus/dni_dps460.c | 152 +++++++++++++++++++++++++++++++++++++++ |
| 9 | + 1 file changed, 152 insertions(+) |
| 10 | + |
| 11 | +diff --git a/drivers/hwmon/pmbus/dni_dps460.c b/drivers/hwmon/pmbus/dni_dps460.c |
| 12 | +index d314c1f..313165a 100644 |
| 13 | +--- a/drivers/hwmon/pmbus/dni_dps460.c |
| 14 | ++++ b/drivers/hwmon/pmbus/dni_dps460.c |
| 15 | +@@ -166,13 +166,165 @@ static ssize_t set_pec(struct device *dev, struct device_attribute *dummy, |
| 16 | + return count; |
| 17 | + } |
| 18 | + |
| 19 | ++static ssize_t show_capability(struct device *dev, struct device_attribute *devattr, |
| 20 | ++ char *buf) { |
| 21 | ++ |
| 22 | ++ struct i2c_client *client = to_i2c_client(dev); |
| 23 | ++ struct pmbus_data *data = i2c_get_clientdata(client); |
| 24 | ++ int val; |
| 25 | ++ |
| 26 | ++ mutex_lock(&data->update_lock); |
| 27 | ++ val = pmbus_read_byte_data(client, 0, PMBUS_CAPABILITY); |
| 28 | ++ pmbus_clear_faults(client); |
| 29 | ++ mutex_unlock(&data->update_lock); |
| 30 | ++ if (val < 0) { |
| 31 | ++ return val; |
| 32 | ++ } |
| 33 | ++ return sprintf(buf, "0x%x\n", val); |
| 34 | ++} |
| 35 | ++ |
| 36 | ++static ssize_t show_status_word(struct device *dev, struct device_attribute *devattr, |
| 37 | ++ char *buf) { |
| 38 | ++ |
| 39 | ++ struct i2c_client *client = to_i2c_client(dev); |
| 40 | ++ struct pmbus_data *data = i2c_get_clientdata(client); |
| 41 | ++ int val; |
| 42 | ++ |
| 43 | ++ mutex_lock(&data->update_lock); |
| 44 | ++ val = pmbus_read_word_data(client, 0, PMBUS_STATUS_WORD); |
| 45 | ++ pmbus_clear_faults(client); |
| 46 | ++ mutex_unlock(&data->update_lock); |
| 47 | ++ if (val < 0) { |
| 48 | ++ return val; |
| 49 | ++ } |
| 50 | ++ return sprintf(buf, "0x%x\n", val); |
| 51 | ++} |
| 52 | ++ |
| 53 | ++static ssize_t show_status_vout(struct device *dev, struct device_attribute *devattr, |
| 54 | ++ char *buf) { |
| 55 | ++ |
| 56 | ++ struct i2c_client *client = to_i2c_client(dev); |
| 57 | ++ struct pmbus_data *data = i2c_get_clientdata(client); |
| 58 | ++ int val; |
| 59 | ++ |
| 60 | ++ mutex_lock(&data->update_lock); |
| 61 | ++ val = pmbus_read_byte_data(client, 0, PMBUS_STATUS_VOUT); |
| 62 | ++ pmbus_clear_faults(client); |
| 63 | ++ mutex_unlock(&data->update_lock); |
| 64 | ++ if (val < 0) { |
| 65 | ++ return val; |
| 66 | ++ } |
| 67 | ++ return sprintf(buf, "0x%x\n", val); |
| 68 | ++} |
| 69 | ++ |
| 70 | ++static ssize_t show_status_iout(struct device *dev, struct device_attribute *devattr, |
| 71 | ++ char *buf) { |
| 72 | ++ |
| 73 | ++ struct i2c_client *client = to_i2c_client(dev); |
| 74 | ++ struct pmbus_data *data = i2c_get_clientdata(client); |
| 75 | ++ int val; |
| 76 | ++ |
| 77 | ++ mutex_lock(&data->update_lock); |
| 78 | ++ val = pmbus_read_byte_data(client, 0, PMBUS_STATUS_IOUT); |
| 79 | ++ pmbus_clear_faults(client); |
| 80 | ++ mutex_unlock(&data->update_lock); |
| 81 | ++ if (val < 0) { |
| 82 | ++ return val; |
| 83 | ++ } |
| 84 | ++ return sprintf(buf, "0x%x\n", val); |
| 85 | ++} |
| 86 | ++ |
| 87 | ++static ssize_t show_status_input(struct device *dev, struct device_attribute *devattr, |
| 88 | ++ char *buf) { |
| 89 | ++ |
| 90 | ++ struct i2c_client *client = to_i2c_client(dev); |
| 91 | ++ struct pmbus_data *data = i2c_get_clientdata(client); |
| 92 | ++ int val; |
| 93 | ++ |
| 94 | ++ mutex_lock(&data->update_lock); |
| 95 | ++ val = pmbus_read_byte_data(client, 0, PMBUS_STATUS_INPUT); |
| 96 | ++ pmbus_clear_faults(client); |
| 97 | ++ mutex_unlock(&data->update_lock); |
| 98 | ++ if (val < 0) { |
| 99 | ++ return val; |
| 100 | ++ } |
| 101 | ++ return sprintf(buf, "0x%x\n", val); |
| 102 | ++} |
| 103 | ++ |
| 104 | ++static ssize_t show_status_temp(struct device *dev, struct device_attribute *devattr, |
| 105 | ++ char *buf) { |
| 106 | ++ |
| 107 | ++ struct i2c_client *client = to_i2c_client(dev); |
| 108 | ++ struct pmbus_data *data = i2c_get_clientdata(client); |
| 109 | ++ int val; |
| 110 | ++ |
| 111 | ++ mutex_lock(&data->update_lock); |
| 112 | ++ val = pmbus_read_byte_data(client, 0, PMBUS_STATUS_TEMPERATURE); |
| 113 | ++ pmbus_clear_faults(client); |
| 114 | ++ mutex_unlock(&data->update_lock); |
| 115 | ++ if (val < 0) { |
| 116 | ++ return val; |
| 117 | ++ } |
| 118 | ++ return sprintf(buf, "0x%x\n", val); |
| 119 | ++} |
| 120 | ++ |
| 121 | ++static ssize_t show_status_cml(struct device *dev, struct device_attribute *devattr, |
| 122 | ++ char *buf) { |
| 123 | ++ |
| 124 | ++ struct i2c_client *client = to_i2c_client(dev); |
| 125 | ++ struct pmbus_data *data = i2c_get_clientdata(client); |
| 126 | ++ int val; |
| 127 | ++ |
| 128 | ++ mutex_lock(&data->update_lock); |
| 129 | ++ val = pmbus_read_byte_data(client, 0, PMBUS_STATUS_CML); |
| 130 | ++ pmbus_clear_faults(client); |
| 131 | ++ mutex_unlock(&data->update_lock); |
| 132 | ++ if (val < 0) { |
| 133 | ++ return val; |
| 134 | ++ } |
| 135 | ++ return sprintf(buf, "0x%x\n", val); |
| 136 | ++} |
| 137 | ++ |
| 138 | ++static ssize_t show_status_fans(struct device *dev, struct device_attribute *devattr, |
| 139 | ++ char *buf) { |
| 140 | ++ |
| 141 | ++ struct i2c_client *client = to_i2c_client(dev); |
| 142 | ++ struct pmbus_data *data = i2c_get_clientdata(client); |
| 143 | ++ int val; |
| 144 | ++ |
| 145 | ++ mutex_lock(&data->update_lock); |
| 146 | ++ val = pmbus_read_byte_data(client, 0, PMBUS_STATUS_FAN_12); |
| 147 | ++ pmbus_clear_faults(client); |
| 148 | ++ mutex_unlock(&data->update_lock); |
| 149 | ++ if (val < 0) { |
| 150 | ++ return val; |
| 151 | ++ } |
| 152 | ++ return sprintf(buf, "0x%x\n", val); |
| 153 | ++} |
| 154 | ++ |
| 155 | + static SENSOR_DEVICE_ATTR(pec, S_IWUSR | S_IRUGO, show_pec, set_pec, 0); |
| 156 | + static SENSOR_DEVICE_ATTR(fan1_target, S_IWUSR | S_IRUGO, get_target, |
| 157 | + set_target, 0); |
| 158 | ++static SENSOR_DEVICE_ATTR(capability, S_IRUGO, show_capability, NULL, 0); |
| 159 | ++static SENSOR_DEVICE_ATTR(status_word, S_IRUGO, show_status_word, NULL, 0); |
| 160 | ++static SENSOR_DEVICE_ATTR(status_vout, S_IRUGO, show_status_vout, NULL, 0); |
| 161 | ++static SENSOR_DEVICE_ATTR(status_iout, S_IRUGO, show_status_iout, NULL, 0); |
| 162 | ++static SENSOR_DEVICE_ATTR(status_input, S_IRUGO, show_status_input, NULL, 0); |
| 163 | ++static SENSOR_DEVICE_ATTR(status_temp, S_IRUGO, show_status_temp, NULL, 0); |
| 164 | ++static SENSOR_DEVICE_ATTR(status_cml, S_IRUGO, show_status_cml, NULL, 0); |
| 165 | ++static SENSOR_DEVICE_ATTR(status_fans_12, S_IRUGO, show_status_fans, NULL, 0); |
| 166 | + |
| 167 | + static struct attribute *dni_dps460_attrs[] = { |
| 168 | + &sensor_dev_attr_fan1_target.dev_attr.attr, |
| 169 | + &sensor_dev_attr_pec.dev_attr.attr, |
| 170 | ++ &sensor_dev_attr_capability.dev_attr.attr, |
| 171 | ++ &sensor_dev_attr_status_word.dev_attr.attr, |
| 172 | ++ &sensor_dev_attr_status_vout.dev_attr.attr, |
| 173 | ++ &sensor_dev_attr_status_iout.dev_attr.attr, |
| 174 | ++ &sensor_dev_attr_status_input.dev_attr.attr, |
| 175 | ++ &sensor_dev_attr_status_temp.dev_attr.attr, |
| 176 | ++ &sensor_dev_attr_status_cml.dev_attr.attr, |
| 177 | ++ &sensor_dev_attr_status_fans_12.dev_attr.attr, |
| 178 | + NULL |
| 179 | + }; |
| 180 | + static struct attribute_group dni_dps460_attr_grp = { |
| 181 | +-- |
| 182 | +2.7.4 |
| 183 | + |
0 commit comments