Commit | Line | Data |
---|---|---|
55c5e0f8 BH |
1 | /**************************************************************************** |
2 | * Driver for Solarflare Solarstorm network controllers and boards | |
3 | * Copyright 2011 Solarflare Communications Inc. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify it | |
6 | * under the terms of the GNU General Public License version 2 as published | |
7 | * by the Free Software Foundation, incorporated herein by reference. | |
8 | */ | |
9 | ||
10 | #include <linux/bitops.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/hwmon.h> | |
13 | #include <linux/stat.h> | |
14 | ||
15 | #include "net_driver.h" | |
16 | #include "mcdi.h" | |
17 | #include "mcdi_pcol.h" | |
18 | #include "nic.h" | |
19 | ||
20 | enum efx_hwmon_type { | |
21 | EFX_HWMON_UNKNOWN, | |
22 | EFX_HWMON_TEMP, /* temperature */ | |
23 | EFX_HWMON_COOL, /* cooling device, probably a heatsink */ | |
24 | EFX_HWMON_IN /* input voltage */ | |
25 | }; | |
26 | ||
27 | static const struct { | |
28 | const char *label; | |
29 | enum efx_hwmon_type hwmon_type; | |
30 | int port; | |
31 | } efx_mcdi_sensor_type[MC_CMD_SENSOR_ENTRY_MAXNUM] = { | |
32 | #define SENSOR(name, label, hwmon_type, port) \ | |
33 | [MC_CMD_SENSOR_##name] = { label, hwmon_type, port } | |
34 | SENSOR(CONTROLLER_TEMP, "Controller temp.", EFX_HWMON_TEMP, -1), | |
35 | SENSOR(PHY_COMMON_TEMP, "PHY temp.", EFX_HWMON_TEMP, -1), | |
36 | SENSOR(CONTROLLER_COOLING, "Controller cooling", EFX_HWMON_COOL, -1), | |
37 | SENSOR(PHY0_TEMP, "PHY temp.", EFX_HWMON_TEMP, 0), | |
38 | SENSOR(PHY0_COOLING, "PHY cooling", EFX_HWMON_COOL, 0), | |
39 | SENSOR(PHY1_TEMP, "PHY temp.", EFX_HWMON_TEMP, 1), | |
2d0cc56d | 40 | SENSOR(PHY1_COOLING, "PHY cooling", EFX_HWMON_COOL, 1), |
55c5e0f8 BH |
41 | SENSOR(IN_1V0, "1.0V supply", EFX_HWMON_IN, -1), |
42 | SENSOR(IN_1V2, "1.2V supply", EFX_HWMON_IN, -1), | |
43 | SENSOR(IN_1V8, "1.8V supply", EFX_HWMON_IN, -1), | |
44 | SENSOR(IN_2V5, "2.5V supply", EFX_HWMON_IN, -1), | |
45 | SENSOR(IN_3V3, "3.3V supply", EFX_HWMON_IN, -1), | |
46 | SENSOR(IN_12V0, "12.0V supply", EFX_HWMON_IN, -1), | |
47 | SENSOR(IN_1V2A, "1.2V analogue supply", EFX_HWMON_IN, -1), | |
48 | SENSOR(IN_VREF, "ref. voltage", EFX_HWMON_IN, -1), | |
49 | #undef SENSOR | |
50 | }; | |
51 | ||
52 | static const char *const sensor_status_names[] = { | |
53 | [MC_CMD_SENSOR_STATE_OK] = "OK", | |
54 | [MC_CMD_SENSOR_STATE_WARNING] = "Warning", | |
55 | [MC_CMD_SENSOR_STATE_FATAL] = "Fatal", | |
56 | [MC_CMD_SENSOR_STATE_BROKEN] = "Device failure", | |
57 | }; | |
58 | ||
59 | void efx_mcdi_sensor_event(struct efx_nic *efx, efx_qword_t *ev) | |
60 | { | |
61 | unsigned int type, state, value; | |
62 | const char *name = NULL, *state_txt; | |
63 | ||
64 | type = EFX_QWORD_FIELD(*ev, MCDI_EVENT_SENSOREVT_MONITOR); | |
65 | state = EFX_QWORD_FIELD(*ev, MCDI_EVENT_SENSOREVT_STATE); | |
66 | value = EFX_QWORD_FIELD(*ev, MCDI_EVENT_SENSOREVT_VALUE); | |
67 | ||
68 | /* Deal gracefully with the board having more drivers than we | |
69 | * know about, but do not expect new sensor states. */ | |
70 | if (type < ARRAY_SIZE(efx_mcdi_sensor_type)) | |
71 | name = efx_mcdi_sensor_type[type].label; | |
72 | if (!name) | |
73 | name = "No sensor name available"; | |
74 | EFX_BUG_ON_PARANOID(state >= ARRAY_SIZE(sensor_status_names)); | |
75 | state_txt = sensor_status_names[state]; | |
76 | ||
77 | netif_err(efx, hw, efx->net_dev, | |
78 | "Sensor %d (%s) reports condition '%s' for raw value %d\n", | |
79 | type, name, state_txt, value); | |
80 | } | |
81 | ||
82 | #ifdef CONFIG_SFC_MCDI_MON | |
83 | ||
84 | struct efx_mcdi_mon_attribute { | |
85 | struct device_attribute dev_attr; | |
86 | unsigned int index; | |
87 | unsigned int type; | |
88 | unsigned int limit_value; | |
89 | char name[12]; | |
90 | }; | |
91 | ||
92 | static int efx_mcdi_mon_update(struct efx_nic *efx) | |
93 | { | |
94 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); | |
95 | u8 inbuf[MC_CMD_READ_SENSORS_IN_LEN]; | |
96 | int rc; | |
97 | ||
98 | MCDI_SET_DWORD(inbuf, READ_SENSORS_IN_DMA_ADDR_LO, | |
99 | hwmon->dma_buf.dma_addr & 0xffffffff); | |
100 | MCDI_SET_DWORD(inbuf, READ_SENSORS_IN_DMA_ADDR_HI, | |
101 | (u64)hwmon->dma_buf.dma_addr >> 32); | |
102 | ||
103 | rc = efx_mcdi_rpc(efx, MC_CMD_READ_SENSORS, | |
104 | inbuf, sizeof(inbuf), NULL, 0, NULL); | |
105 | if (rc == 0) | |
106 | hwmon->last_update = jiffies; | |
107 | return rc; | |
108 | } | |
109 | ||
110 | static ssize_t efx_mcdi_mon_show_name(struct device *dev, | |
111 | struct device_attribute *attr, | |
112 | char *buf) | |
113 | { | |
114 | return sprintf(buf, "%s\n", KBUILD_MODNAME); | |
115 | } | |
116 | ||
117 | static int efx_mcdi_mon_get_entry(struct device *dev, unsigned int index, | |
118 | efx_dword_t *entry) | |
119 | { | |
120 | struct efx_nic *efx = dev_get_drvdata(dev); | |
121 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); | |
122 | int rc; | |
123 | ||
124 | BUILD_BUG_ON(MC_CMD_READ_SENSORS_OUT_LEN != 0); | |
125 | ||
126 | mutex_lock(&hwmon->update_lock); | |
127 | ||
128 | /* Use cached value if last update was < 1 s ago */ | |
129 | if (time_before(jiffies, hwmon->last_update + HZ)) | |
130 | rc = 0; | |
131 | else | |
132 | rc = efx_mcdi_mon_update(efx); | |
133 | ||
134 | /* Copy out the requested entry */ | |
135 | *entry = ((efx_dword_t *)hwmon->dma_buf.addr)[index]; | |
136 | ||
137 | mutex_unlock(&hwmon->update_lock); | |
138 | ||
139 | return rc; | |
140 | } | |
141 | ||
142 | static ssize_t efx_mcdi_mon_show_value(struct device *dev, | |
143 | struct device_attribute *attr, | |
144 | char *buf) | |
145 | { | |
146 | struct efx_mcdi_mon_attribute *mon_attr = | |
147 | container_of(attr, struct efx_mcdi_mon_attribute, dev_attr); | |
148 | efx_dword_t entry; | |
149 | unsigned int value; | |
150 | int rc; | |
151 | ||
152 | rc = efx_mcdi_mon_get_entry(dev, mon_attr->index, &entry); | |
153 | if (rc) | |
154 | return rc; | |
155 | ||
156 | value = EFX_DWORD_FIELD(entry, MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_VALUE); | |
157 | ||
158 | /* Convert temperature from degrees to milli-degrees Celsius */ | |
159 | if (efx_mcdi_sensor_type[mon_attr->type].hwmon_type == EFX_HWMON_TEMP) | |
160 | value *= 1000; | |
161 | ||
162 | return sprintf(buf, "%u\n", value); | |
163 | } | |
164 | ||
165 | static ssize_t efx_mcdi_mon_show_limit(struct device *dev, | |
166 | struct device_attribute *attr, | |
167 | char *buf) | |
168 | { | |
169 | struct efx_mcdi_mon_attribute *mon_attr = | |
170 | container_of(attr, struct efx_mcdi_mon_attribute, dev_attr); | |
171 | unsigned int value; | |
172 | ||
173 | value = mon_attr->limit_value; | |
174 | ||
175 | /* Convert temperature from degrees to milli-degrees Celsius */ | |
176 | if (efx_mcdi_sensor_type[mon_attr->type].hwmon_type == EFX_HWMON_TEMP) | |
177 | value *= 1000; | |
178 | ||
179 | return sprintf(buf, "%u\n", value); | |
180 | } | |
181 | ||
182 | static ssize_t efx_mcdi_mon_show_alarm(struct device *dev, | |
183 | struct device_attribute *attr, | |
184 | char *buf) | |
185 | { | |
186 | struct efx_mcdi_mon_attribute *mon_attr = | |
187 | container_of(attr, struct efx_mcdi_mon_attribute, dev_attr); | |
188 | efx_dword_t entry; | |
189 | int state; | |
190 | int rc; | |
191 | ||
192 | rc = efx_mcdi_mon_get_entry(dev, mon_attr->index, &entry); | |
193 | if (rc) | |
194 | return rc; | |
195 | ||
196 | state = EFX_DWORD_FIELD(entry, MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_STATE); | |
197 | return sprintf(buf, "%d\n", state != MC_CMD_SENSOR_STATE_OK); | |
198 | } | |
199 | ||
200 | static ssize_t efx_mcdi_mon_show_label(struct device *dev, | |
201 | struct device_attribute *attr, | |
202 | char *buf) | |
203 | { | |
204 | struct efx_mcdi_mon_attribute *mon_attr = | |
205 | container_of(attr, struct efx_mcdi_mon_attribute, dev_attr); | |
206 | return sprintf(buf, "%s\n", | |
207 | efx_mcdi_sensor_type[mon_attr->type].label); | |
208 | } | |
209 | ||
210 | static int | |
211 | efx_mcdi_mon_add_attr(struct efx_nic *efx, const char *name, | |
212 | ssize_t (*reader)(struct device *, | |
213 | struct device_attribute *, char *), | |
214 | unsigned int index, unsigned int type, | |
215 | unsigned int limit_value) | |
216 | { | |
217 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); | |
218 | struct efx_mcdi_mon_attribute *attr = &hwmon->attrs[hwmon->n_attrs]; | |
219 | int rc; | |
220 | ||
221 | strlcpy(attr->name, name, sizeof(attr->name)); | |
222 | attr->index = index; | |
223 | attr->type = type; | |
224 | attr->limit_value = limit_value; | |
a9ec6bd1 | 225 | sysfs_attr_init(&attr->dev_attr.attr); |
55c5e0f8 BH |
226 | attr->dev_attr.attr.name = attr->name; |
227 | attr->dev_attr.attr.mode = S_IRUGO; | |
228 | attr->dev_attr.show = reader; | |
229 | rc = device_create_file(&efx->pci_dev->dev, &attr->dev_attr); | |
230 | if (rc == 0) | |
231 | ++hwmon->n_attrs; | |
232 | return rc; | |
233 | } | |
234 | ||
235 | int efx_mcdi_mon_probe(struct efx_nic *efx) | |
236 | { | |
237 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); | |
238 | unsigned int n_attrs, n_temp = 0, n_cool = 0, n_in = 0; | |
239 | u8 outbuf[MC_CMD_SENSOR_INFO_OUT_LENMAX]; | |
240 | size_t outlen; | |
241 | char name[12]; | |
242 | u32 mask; | |
243 | int rc, i, type; | |
244 | ||
245 | BUILD_BUG_ON(MC_CMD_SENSOR_INFO_IN_LEN != 0); | |
246 | ||
247 | rc = efx_mcdi_rpc(efx, MC_CMD_SENSOR_INFO, NULL, 0, | |
248 | outbuf, sizeof(outbuf), &outlen); | |
249 | if (rc) | |
250 | return rc; | |
251 | if (outlen < MC_CMD_SENSOR_INFO_OUT_LENMIN) | |
252 | return -EIO; | |
253 | ||
254 | /* Find out which sensors are present. Don't create a device | |
255 | * if there are none. | |
256 | */ | |
257 | mask = MCDI_DWORD(outbuf, SENSOR_INFO_OUT_MASK); | |
258 | if (mask == 0) | |
259 | return 0; | |
260 | ||
261 | /* Check again for short response */ | |
262 | if (outlen < MC_CMD_SENSOR_INFO_OUT_LEN(hweight32(mask))) | |
263 | return -EIO; | |
264 | ||
265 | rc = efx_nic_alloc_buffer(efx, &hwmon->dma_buf, | |
266 | 4 * MC_CMD_SENSOR_ENTRY_MAXNUM); | |
267 | if (rc) | |
268 | return rc; | |
269 | ||
270 | mutex_init(&hwmon->update_lock); | |
271 | efx_mcdi_mon_update(efx); | |
272 | ||
273 | /* Allocate space for the maximum possible number of | |
274 | * attributes for this set of sensors: name of the driver plus | |
275 | * value, min, max, crit, alarm and label for each sensor. | |
276 | */ | |
277 | n_attrs = 1 + 6 * hweight32(mask); | |
278 | hwmon->attrs = kcalloc(n_attrs, sizeof(*hwmon->attrs), GFP_KERNEL); | |
279 | if (!hwmon->attrs) { | |
280 | rc = -ENOMEM; | |
281 | goto fail; | |
282 | } | |
283 | ||
284 | hwmon->device = hwmon_device_register(&efx->pci_dev->dev); | |
285 | if (IS_ERR(hwmon->device)) { | |
286 | rc = PTR_ERR(hwmon->device); | |
287 | goto fail; | |
288 | } | |
289 | ||
290 | rc = efx_mcdi_mon_add_attr(efx, "name", efx_mcdi_mon_show_name, 0, 0, 0); | |
291 | if (rc) | |
292 | goto fail; | |
293 | ||
294 | for (i = 0, type = -1; ; i++) { | |
295 | const char *hwmon_prefix; | |
296 | unsigned hwmon_index; | |
297 | u16 min1, max1, min2, max2; | |
298 | ||
299 | /* Find next sensor type or exit if there is none */ | |
300 | type++; | |
301 | while (!(mask & (1 << type))) { | |
302 | type++; | |
303 | if (type == 32) | |
304 | return 0; | |
305 | } | |
306 | ||
307 | /* Skip sensors specific to a different port */ | |
308 | if (efx_mcdi_sensor_type[type].hwmon_type != EFX_HWMON_UNKNOWN && | |
309 | efx_mcdi_sensor_type[type].port >= 0 && | |
310 | efx_mcdi_sensor_type[type].port != efx_port_num(efx)) | |
311 | continue; | |
312 | ||
313 | switch (efx_mcdi_sensor_type[type].hwmon_type) { | |
314 | case EFX_HWMON_TEMP: | |
315 | hwmon_prefix = "temp"; | |
316 | hwmon_index = ++n_temp; /* 1-based */ | |
317 | break; | |
318 | case EFX_HWMON_COOL: | |
319 | /* This is likely to be a heatsink, but there | |
320 | * is no convention for representing cooling | |
321 | * devices other than fans. | |
322 | */ | |
323 | hwmon_prefix = "fan"; | |
324 | hwmon_index = ++n_cool; /* 1-based */ | |
325 | break; | |
326 | default: | |
327 | hwmon_prefix = "in"; | |
328 | hwmon_index = n_in++; /* 0-based */ | |
329 | break; | |
330 | } | |
331 | ||
332 | min1 = MCDI_ARRAY_FIELD(outbuf, SENSOR_ENTRY, | |
333 | SENSOR_INFO_ENTRY, i, MIN1); | |
334 | max1 = MCDI_ARRAY_FIELD(outbuf, SENSOR_ENTRY, | |
335 | SENSOR_INFO_ENTRY, i, MAX1); | |
336 | min2 = MCDI_ARRAY_FIELD(outbuf, SENSOR_ENTRY, | |
337 | SENSOR_INFO_ENTRY, i, MIN2); | |
338 | max2 = MCDI_ARRAY_FIELD(outbuf, SENSOR_ENTRY, | |
339 | SENSOR_INFO_ENTRY, i, MAX2); | |
340 | ||
341 | if (min1 != max1) { | |
342 | snprintf(name, sizeof(name), "%s%u_input", | |
343 | hwmon_prefix, hwmon_index); | |
344 | rc = efx_mcdi_mon_add_attr( | |
345 | efx, name, efx_mcdi_mon_show_value, i, type, 0); | |
346 | if (rc) | |
347 | goto fail; | |
348 | ||
349 | snprintf(name, sizeof(name), "%s%u_min", | |
350 | hwmon_prefix, hwmon_index); | |
351 | rc = efx_mcdi_mon_add_attr( | |
352 | efx, name, efx_mcdi_mon_show_limit, | |
353 | i, type, min1); | |
354 | if (rc) | |
355 | goto fail; | |
356 | ||
357 | snprintf(name, sizeof(name), "%s%u_max", | |
358 | hwmon_prefix, hwmon_index); | |
359 | rc = efx_mcdi_mon_add_attr( | |
360 | efx, name, efx_mcdi_mon_show_limit, | |
361 | i, type, max1); | |
362 | if (rc) | |
363 | goto fail; | |
364 | ||
365 | if (min2 != max2) { | |
366 | /* Assume max2 is critical value. | |
367 | * But we have no good way to expose min2. | |
368 | */ | |
369 | snprintf(name, sizeof(name), "%s%u_crit", | |
370 | hwmon_prefix, hwmon_index); | |
371 | rc = efx_mcdi_mon_add_attr( | |
372 | efx, name, efx_mcdi_mon_show_limit, | |
373 | i, type, max2); | |
374 | if (rc) | |
375 | goto fail; | |
376 | } | |
377 | } | |
378 | ||
379 | snprintf(name, sizeof(name), "%s%u_alarm", | |
380 | hwmon_prefix, hwmon_index); | |
381 | rc = efx_mcdi_mon_add_attr( | |
382 | efx, name, efx_mcdi_mon_show_alarm, i, type, 0); | |
383 | if (rc) | |
384 | goto fail; | |
385 | ||
386 | if (efx_mcdi_sensor_type[type].label) { | |
387 | snprintf(name, sizeof(name), "%s%u_label", | |
388 | hwmon_prefix, hwmon_index); | |
389 | rc = efx_mcdi_mon_add_attr( | |
390 | efx, name, efx_mcdi_mon_show_label, i, type, 0); | |
391 | if (rc) | |
392 | goto fail; | |
393 | } | |
394 | } | |
395 | ||
396 | fail: | |
397 | efx_mcdi_mon_remove(efx); | |
398 | return rc; | |
399 | } | |
400 | ||
401 | void efx_mcdi_mon_remove(struct efx_nic *efx) | |
402 | { | |
403 | struct siena_nic_data *nic_data = efx->nic_data; | |
404 | struct efx_mcdi_mon *hwmon = &nic_data->hwmon; | |
405 | unsigned int i; | |
406 | ||
407 | for (i = 0; i < hwmon->n_attrs; i++) | |
408 | device_remove_file(&efx->pci_dev->dev, | |
409 | &hwmon->attrs[i].dev_attr); | |
410 | kfree(hwmon->attrs); | |
411 | if (hwmon->device) | |
412 | hwmon_device_unregister(hwmon->device); | |
413 | efx_nic_free_buffer(efx, &hwmon->dma_buf); | |
414 | } | |
415 | ||
416 | #endif /* CONFIG_SFC_MCDI_MON */ |