1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * NVM Express hardware monitoring support
4 * Copyright (c) 2019, Guenter Roeck
5 */
6
7 #include <linux/hwmon.h>
8 #include <linux/units.h>
9 #include <asm/unaligned.h>
10
11 #include "nvme.h"
12
13 struct nvme_hwmon_data {
14 struct nvme_ctrl *ctrl;
15 struct nvme_smart_log *log;
16 struct mutex read_lock;
17 };
18
nvme_get_temp_thresh(struct nvme_ctrl * ctrl,int sensor,bool under,long * temp)19 static int nvme_get_temp_thresh(struct nvme_ctrl *ctrl, int sensor, bool under,
20 long *temp)
21 {
22 unsigned int threshold = sensor << NVME_TEMP_THRESH_SELECT_SHIFT;
23 u32 status;
24 int ret;
25
26 if (under)
27 threshold |= NVME_TEMP_THRESH_TYPE_UNDER;
28
29 ret = nvme_get_features(ctrl, NVME_FEAT_TEMP_THRESH, threshold, NULL, 0,
30 &status);
31 if (ret > 0)
32 return -EIO;
33 if (ret < 0)
34 return ret;
35 *temp = kelvin_to_millicelsius(status & NVME_TEMP_THRESH_MASK);
36
37 return 0;
38 }
39
nvme_set_temp_thresh(struct nvme_ctrl * ctrl,int sensor,bool under,long temp)40 static int nvme_set_temp_thresh(struct nvme_ctrl *ctrl, int sensor, bool under,
41 long temp)
42 {
43 unsigned int threshold = sensor << NVME_TEMP_THRESH_SELECT_SHIFT;
44 int ret;
45
46 temp = millicelsius_to_kelvin(temp);
47 threshold |= clamp_val(temp, 0, NVME_TEMP_THRESH_MASK);
48
49 if (under)
50 threshold |= NVME_TEMP_THRESH_TYPE_UNDER;
51
52 ret = nvme_set_features(ctrl, NVME_FEAT_TEMP_THRESH, threshold, NULL, 0,
53 NULL);
54 if (ret > 0)
55 return -EIO;
56
57 return ret;
58 }
59
nvme_hwmon_get_smart_log(struct nvme_hwmon_data * data)60 static int nvme_hwmon_get_smart_log(struct nvme_hwmon_data *data)
61 {
62 return nvme_get_log(data->ctrl, NVME_NSID_ALL, NVME_LOG_SMART, 0,
63 NVME_CSI_NVM, data->log, sizeof(*data->log), 0);
64 }
65
nvme_hwmon_read(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long * val)66 static int nvme_hwmon_read(struct device *dev, enum hwmon_sensor_types type,
67 u32 attr, int channel, long *val)
68 {
69 struct nvme_hwmon_data *data = dev_get_drvdata(dev);
70 struct nvme_smart_log *log = data->log;
71 int temp;
72 int err;
73
74 /*
75 * First handle attributes which don't require us to read
76 * the smart log.
77 */
78 switch (attr) {
79 case hwmon_temp_max:
80 return nvme_get_temp_thresh(data->ctrl, channel, false, val);
81 case hwmon_temp_min:
82 return nvme_get_temp_thresh(data->ctrl, channel, true, val);
83 case hwmon_temp_crit:
84 *val = kelvin_to_millicelsius(data->ctrl->cctemp);
85 return 0;
86 default:
87 break;
88 }
89
90 mutex_lock(&data->read_lock);
91 err = nvme_hwmon_get_smart_log(data);
92 if (err)
93 goto unlock;
94
95 switch (attr) {
96 case hwmon_temp_input:
97 if (!channel)
98 temp = get_unaligned_le16(log->temperature);
99 else
100 temp = le16_to_cpu(log->temp_sensor[channel - 1]);
101 *val = kelvin_to_millicelsius(temp);
102 break;
103 case hwmon_temp_alarm:
104 *val = !!(log->critical_warning & NVME_SMART_CRIT_TEMPERATURE);
105 break;
106 default:
107 err = -EOPNOTSUPP;
108 break;
109 }
110 unlock:
111 mutex_unlock(&data->read_lock);
112 return err;
113 }
114
nvme_hwmon_write(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,long val)115 static int nvme_hwmon_write(struct device *dev, enum hwmon_sensor_types type,
116 u32 attr, int channel, long val)
117 {
118 struct nvme_hwmon_data *data = dev_get_drvdata(dev);
119
120 switch (attr) {
121 case hwmon_temp_max:
122 return nvme_set_temp_thresh(data->ctrl, channel, false, val);
123 case hwmon_temp_min:
124 return nvme_set_temp_thresh(data->ctrl, channel, true, val);
125 default:
126 break;
127 }
128
129 return -EOPNOTSUPP;
130 }
131
132 static const char * const nvme_hwmon_sensor_names[] = {
133 "Composite",
134 "Sensor 1",
135 "Sensor 2",
136 "Sensor 3",
137 "Sensor 4",
138 "Sensor 5",
139 "Sensor 6",
140 "Sensor 7",
141 "Sensor 8",
142 };
143
nvme_hwmon_read_string(struct device * dev,enum hwmon_sensor_types type,u32 attr,int channel,const char ** str)144 static int nvme_hwmon_read_string(struct device *dev,
145 enum hwmon_sensor_types type, u32 attr,
146 int channel, const char **str)
147 {
148 *str = nvme_hwmon_sensor_names[channel];
149 return 0;
150 }
151
nvme_hwmon_is_visible(const void * _data,enum hwmon_sensor_types type,u32 attr,int channel)152 static umode_t nvme_hwmon_is_visible(const void *_data,
153 enum hwmon_sensor_types type,
154 u32 attr, int channel)
155 {
156 const struct nvme_hwmon_data *data = _data;
157
158 switch (attr) {
159 case hwmon_temp_crit:
160 if (!channel && data->ctrl->cctemp)
161 return 0444;
162 break;
163 case hwmon_temp_max:
164 case hwmon_temp_min:
165 if ((!channel && data->ctrl->wctemp) ||
166 (channel && data->log->temp_sensor[channel - 1] &&
167 !(data->ctrl->quirks &
168 NVME_QUIRK_NO_SECONDARY_TEMP_THRESH))) {
169 if (data->ctrl->quirks &
170 NVME_QUIRK_NO_TEMP_THRESH_CHANGE)
171 return 0444;
172 return 0644;
173 }
174 break;
175 case hwmon_temp_alarm:
176 if (!channel)
177 return 0444;
178 break;
179 case hwmon_temp_input:
180 case hwmon_temp_label:
181 if (!channel || data->log->temp_sensor[channel - 1])
182 return 0444;
183 break;
184 default:
185 break;
186 }
187 return 0;
188 }
189
190 static const struct hwmon_channel_info *const nvme_hwmon_info[] = {
191 HWMON_CHANNEL_INFO(chip, HWMON_C_REGISTER_TZ),
192 HWMON_CHANNEL_INFO(temp,
193 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
194 HWMON_T_CRIT | HWMON_T_LABEL | HWMON_T_ALARM,
195 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
196 HWMON_T_LABEL,
197 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
198 HWMON_T_LABEL,
199 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
200 HWMON_T_LABEL,
201 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
202 HWMON_T_LABEL,
203 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
204 HWMON_T_LABEL,
205 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
206 HWMON_T_LABEL,
207 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
208 HWMON_T_LABEL,
209 HWMON_T_INPUT | HWMON_T_MAX | HWMON_T_MIN |
210 HWMON_T_LABEL),
211 NULL
212 };
213
214 static const struct hwmon_ops nvme_hwmon_ops = {
215 .is_visible = nvme_hwmon_is_visible,
216 .read = nvme_hwmon_read,
217 .read_string = nvme_hwmon_read_string,
218 .write = nvme_hwmon_write,
219 };
220
221 static const struct hwmon_chip_info nvme_hwmon_chip_info = {
222 .ops = &nvme_hwmon_ops,
223 .info = nvme_hwmon_info,
224 };
225
nvme_hwmon_init(struct nvme_ctrl * ctrl)226 int nvme_hwmon_init(struct nvme_ctrl *ctrl)
227 {
228 struct device *dev = ctrl->device;
229 struct nvme_hwmon_data *data;
230 struct device *hwmon;
231 int err;
232
233 data = kzalloc(sizeof(*data), GFP_KERNEL);
234 if (!data)
235 return -ENOMEM;
236
237 data->log = kzalloc(sizeof(*data->log), GFP_KERNEL);
238 if (!data->log) {
239 err = -ENOMEM;
240 goto err_free_data;
241 }
242
243 data->ctrl = ctrl;
244 mutex_init(&data->read_lock);
245
246 err = nvme_hwmon_get_smart_log(data);
247 if (err) {
248 dev_warn(dev, "Failed to read smart log (error %d)\n", err);
249 goto err_free_log;
250 }
251
252 hwmon = hwmon_device_register_with_info(dev, "nvme",
253 data, &nvme_hwmon_chip_info,
254 NULL);
255 if (IS_ERR(hwmon)) {
256 dev_warn(dev, "Failed to instantiate hwmon device\n");
257 err = PTR_ERR(hwmon);
258 goto err_free_log;
259 }
260 ctrl->hwmon_device = hwmon;
261 return 0;
262
263 err_free_log:
264 kfree(data->log);
265 err_free_data:
266 kfree(data);
267 return err;
268 }
269
nvme_hwmon_exit(struct nvme_ctrl * ctrl)270 void nvme_hwmon_exit(struct nvme_ctrl *ctrl)
271 {
272 if (ctrl->hwmon_device) {
273 struct nvme_hwmon_data *data =
274 dev_get_drvdata(ctrl->hwmon_device);
275
276 hwmon_device_unregister(ctrl->hwmon_device);
277 ctrl->hwmon_device = NULL;
278 kfree(data->log);
279 kfree(data);
280 }
281 }
282