drivers/net/sfc/base/mcdi_mon.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  *
   3  * Copyright (c) 2009-2018 Solarflare Communications Inc.
   4  * All rights reserved.
   5  */
   6
   7 #include "efx.h"
   8 #include "efx_impl.h"
   9 #include "mcdi_mon.h"
  10
  11 #if EFSYS_OPT_MON_MCDI
  12
  13 #if EFSYS_OPT_MON_STATS
  14
  15 /* Get port mask from one-based MCDI port number */
  16 #define MCDI_MON_PORT_MASK(_emip) (1U << ((_emip)->emi_port - 1))
  17
  18 #define MCDI_STATIC_SENSOR_ASSERT(_field)                               \
  19         EFX_STATIC_ASSERT(MC_CMD_SENSOR_STATE_ ## _field                \
  20                             == EFX_MON_STAT_STATE_ ## _field)
  21
  22 static                                          void
  23 mcdi_mon_decode_stats(
  24         __in                                    efx_nic_t *enp,
  25         __in_bcount(sensor_mask_size)           uint32_t *sensor_mask,
  26         __in                                    size_t sensor_mask_size,
  27         __in_opt                                efsys_mem_t *esmp,
  28         __out_bcount_opt(sensor_mask_size)      uint32_t *stat_maskp,
  29         __inout_ecount_opt(EFX_MON_NSTATS)      efx_mon_stat_value_t *stat)
  30 {
  31         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
  32         efx_mon_stat_portmask_t port_mask;
  33         uint16_t sensor;
  34         size_t sensor_max;
  35         uint32_t stat_mask[(EFX_MON_NSTATS + 31) / 32];
  36         uint32_t idx = 0;
  37         uint32_t page = 0;
  38
  39         /* Assert the MC_CMD_SENSOR and EFX_MON_STATE namespaces agree */
  40         MCDI_STATIC_SENSOR_ASSERT(OK);
  41         MCDI_STATIC_SENSOR_ASSERT(WARNING);
  42         MCDI_STATIC_SENSOR_ASSERT(FATAL);
  43         MCDI_STATIC_SENSOR_ASSERT(BROKEN);
  44         MCDI_STATIC_SENSOR_ASSERT(NO_READING);
  45
  46         sensor_max = 8 * sensor_mask_size;
  47
  48         EFSYS_ASSERT(emip->emi_port > 0); /* MCDI port number is one-based */
  49         port_mask = (efx_mon_stat_portmask_t)MCDI_MON_PORT_MASK(emip);
  50
  51         memset(stat_mask, 0, sizeof (stat_mask));
  52
  53         /*
  54          * The MCDI sensor readings in the DMA buffer are a packed array of
  55          * MC_CMD_SENSOR_VALUE_ENTRY structures, which only includes entries for
  56          * supported sensors (bit set in sensor_mask). The sensor_mask and
  57          * sensor readings do not include entries for the per-page NEXT_PAGE
  58          * flag.
  59          *
  60          * sensor_mask may legitimately contain MCDI sensors that the driver
  61          * does not understand.
  62          */
  63         for (sensor = 0; sensor < sensor_max; ++sensor) {
  64                 efx_mon_stat_t id;
  65                 efx_mon_stat_portmask_t stat_portmask = 0;
  66                 boolean_t decode_ok;
  67                 efx_mon_stat_unit_t stat_unit;
  68
  69                 if ((sensor % (MC_CMD_SENSOR_PAGE0_NEXT + 1)) ==
  70                     MC_CMD_SENSOR_PAGE0_NEXT) {
  71                         page++;
  72                         continue;
  73                         /* This sensor is one of the page boundary bits. */
  74                 }
  75
  76                 if (~(sensor_mask[page]) & (1U << sensor))
  77                         continue;
  78                 /* This sensor not in DMA buffer */
  79
  80                 idx++;
  81                 /*
  82                  * Valid stat in DMA buffer that we need to increment over, even
  83                  * if we couldn't look up the id
  84                  */
  85
  86                 decode_ok = efx_mon_mcdi_to_efx_stat(sensor, &id);
  87                 decode_ok =
  88                     decode_ok && efx_mon_get_stat_portmap(id, &stat_portmask);
  89
  90                 if (!(decode_ok && (stat_portmask & port_mask)))
  91                         continue;
  92                 /* Either bad decode, or don't know what port stat is on */
  93
  94                 EFSYS_ASSERT(id < EFX_MON_NSTATS);
  95
  96                 /*
  97                  * stat_mask is a bitmask indexed by EFX_MON_* monitor statistic
  98                  * identifiers from efx_mon_stat_t (without NEXT_PAGE bits).
  99                  *
 100                  * If there is an entry in the MCDI sensor to monitor statistic
 101                  * map then the sensor reading is used for the value of the
 102                  * monitor statistic.
 103                  */
 104                 stat_mask[id / EFX_MON_MASK_ELEMENT_SIZE] |=
 105                     (1U << (id % EFX_MON_MASK_ELEMENT_SIZE));
 106
 107                 if (stat != NULL && esmp != NULL && !EFSYS_MEM_IS_NULL(esmp)) {
 108                         efx_dword_t dword;
 109
 110                         /* Get MCDI sensor reading from DMA buffer */
 111                         EFSYS_MEM_READD(esmp, 4 * (idx - 1), &dword);
 112
 113                         /* Update EFX monitor stat from MCDI sensor reading */
 114                         stat[id].emsv_value = (uint16_t)EFX_DWORD_FIELD(dword,
 115                             MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_VALUE);
 116
 117                         stat[id].emsv_state = (uint16_t)EFX_DWORD_FIELD(dword,
 118                             MC_CMD_SENSOR_VALUE_ENTRY_TYPEDEF_STATE);
 119
 120                         stat[id].emsv_unit =
 121                             efx_mon_get_stat_unit(id, &stat_unit) ?
 122                             stat_unit : EFX_MON_STAT_UNIT_UNKNOWN;
 123                 }
 124         }
 125
 126         if (stat_maskp != NULL) {
 127                 memcpy(stat_maskp, stat_mask, sizeof (stat_mask));
 128         }
 129 }
 130
 131         __checkReturn                   efx_rc_t
 132 mcdi_mon_ev(
 133         __in                            efx_nic_t *enp,
 134         __in                            efx_qword_t *eqp,
 135         __out                           efx_mon_stat_t *idp,
 136         __out                           efx_mon_stat_value_t *valuep)
 137 {
 138         efx_mcdi_iface_t *emip = &(enp->en_mcdi.em_emip);
 139         efx_mon_stat_portmask_t port_mask, sensor_port_mask;
 140         uint16_t sensor;
 141         uint16_t state;
 142         uint16_t value;
 143         efx_mon_stat_t id;
 144         efx_rc_t rc;
 145
 146         EFSYS_ASSERT(emip->emi_port > 0); /* MCDI port number is one-based */
 147         port_mask = MCDI_MON_PORT_MASK(emip);
 148
 149         sensor = (uint16_t)MCDI_EV_FIELD(eqp, SENSOREVT_MONITOR);
 150         state = (uint16_t)MCDI_EV_FIELD(eqp, SENSOREVT_STATE);
 151         value = (uint16_t)MCDI_EV_FIELD(eqp, SENSOREVT_VALUE);
 152
 153         /* Hardware must support this MCDI sensor */
 154         EFSYS_ASSERT3U(sensor, <,
 155             (8 * enp->en_nic_cfg.enc_mcdi_sensor_mask_size));
 156         EFSYS_ASSERT((sensor % (MC_CMD_SENSOR_PAGE0_NEXT + 1)) !=
 157             MC_CMD_SENSOR_PAGE0_NEXT);
 158         EFSYS_ASSERT(enp->en_nic_cfg.enc_mcdi_sensor_maskp != NULL);
 159         EFSYS_ASSERT((enp->en_nic_cfg.enc_mcdi_sensor_maskp[
 160                     sensor / (MC_CMD_SENSOR_PAGE0_NEXT + 1)] &
 161                 (1U << (sensor % (MC_CMD_SENSOR_PAGE0_NEXT + 1)))) != 0);
 162
 163         /* And we need to understand it, to get port-map */
 164         if (!efx_mon_mcdi_to_efx_stat(sensor, &id)) {
 165                 rc = ENOTSUP;
 166                 goto fail1;
 167         }
 168         if (!(efx_mon_get_stat_portmap(id, &sensor_port_mask) &&
 169                 (port_mask && sensor_port_mask))) {
 170                 return (ENODEV);
 171         }
 172         EFSYS_ASSERT(id < EFX_MON_NSTATS);
 173
 174         *idp = id;
 175         valuep->emsv_value = value;
 176         valuep->emsv_state = state;
 177
 178         return (0);
 179
 180 fail1:
 181         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 182
 183         return (rc);
 184 }
 185
 186
 187 static  __checkReturn   efx_rc_t
 188 efx_mcdi_read_sensors(
 189         __in            efx_nic_t *enp,
 190         __in            efsys_mem_t *esmp,
 191         __in            uint32_t size)
 192 {
 193         efx_mcdi_req_t req;
 194         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_READ_SENSORS_EXT_IN_LEN,
 195                 MC_CMD_READ_SENSORS_EXT_OUT_LEN);
 196         uint32_t addr_lo, addr_hi;
 197         efx_rc_t rc;
 198
 199         if (EFSYS_MEM_SIZE(esmp) < size) {
 200                 rc = EINVAL;
 201                 goto fail1;
 202         }
 203
 204         req.emr_cmd = MC_CMD_READ_SENSORS;
 205         req.emr_in_buf = payload;
 206         req.emr_in_length = MC_CMD_READ_SENSORS_EXT_IN_LEN;
 207         req.emr_out_buf = payload;
 208         req.emr_out_length = MC_CMD_READ_SENSORS_EXT_OUT_LEN;
 209
 210         addr_lo = (uint32_t)(EFSYS_MEM_ADDR(esmp) & 0xffffffff);
 211         addr_hi = (uint32_t)(EFSYS_MEM_ADDR(esmp) >> 32);
 212
 213         MCDI_IN_SET_DWORD(req, READ_SENSORS_EXT_IN_DMA_ADDR_LO, addr_lo);
 214         MCDI_IN_SET_DWORD(req, READ_SENSORS_EXT_IN_DMA_ADDR_HI, addr_hi);
 215         MCDI_IN_SET_DWORD(req, READ_SENSORS_EXT_IN_LENGTH, size);
 216
 217         efx_mcdi_execute(enp, &req);
 218
 219         return (req.emr_rc);
 220
 221 fail1:
 222         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 223
 224         return (rc);
 225 }
 226
 227 static  __checkReturn   efx_rc_t
 228 efx_mcdi_sensor_info_npages(
 229         __in            efx_nic_t *enp,
 230         __out           uint32_t *npagesp)
 231 {
 232         efx_mcdi_req_t req;
 233         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SENSOR_INFO_EXT_IN_LEN,
 234                 MC_CMD_SENSOR_INFO_OUT_LENMAX);
 235         int page;
 236         efx_rc_t rc;
 237
 238         EFSYS_ASSERT(npagesp != NULL);
 239
 240         page = 0;
 241         do {
 242                 (void) memset(payload, 0, sizeof (payload));
 243                 req.emr_cmd = MC_CMD_SENSOR_INFO;
 244                 req.emr_in_buf = payload;
 245                 req.emr_in_length = MC_CMD_SENSOR_INFO_EXT_IN_LEN;
 246                 req.emr_out_buf = payload;
 247                 req.emr_out_length = MC_CMD_SENSOR_INFO_OUT_LENMAX;
 248
 249                 MCDI_IN_SET_DWORD(req, SENSOR_INFO_EXT_IN_PAGE, page++);
 250
 251                 efx_mcdi_execute_quiet(enp, &req);
 252
 253                 if (req.emr_rc != 0) {
 254                         rc = req.emr_rc;
 255                         goto fail1;
 256                 }
 257         } while (MCDI_OUT_DWORD(req, SENSOR_INFO_OUT_MASK) &
 258             (1U << MC_CMD_SENSOR_PAGE0_NEXT));
 259
 260         *npagesp = page;
 261
 262         return (0);
 263
 264 fail1:
 265         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 266
 267         return (rc);
 268 }
 269
 270 static  __checkReturn           efx_rc_t
 271 efx_mcdi_sensor_info(
 272         __in                    efx_nic_t *enp,
 273         __out_ecount(npages)    uint32_t *sensor_maskp,
 274         __in                    size_t npages)
 275 {
 276         efx_mcdi_req_t req;
 277         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SENSOR_INFO_EXT_IN_LEN,
 278                 MC_CMD_SENSOR_INFO_OUT_LENMAX);
 279         uint32_t page;
 280         efx_rc_t rc;
 281
 282         EFSYS_ASSERT(sensor_maskp != NULL);
 283
 284         if (npages < 1) {
 285                 rc = EINVAL;
 286                 goto fail1;
 287         }
 288
 289         for (page = 0; page < npages; page++) {
 290                 uint32_t mask;
 291
 292                 (void) memset(payload, 0, sizeof (payload));
 293                 req.emr_cmd = MC_CMD_SENSOR_INFO;
 294                 req.emr_in_buf = payload;
 295                 req.emr_in_length = MC_CMD_SENSOR_INFO_EXT_IN_LEN;
 296                 req.emr_out_buf = payload;
 297                 req.emr_out_length = MC_CMD_SENSOR_INFO_OUT_LENMAX;
 298
 299                 MCDI_IN_SET_DWORD(req, SENSOR_INFO_EXT_IN_PAGE, page);
 300
 301                 efx_mcdi_execute(enp, &req);
 302
 303                 if (req.emr_rc != 0) {
 304                         rc = req.emr_rc;
 305                         goto fail2;
 306                 }
 307
 308                 mask = MCDI_OUT_DWORD(req, SENSOR_INFO_OUT_MASK);
 309
 310                 if ((page != (npages - 1)) &&
 311                     ((mask & (1U << MC_CMD_SENSOR_PAGE0_NEXT)) == 0)) {
 312                         rc = EINVAL;
 313                         goto fail3;
 314                 }
 315                 sensor_maskp[page] = mask;
 316         }
 317
 318         if (sensor_maskp[npages - 1] & (1U << MC_CMD_SENSOR_PAGE0_NEXT)) {
 319                 rc = EINVAL;
 320                 goto fail4;
 321         }
 322
 323         return (0);
 324
 325 fail4:
 326         EFSYS_PROBE(fail4);
 327 fail3:
 328         EFSYS_PROBE(fail3);
 329 fail2:
 330         EFSYS_PROBE(fail2);
 331 fail1:
 332         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 333
 334         return (rc);
 335 }
 336
 337 static  __checkReturn           efx_rc_t
 338 efx_mcdi_sensor_info_page(
 339         __in                    efx_nic_t *enp,
 340         __in                    uint32_t page,
 341         __out                   uint32_t *mask_part,
 342         __out_ecount((sizeof (*mask_part) * 8) - 1)
 343                                 efx_mon_stat_limits_t *limits)
 344 {
 345         efx_mcdi_req_t req;
 346         EFX_MCDI_DECLARE_BUF(payload, MC_CMD_SENSOR_INFO_EXT_IN_LEN,
 347                 MC_CMD_SENSOR_INFO_OUT_LENMAX);
 348         efx_rc_t rc;
 349         uint32_t mask_copy;
 350         efx_dword_t *maskp;
 351         efx_qword_t *limit_info;
 352
 353         EFSYS_ASSERT(mask_part != NULL);
 354         EFSYS_ASSERT(limits != NULL);
 355
 356         memset(limits, 0,
 357             ((sizeof (*mask_part) * 8) - 1) * sizeof (efx_mon_stat_limits_t));
 358
 359         req.emr_cmd = MC_CMD_SENSOR_INFO;
 360         req.emr_in_buf = payload;
 361         req.emr_in_length = MC_CMD_SENSOR_INFO_EXT_IN_LEN;
 362         req.emr_out_buf = payload;
 363         req.emr_out_length = MC_CMD_SENSOR_INFO_OUT_LENMAX;
 364
 365         MCDI_IN_SET_DWORD(req, SENSOR_INFO_EXT_IN_PAGE, page);
 366
 367         efx_mcdi_execute(enp, &req);
 368
 369         rc = req.emr_rc;
 370
 371         if (rc != 0)
 372                 goto fail1;
 373
 374         EFSYS_ASSERT(sizeof (*limit_info) ==
 375             MC_CMD_SENSOR_INFO_ENTRY_TYPEDEF_LEN);
 376         maskp = MCDI_OUT2(req, efx_dword_t, SENSOR_INFO_OUT_MASK);
 377         limit_info = (efx_qword_t *)(maskp + 1);
 378
 379         *mask_part = maskp->ed_u32[0];
 380         mask_copy = *mask_part;
 381
 382         /* Copy an entry for all but the highest bit set. */
 383         while (mask_copy) {
 384
 385                 if (mask_copy == (1U << MC_CMD_SENSOR_PAGE0_NEXT)) {
 386                         /* Only next page bit set. */
 387                         mask_copy = 0;
 388                 } else {
 389                         /* Clear lowest bit */
 390                         mask_copy = mask_copy & ~(mask_copy ^ (mask_copy - 1));
 391                         /* And copy out limit entry into buffer */
 392                         limits->emlv_warning_min = EFX_QWORD_FIELD(*limit_info,
 393                             MC_CMD_SENSOR_INFO_ENTRY_TYPEDEF_MIN1);
 394
 395                         limits->emlv_warning_max = EFX_QWORD_FIELD(*limit_info,
 396                             MC_CMD_SENSOR_INFO_ENTRY_TYPEDEF_MAX1);
 397
 398                         limits->emlv_fatal_min = EFX_QWORD_FIELD(*limit_info,
 399                             MC_CMD_SENSOR_INFO_ENTRY_TYPEDEF_MIN2);
 400
 401                         limits->emlv_fatal_max = EFX_QWORD_FIELD(*limit_info,
 402                             MC_CMD_SENSOR_INFO_ENTRY_TYPEDEF_MAX2);
 403
 404                         limits++;
 405                         limit_info++;
 406                 }
 407         }
 408
 409         return (rc);
 410
 411 fail1:
 412         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 413
 414         return (rc);
 415 }
 416
 417         __checkReturn                   efx_rc_t
 418 mcdi_mon_stats_update(
 419         __in                            efx_nic_t *enp,
 420         __in                            efsys_mem_t *esmp,
 421         __inout_ecount(EFX_MON_NSTATS)  efx_mon_stat_value_t *values)
 422 {
 423         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 424         uint32_t size = encp->enc_mon_stat_dma_buf_size;
 425         efx_rc_t rc;
 426
 427         if ((rc = efx_mcdi_read_sensors(enp, esmp, size)) != 0)
 428                 goto fail1;
 429
 430         EFSYS_DMA_SYNC_FOR_KERNEL(esmp, 0, size);
 431
 432         mcdi_mon_decode_stats(enp,
 433             encp->enc_mcdi_sensor_maskp,
 434             encp->enc_mcdi_sensor_mask_size,
 435             esmp, NULL, values);
 436
 437         return (0);
 438
 439 fail1:
 440         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 441
 442         return (rc);
 443 }
 444
 445 static          void
 446 lowest_set_bit(
 447         __in    uint32_t input_mask,
 448         __out   uint32_t *lowest_bit_mask,
 449         __out   uint32_t *lowest_bit_num
 450 )
 451 {
 452         uint32_t x;
 453         uint32_t set_bit, bit_index;
 454
 455         x = (input_mask ^ (input_mask - 1));
 456         set_bit = (x + 1) >> 1;
 457         if (!set_bit)
 458                 set_bit = (1U << 31U);
 459
 460         bit_index = 0;
 461         if (set_bit & 0xFFFF0000)
 462                 bit_index += 16;
 463         if (set_bit & 0xFF00FF00)
 464                 bit_index += 8;
 465         if (set_bit & 0xF0F0F0F0)
 466                 bit_index += 4;
 467         if (set_bit & 0xCCCCCCCC)
 468                 bit_index += 2;
 469         if (set_bit & 0xAAAAAAAA)
 470                 bit_index += 1;
 471
 472         *lowest_bit_mask = set_bit;
 473         *lowest_bit_num = bit_index;
 474 }
 475
 476         __checkReturn                   efx_rc_t
 477 mcdi_mon_limits_update(
 478         __in                            efx_nic_t *enp,
 479         __inout_ecount(EFX_MON_NSTATS)  efx_mon_stat_limits_t *values)
 480 {
 481         efx_rc_t rc;
 482         uint32_t page;
 483         uint32_t page_mask;
 484         uint32_t limit_index;
 485         efx_mon_stat_limits_t limits[sizeof (page_mask) * 8];
 486         efx_mon_stat_t stat;
 487
 488         page = 0;
 489         page--;
 490         do {
 491                 page++;
 492
 493                 rc = efx_mcdi_sensor_info_page(enp, page, &page_mask, limits);
 494                 if (rc != 0)
 495                         goto fail1;
 496
 497                 limit_index = 0;
 498                 while (page_mask) {
 499                         uint32_t set_bit;
 500                         uint32_t page_index;
 501                         uint32_t mcdi_index;
 502
 503                         if (page_mask == (1U << MC_CMD_SENSOR_PAGE0_NEXT))
 504                                 break;
 505
 506                         lowest_set_bit(page_mask, &set_bit, &page_index);
 507                         page_mask = page_mask & ~set_bit;
 508
 509                         mcdi_index =
 510                             page_index + (sizeof (page_mask) * 8 * page);
 511
 512                         /*
 513                          * This can fail if MCDI reports newer stats than the
 514                          * drivers understand, or the bit is the next page bit.
 515                          *
 516                          * Driver needs to be tolerant of this.
 517                          */
 518                         if (!efx_mon_mcdi_to_efx_stat(mcdi_index, &stat))
 519                                 continue;
 520
 521                         values[stat] = limits[limit_index];
 522                         limit_index++;
 523                 }
 524
 525         } while (page_mask & (1U << MC_CMD_SENSOR_PAGE0_NEXT));
 526
 527         return (rc);
 528
 529 fail1:
 530         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 531
 532         return (rc);
 533 }
 534
 535         __checkReturn   efx_rc_t
 536 mcdi_mon_cfg_build(
 537         __in            efx_nic_t *enp)
 538 {
 539         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 540         uint32_t npages;
 541         efx_rc_t rc;
 542
 543         switch (enp->en_family) {
 544 #if EFSYS_OPT_SIENA
 545         case EFX_FAMILY_SIENA:
 546                 encp->enc_mon_type = EFX_MON_SFC90X0;
 547                 break;
 548 #endif
 549 #if EFSYS_OPT_HUNTINGTON
 550         case EFX_FAMILY_HUNTINGTON:
 551                 encp->enc_mon_type = EFX_MON_SFC91X0;
 552                 break;
 553 #endif
 554 #if EFSYS_OPT_MEDFORD
 555         case EFX_FAMILY_MEDFORD:
 556                 encp->enc_mon_type = EFX_MON_SFC92X0;
 557                 break;
 558 #endif
 559 #if EFSYS_OPT_MEDFORD2
 560         case EFX_FAMILY_MEDFORD2:
 561                 encp->enc_mon_type = EFX_MON_SFC92X0;
 562                 break;
 563 #endif
 564         default:
 565                 rc = EINVAL;
 566                 goto fail1;
 567         }
 568
 569         /* Get mc sensor mask size */
 570         npages = 0;
 571         if ((rc = efx_mcdi_sensor_info_npages(enp, &npages)) != 0)
 572                 goto fail2;
 573
 574         encp->enc_mon_stat_dma_buf_size = npages * EFX_MON_STATS_PAGE_SIZE;
 575         encp->enc_mcdi_sensor_mask_size = npages * sizeof (uint32_t);
 576
 577         /* Allocate mc sensor mask */
 578         EFSYS_KMEM_ALLOC(enp->en_esip,
 579             encp->enc_mcdi_sensor_mask_size,
 580             encp->enc_mcdi_sensor_maskp);
 581
 582         if (encp->enc_mcdi_sensor_maskp == NULL) {
 583                 rc = ENOMEM;
 584                 goto fail3;
 585         }
 586
 587         /* Read mc sensor mask */
 588         if ((rc = efx_mcdi_sensor_info(enp,
 589                     encp->enc_mcdi_sensor_maskp,
 590                     npages)) != 0)
 591                 goto fail4;
 592
 593         /* Build monitor statistics mask */
 594         mcdi_mon_decode_stats(enp,
 595             encp->enc_mcdi_sensor_maskp,
 596             encp->enc_mcdi_sensor_mask_size,
 597             NULL, encp->enc_mon_stat_mask, NULL);
 598
 599         return (0);
 600
 601 fail4:
 602         EFSYS_PROBE(fail4);
 603         EFSYS_KMEM_FREE(enp->en_esip,
 604             encp->enc_mcdi_sensor_mask_size,
 605             encp->enc_mcdi_sensor_maskp);
 606
 607 fail3:
 608         EFSYS_PROBE(fail3);
 609
 610 fail2:
 611         EFSYS_PROBE(fail2);
 612
 613 fail1:
 614         EFSYS_PROBE1(fail1, efx_rc_t, rc);
 615
 616         return (rc);
 617 }
 618
 619                         void
 620 mcdi_mon_cfg_free(
 621         __in            efx_nic_t *enp)
 622 {
 623         efx_nic_cfg_t *encp = &(enp->en_nic_cfg);
 624
 625         if (encp->enc_mcdi_sensor_maskp != NULL) {
 626                 EFSYS_KMEM_FREE(enp->en_esip,
 627                     encp->enc_mcdi_sensor_mask_size,
 628                     encp->enc_mcdi_sensor_maskp);
 629         }
 630 }
 631
 632
 633 #endif  /* EFSYS_OPT_MON_STATS */
 634
 635 #endif  /* EFSYS_OPT_MON_MCDI */