1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * System Control and Management Interface(SCMI) based hwmon sensor driver 4 * 5 * Copyright (C) 2018-2021 ARM Ltd. 6 * Sudeep Holla <sudeep.holla@arm.com> 7 */ 8 9 #include <linux/hwmon.h> 10 #include <linux/module.h> 11 #include <linux/scmi_protocol.h> 12 #include <linux/slab.h> 13 #include <linux/sysfs.h> 14 #include <linux/thermal.h> 15 16 static const struct scmi_sensor_proto_ops *sensor_ops; 17 18 struct scmi_sensors { 19 const struct scmi_protocol_handle *ph; 20 const struct scmi_sensor_info **info[hwmon_max]; 21 }; 22 23 static inline u64 __pow10(u8 x) 24 { 25 u64 r = 1; 26 27 while (x--) 28 r *= 10; 29 30 return r; 31 } 32 33 static int scmi_hwmon_scale(const struct scmi_sensor_info *sensor, u64 *value) 34 { 35 int scale = sensor->scale; 36 u64 f; 37 38 switch (sensor->type) { 39 case TEMPERATURE_C: 40 case VOLTAGE: 41 case CURRENT: 42 scale += 3; 43 break; 44 case POWER: 45 case ENERGY: 46 scale += 6; 47 break; 48 default: 49 break; 50 } 51 52 if (scale == 0) 53 return 0; 54 55 if (abs(scale) > 19) 56 return -E2BIG; 57 58 f = __pow10(abs(scale)); 59 if (scale > 0) 60 *value *= f; 61 else 62 *value = div64_u64(*value, f); 63 64 return 0; 65 } 66 67 static int scmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type, 68 u32 attr, int channel, long *val) 69 { 70 int ret; 71 u64 value; 72 const struct scmi_sensor_info *sensor; 73 struct scmi_sensors *scmi_sensors = dev_get_drvdata(dev); 74 75 sensor = *(scmi_sensors->info[type] + channel); 76 ret = sensor_ops->reading_get(scmi_sensors->ph, sensor->id, &value); 77 if (ret) 78 return ret; 79 80 ret = scmi_hwmon_scale(sensor, &value); 81 if (!ret) 82 *val = value; 83 84 return ret; 85 } 86 87 static int 88 scmi_hwmon_read_string(struct device *dev, enum hwmon_sensor_types type, 89 u32 attr, int channel, const char **str) 90 { 91 const struct scmi_sensor_info *sensor; 92 struct scmi_sensors *scmi_sensors = dev_get_drvdata(dev); 93 94 sensor = *(scmi_sensors->info[type] + channel); 95 *str = sensor->name; 96 97 return 0; 98 } 99 100 static umode_t 101 scmi_hwmon_is_visible(const void *drvdata, enum hwmon_sensor_types type, 102 u32 attr, int channel) 103 { 104 const struct scmi_sensor_info *sensor; 105 const struct scmi_sensors *scmi_sensors = drvdata; 106 107 sensor = *(scmi_sensors->info[type] + channel); 108 if (sensor) 109 return 0444; 110 111 return 0; 112 } 113 114 static const struct hwmon_ops scmi_hwmon_ops = { 115 .is_visible = scmi_hwmon_is_visible, 116 .read = scmi_hwmon_read, 117 .read_string = scmi_hwmon_read_string, 118 }; 119 120 static struct hwmon_chip_info scmi_chip_info = { 121 .ops = &scmi_hwmon_ops, 122 .info = NULL, 123 }; 124 125 static int scmi_hwmon_add_chan_info(struct hwmon_channel_info *scmi_hwmon_chan, 126 struct device *dev, int num, 127 enum hwmon_sensor_types type, u32 config) 128 { 129 int i; 130 u32 *cfg = devm_kcalloc(dev, num + 1, sizeof(*cfg), GFP_KERNEL); 131 132 if (!cfg) 133 return -ENOMEM; 134 135 scmi_hwmon_chan->type = type; 136 scmi_hwmon_chan->config = cfg; 137 for (i = 0; i < num; i++, cfg++) 138 *cfg = config; 139 140 return 0; 141 } 142 143 static enum hwmon_sensor_types scmi_types[] = { 144 [TEMPERATURE_C] = hwmon_temp, 145 [VOLTAGE] = hwmon_in, 146 [CURRENT] = hwmon_curr, 147 [POWER] = hwmon_power, 148 [ENERGY] = hwmon_energy, 149 }; 150 151 static u32 hwmon_attributes[hwmon_max] = { 152 [hwmon_chip] = HWMON_C_REGISTER_TZ, 153 [hwmon_temp] = HWMON_T_INPUT | HWMON_T_LABEL, 154 [hwmon_in] = HWMON_I_INPUT | HWMON_I_LABEL, 155 [hwmon_curr] = HWMON_C_INPUT | HWMON_C_LABEL, 156 [hwmon_power] = HWMON_P_INPUT | HWMON_P_LABEL, 157 [hwmon_energy] = HWMON_E_INPUT | HWMON_E_LABEL, 158 }; 159 160 static int scmi_hwmon_probe(struct scmi_device *sdev) 161 { 162 int i, idx; 163 u16 nr_sensors; 164 enum hwmon_sensor_types type; 165 struct scmi_sensors *scmi_sensors; 166 const struct scmi_sensor_info *sensor; 167 int nr_count[hwmon_max] = {0}, nr_types = 0; 168 const struct hwmon_chip_info *chip_info; 169 struct device *hwdev, *dev = &sdev->dev; 170 struct hwmon_channel_info *scmi_hwmon_chan; 171 const struct hwmon_channel_info **ptr_scmi_ci; 172 const struct scmi_handle *handle = sdev->handle; 173 struct scmi_protocol_handle *ph; 174 175 if (!handle) 176 return -ENODEV; 177 178 sensor_ops = handle->devm_protocol_get(sdev, SCMI_PROTOCOL_SENSOR, &ph); 179 if (IS_ERR(sensor_ops)) 180 return PTR_ERR(sensor_ops); 181 182 nr_sensors = sensor_ops->count_get(ph); 183 if (!nr_sensors) 184 return -EIO; 185 186 scmi_sensors = devm_kzalloc(dev, sizeof(*scmi_sensors), GFP_KERNEL); 187 if (!scmi_sensors) 188 return -ENOMEM; 189 190 scmi_sensors->ph = ph; 191 192 for (i = 0; i < nr_sensors; i++) { 193 sensor = sensor_ops->info_get(ph, i); 194 if (!sensor) 195 return -EINVAL; 196 197 switch (sensor->type) { 198 case TEMPERATURE_C: 199 case VOLTAGE: 200 case CURRENT: 201 case POWER: 202 case ENERGY: 203 type = scmi_types[sensor->type]; 204 if (!nr_count[type]) 205 nr_types++; 206 nr_count[type]++; 207 break; 208 } 209 } 210 211 if (nr_count[hwmon_temp]) { 212 nr_count[hwmon_chip]++; 213 nr_types++; 214 } 215 216 scmi_hwmon_chan = devm_kcalloc(dev, nr_types, sizeof(*scmi_hwmon_chan), 217 GFP_KERNEL); 218 if (!scmi_hwmon_chan) 219 return -ENOMEM; 220 221 ptr_scmi_ci = devm_kcalloc(dev, nr_types + 1, sizeof(*ptr_scmi_ci), 222 GFP_KERNEL); 223 if (!ptr_scmi_ci) 224 return -ENOMEM; 225 226 scmi_chip_info.info = ptr_scmi_ci; 227 chip_info = &scmi_chip_info; 228 229 for (type = 0; type < hwmon_max; type++) { 230 if (!nr_count[type]) 231 continue; 232 233 scmi_hwmon_add_chan_info(scmi_hwmon_chan, dev, nr_count[type], 234 type, hwmon_attributes[type]); 235 *ptr_scmi_ci++ = scmi_hwmon_chan++; 236 237 scmi_sensors->info[type] = 238 devm_kcalloc(dev, nr_count[type], 239 sizeof(*scmi_sensors->info), GFP_KERNEL); 240 if (!scmi_sensors->info[type]) 241 return -ENOMEM; 242 } 243 244 for (i = nr_sensors - 1; i >= 0 ; i--) { 245 sensor = sensor_ops->info_get(ph, i); 246 if (!sensor) 247 continue; 248 249 switch (sensor->type) { 250 case TEMPERATURE_C: 251 case VOLTAGE: 252 case CURRENT: 253 case POWER: 254 case ENERGY: 255 type = scmi_types[sensor->type]; 256 idx = --nr_count[type]; 257 *(scmi_sensors->info[type] + idx) = sensor; 258 break; 259 } 260 } 261 262 hwdev = devm_hwmon_device_register_with_info(dev, "scmi_sensors", 263 scmi_sensors, chip_info, 264 NULL); 265 266 return PTR_ERR_OR_ZERO(hwdev); 267 } 268 269 static const struct scmi_device_id scmi_id_table[] = { 270 { SCMI_PROTOCOL_SENSOR, "hwmon" }, 271 { }, 272 }; 273 MODULE_DEVICE_TABLE(scmi, scmi_id_table); 274 275 static struct scmi_driver scmi_hwmon_drv = { 276 .name = "scmi-hwmon", 277 .probe = scmi_hwmon_probe, 278 .id_table = scmi_id_table, 279 }; 280 module_scmi_driver(scmi_hwmon_drv); 281 282 MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>"); 283 MODULE_DESCRIPTION("ARM SCMI HWMON interface driver"); 284 MODULE_LICENSE("GPL v2"); 285