2 * Copyright (c) 2009-2016 Solarflare Communications Inc.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
15 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
21 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
22 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
24 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 * The views and conclusions contained in the software and documentation are
27 * those of the authors and should not be interpreted as representing official
28 * policies, either expressed or implied, of the FreeBSD Project.
34 #if EFSYS_OPT_MON_MCDI
36 #if EFSYS_OPT_MON_STATS
38 #define MCDI_MON_NEXT_PAGE ((uint16_t)0xfffe)
39 #define MCDI_MON_INVALID_SENSOR ((uint16_t)0xfffd)
40 #define MCDI_MON_PAGE_SIZE 0x20
42 /* Bitmasks of valid port(s) for each sensor */
43 #define MCDI_MON_PORT_NONE (0x00)
44 #define MCDI_MON_PORT_P1 (0x01)
45 #define MCDI_MON_PORT_P2 (0x02)
46 #define MCDI_MON_PORT_P3 (0x04)
47 #define MCDI_MON_PORT_P4 (0x08)
48 #define MCDI_MON_PORT_Px (0xFFFF)
50 /* Get port mask from one-based MCDI port number */
51 #define MCDI_MON_PORT_MASK(_emip) (1U << ((_emip)->emi_port - 1))
53 /* Entry for MCDI sensor in sensor map */
54 #define STAT(portmask, stat) \
55 { (MCDI_MON_PORT_##portmask), (EFX_MON_STAT_##stat) }
57 /* Entry for sensor next page flag in sensor map */
58 #define STAT_NEXT_PAGE() \
59 { MCDI_MON_PORT_NONE, MCDI_MON_NEXT_PAGE }
61 /* Placeholder for gaps in the array */
62 #define STAT_NO_SENSOR() \
63 { MCDI_MON_PORT_NONE, MCDI_MON_INVALID_SENSOR }
65 /* Map from MC sensors to monitor statistics */
66 static const struct mcdi_sensor_map_s
{
67 uint16_t msm_port_mask
;
69 } mcdi_sensor_map
[] = {
70 /* Sensor page 0 MC_CMD_SENSOR_xxx */
71 STAT(Px
, INT_TEMP
), /* 0x00 CONTROLLER_TEMP */
72 STAT(Px
, EXT_TEMP
), /* 0x01 PHY_COMMON_TEMP */
73 STAT(Px
, INT_COOLING
), /* 0x02 CONTROLLER_COOLING */
74 STAT(P1
, EXT_TEMP
), /* 0x03 PHY0_TEMP */
75 STAT(P1
, EXT_COOLING
), /* 0x04 PHY0_COOLING */
76 STAT(P2
, EXT_TEMP
), /* 0x05 PHY1_TEMP */
77 STAT(P2
, EXT_COOLING
), /* 0x06 PHY1_COOLING */
78 STAT(Px
, 1V
), /* 0x07 IN_1V0 */
79 STAT(Px
, 1_2V
), /* 0x08 IN_1V2 */
80 STAT(Px
, 1_8V
), /* 0x09 IN_1V8 */
81 STAT(Px
, 2_5V
), /* 0x0a IN_2V5 */
82 STAT(Px
, 3_3V
), /* 0x0b IN_3V3 */
83 STAT(Px
, 12V
), /* 0x0c IN_12V0 */
84 STAT(Px
, 1_2VA
), /* 0x0d IN_1V2A */
85 STAT(Px
, VREF
), /* 0x0e IN_VREF */
86 STAT(Px
, VAOE
), /* 0x0f OUT_VAOE */
87 STAT(Px
, AOE_TEMP
), /* 0x10 AOE_TEMP */
88 STAT(Px
, PSU_AOE_TEMP
), /* 0x11 PSU_AOE_TEMP */
89 STAT(Px
, PSU_TEMP
), /* 0x12 PSU_TEMP */
90 STAT(Px
, FAN0
), /* 0x13 FAN_0 */
91 STAT(Px
, FAN1
), /* 0x14 FAN_1 */
92 STAT(Px
, FAN2
), /* 0x15 FAN_2 */
93 STAT(Px
, FAN3
), /* 0x16 FAN_3 */
94 STAT(Px
, FAN4
), /* 0x17 FAN_4 */
95 STAT(Px
, VAOE_IN
), /* 0x18 IN_VAOE */
96 STAT(Px
, IAOE
), /* 0x19 OUT_IAOE */
97 STAT(Px
, IAOE_IN
), /* 0x1a IN_IAOE */
98 STAT(Px
, NIC_POWER
), /* 0x1b NIC_POWER */
99 STAT(Px
, 0_9V
), /* 0x1c IN_0V9 */
100 STAT(Px
, I0_9V
), /* 0x1d IN_I0V9 */
101 STAT(Px
, I1_2V
), /* 0x1e IN_I1V2 */
102 STAT_NEXT_PAGE(), /* 0x1f Next page flag (not a sensor) */
104 /* Sensor page 1 MC_CMD_SENSOR_xxx */
105 STAT(Px
, 0_9V_ADC
), /* 0x20 IN_0V9_ADC */
106 STAT(Px
, INT_TEMP2
), /* 0x21 CONTROLLER_2_TEMP */
107 STAT(Px
, VREG_TEMP
), /* 0x22 VREG_INTERNAL_TEMP */
108 STAT(Px
, VREG_0_9V_TEMP
), /* 0x23 VREG_0V9_TEMP */
109 STAT(Px
, VREG_1_2V_TEMP
), /* 0x24 VREG_1V2_TEMP */
110 STAT(Px
, INT_VPTAT
), /* 0x25 CTRLR. VPTAT */
111 STAT(Px
, INT_ADC_TEMP
), /* 0x26 CTRLR. INTERNAL_TEMP */
112 STAT(Px
, EXT_VPTAT
), /* 0x27 CTRLR. VPTAT_EXTADC */
113 STAT(Px
, EXT_ADC_TEMP
), /* 0x28 CTRLR. INTERNAL_TEMP_EXTADC */
114 STAT(Px
, AMBIENT_TEMP
), /* 0x29 AMBIENT_TEMP */
115 STAT(Px
, AIRFLOW
), /* 0x2a AIRFLOW */
116 STAT(Px
, VDD08D_VSS08D_CSR
), /* 0x2b VDD08D_VSS08D_CSR */
117 STAT(Px
, VDD08D_VSS08D_CSR_EXTADC
), /* 0x2c VDD08D_VSS08D_CSR_EXTADC */
118 STAT(Px
, HOTPOINT_TEMP
), /* 0x2d HOTPOINT_TEMP */
119 STAT(P1
, PHY_POWER_SWITCH_PORT0
), /* 0x2e PHY_POWER_SWITCH_PORT0 */
120 STAT(P2
, PHY_POWER_SWITCH_PORT1
), /* 0x2f PHY_POWER_SWITCH_PORT1 */
121 STAT(Px
, MUM_VCC
), /* 0x30 MUM_VCC */
122 STAT(Px
, 0V9_A
), /* 0x31 0V9_A */
123 STAT(Px
, I0V9_A
), /* 0x32 I0V9_A */
124 STAT(Px
, 0V9_A_TEMP
), /* 0x33 0V9_A_TEMP */
125 STAT(Px
, 0V9_B
), /* 0x34 0V9_B */
126 STAT(Px
, I0V9_B
), /* 0x35 I0V9_B */
127 STAT(Px
, 0V9_B_TEMP
), /* 0x36 0V9_B_TEMP */
128 STAT(Px
, CCOM_AVREG_1V2_SUPPLY
), /* 0x37 CCOM_AVREG_1V2_SUPPLY */
129 STAT(Px
, CCOM_AVREG_1V2_SUPPLY_EXT_ADC
),
130 /* 0x38 CCOM_AVREG_1V2_SUPPLY_EXT_ADC */
131 STAT(Px
, CCOM_AVREG_1V8_SUPPLY
), /* 0x39 CCOM_AVREG_1V8_SUPPLY */
132 STAT(Px
, CCOM_AVREG_1V8_SUPPLY_EXT_ADC
),
133 /* 0x3a CCOM_AVREG_1V8_SUPPLY_EXT_ADC */
134 STAT_NO_SENSOR(), /* 0x3b (no sensor) */
135 STAT_NO_SENSOR(), /* 0x3c (no sensor) */
136 STAT_NO_SENSOR(), /* 0x3d (no sensor) */
137 STAT_NO_SENSOR(), /* 0x3e (no sensor) */
138 STAT_NEXT_PAGE(), /* 0x3f Next page flag (not a sensor) */
140 /* Sensor page 2 MC_CMD_SENSOR_xxx */
141 STAT(Px
, CONTROLLER_MASTER_VPTAT
), /* 0x40 MASTER_VPTAT */
142 STAT(Px
, CONTROLLER_MASTER_INTERNAL_TEMP
), /* 0x41 MASTER_INT_TEMP */
143 STAT(Px
, CONTROLLER_MASTER_VPTAT_EXT_ADC
), /* 0x42 MAST_VPTAT_EXT_ADC */
144 STAT(Px
, CONTROLLER_MASTER_INTERNAL_TEMP_EXT_ADC
),
145 /* 0x43 MASTER_INTERNAL_TEMP_EXT_ADC */
146 STAT(Px
, CONTROLLER_SLAVE_VPTAT
), /* 0x44 SLAVE_VPTAT */
147 STAT(Px
, CONTROLLER_SLAVE_INTERNAL_TEMP
), /* 0x45 SLAVE_INTERNAL_TEMP */
148 STAT(Px
, CONTROLLER_SLAVE_VPTAT_EXT_ADC
), /* 0x46 SLAVE_VPTAT_EXT_ADC */
149 STAT(Px
, CONTROLLER_SLAVE_INTERNAL_TEMP_EXT_ADC
),
150 /* 0x47 SLAVE_INTERNAL_TEMP_EXT_ADC */
151 STAT_NO_SENSOR(), /* 0x48 (no sensor) */
152 STAT(Px
, SODIMM_VOUT
), /* 0x49 SODIMM_VOUT */
153 STAT(Px
, SODIMM_0_TEMP
), /* 0x4a SODIMM_0_TEMP */
154 STAT(Px
, SODIMM_1_TEMP
), /* 0x4b SODIMM_1_TEMP */
155 STAT(Px
, PHY0_VCC
), /* 0x4c PHY0_VCC */
156 STAT(Px
, PHY1_VCC
), /* 0x4d PHY1_VCC */
157 STAT(Px
, CONTROLLER_TDIODE_TEMP
), /* 0x4e CONTROLLER_TDIODE_TEMP */
158 STAT(Px
, BOARD_FRONT_TEMP
), /* 0x4f BOARD_FRONT_TEMP */
159 STAT(Px
, BOARD_BACK_TEMP
), /* 0x50 BOARD_BACK_TEMP */
162 #define MCDI_STATIC_SENSOR_ASSERT(_field) \
163 EFX_STATIC_ASSERT(MC_CMD_SENSOR_STATE_ ## _field \
164 == EFX_MON_STAT_STATE_ ## _field)
167 mcdi_mon_decode_stats(
169 __in_bcount(sensor_mask_size
) uint32_t *sensor_mask
,
170 __in
size_t sensor_mask_size
,
171 __in_opt efsys_mem_t
*esmp
,
172 __out_bcount_opt(sensor_mask_size
) uint32_t *stat_maskp
,
173 __inout_ecount_opt(EFX_MON_NSTATS
) efx_mon_stat_value_t
*stat
)
175 efx_mcdi_iface_t
*emip
= &(enp
->en_mcdi
.em_emip
);
179 uint32_t stat_mask
[(EFX_ARRAY_SIZE(mcdi_sensor_map
) + 31) / 32];
183 /* Assert the MC_CMD_SENSOR and EFX_MON_STATE namespaces agree */
184 MCDI_STATIC_SENSOR_ASSERT(OK
);
185 MCDI_STATIC_SENSOR_ASSERT(WARNING
);
186 MCDI_STATIC_SENSOR_ASSERT(FATAL
);
187 MCDI_STATIC_SENSOR_ASSERT(BROKEN
);
188 MCDI_STATIC_SENSOR_ASSERT(NO_READING
);
190 EFX_STATIC_ASSERT(sizeof (stat_mask
[0]) * 8 ==
191 EFX_MON_MASK_ELEMENT_SIZE
);
193 MIN((8 * sensor_mask_size
), EFX_ARRAY_SIZE(mcdi_sensor_map
));
195 EFSYS_ASSERT(emip
->emi_port
> 0); /* MCDI port number is one-based */
196 port_mask
= MCDI_MON_PORT_MASK(emip
);
198 memset(stat_mask
, 0, sizeof (stat_mask
));
201 * The MCDI sensor readings in the DMA buffer are a packed array of
202 * MC_CMD_SENSOR_VALUE_ENTRY structures, which only includes entries for
203 * supported sensors (bit set in sensor_mask). The sensor_mask and
204 * sensor readings do not include entries for the per-page NEXT_PAGE
207 * sensor_mask may legitimately contain MCDI sensors that the driver
208 * does not understand.
210 for (sensor
= 0; sensor
< sensor_max
; ++sensor
) {
211 efx_mon_stat_t id
= mcdi_sensor_map
[sensor
].msm_stat
;
213 if ((sensor
% MCDI_MON_PAGE_SIZE
) == MC_CMD_SENSOR_PAGE0_NEXT
) {
214 EFSYS_ASSERT3U(id
, ==, MCDI_MON_NEXT_PAGE
);
218 if (~(sensor_mask
[page
]) & (1U << sensor
))
222 if ((port_mask
& mcdi_sensor_map
[sensor
].msm_port_mask
) == 0)
224 EFSYS_ASSERT(id
< EFX_MON_NSTATS
);
227 * stat_mask is a bitmask indexed by EFX_MON_* monitor statistic
228 * identifiers from efx_mon_stat_t (without NEXT_PAGE bits).
230 * If there is an entry in the MCDI sensor to monitor statistic
231 * map then the sensor reading is used for the value of the
234 stat_mask
[id
/ EFX_MON_MASK_ELEMENT_SIZE
] |=
235 (1U << (id
% EFX_MON_MASK_ELEMENT_SIZE
));
237 if (stat
!= NULL
&& esmp
!= NULL
&& !EFSYS_MEM_IS_NULL(esmp
)) {
240 /* Get MCDI sensor reading from DMA buffer */
241 EFSYS_MEM_READD(esmp
, 4 * (idx
- 1), &dword
);
243 /* Update EFX monitor stat from MCDI sensor reading */
244 stat
[id
].emsv_value
= (uint16_t)EFX_DWORD_FIELD(dword
,
245 MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_VALUE
);
247 stat
[id
].emsv_state
= (uint16_t)EFX_DWORD_FIELD(dword
,
248 MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_STATE
);
252 if (stat_maskp
!= NULL
) {
253 memcpy(stat_maskp
, stat_mask
, sizeof (stat_mask
));
257 __checkReturn efx_rc_t
260 __in efx_qword_t
*eqp
,
261 __out efx_mon_stat_t
*idp
,
262 __out efx_mon_stat_value_t
*valuep
)
264 efx_mcdi_iface_t
*emip
= &(enp
->en_mcdi
.em_emip
);
265 efx_nic_cfg_t
*encp
= &(enp
->en_nic_cfg
);
273 EFSYS_ASSERT(emip
->emi_port
> 0); /* MCDI port number is one-based */
274 port_mask
= MCDI_MON_PORT_MASK(emip
);
276 sensor
= (uint16_t)MCDI_EV_FIELD(eqp
, SENSOREVT_MONITOR
);
277 state
= (uint16_t)MCDI_EV_FIELD(eqp
, SENSOREVT_STATE
);
278 value
= (uint16_t)MCDI_EV_FIELD(eqp
, SENSOREVT_VALUE
);
280 /* Hardware must support this MCDI sensor */
281 EFSYS_ASSERT3U(sensor
, <, (8 * encp
->enc_mcdi_sensor_mask_size
));
282 EFSYS_ASSERT((sensor
% MCDI_MON_PAGE_SIZE
) != MC_CMD_SENSOR_PAGE0_NEXT
);
283 EFSYS_ASSERT(encp
->enc_mcdi_sensor_maskp
!= NULL
);
284 EFSYS_ASSERT((encp
->enc_mcdi_sensor_maskp
[sensor
/ MCDI_MON_PAGE_SIZE
] &
285 (1U << (sensor
% MCDI_MON_PAGE_SIZE
))) != 0);
287 /* But we don't have to understand it */
288 if (sensor
>= EFX_ARRAY_SIZE(mcdi_sensor_map
)) {
292 id
= mcdi_sensor_map
[sensor
].msm_stat
;
293 if ((port_mask
& mcdi_sensor_map
[sensor
].msm_port_mask
) == 0)
295 EFSYS_ASSERT(id
< EFX_MON_NSTATS
);
298 valuep
->emsv_value
= value
;
299 valuep
->emsv_state
= state
;
304 EFSYS_PROBE1(fail1
, efx_rc_t
, rc
);
310 static __checkReturn efx_rc_t
311 efx_mcdi_read_sensors(
313 __in efsys_mem_t
*esmp
,
317 uint8_t payload
[MAX(MC_CMD_READ_SENSORS_EXT_IN_LEN
,
318 MC_CMD_READ_SENSORS_EXT_OUT_LEN
)];
319 uint32_t addr_lo
, addr_hi
;
321 req
.emr_cmd
= MC_CMD_READ_SENSORS
;
322 req
.emr_in_buf
= payload
;
323 req
.emr_in_length
= MC_CMD_READ_SENSORS_EXT_IN_LEN
;
324 req
.emr_out_buf
= payload
;
325 req
.emr_out_length
= MC_CMD_READ_SENSORS_EXT_OUT_LEN
;
327 addr_lo
= (uint32_t)(EFSYS_MEM_ADDR(esmp
) & 0xffffffff);
328 addr_hi
= (uint32_t)(EFSYS_MEM_ADDR(esmp
) >> 32);
330 MCDI_IN_SET_DWORD(req
, READ_SENSORS_EXT_IN_DMA_ADDR_LO
, addr_lo
);
331 MCDI_IN_SET_DWORD(req
, READ_SENSORS_EXT_IN_DMA_ADDR_HI
, addr_hi
);
332 MCDI_IN_SET_DWORD(req
, READ_SENSORS_EXT_IN_LENGTH
, size
);
334 efx_mcdi_execute(enp
, &req
);
339 static __checkReturn efx_rc_t
340 efx_mcdi_sensor_info_npages(
342 __out
uint32_t *npagesp
)
345 uint8_t payload
[MAX(MC_CMD_SENSOR_INFO_EXT_IN_LEN
,
346 MC_CMD_SENSOR_INFO_OUT_LENMAX
)];
350 EFSYS_ASSERT(npagesp
!= NULL
);
354 (void) memset(payload
, 0, sizeof (payload
));
355 req
.emr_cmd
= MC_CMD_SENSOR_INFO
;
356 req
.emr_in_buf
= payload
;
357 req
.emr_in_length
= MC_CMD_SENSOR_INFO_EXT_IN_LEN
;
358 req
.emr_out_buf
= payload
;
359 req
.emr_out_length
= MC_CMD_SENSOR_INFO_OUT_LENMAX
;
361 MCDI_IN_SET_DWORD(req
, SENSOR_INFO_EXT_IN_PAGE
, page
++);
363 efx_mcdi_execute_quiet(enp
, &req
);
365 if (req
.emr_rc
!= 0) {
369 } while (MCDI_OUT_DWORD(req
, SENSOR_INFO_OUT_MASK
) &
370 (1U << MC_CMD_SENSOR_PAGE0_NEXT
));
377 EFSYS_PROBE1(fail1
, efx_rc_t
, rc
);
382 static __checkReturn efx_rc_t
383 efx_mcdi_sensor_info(
385 __out_ecount(npages
) uint32_t *sensor_maskp
,
389 uint8_t payload
[MAX(MC_CMD_SENSOR_INFO_EXT_IN_LEN
,
390 MC_CMD_SENSOR_INFO_OUT_LENMAX
)];
394 EFSYS_ASSERT(sensor_maskp
!= NULL
);
396 for (page
= 0; page
< npages
; page
++) {
399 (void) memset(payload
, 0, sizeof (payload
));
400 req
.emr_cmd
= MC_CMD_SENSOR_INFO
;
401 req
.emr_in_buf
= payload
;
402 req
.emr_in_length
= MC_CMD_SENSOR_INFO_EXT_IN_LEN
;
403 req
.emr_out_buf
= payload
;
404 req
.emr_out_length
= MC_CMD_SENSOR_INFO_OUT_LENMAX
;
406 MCDI_IN_SET_DWORD(req
, SENSOR_INFO_EXT_IN_PAGE
, page
);
408 efx_mcdi_execute(enp
, &req
);
410 if (req
.emr_rc
!= 0) {
415 mask
= MCDI_OUT_DWORD(req
, SENSOR_INFO_OUT_MASK
);
417 if ((page
!= (npages
- 1)) &&
418 ((mask
& (1U << MC_CMD_SENSOR_PAGE0_NEXT
)) == 0)) {
422 sensor_maskp
[page
] = mask
;
425 if (sensor_maskp
[npages
- 1] & (1U << MC_CMD_SENSOR_PAGE0_NEXT
)) {
437 EFSYS_PROBE1(fail1
, efx_rc_t
, rc
);
442 __checkReturn efx_rc_t
443 mcdi_mon_stats_update(
445 __in efsys_mem_t
*esmp
,
446 __inout_ecount(EFX_MON_NSTATS
) efx_mon_stat_value_t
*values
)
448 efx_nic_cfg_t
*encp
= &(enp
->en_nic_cfg
);
449 uint32_t size
= encp
->enc_mon_stat_dma_buf_size
;
452 if ((rc
= efx_mcdi_read_sensors(enp
, esmp
, size
)) != 0)
455 EFSYS_DMA_SYNC_FOR_KERNEL(esmp
, 0, size
);
457 mcdi_mon_decode_stats(enp
,
458 encp
->enc_mcdi_sensor_maskp
,
459 encp
->enc_mcdi_sensor_mask_size
,
465 EFSYS_PROBE1(fail1
, efx_rc_t
, rc
);
470 __checkReturn efx_rc_t
474 efx_nic_cfg_t
*encp
= &(enp
->en_nic_cfg
);
478 switch (enp
->en_family
) {
480 case EFX_FAMILY_SIENA
:
481 encp
->enc_mon_type
= EFX_MON_SFC90X0
;
484 #if EFSYS_OPT_HUNTINGTON
485 case EFX_FAMILY_HUNTINGTON
:
486 encp
->enc_mon_type
= EFX_MON_SFC91X0
;
489 #if EFSYS_OPT_MEDFORD
490 case EFX_FAMILY_MEDFORD
:
491 encp
->enc_mon_type
= EFX_MON_SFC92X0
;
499 /* Get mc sensor mask size */
501 if ((rc
= efx_mcdi_sensor_info_npages(enp
, &npages
)) != 0)
504 encp
->enc_mon_stat_dma_buf_size
= npages
* EFX_MON_STATS_PAGE_SIZE
;
505 encp
->enc_mcdi_sensor_mask_size
= npages
* sizeof (uint32_t);
507 /* Allocate mc sensor mask */
508 EFSYS_KMEM_ALLOC(enp
->en_esip
,
509 encp
->enc_mcdi_sensor_mask_size
,
510 encp
->enc_mcdi_sensor_maskp
);
512 if (encp
->enc_mcdi_sensor_maskp
== NULL
) {
517 /* Read mc sensor mask */
518 if ((rc
= efx_mcdi_sensor_info(enp
,
519 encp
->enc_mcdi_sensor_maskp
,
523 /* Build monitor statistics mask */
524 mcdi_mon_decode_stats(enp
,
525 encp
->enc_mcdi_sensor_maskp
,
526 encp
->enc_mcdi_sensor_mask_size
,
527 NULL
, encp
->enc_mon_stat_mask
, NULL
);
533 EFSYS_KMEM_FREE(enp
->en_esip
,
534 encp
->enc_mcdi_sensor_mask_size
,
535 encp
->enc_mcdi_sensor_maskp
);
544 EFSYS_PROBE1(fail1
, efx_rc_t
, rc
);
553 efx_nic_cfg_t
*encp
= &(enp
->en_nic_cfg
);
555 if (encp
->enc_mcdi_sensor_maskp
!= NULL
) {
556 EFSYS_KMEM_FREE(enp
->en_esip
,
557 encp
->enc_mcdi_sensor_mask_size
,
558 encp
->enc_mcdi_sensor_maskp
);
563 #endif /* EFSYS_OPT_MON_STATS */
565 #endif /* EFSYS_OPT_MON_MCDI */