1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /**************************************************************************** |
3 | * Driver for Solarflare network controllers and boards |
4 | * Copyright 2011-2013 Solarflare Communications Inc. |
5 | */ |
6 | |
7 | #include <linux/bitops.h> |
8 | #include <linux/slab.h> |
9 | #include <linux/hwmon.h> |
10 | #include <linux/stat.h> |
11 | |
12 | #include "net_driver.h" |
13 | #include "mcdi.h" |
14 | #include "mcdi_pcol.h" |
15 | #include "nic.h" |
16 | |
17 | enum efx_hwmon_type { |
18 | EFX_HWMON_UNKNOWN, |
19 | EFX_HWMON_TEMP, /* temperature */ |
20 | EFX_HWMON_COOL, /* cooling device, probably a heatsink */ |
21 | EFX_HWMON_IN, /* voltage */ |
22 | EFX_HWMON_CURR, /* current */ |
23 | EFX_HWMON_POWER, /* power */ |
24 | EFX_HWMON_TYPES_COUNT |
25 | }; |
26 | |
27 | static const char *const efx_hwmon_unit[EFX_HWMON_TYPES_COUNT] = { |
28 | [EFX_HWMON_TEMP] = " degC" , |
29 | [EFX_HWMON_COOL] = " rpm" , /* though nonsense for a heatsink */ |
30 | [EFX_HWMON_IN] = " mV" , |
31 | [EFX_HWMON_CURR] = " mA" , |
32 | [EFX_HWMON_POWER] = " W" , |
33 | }; |
34 | |
35 | static const struct { |
36 | const char *label; |
37 | enum efx_hwmon_type hwmon_type; |
38 | int port; |
39 | } efx_mcdi_sensor_type[] = { |
40 | #define SENSOR(name, label, hwmon_type, port) \ |
41 | [MC_CMD_SENSOR_##name] = { label, EFX_HWMON_ ## hwmon_type, port } |
42 | SENSOR(CONTROLLER_TEMP, "Controller board temp." , TEMP, -1), |
43 | SENSOR(PHY_COMMON_TEMP, "PHY temp." , TEMP, -1), |
44 | SENSOR(CONTROLLER_COOLING, "Controller heat sink" , COOL, -1), |
45 | SENSOR(PHY0_TEMP, "PHY temp." , TEMP, 0), |
46 | SENSOR(PHY0_COOLING, "PHY heat sink" , COOL, 0), |
47 | SENSOR(PHY1_TEMP, "PHY temp." , TEMP, 1), |
48 | SENSOR(PHY1_COOLING, "PHY heat sink" , COOL, 1), |
49 | SENSOR(IN_1V0, "1.0V supply" , IN, -1), |
50 | SENSOR(IN_1V2, "1.2V supply" , IN, -1), |
51 | SENSOR(IN_1V8, "1.8V supply" , IN, -1), |
52 | SENSOR(IN_2V5, "2.5V supply" , IN, -1), |
53 | SENSOR(IN_3V3, "3.3V supply" , IN, -1), |
54 | SENSOR(IN_12V0, "12.0V supply" , IN, -1), |
55 | SENSOR(IN_1V2A, "1.2V analogue supply" , IN, -1), |
56 | SENSOR(IN_VREF, "Ref. voltage" , IN, -1), |
57 | SENSOR(OUT_VAOE, "AOE FPGA supply" , IN, -1), |
58 | SENSOR(AOE_TEMP, "AOE FPGA temp." , TEMP, -1), |
59 | SENSOR(PSU_AOE_TEMP, "AOE regulator temp." , TEMP, -1), |
60 | SENSOR(PSU_TEMP, "Controller regulator temp." , |
61 | TEMP, -1), |
62 | SENSOR(FAN_0, "Fan 0" , COOL, -1), |
63 | SENSOR(FAN_1, "Fan 1" , COOL, -1), |
64 | SENSOR(FAN_2, "Fan 2" , COOL, -1), |
65 | SENSOR(FAN_3, "Fan 3" , COOL, -1), |
66 | SENSOR(FAN_4, "Fan 4" , COOL, -1), |
67 | SENSOR(IN_VAOE, "AOE input supply" , IN, -1), |
68 | SENSOR(OUT_IAOE, "AOE output current" , CURR, -1), |
69 | SENSOR(IN_IAOE, "AOE input current" , CURR, -1), |
70 | SENSOR(NIC_POWER, "Board power use" , POWER, -1), |
71 | SENSOR(IN_0V9, "0.9V supply" , IN, -1), |
72 | SENSOR(IN_I0V9, "0.9V supply current" , CURR, -1), |
73 | SENSOR(IN_I1V2, "1.2V supply current" , CURR, -1), |
74 | SENSOR(IN_0V9_ADC, "0.9V supply (ext. ADC)" , IN, -1), |
75 | SENSOR(CONTROLLER_2_TEMP, "Controller board temp. 2" , TEMP, -1), |
76 | SENSOR(VREG_INTERNAL_TEMP, "Regulator die temp." , TEMP, -1), |
77 | SENSOR(VREG_0V9_TEMP, "0.9V regulator temp." , TEMP, -1), |
78 | SENSOR(VREG_1V2_TEMP, "1.2V regulator temp." , TEMP, -1), |
79 | SENSOR(CONTROLLER_VPTAT, |
80 | "Controller PTAT voltage (int. ADC)" , IN, -1), |
81 | SENSOR(CONTROLLER_INTERNAL_TEMP, |
82 | "Controller die temp. (int. ADC)" , TEMP, -1), |
83 | SENSOR(CONTROLLER_VPTAT_EXTADC, |
84 | "Controller PTAT voltage (ext. ADC)" , IN, -1), |
85 | SENSOR(CONTROLLER_INTERNAL_TEMP_EXTADC, |
86 | "Controller die temp. (ext. ADC)" , TEMP, -1), |
87 | SENSOR(AMBIENT_TEMP, "Ambient temp." , TEMP, -1), |
88 | SENSOR(AIRFLOW, "Air flow raw" , IN, -1), |
89 | SENSOR(VDD08D_VSS08D_CSR, "0.9V die (int. ADC)" , IN, -1), |
90 | SENSOR(VDD08D_VSS08D_CSR_EXTADC, "0.9V die (ext. ADC)" , IN, -1), |
91 | SENSOR(HOTPOINT_TEMP, "Controller board temp. (hotpoint)" , TEMP, -1), |
92 | #undef SENSOR |
93 | }; |
94 | |
95 | static const char *const sensor_status_names[] = { |
96 | [MC_CMD_SENSOR_STATE_OK] = "OK" , |
97 | [MC_CMD_SENSOR_STATE_WARNING] = "Warning" , |
98 | [MC_CMD_SENSOR_STATE_FATAL] = "Fatal" , |
99 | [MC_CMD_SENSOR_STATE_BROKEN] = "Device failure" , |
100 | [MC_CMD_SENSOR_STATE_NO_READING] = "No reading" , |
101 | }; |
102 | |
103 | void efx_mcdi_sensor_event(struct efx_nic *efx, efx_qword_t *ev) |
104 | { |
105 | unsigned int type, state, value; |
106 | enum efx_hwmon_type hwmon_type = EFX_HWMON_UNKNOWN; |
107 | const char *name = NULL, *state_txt, *unit; |
108 | |
109 | type = EFX_QWORD_FIELD(*ev, MCDI_EVENT_SENSOREVT_MONITOR); |
110 | state = EFX_QWORD_FIELD(*ev, MCDI_EVENT_SENSOREVT_STATE); |
111 | value = EFX_QWORD_FIELD(*ev, MCDI_EVENT_SENSOREVT_VALUE); |
112 | |
113 | /* Deal gracefully with the board having more drivers than we |
114 | * know about, but do not expect new sensor states. */ |
115 | if (type < ARRAY_SIZE(efx_mcdi_sensor_type)) { |
116 | name = efx_mcdi_sensor_type[type].label; |
117 | hwmon_type = efx_mcdi_sensor_type[type].hwmon_type; |
118 | } |
119 | if (!name) |
120 | name = "No sensor name available" ; |
121 | EFX_WARN_ON_PARANOID(state >= ARRAY_SIZE(sensor_status_names)); |
122 | state_txt = sensor_status_names[state]; |
123 | EFX_WARN_ON_PARANOID(hwmon_type >= EFX_HWMON_TYPES_COUNT); |
124 | unit = efx_hwmon_unit[hwmon_type]; |
125 | if (!unit) |
126 | unit = "" ; |
127 | |
128 | netif_err(efx, hw, efx->net_dev, |
129 | "Sensor %d (%s) reports condition '%s' for value %d%s\n" , |
130 | type, name, state_txt, value, unit); |
131 | } |
132 | |
133 | #ifdef CONFIG_SFC_MCDI_MON |
134 | |
135 | struct efx_mcdi_mon_attribute { |
136 | struct device_attribute dev_attr; |
137 | unsigned int index; |
138 | unsigned int type; |
139 | enum efx_hwmon_type hwmon_type; |
140 | unsigned int limit_value; |
141 | char name[12]; |
142 | }; |
143 | |
144 | static int efx_mcdi_mon_update(struct efx_nic *efx) |
145 | { |
146 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); |
147 | MCDI_DECLARE_BUF(inbuf, MC_CMD_READ_SENSORS_EXT_IN_LEN); |
148 | int rc; |
149 | |
150 | MCDI_SET_QWORD(inbuf, READ_SENSORS_EXT_IN_DMA_ADDR, |
151 | hwmon->dma_buf.dma_addr); |
152 | MCDI_SET_DWORD(inbuf, READ_SENSORS_EXT_IN_LENGTH, hwmon->dma_buf.len); |
153 | |
154 | rc = efx_mcdi_rpc(efx, MC_CMD_READ_SENSORS, |
155 | inbuf, inlen: sizeof(inbuf), NULL, outlen: 0, NULL); |
156 | if (rc == 0) |
157 | hwmon->last_update = jiffies; |
158 | return rc; |
159 | } |
160 | |
161 | static int efx_mcdi_mon_get_entry(struct device *dev, unsigned int index, |
162 | efx_dword_t *entry) |
163 | { |
164 | struct efx_nic *efx = dev_get_drvdata(dev: dev->parent); |
165 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); |
166 | int rc; |
167 | |
168 | BUILD_BUG_ON(MC_CMD_READ_SENSORS_OUT_LEN != 0); |
169 | |
170 | mutex_lock(&hwmon->update_lock); |
171 | |
172 | /* Use cached value if last update was < 1 s ago */ |
173 | if (time_before(jiffies, hwmon->last_update + HZ)) |
174 | rc = 0; |
175 | else |
176 | rc = efx_mcdi_mon_update(efx); |
177 | |
178 | /* Copy out the requested entry */ |
179 | *entry = ((efx_dword_t *)hwmon->dma_buf.addr)[index]; |
180 | |
181 | mutex_unlock(lock: &hwmon->update_lock); |
182 | |
183 | return rc; |
184 | } |
185 | |
186 | static ssize_t efx_mcdi_mon_show_value(struct device *dev, |
187 | struct device_attribute *attr, |
188 | char *buf) |
189 | { |
190 | struct efx_mcdi_mon_attribute *mon_attr = |
191 | container_of(attr, struct efx_mcdi_mon_attribute, dev_attr); |
192 | efx_dword_t entry; |
193 | unsigned int value, state; |
194 | int rc; |
195 | |
196 | rc = efx_mcdi_mon_get_entry(dev, index: mon_attr->index, entry: &entry); |
197 | if (rc) |
198 | return rc; |
199 | |
200 | state = EFX_DWORD_FIELD(entry, MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_STATE); |
201 | if (state == MC_CMD_SENSOR_STATE_NO_READING) |
202 | return -EBUSY; |
203 | |
204 | value = EFX_DWORD_FIELD(entry, MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_VALUE); |
205 | |
206 | switch (mon_attr->hwmon_type) { |
207 | case EFX_HWMON_TEMP: |
208 | /* Convert temperature from degrees to milli-degrees Celsius */ |
209 | value *= 1000; |
210 | break; |
211 | case EFX_HWMON_POWER: |
212 | /* Convert power from watts to microwatts */ |
213 | value *= 1000000; |
214 | break; |
215 | default: |
216 | /* No conversion needed */ |
217 | break; |
218 | } |
219 | |
220 | return sprintf(buf, fmt: "%u\n" , value); |
221 | } |
222 | |
223 | static ssize_t efx_mcdi_mon_show_limit(struct device *dev, |
224 | struct device_attribute *attr, |
225 | char *buf) |
226 | { |
227 | struct efx_mcdi_mon_attribute *mon_attr = |
228 | container_of(attr, struct efx_mcdi_mon_attribute, dev_attr); |
229 | unsigned int value; |
230 | |
231 | value = mon_attr->limit_value; |
232 | |
233 | switch (mon_attr->hwmon_type) { |
234 | case EFX_HWMON_TEMP: |
235 | /* Convert temperature from degrees to milli-degrees Celsius */ |
236 | value *= 1000; |
237 | break; |
238 | case EFX_HWMON_POWER: |
239 | /* Convert power from watts to microwatts */ |
240 | value *= 1000000; |
241 | break; |
242 | default: |
243 | /* No conversion needed */ |
244 | break; |
245 | } |
246 | |
247 | return sprintf(buf, fmt: "%u\n" , value); |
248 | } |
249 | |
250 | static ssize_t efx_mcdi_mon_show_alarm(struct device *dev, |
251 | struct device_attribute *attr, |
252 | char *buf) |
253 | { |
254 | struct efx_mcdi_mon_attribute *mon_attr = |
255 | container_of(attr, struct efx_mcdi_mon_attribute, dev_attr); |
256 | efx_dword_t entry; |
257 | int state; |
258 | int rc; |
259 | |
260 | rc = efx_mcdi_mon_get_entry(dev, index: mon_attr->index, entry: &entry); |
261 | if (rc) |
262 | return rc; |
263 | |
264 | state = EFX_DWORD_FIELD(entry, MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_STATE); |
265 | return sprintf(buf, fmt: "%d\n" , state != MC_CMD_SENSOR_STATE_OK); |
266 | } |
267 | |
268 | static ssize_t efx_mcdi_mon_show_label(struct device *dev, |
269 | struct device_attribute *attr, |
270 | char *buf) |
271 | { |
272 | struct efx_mcdi_mon_attribute *mon_attr = |
273 | container_of(attr, struct efx_mcdi_mon_attribute, dev_attr); |
274 | return sprintf(buf, fmt: "%s\n" , |
275 | efx_mcdi_sensor_type[mon_attr->type].label); |
276 | } |
277 | |
278 | static void |
279 | efx_mcdi_mon_add_attr(struct efx_nic *efx, const char *name, |
280 | ssize_t (*reader)(struct device *, |
281 | struct device_attribute *, char *), |
282 | unsigned int index, unsigned int type, |
283 | unsigned int limit_value) |
284 | { |
285 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); |
286 | struct efx_mcdi_mon_attribute *attr = &hwmon->attrs[hwmon->n_attrs]; |
287 | |
288 | strscpy(p: attr->name, q: name, size: sizeof(attr->name)); |
289 | attr->index = index; |
290 | attr->type = type; |
291 | if (type < ARRAY_SIZE(efx_mcdi_sensor_type)) |
292 | attr->hwmon_type = efx_mcdi_sensor_type[type].hwmon_type; |
293 | else |
294 | attr->hwmon_type = EFX_HWMON_UNKNOWN; |
295 | attr->limit_value = limit_value; |
296 | sysfs_attr_init(&attr->dev_attr.attr); |
297 | attr->dev_attr.attr.name = attr->name; |
298 | attr->dev_attr.attr.mode = 0444; |
299 | attr->dev_attr.show = reader; |
300 | hwmon->group.attrs[hwmon->n_attrs++] = &attr->dev_attr.attr; |
301 | } |
302 | |
303 | int efx_mcdi_mon_probe(struct efx_nic *efx) |
304 | { |
305 | unsigned int n_temp = 0, n_cool = 0, n_in = 0, n_curr = 0, n_power = 0; |
306 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); |
307 | MCDI_DECLARE_BUF(inbuf, MC_CMD_SENSOR_INFO_EXT_IN_LEN); |
308 | MCDI_DECLARE_BUF(outbuf, MC_CMD_SENSOR_INFO_OUT_LENMAX); |
309 | unsigned int n_pages, n_sensors, n_attrs, page; |
310 | size_t outlen; |
311 | char name[12]; |
312 | u32 mask; |
313 | int rc, i, j, type; |
314 | |
315 | /* Find out how many sensors are present */ |
316 | n_sensors = 0; |
317 | page = 0; |
318 | do { |
319 | MCDI_SET_DWORD(inbuf, SENSOR_INFO_EXT_IN_PAGE, page); |
320 | |
321 | rc = efx_mcdi_rpc(efx, MC_CMD_SENSOR_INFO, inbuf, inlen: sizeof(inbuf), |
322 | outbuf, outlen: sizeof(outbuf), outlen_actual: &outlen); |
323 | if (rc) |
324 | return rc; |
325 | if (outlen < MC_CMD_SENSOR_INFO_OUT_LENMIN) |
326 | return -EIO; |
327 | |
328 | mask = MCDI_DWORD(outbuf, SENSOR_INFO_OUT_MASK); |
329 | n_sensors += hweight32(mask & ~(1 << MC_CMD_SENSOR_PAGE0_NEXT)); |
330 | ++page; |
331 | } while (mask & (1 << MC_CMD_SENSOR_PAGE0_NEXT)); |
332 | n_pages = page; |
333 | |
334 | /* Don't create a device if there are none */ |
335 | if (n_sensors == 0) |
336 | return 0; |
337 | |
338 | rc = efx_nic_alloc_buffer( |
339 | efx, buffer: &hwmon->dma_buf, |
340 | len: n_sensors * MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_LEN, |
341 | GFP_KERNEL); |
342 | if (rc) |
343 | return rc; |
344 | |
345 | mutex_init(&hwmon->update_lock); |
346 | efx_mcdi_mon_update(efx); |
347 | |
348 | /* Allocate space for the maximum possible number of |
349 | * attributes for this set of sensors: |
350 | * value, min, max, crit, alarm and label for each sensor. |
351 | */ |
352 | n_attrs = 6 * n_sensors; |
353 | hwmon->attrs = kcalloc(n: n_attrs, size: sizeof(*hwmon->attrs), GFP_KERNEL); |
354 | if (!hwmon->attrs) { |
355 | rc = -ENOMEM; |
356 | goto fail; |
357 | } |
358 | hwmon->group.attrs = kcalloc(n: n_attrs + 1, size: sizeof(struct attribute *), |
359 | GFP_KERNEL); |
360 | if (!hwmon->group.attrs) { |
361 | rc = -ENOMEM; |
362 | goto fail; |
363 | } |
364 | |
365 | for (i = 0, j = -1, type = -1; ; i++) { |
366 | enum efx_hwmon_type hwmon_type; |
367 | const char *hwmon_prefix; |
368 | unsigned hwmon_index; |
369 | u16 min1, max1, min2, max2; |
370 | |
371 | /* Find next sensor type or exit if there is none */ |
372 | do { |
373 | type++; |
374 | |
375 | if ((type % 32) == 0) { |
376 | page = type / 32; |
377 | j = -1; |
378 | if (page == n_pages) |
379 | goto hwmon_register; |
380 | |
381 | MCDI_SET_DWORD(inbuf, SENSOR_INFO_EXT_IN_PAGE, |
382 | page); |
383 | rc = efx_mcdi_rpc(efx, MC_CMD_SENSOR_INFO, |
384 | inbuf, inlen: sizeof(inbuf), |
385 | outbuf, outlen: sizeof(outbuf), |
386 | outlen_actual: &outlen); |
387 | if (rc) |
388 | goto fail; |
389 | if (outlen < MC_CMD_SENSOR_INFO_OUT_LENMIN) { |
390 | rc = -EIO; |
391 | goto fail; |
392 | } |
393 | |
394 | mask = (MCDI_DWORD(outbuf, |
395 | SENSOR_INFO_OUT_MASK) & |
396 | ~(1 << MC_CMD_SENSOR_PAGE0_NEXT)); |
397 | |
398 | /* Check again for short response */ |
399 | if (outlen < |
400 | MC_CMD_SENSOR_INFO_OUT_LEN(hweight32(mask))) { |
401 | rc = -EIO; |
402 | goto fail; |
403 | } |
404 | } |
405 | } while (!(mask & (1 << type % 32))); |
406 | j++; |
407 | |
408 | if (type < ARRAY_SIZE(efx_mcdi_sensor_type)) { |
409 | hwmon_type = efx_mcdi_sensor_type[type].hwmon_type; |
410 | |
411 | /* Skip sensors specific to a different port */ |
412 | if (hwmon_type != EFX_HWMON_UNKNOWN && |
413 | efx_mcdi_sensor_type[type].port >= 0 && |
414 | efx_mcdi_sensor_type[type].port != |
415 | efx_port_num(efx)) |
416 | continue; |
417 | } else { |
418 | hwmon_type = EFX_HWMON_UNKNOWN; |
419 | } |
420 | |
421 | switch (hwmon_type) { |
422 | case EFX_HWMON_TEMP: |
423 | hwmon_prefix = "temp" ; |
424 | hwmon_index = ++n_temp; /* 1-based */ |
425 | break; |
426 | case EFX_HWMON_COOL: |
427 | /* This is likely to be a heatsink, but there |
428 | * is no convention for representing cooling |
429 | * devices other than fans. |
430 | */ |
431 | hwmon_prefix = "fan" ; |
432 | hwmon_index = ++n_cool; /* 1-based */ |
433 | break; |
434 | default: |
435 | hwmon_prefix = "in" ; |
436 | hwmon_index = n_in++; /* 0-based */ |
437 | break; |
438 | case EFX_HWMON_CURR: |
439 | hwmon_prefix = "curr" ; |
440 | hwmon_index = ++n_curr; /* 1-based */ |
441 | break; |
442 | case EFX_HWMON_POWER: |
443 | hwmon_prefix = "power" ; |
444 | hwmon_index = ++n_power; /* 1-based */ |
445 | break; |
446 | } |
447 | |
448 | min1 = MCDI_ARRAY_FIELD(outbuf, SENSOR_ENTRY, |
449 | SENSOR_INFO_ENTRY, j, MIN1); |
450 | max1 = MCDI_ARRAY_FIELD(outbuf, SENSOR_ENTRY, |
451 | SENSOR_INFO_ENTRY, j, MAX1); |
452 | min2 = MCDI_ARRAY_FIELD(outbuf, SENSOR_ENTRY, |
453 | SENSOR_INFO_ENTRY, j, MIN2); |
454 | max2 = MCDI_ARRAY_FIELD(outbuf, SENSOR_ENTRY, |
455 | SENSOR_INFO_ENTRY, j, MAX2); |
456 | |
457 | if (min1 != max1) { |
458 | snprintf(buf: name, size: sizeof(name), fmt: "%s%u_input" , |
459 | hwmon_prefix, hwmon_index); |
460 | efx_mcdi_mon_add_attr( |
461 | efx, name, reader: efx_mcdi_mon_show_value, index: i, type, limit_value: 0); |
462 | |
463 | if (hwmon_type != EFX_HWMON_POWER) { |
464 | snprintf(buf: name, size: sizeof(name), fmt: "%s%u_min" , |
465 | hwmon_prefix, hwmon_index); |
466 | efx_mcdi_mon_add_attr( |
467 | efx, name, reader: efx_mcdi_mon_show_limit, |
468 | index: i, type, limit_value: min1); |
469 | } |
470 | |
471 | snprintf(buf: name, size: sizeof(name), fmt: "%s%u_max" , |
472 | hwmon_prefix, hwmon_index); |
473 | efx_mcdi_mon_add_attr( |
474 | efx, name, reader: efx_mcdi_mon_show_limit, |
475 | index: i, type, limit_value: max1); |
476 | |
477 | if (min2 != max2) { |
478 | /* Assume max2 is critical value. |
479 | * But we have no good way to expose min2. |
480 | */ |
481 | snprintf(buf: name, size: sizeof(name), fmt: "%s%u_crit" , |
482 | hwmon_prefix, hwmon_index); |
483 | efx_mcdi_mon_add_attr( |
484 | efx, name, reader: efx_mcdi_mon_show_limit, |
485 | index: i, type, limit_value: max2); |
486 | } |
487 | } |
488 | |
489 | snprintf(buf: name, size: sizeof(name), fmt: "%s%u_alarm" , |
490 | hwmon_prefix, hwmon_index); |
491 | efx_mcdi_mon_add_attr( |
492 | efx, name, reader: efx_mcdi_mon_show_alarm, index: i, type, limit_value: 0); |
493 | |
494 | if (type < ARRAY_SIZE(efx_mcdi_sensor_type) && |
495 | efx_mcdi_sensor_type[type].label) { |
496 | snprintf(buf: name, size: sizeof(name), fmt: "%s%u_label" , |
497 | hwmon_prefix, hwmon_index); |
498 | efx_mcdi_mon_add_attr( |
499 | efx, name, reader: efx_mcdi_mon_show_label, index: i, type, limit_value: 0); |
500 | } |
501 | } |
502 | |
503 | hwmon_register: |
504 | hwmon->groups[0] = &hwmon->group; |
505 | hwmon->device = hwmon_device_register_with_groups(dev: &efx->pci_dev->dev, |
506 | KBUILD_MODNAME, NULL, |
507 | groups: hwmon->groups); |
508 | if (IS_ERR(ptr: hwmon->device)) { |
509 | rc = PTR_ERR(ptr: hwmon->device); |
510 | goto fail; |
511 | } |
512 | |
513 | return 0; |
514 | |
515 | fail: |
516 | efx_mcdi_mon_remove(efx); |
517 | return rc; |
518 | } |
519 | |
520 | void efx_mcdi_mon_remove(struct efx_nic *efx) |
521 | { |
522 | struct efx_mcdi_mon *hwmon = efx_mcdi_mon(efx); |
523 | |
524 | if (hwmon->device) |
525 | hwmon_device_unregister(dev: hwmon->device); |
526 | kfree(objp: hwmon->attrs); |
527 | kfree(objp: hwmon->group.attrs); |
528 | efx_nic_free_buffer(efx, buffer: &hwmon->dma_buf); |
529 | } |
530 | |
531 | #endif /* CONFIG_SFC_MCDI_MON */ |
532 | |