1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <sys/conf.h>
  31 #include <sys/modctl.h>
  32 #include <sys/callb.h>
  33 #include <sys/strlog.h>
  34 #include <sys/cyclic.h>
  35 #include <sys/rmc_comm_dp.h>
  36 #include <sys/rmc_comm_dp_boot.h>
  37 #include <sys/rmc_comm_drvintf.h>
  38 #include <sys/rmc_comm.h>
  39 #include <sys/machsystm.h>
  40 #include <sys/sysevent.h>
  41 #include <sys/sysevent/dr.h>
  42 #include <sys/sysevent/env.h>
  43 #include <sys/sysevent/eventdefs.h>
  44 #include <sys/file.h>
  45 #include <sys/disp.h>
  46 #include <sys/reboot.h>
  47 #include <sys/envmon.h>
  48 #include <sys/rmclomv_impl.h>
  49 #include <sys/cpu_sgnblk_defs.h>
  50 #include <sys/utsname.h>
  51 #include <sys/systeminfo.h>
  52 #include <sys/ddi.h>
  53 #include <sys/time.h>
  54 #include <sys/promif.h>
  55 #include <sys/sysmacros.h>
  56 
  57 #define RMCRESBUFLEN    1024
  58 #define DATE_TIME_MSG_SIZE      78
  59 #define RMCLOMV_WATCHDOG_MODE   "rmclomv-watchdog-mode"
  60 #define DELAY_TIME      5000000  /* 5 seconds, in microseconds */
  61 #define CPU_SIGNATURE_DELAY_TIME        5000000  /* 5 secs, in microsecs */
  62 
  63 extern void     pmugpio_watchdog_pat();
  64 
  65 extern int      watchdog_activated;
  66 static int      last_watchdog_msg = 1;
  67 extern int      watchdog_enable;
  68 extern int      boothowto;
  69 
  70 int             rmclomv_watchdog_mode;
  71 
  72 /*
  73  * functions local to this driver.
  74  */
  75 static int      rmclomv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg,
  76     void **resultp);
  77 static int      rmclomv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
  78 static int      rmclomv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
  79 static uint_t   rmclomv_break_intr(caddr_t arg);
  80 static int      rmclomv_add_intr_handlers(void);
  81 static int      rmclomv_remove_intr_handlers(void);
  82 static uint_t   rmclomv_event_data_handler(char *);
  83 static void     rmclomv_dr_data_handler(const char *, int);
  84 static int      rmclomv_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p);
  85 static int      rmclomv_close(dev_t dev, int flag, int otyp, cred_t *cred_p);
  86 static int      rmclomv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
  87     cred_t *cred_p, int *rval_p);
  88 static void     rmclomv_checkrmc_start(void);
  89 static void     rmclomv_checkrmc_destroy(void);
  90 static void     rmclomv_checkrmc_wakeup(void *);
  91 static void     rmclomv_refresh_start(void);
  92 static void     rmclomv_refresh_destroy(void);
  93 static void     rmclomv_refresh_wakeup(void);
  94 static void     rmclomv_reset_cache(rmclomv_cache_section_t *new_chain,
  95     rmclomv_cache_section_t *new_subchain, dp_get_sysinfo_r_t *sysinfo);
  96 static rmclomv_cache_section_t *rmclomv_find_section(
  97     rmclomv_cache_section_t *start, uint16_t sensor);
  98 static rmclomv_cache_section_t *create_cache_section(int sensor_type, int num);
  99 static int      get_sensor_by_name(const rmclomv_cache_section_t *section,
 100     const char *name, int *index);
 101 static int      validate_section_entry(rmclomv_cache_section_t *section,
 102     int index);
 103 static int      add_names_to_section(rmclomv_cache_section_t *section);
 104 static void     free_section(rmclomv_cache_section_t *section);
 105 static void     add_section(rmclomv_cache_section_t **head,
 106     rmclomv_cache_section_t *section);
 107 static int      rmclomv_do_cmd(int req_cmd, int resp_cmd, int resp_len,
 108     intptr_t arg_req, intptr_t arg_res);
 109 static void     refresh_name_cache(int force_fail);
 110 static void     set_val_unav(envmon_sensor_t *sensor);
 111 static void     set_fan_unav(envmon_fan_t *fan);
 112 static int      do_psu_cmd(intptr_t arg, int mode, envmon_indicator_t *env_ind,
 113     dp_get_psu_status_t *rmc_psu, dp_get_psu_status_r_t *rmc_psu_r,
 114     int detector_type);
 115 static uint_t rmc_set_watchdog_timer(uint_t timeoutval);
 116 static uint_t rmc_clear_watchdog_timer(void);
 117 static void send_watchdog_msg(int msg);
 118 static void plat_timesync(void *arg);
 119 
 120 static kmutex_t         timesync_lock;
 121 static clock_t          timesync_interval = 0;
 122 static timeout_id_t     timesync_tid = 0;
 123 
 124 /*
 125  * Driver entry points
 126  */
 127 static struct cb_ops rmclomv_cb_ops = {
 128         rmclomv_open,   /* open */
 129         rmclomv_close,  /* close */
 130         nodev,          /* strategy() */
 131         nodev,          /* print() */
 132         nodev,          /* dump() */
 133         nodev,          /* read() */
 134         nodev,          /* write() */
 135         rmclomv_ioctl,  /* ioctl() */
 136         nodev,          /* devmap() */
 137         nodev,          /* mmap() */
 138         ddi_segmap,     /* segmap() */
 139         nochpoll,       /* poll() */
 140         ddi_prop_op,    /* prop_op() */
 141         NULL,           /* cb_str */
 142         D_NEW | D_MP    /* cb_flag */
 143 };
 144 
 145 
 146 static struct dev_ops rmclomv_ops = {
 147         DEVO_REV,
 148         0,                      /* ref count */
 149         rmclomv_getinfo,        /* getinfo() */
 150         nulldev,                /* identify() */
 151         nulldev,                /* probe() */
 152         rmclomv_attach,         /* attach() */
 153         rmclomv_detach,         /* detach */
 154         nodev,                  /* reset */
 155         &rmclomv_cb_ops,            /* pointer to cb_ops structure */
 156         (struct bus_ops *)NULL,
 157         nulldev,                /* power() */
 158         ddi_quiesce_not_supported,      /* devo_quiesce */
 159 };
 160 
 161 /*
 162  * Loadable module support.
 163  */
 164 extern struct mod_ops mod_driverops;
 165 
 166 static struct modldrv modldrv = {
 167         &mod_driverops,                     /* Type of module. This is a driver */
 168         "rmclomv control driver",       /* Name of the module */
 169         &rmclomv_ops                        /* pointer to the dev_ops structure */
 170 };
 171 
 172 static struct modlinkage modlinkage = {
 173         MODREV_1,
 174         &modldrv,
 175         NULL
 176 };
 177 
 178 /*
 179  * Device info
 180  */
 181 static dev_info_t               *rmclomv_dip = NULL;
 182 static int                      rmclomv_break_requested = B_FALSE;
 183 static ddi_softintr_t           rmclomv_softintr_id;
 184 static ddi_iblock_cookie_t      rmclomv_soft_iblock_cookie;
 185 
 186 extern void (*abort_seq_handler)();
 187 /* key_position is effective key-position. Set to locked if unknown */
 188 static rsci8 key_position = RMC_KEYSWITCH_POS_LOCKED;
 189 /* real_key_position starts off as unknown and records value actually seen */
 190 static rsci8 real_key_position = RMC_KEYSWITCH_POS_UNKNOWN;
 191 static void rmclomv_abort_seq_handler(char *msg);
 192 
 193 /*
 194  * mutexes which protect the interrupt handlers.
 195  */
 196 static kmutex_t         rmclomv_event_hdlr_lock;
 197 static kmutex_t         rmclomv_refresh_lock;
 198 static kcondvar_t       rmclomv_refresh_sig_cv;
 199 static kmutex_t         rmclomv_checkrmc_lock;
 200 static kcondvar_t       rmclomv_checkrmc_sig_cv;
 201 
 202 /*
 203  * mutex to protect the handle_name cache
 204  */
 205 static kmutex_t         rmclomv_cache_lock;
 206 
 207 /*
 208  * mutex to protect the RMC state
 209  */
 210 static kmutex_t         rmclomv_state_lock;
 211 
 212 /*
 213  * Payloads of the event handlers.
 214  */
 215 static dp_event_notification_t  rmclomv_event_payload;
 216 static rmc_comm_msg_t   rmclomv_event_payload_msg;
 217 
 218 /*
 219  * Checkrmc commands..
 220  */
 221 #define RMCLOMV_CHECKRMC_EXITNOW        (-1)
 222 #define RMCLOMV_CHECKRMC_WAIT           0
 223 #define RMCLOMV_CHECKRMC_PROCESSNOW     1
 224 
 225 /*
 226  * Checkrmc thread state
 227  */
 228 static int rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_WAIT;
 229 static kt_did_t rmclomv_checkrmc_tid = 0;
 230 
 231 /*
 232  * RMC state data
 233  */
 234 #define RMCLOMV_RMCSTATE_UNKNOWN        0
 235 #define RMCLOMV_RMCSTATE_OK             1
 236 #define RMCLOMV_RMCSTATE_FAILED         2
 237 #define RMCLOMV_RMCSTATE_DOWNLOAD       3
 238 
 239 /*
 240  * RMC error indicator values (status from last RMC command)
 241  */
 242 #define RMCLOMV_RMCERROR_NONE           0
 243 
 244 /* fail RMC after 5 minutes without a good response */
 245 #define RMCLOMV_RMCFAILTHRESHOLD        5
 246 
 247 /*
 248  * rmclomv_rmc_state is the state reported in OperationalStatus.
 249  * rmclomv_rmc_error reflects the result of the last RMC interaction.
 250  * rmclomv_rmcfailcount is used by the rmclomv_checkrmc thread to count
 251  * failures in its regular status polls. Once RMCLOMV_RMCFAILTHRESHOLD
 252  * is reached, rmclomv_rmc_state is marked as RMCLOMV_RMCSTATE_FAILED.
 253  */
 254 static int      rmclomv_rmc_state = RMCLOMV_RMCSTATE_UNKNOWN;
 255 static int      rmclomv_rmc_error = RMCLOMV_RMCERROR_NONE;
 256 static int      rmclomv_rmcfailcount;
 257 
 258 /*
 259  * Refresh commands..
 260  */
 261 #define RMCLOMV_REFRESH_EXITNOW         (-1)
 262 #define RMCLOMV_REFRESH_WAIT            0
 263 #define RMCLOMV_REFRESH_PROCESSNOW      1
 264 
 265 /*
 266  * Refresh thread state
 267  */
 268 static int rmclomv_refresh_sig = RMCLOMV_REFRESH_WAIT;
 269 static kt_did_t rmclomv_refresh_tid = 0;
 270 
 271 /*
 272  * timeout id
 273  */
 274 static timeout_id_t     timer_id;
 275 
 276 /*
 277  * Handle-name cache
 278  */
 279 #define LOCK_CACHE              mutex_enter(&rmclomv_cache_lock);
 280 #define RELEASE_CACHE           mutex_exit(&rmclomv_cache_lock);
 281 static rmclomv_cache_section_t  *rmclomv_cache;         /* main handle-names */
 282 static rmclomv_cache_section_t  *rmclomv_subcache;      /* derived names */
 283 static dp_get_sysinfo_r_t       rmclomv_sysinfo_data;
 284 static boolean_t                rmclomv_sysinfo_valid;
 285 static int                      rmclomv_cache_valid;
 286 
 287 extern pri_t maxclsyspri;
 288 
 289 /*
 290  * static strings
 291  */
 292 static const char       str_percent[]           = "%";
 293 static const char       str_rpm[]               = " rpm";
 294 static const char       str_ip_volts_ind[]      = "P_PWR";
 295 static const char       str_ip2_volts_ind[]     = "P_PWR2";
 296 static const char       str_ff_pok_ind[]        = "FF_POK";
 297 static const char       str_vlo_volts_ind[]     = "FF_UV";
 298 static const char       str_vhi_volts_ind[]     = "FF_OV";
 299 static const char       str_chi_amps_ind[]      = "FF_OC";
 300 static const char       str_chi_nr_ind[]        = "FF_NR";
 301 static const char       str_ot_tmpr_ind[]       = "FF_OT";
 302 static const char       str_fan_ind[]           = "FF_FAN";
 303 static const char       str_pdct_fan_ind[]      = "FF_PDCT_FAN";
 304 static const char       str_sc[]                = "SC";
 305 
 306 int
 307 _init(void)
 308 {
 309         int     error = 0;
 310 
 311         mutex_init(&rmclomv_event_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
 312         mutex_init(&rmclomv_checkrmc_lock, NULL, MUTEX_DRIVER, NULL);
 313         mutex_init(&rmclomv_refresh_lock, NULL, MUTEX_DRIVER, NULL);
 314         mutex_init(&rmclomv_cache_lock, NULL, MUTEX_DRIVER, NULL);
 315         mutex_init(&rmclomv_state_lock, NULL, MUTEX_DRIVER, NULL);
 316         mutex_init(&timesync_lock, NULL, MUTEX_DEFAULT, NULL);
 317         cv_init(&rmclomv_checkrmc_sig_cv, NULL, CV_DRIVER, NULL);
 318         cv_init(&rmclomv_refresh_sig_cv, NULL, CV_DRIVER, NULL);
 319 
 320         error = mod_install(&modlinkage);
 321         if (error) {
 322                 cv_destroy(&rmclomv_refresh_sig_cv);
 323                 cv_destroy(&rmclomv_checkrmc_sig_cv);
 324                 mutex_destroy(&rmclomv_state_lock);
 325                 mutex_destroy(&rmclomv_cache_lock);
 326                 mutex_destroy(&rmclomv_refresh_lock);
 327                 mutex_destroy(&rmclomv_checkrmc_lock);
 328                 mutex_destroy(&rmclomv_event_hdlr_lock);
 329         }
 330         return (error);
 331 }
 332 
 333 
 334 int
 335 _info(struct modinfo *modinfop)
 336 {
 337         return (mod_info(&modlinkage, modinfop));
 338 }
 339 
 340 
 341 int
 342 _fini(void)
 343 {
 344         int     error = 0;
 345 
 346         error = mod_remove(&modlinkage);
 347         if (error)
 348                 return (error);
 349         cv_destroy(&rmclomv_refresh_sig_cv);
 350         cv_destroy(&rmclomv_checkrmc_sig_cv);
 351         mutex_destroy(&timesync_lock);
 352         mutex_destroy(&rmclomv_state_lock);
 353         mutex_destroy(&rmclomv_cache_lock);
 354         mutex_destroy(&rmclomv_refresh_lock);
 355         mutex_destroy(&rmclomv_checkrmc_lock);
 356         mutex_destroy(&rmclomv_event_hdlr_lock);
 357         return (error);
 358 }
 359 
 360 
 361 /* ARGSUSED */
 362 static int
 363 rmclomv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
 364 {
 365         minor_t m = getminor((dev_t)arg);
 366 
 367         switch (cmd) {
 368         case DDI_INFO_DEVT2DEVINFO:
 369                 if ((m != 0) || (rmclomv_dip == NULL)) {
 370                         *resultp = NULL;
 371                         return (DDI_FAILURE);
 372                 }
 373                 *resultp = rmclomv_dip;
 374                 return (DDI_SUCCESS);
 375         case DDI_INFO_DEVT2INSTANCE:
 376                 *resultp = (void *)(uintptr_t)m;
 377                 return (DDI_SUCCESS);
 378         default:
 379                 return (DDI_FAILURE);
 380         }
 381 }
 382 
 383 
 384 static int
 385 rmclomv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
 386 {
 387         int                     instance;
 388         int                     err;
 389         char                    *wdog_state;
 390         int                     attaching = 1;
 391 
 392         switch (cmd) {
 393         case DDI_ATTACH:
 394                 /*
 395                  * only allow one instance
 396                  */
 397                 instance = ddi_get_instance(dip);
 398                 if (instance != 0)
 399                         return (DDI_FAILURE);
 400 
 401                 err = ddi_create_minor_node(dip, "rmclomv", S_IFCHR,
 402                     instance, DDI_PSEUDO, NULL);
 403                 if (err != DDI_SUCCESS)
 404                         return (DDI_FAILURE);
 405 
 406                 /*
 407                  * Register with rmc_comm to prevent it being detached
 408                  * (in the unlikely event that its attach succeeded on a
 409                  * platform whose platmod doesn't lock it down).
 410                  */
 411                 err = rmc_comm_register();
 412                 if (err != DDI_SUCCESS) {
 413                         ddi_remove_minor_node(dip, NULL);
 414                         return (DDI_FAILURE);
 415                 }
 416 
 417                 /* Remember the dev info */
 418                 rmclomv_dip = dip;
 419 
 420                 /*
 421                  * Add the handlers which watch for unsolicited messages
 422                  * and post event to Sysevent Framework.
 423                  */
 424                 err = rmclomv_add_intr_handlers();
 425                 if (err != DDI_SUCCESS) {
 426                         rmc_comm_unregister();
 427                         ddi_remove_minor_node(dip, NULL);
 428                         rmclomv_dip = NULL;
 429                         return (DDI_FAILURE);
 430                 }
 431 
 432                 rmclomv_checkrmc_start();
 433                 rmclomv_refresh_start();
 434 
 435                 abort_seq_handler = rmclomv_abort_seq_handler;
 436                 ddi_report_dev(dip);
 437 
 438                 /*
 439                  * Check whether we have an application watchdog
 440                  */
 441                 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip,
 442                     DDI_PROP_DONTPASS, RMCLOMV_WATCHDOG_MODE,
 443                     &wdog_state) == DDI_PROP_SUCCESS) {
 444                         if (strcmp(wdog_state, "app") == 0) {
 445                                 rmclomv_watchdog_mode = 1;
 446                                 watchdog_enable = 0;
 447                         }
 448                         else
 449                                 rmclomv_watchdog_mode = 0;
 450                         ddi_prop_free(wdog_state);
 451                 }
 452 
 453                 tod_ops.tod_set_watchdog_timer = rmc_set_watchdog_timer;
 454                 tod_ops.tod_clear_watchdog_timer = rmc_clear_watchdog_timer;
 455 
 456                 /*
 457                  * Now is a good time to activate hardware watchdog
 458                  * (if one exists).
 459                  */
 460                 mutex_enter(&tod_lock);
 461                 if (watchdog_enable && tod_ops.tod_set_watchdog_timer != NULL)
 462                         err = tod_ops.tod_set_watchdog_timer(0);
 463                 mutex_exit(&tod_lock);
 464                 if (err != 0)
 465                         printf("Hardware watchdog enabled\n");
 466 
 467                 /*
 468                  * Set time interval and start timesync routine.
 469                  * Also just this once set the Solaris clock
 470                  * to the RMC clock.
 471                  */
 472                 timesync_interval = drv_usectohz(5*60 * MICROSEC);
 473                 plat_timesync((void *) &attaching);
 474 
 475                 return (DDI_SUCCESS);
 476         case DDI_RESUME:
 477                 return (DDI_SUCCESS);
 478         default:
 479                 return (DDI_FAILURE);
 480         }
 481 }
 482 
 483 
 484 static int
 485 rmclomv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 486 {
 487         timeout_id_t    tid;
 488         int             instance;
 489         int             err;
 490 
 491         switch (cmd) {
 492         case DDI_DETACH:
 493                 instance = ddi_get_instance(dip);
 494                 if (instance != 0)
 495                         return (DDI_FAILURE);
 496 
 497                 /*
 498                  * Remove the handlers which watch for unsolicited messages
 499                  * and post event to Sysevent Framework.
 500                  */
 501                 err = rmclomv_remove_intr_handlers();
 502                 if (err != DDI_SUCCESS) {
 503                         cmn_err(CE_WARN, "Failed to remove event handlers");
 504                         return (DDI_FAILURE);
 505                 }
 506                 rmclomv_checkrmc_destroy();
 507                 rmclomv_refresh_destroy();
 508                 rmclomv_reset_cache(NULL, NULL, NULL);
 509                 ddi_remove_minor_node(dip, NULL);
 510 
 511                 mutex_enter(&timesync_lock);
 512                 tid = timesync_tid;
 513                 timesync_tid = 0;
 514                 timesync_interval = 0;
 515                 mutex_exit(&timesync_lock);
 516                 (void) untimeout(tid);
 517 
 518                 /* Forget the dev info */
 519                 rmclomv_dip = NULL;
 520                 rmc_comm_unregister();
 521                 return (DDI_SUCCESS);
 522         case DDI_SUSPEND:
 523                 return (DDI_SUCCESS);
 524         default:
 525                 return (DDI_FAILURE);
 526         }
 527 }
 528 
 529 static int
 530 rmclomv_add_intr_handlers()
 531 {
 532         int     err;
 533 
 534         if (ddi_get_soft_iblock_cookie(rmclomv_dip, DDI_SOFTINT_HIGH,
 535             &rmclomv_soft_iblock_cookie) != DDI_SUCCESS) {
 536                 return (DDI_FAILURE);
 537         }
 538         err = ddi_add_softintr(rmclomv_dip, DDI_SOFTINT_HIGH,
 539             &rmclomv_softintr_id, &rmclomv_soft_iblock_cookie, NULL,
 540             rmclomv_break_intr, NULL);
 541         if (err != DDI_SUCCESS)
 542                 return (DDI_FAILURE);
 543         rmclomv_event_payload_msg.msg_buf = (caddr_t)&rmclomv_event_payload;
 544         rmclomv_event_payload_msg.msg_len = sizeof (rmclomv_event_payload);
 545         err = rmc_comm_reg_intr(DP_RMC_EVENTS, rmclomv_event_data_handler,
 546             &rmclomv_event_payload_msg, NULL, &rmclomv_event_hdlr_lock);
 547         if (err != 0) {
 548                 ddi_remove_softintr(rmclomv_softintr_id);
 549                 return (DDI_FAILURE);
 550         }
 551         return (DDI_SUCCESS);
 552 }
 553 
 554 static int
 555 rmclomv_remove_intr_handlers(void)
 556 {
 557         int err = rmc_comm_unreg_intr(DP_RMC_EVENTS,
 558             rmclomv_event_data_handler);
 559         if (err != 0) {
 560                 cmn_err(CE_WARN, "Failed to unregister DP_RMC_EVENTS "
 561                     "handler. Err=%d", err);
 562                 return (DDI_FAILURE);
 563         }
 564         ddi_remove_softintr(rmclomv_softintr_id);
 565         return (DDI_SUCCESS);
 566 }
 567 
 568 static void
 569 rmclomv_abort_seq_handler(char *msg)
 570 {
 571         if (key_position == RMC_KEYSWITCH_POS_LOCKED)
 572                 cmn_err(CE_CONT, "KEY in LOCKED position, "
 573                     "ignoring debug enter sequence");
 574         else  {
 575                 rmclomv_break_requested = B_TRUE;
 576                 if (msg != NULL)
 577                         prom_printf("%s\n", msg);
 578 
 579                 ddi_trigger_softintr(rmclomv_softintr_id);
 580         }
 581 }
 582 
 583 /* ARGSUSED */
 584 static uint_t
 585 rmclomv_break_intr(caddr_t arg)
 586 {
 587         if (rmclomv_break_requested) {
 588                 rmclomv_break_requested = B_FALSE;
 589                 debug_enter(NULL);
 590                 return (DDI_INTR_CLAIMED);
 591         }
 592 
 593         return (DDI_INTR_UNCLAIMED);
 594 }
 595 
 596 /*
 597  * Create a cache section structure
 598  */
 599 static rmclomv_cache_section_t *
 600 create_cache_section(int sensor_type, int num)
 601 {
 602         size_t len = offsetof(rmclomv_cache_section_t, entry[0]) +
 603             num * sizeof (rmclomv_cache_entry_t);
 604         rmclomv_cache_section_t *ptr = kmem_zalloc(len, KM_SLEEP);
 605         ptr->next_section = NULL;
 606         ptr->sensor_type = sensor_type;
 607         ptr->num_entries = num;
 608         ptr->section_len = len;
 609         return (ptr);
 610 }
 611 
 612 /*
 613  * Free a cache_section.
 614  */
 615 static void
 616 free_section(rmclomv_cache_section_t *section)
 617 {
 618         size_t len = section->section_len;
 619         kmem_free(section, len);
 620 }
 621 
 622 /*
 623  * adds supplied section to end of cache chain
 624  * must be called with cache locked
 625  */
 626 static void
 627 add_section(rmclomv_cache_section_t **head, rmclomv_cache_section_t *section)
 628 {
 629         section->next_section = *head;
 630         *head = section;
 631 }
 632 
 633 /*
 634  * This function releases all cache sections and exchanges the two
 635  * chain heads for new values.
 636  */
 637 static void
 638 rmclomv_reset_cache(rmclomv_cache_section_t *new_chain,
 639     rmclomv_cache_section_t *new_subchain, dp_get_sysinfo_r_t *sysinfo)
 640 {
 641         rmclomv_cache_section_t *first;
 642         rmclomv_cache_section_t *sub_first;
 643         rmclomv_cache_section_t *next;
 644 
 645         LOCK_CACHE
 646 
 647         rmclomv_cache_valid = (new_chain != NULL);
 648         first = rmclomv_cache;
 649         rmclomv_cache = new_chain;
 650         sub_first = rmclomv_subcache;
 651         rmclomv_subcache = new_subchain;
 652 
 653         if (sysinfo == NULL)
 654                 bzero(&rmclomv_sysinfo_data, sizeof (rmclomv_sysinfo_data));
 655         else
 656                 bcopy(sysinfo, &rmclomv_sysinfo_data,
 657                     sizeof (rmclomv_sysinfo_data));
 658 
 659         rmclomv_sysinfo_valid = (sysinfo != NULL);
 660 
 661         RELEASE_CACHE
 662 
 663         while (first != NULL) {
 664                 next = first->next_section;
 665                 free_section(first);
 666                 first = next;
 667         }
 668 
 669         while (sub_first != NULL) {
 670                 next = sub_first->next_section;
 671                 free_section(sub_first);
 672                 sub_first = next;
 673         }
 674 }
 675 
 676 /*
 677  * cache must be locked before calling rmclomv_find_section
 678  */
 679 static rmclomv_cache_section_t *
 680 rmclomv_find_section(rmclomv_cache_section_t *start, uint16_t sensor)
 681 {
 682         rmclomv_cache_section_t *next = start;
 683 
 684         while ((next != NULL) && (next->sensor_type != sensor))
 685                 next = next->next_section;
 686 
 687         return (next);
 688 }
 689 
 690 /*
 691  * Return a string presenting the keyswitch position
 692  * For unknown values returns "Unknown"
 693  */
 694 static char *
 695 rmclomv_key_position(enum rmc_keyswitch_pos pos)
 696 {
 697         switch (pos) {
 698 
 699         case RMC_KEYSWITCH_POS_NORMAL:
 700                 return ("NORMAL");
 701         case RMC_KEYSWITCH_POS_DIAG:
 702                 return ("DIAG");
 703         case RMC_KEYSWITCH_POS_LOCKED:
 704                 return ("LOCKED");
 705         case RMC_KEYSWITCH_POS_OFF:
 706                 return ("STBY");
 707         default:
 708                 return ("UNKNOWN");
 709         }
 710 }
 711 
 712 /*
 713  * The sensor id name is sought in the supplied section and if found
 714  * its index within the section is written to *index.
 715  * Return value is zero for success, otherwise -1.
 716  * The cache must be locked before calling get_sensor_by_name
 717  */
 718 static int
 719 get_sensor_by_name(const rmclomv_cache_section_t *section,
 720     const char *name, int *index)
 721 {
 722         int i;
 723 
 724         for (i = 0; i < section->num_entries; i++) {
 725                 if (strcmp(name, section->entry[i].handle_name.name) == 0) {
 726                         *index = i;
 727                         return (0);
 728                 }
 729         }
 730 
 731         *index = 0;
 732         return (-1);
 733 }
 734 
 735 /*
 736  * fills in the envmon_handle name
 737  * if it is unknown (not cached), the dp_handle_t is returned as a hex-digit
 738  * string
 739  */
 740 static void
 741 rmclomv_hdl_to_envhdl(dp_handle_t hdl, envmon_handle_t *envhdl)
 742 {
 743         rmclomv_cache_section_t *next;
 744         int                     i;
 745 
 746         LOCK_CACHE
 747 
 748         for (next = rmclomv_cache; next != NULL; next = next->next_section) {
 749                 for (i = 0; i < next->num_entries; i++) {
 750                         if (next->entry[i].handle == hdl) {
 751                                 *envhdl = next->entry[i].handle_name;
 752                                         RELEASE_CACHE
 753                                         return;
 754                         }
 755                 }
 756         }
 757 
 758         /*
 759          * Sought handle not currently cached.
 760          */
 761         RELEASE_CACHE
 762 
 763         (void) snprintf(envhdl->name, sizeof (envhdl->name),
 764             "Unknown SC node 0x%x", hdl);
 765 }
 766 
 767 static void
 768 rmclomv_dr_data_handler(const char *fru_name, int hint)
 769 {
 770         int                             err = 0;
 771         nvlist_t                        *attr_list;
 772         char                            attach_pnt[MAXPATHLEN];
 773 
 774         (void) snprintf(attach_pnt, sizeof (attach_pnt), "%s", fru_name);
 775 
 776         err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
 777         if (err != 0) {
 778                 cmn_err(CE_WARN,
 779                     "Failed to allocate name-value list for %s event", EC_DR);
 780                 return;
 781         }
 782 
 783         err = nvlist_add_string(attr_list, DR_AP_ID, attach_pnt);
 784         if (err != 0) {
 785                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s event",
 786                     DR_AP_ID, EC_DR);
 787                 nvlist_free(attr_list);
 788                 return;
 789         }
 790 
 791         /*
 792          * Add the hint
 793          */
 794         err = nvlist_add_string(attr_list, DR_HINT, SE_HINT2STR(hint));
 795         if (err != 0) {
 796                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s event",
 797                     DR_HINT, EC_DR);
 798                 nvlist_free(attr_list);
 799                 return;
 800         }
 801 
 802         err = ddi_log_sysevent(rmclomv_dip, DDI_VENDOR_SUNW, EC_DR,
 803             ESC_DR_AP_STATE_CHANGE, attr_list, NULL, DDI_NOSLEEP);
 804         if (err != 0) {
 805                 cmn_err(CE_WARN, "Failed to log %s/%s event",
 806                     DR_AP_ID, EC_DR);
 807         }
 808 
 809         nvlist_free(attr_list);
 810 }
 811 
 812 static void
 813 fan_sysevent(char *fru_name, char *sensor_name, int sub_event)
 814 {
 815         nvlist_t                *attr_list;
 816         char                    fan_str[MAXNAMELEN];
 817         int                     err;
 818 
 819         err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
 820         if (err != 0) {
 821                 cmn_err(CE_WARN,
 822                     "Failed to allocate name-value list for %s/%s event",
 823                     EC_ENV, ESC_ENV_FAN);
 824                 return;
 825         }
 826 
 827         err = nvlist_add_string(attr_list, ENV_FRU_ID, fru_name);
 828         if (err != 0) {
 829                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 830                     ENV_FRU_ID, EC_ENV, ESC_ENV_FAN);
 831                 nvlist_free(attr_list);
 832                 return;
 833         }
 834 
 835         err = nvlist_add_string(attr_list, ENV_FRU_RESOURCE_ID, sensor_name);
 836         if (err != 0) {
 837                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 838                     ENV_FRU_RESOURCE_ID, EC_ENV, ESC_ENV_FAN);
 839                 nvlist_free(attr_list);
 840                 return;
 841         }
 842 
 843         err = nvlist_add_string(attr_list, ENV_FRU_DEVICE, ENV_RESERVED_ATTR);
 844         if (err != 0) {
 845                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 846                     ENV_FRU_DEVICE, EC_ENV, ESC_ENV_FAN);
 847                 nvlist_free(attr_list);
 848                 return;
 849         }
 850 
 851         err = nvlist_add_int32(attr_list, ENV_FRU_STATE,
 852             (sub_event == RMC_ENV_FAULT_EVENT) ? ENV_FAILED : ENV_OK);
 853         if (err != 0) {
 854                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 855                     ENV_FRU_STATE, EC_ENV, ESC_ENV_FAN);
 856                 nvlist_free(attr_list);
 857                 return;
 858         }
 859 
 860         if (sub_event == RMC_ENV_FAULT_EVENT) {
 861                 (void) snprintf(fan_str, sizeof (fan_str),
 862                     "fan %s/%s is now failed", fru_name, sensor_name);
 863         } else {
 864                 (void) snprintf(fan_str, sizeof (fan_str),
 865                     "fan %s/%s is now ok", fru_name, sensor_name);
 866         }
 867         err = nvlist_add_string(attr_list, ENV_MSG, fan_str);
 868         if (err != 0) {
 869                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 870                     ENV_MSG, EC_ENV, ESC_ENV_FAN);
 871                 nvlist_free(attr_list);
 872                 return;
 873         }
 874 
 875         err = ddi_log_sysevent(rmclomv_dip, DDI_VENDOR_SUNW, EC_ENV,
 876             ESC_ENV_FAN, attr_list, NULL, DDI_NOSLEEP);
 877         if (err != 0) {
 878                 cmn_err(CE_WARN, "Failed to log %s/%s event",
 879                     EC_ENV, ESC_ENV_FAN);
 880         }
 881 
 882         cmn_err(CE_NOTE, "%s", fan_str);
 883         nvlist_free(attr_list);
 884 }
 885 
 886 static void
 887 threshold_sysevent(char *fru_name, char *sensor_name, int sub_event,
 888         char event_type)
 889 {
 890         nvlist_t                *attr_list;
 891         int                     err;
 892         char                    *subclass;
 893         char                    sensor_str[MAXNAMELEN];
 894 
 895         subclass = (event_type == 'T') ? ESC_ENV_TEMP : ESC_ENV_POWER;
 896 
 897         err = nvlist_alloc(&attr_list, NV_UNIQUE_NAME_TYPE, KM_NOSLEEP);
 898         if (err != 0) {
 899                 cmn_err(CE_WARN,
 900                     "Failed to allocate name-value list for %s/%s event",
 901                     EC_ENV, subclass);
 902                 return;
 903         }
 904 
 905         err = nvlist_add_string(attr_list, ENV_FRU_ID, fru_name);
 906         if (err != 0) {
 907                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 908                     ENV_FRU_ID, EC_ENV, subclass);
 909                 nvlist_free(attr_list);
 910                 return;
 911         }
 912 
 913         err = nvlist_add_string(attr_list, ENV_FRU_RESOURCE_ID, sensor_name);
 914         if (err != 0) {
 915                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 916                     ENV_FRU_RESOURCE_ID, EC_ENV, subclass);
 917                 nvlist_free(attr_list);
 918                 return;
 919         }
 920 
 921         err = nvlist_add_string(attr_list, ENV_FRU_DEVICE, ENV_RESERVED_ATTR);
 922         if (err != 0) {
 923                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 924                     ENV_FRU_DEVICE, EC_ENV, subclass);
 925                 nvlist_free(attr_list);
 926                 return;
 927         }
 928 
 929         switch (sub_event) {
 930         case RMC_ENV_OK_EVENT:
 931                 err = nvlist_add_int32(attr_list, ENV_FRU_STATE, ENV_OK);
 932                 break;
 933         case RMC_ENV_WARNING_THRESHOLD_EVENT:
 934                 err = nvlist_add_int32(attr_list, ENV_FRU_STATE, ENV_WARNING);
 935                 break;
 936         case RMC_ENV_SHUTDOWN_THRESHOLD_EVENT:
 937                 err = nvlist_add_int32(attr_list, ENV_FRU_STATE, ENV_FAILED);
 938                 break;
 939         }
 940         if (err != 0) {
 941                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 942                     ENV_FRU_STATE, EC_ENV, subclass);
 943                 nvlist_free(attr_list);
 944                 return;
 945         }
 946 
 947         switch (sub_event) {
 948         case RMC_ENV_OK_EVENT:
 949                 (void) snprintf(sensor_str, sizeof (sensor_str),
 950                     "sensor %s/%s is now ok", fru_name,
 951                     sensor_name);
 952                 break;
 953         case RMC_ENV_WARNING_THRESHOLD_EVENT:
 954                 (void) snprintf(sensor_str, sizeof (sensor_str),
 955                     "sensor %s/%s is now outside warning thresholds", fru_name,
 956                     sensor_name);
 957                 break;
 958         case RMC_ENV_SHUTDOWN_THRESHOLD_EVENT:
 959                 (void) snprintf(sensor_str, sizeof (sensor_str),
 960                     "sensor %s/%s is now outside shutdown thresholds", fru_name,
 961                     sensor_name);
 962                 break;
 963         }
 964         err = nvlist_add_string(attr_list, ENV_MSG, sensor_str);
 965         if (err != 0) {
 966                 cmn_err(CE_WARN, "Failed to add attr [%s] for %s/%s event",
 967                     ENV_MSG, EC_ENV, subclass);
 968                 nvlist_free(attr_list);
 969                 return;
 970         }
 971 
 972         err = ddi_log_sysevent(rmclomv_dip, DDI_VENDOR_SUNW, EC_ENV,
 973             subclass, attr_list, NULL, DDI_NOSLEEP);
 974         if (err != 0) {
 975                 cmn_err(CE_WARN, "Failed to log %s/%s event",
 976                     EC_ENV, subclass);
 977         }
 978 
 979         cmn_err(CE_NOTE, "%s", sensor_str);
 980         nvlist_free(attr_list);
 981 }
 982 
 983 static uint_t
 984 rmclomv_event_data_handler(char *arg)
 985 {
 986         dp_event_notification_t *payload;
 987         rmc_comm_msg_t  *msg;
 988         envmon_handle_t envhdl;
 989         int hint;
 990         char *ptr, *save_ptr;
 991 
 992         if (arg == NULL) {
 993                 return (DDI_INTR_CLAIMED);
 994         }
 995 
 996         msg = (rmc_comm_msg_t *)arg;
 997         if (msg->msg_buf == NULL) {
 998                 return (DDI_INTR_CLAIMED);
 999         }
1000 
1001         payload = (dp_event_notification_t *)msg->msg_buf;
1002         switch (payload->event) {
1003 
1004         case RMC_KEYSWITCH_EVENT:
1005                 real_key_position = payload->event_info.ev_keysw.key_position;
1006                 cmn_err(CE_NOTE, "keyswitch change event - state = %s",
1007                     rmclomv_key_position(real_key_position));
1008                 if ((real_key_position != RMC_KEYSWITCH_POS_UNKNOWN) &&
1009                     (real_key_position <= RMC_KEYSWITCH_POS_OFF)) {
1010                         key_position = real_key_position;
1011                 } else {
1012                         /* treat unknown key position as locked */
1013                         key_position = RMC_KEYSWITCH_POS_LOCKED;
1014                 }
1015                 break;
1016 
1017         case RMC_HPU_EVENT:
1018                 /*
1019                  * send appropriate sysevent
1020                  */
1021                 switch (payload->event_info.ev_hpunot.sub_event) {
1022                 case RMC_HPU_REMOVE_EVENT:
1023                         hint = SE_HINT_REMOVE;
1024                         break;
1025                 case RMC_HPU_INSERT_EVENT:
1026                         hint = SE_HINT_INSERT;
1027                         break;
1028                 default:
1029                         hint = SE_NO_HINT;
1030                         break;
1031                 }
1032                 rmclomv_hdl_to_envhdl(payload->event_info.ev_hpunot.hpu_hdl,
1033                     &envhdl);
1034                 rmclomv_dr_data_handler(envhdl.name, hint);
1035                 break;
1036 
1037         case RMC_INIT_EVENT:
1038                 /*
1039                  * Wake up the refresh thread.
1040                  */
1041                 rmclomv_refresh_wakeup();
1042 
1043                 /*
1044                  * Wake up the checkrmc thread for an early indication to PICL
1045                  */
1046                 rmclomv_checkrmc_wakeup(NULL);
1047                 break;
1048 
1049         case RMC_ENV_EVENT:
1050                 rmclomv_hdl_to_envhdl(payload->event_info.ev_envnot.env_hdl,
1051                     &envhdl);
1052 
1053                 /* split name into fru name and sensor name */
1054                 ptr = strchr(envhdl.name, '.');
1055 
1056                 /* must have at least one '.' */
1057                 if (ptr == NULL)
1058                         break;
1059 
1060                 /* find last '.' - convert the others to '/' */
1061                 for (;;) {
1062                         save_ptr = ptr;
1063                         ptr = strchr(ptr, '.');
1064                         if (ptr == NULL) {
1065                                 ptr = save_ptr;
1066                                 break;
1067                         }
1068                         *save_ptr = '/';
1069                 }
1070                 *ptr = '\0';
1071                 ptr++;
1072                 /* is it a voltage or temperature sensor? */
1073                 if ((*ptr == 'V' || *ptr == 'T') && *(ptr + 1) == '_') {
1074                         switch (payload->event_info.ev_envnot.sub_event) {
1075                         case RMC_ENV_WARNING_THRESHOLD_EVENT:
1076                         case RMC_ENV_SHUTDOWN_THRESHOLD_EVENT:
1077                         case RMC_ENV_OK_EVENT:
1078                                 threshold_sysevent(envhdl.name, ptr,
1079                                     payload->event_info.ev_envnot.sub_event,
1080                                     *ptr);
1081                                 break;
1082                         default:
1083                                 break;
1084                         }
1085                 }
1086 
1087                 /*
1088                  * is it a fan sensor?
1089                  * Fan sensor names end either in RS, F0 or F1
1090                  */
1091                 if ((*ptr == 'R' && *(ptr + 1) == 'S' && *(ptr + 2) == '\0') ||
1092                     (*ptr == 'F' && *(ptr + 1) == '0' && *(ptr + 2) == '\0') ||
1093                     (*ptr == 'F' && *(ptr + 1) == '1' && *(ptr + 2) == '\0')) {
1094                         switch (payload->event_info.ev_envnot.sub_event) {
1095                         case RMC_ENV_FAULT_EVENT:
1096                         case RMC_ENV_OK_EVENT:
1097                                 fan_sysevent(envhdl.name, ptr,
1098                                     payload->event_info.ev_envnot.sub_event);
1099                                 break;
1100                         default:
1101                                 break;
1102                         }
1103                 }
1104                 break;
1105 
1106         case RMC_LOG_EVENT:
1107         {
1108                 int level = 10;
1109                 int flags = SL_NOTE | SL_CONSOLE;
1110                 char *message =
1111                     (char *)payload->event_info.ev_rmclog.log_record;
1112 
1113                 message[ payload->event_info.ev_rmclog.log_record_size] = '\0';
1114 
1115                 /*
1116                  * Logs have a 10 character prefix - specifying the severity of
1117                  * the event being logged. Thus all the magic number 10s down
1118                  * here
1119                  */
1120                 if (0 == strncmp("CRITICAL: ", message, 10)) {
1121                         message += 10;
1122                         level = 0;
1123                         flags = SL_FATAL | SL_ERROR | SL_CONSOLE;
1124                 } else if (0 == strncmp("MAJOR:    ", message, 10)) {
1125                         message += 10;
1126                         level = 5;
1127                         flags = SL_WARN | SL_ERROR | SL_CONSOLE;
1128                 } else if (0 == strncmp("MINOR:    ", message, 10)) {
1129                         message += 10;
1130                         level = 10;
1131                         flags = SL_NOTE | SL_CONSOLE;
1132                 }
1133 
1134                 (void) strlog(0, 0, level, flags, message);
1135                 break;
1136         }
1137 
1138         default:
1139                 return (DDI_INTR_CLAIMED);
1140         }
1141 
1142         return (DDI_INTR_CLAIMED);
1143 }
1144 
1145 /*ARGSUSED*/
1146 static int
1147 rmclomv_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
1148 {
1149         int error = 0;
1150         int instance = getminor(*dev_p);
1151 
1152         if (instance != 0)
1153                 return (ENXIO);
1154 
1155         if ((flag & FWRITE) != 0 && (error = drv_priv(cred_p)) != 0)
1156                 return (error);
1157 
1158         return (0);
1159 }
1160 
1161 /*ARGSUSED*/
1162 static int
1163 rmclomv_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
1164 {
1165         return (DDI_SUCCESS);
1166 }
1167 
1168 static int
1169 rmclomv_do_cmd(int req_cmd, int resp_cmd, int resp_len, intptr_t arg_req,
1170     intptr_t arg_res)
1171 {
1172         rmc_comm_msg_t request, *reqp = &request;
1173         rmc_comm_msg_t response, *resp = &response;
1174         int rv = 0;
1175 
1176         bzero((caddr_t)&request, sizeof (request));
1177         reqp->msg_type = req_cmd;
1178         reqp->msg_buf = (caddr_t)arg_req;
1179         bzero((caddr_t)&response, sizeof (response));
1180         resp->msg_type = resp_cmd;
1181         resp->msg_buf = (caddr_t)arg_res;
1182         resp->msg_len = resp_len;
1183 
1184         switch (req_cmd) {
1185         case DP_GET_SYSINFO:
1186                 resp->msg_len = sizeof (dp_get_sysinfo_r_t);
1187                 break;
1188         case DP_GET_EVENT_LOG:
1189                 resp->msg_len = sizeof (dp_get_event_log_r_t);
1190                 break;
1191         case DP_GET_VOLTS:
1192                 reqp->msg_len = sizeof (dp_get_volts_t);
1193                 break;
1194         case DP_GET_TEMPERATURES:
1195                 reqp->msg_len = sizeof (dp_get_temperatures_t);
1196                 break;
1197         case DP_GET_CIRCUIT_BRKS:
1198                 reqp->msg_len = sizeof (dp_get_circuit_brks_t);
1199                 break;
1200         case DP_GET_FAN_STATUS:
1201                 reqp->msg_len = sizeof (dp_get_fan_status_t);
1202                 break;
1203         case DP_GET_PSU_STATUS:
1204                 reqp->msg_len = sizeof (dp_get_psu_status_t);
1205                 break;
1206         case DP_GET_LED_STATE:
1207                 reqp->msg_len = sizeof (dp_get_led_state_t);
1208                 break;
1209         case DP_SET_LED_STATE:
1210                 reqp->msg_len = sizeof (dp_set_led_state_t);
1211                 break;
1212         case DP_GET_FRU_STATUS:
1213                 reqp->msg_len = sizeof (dp_get_fru_status_t);
1214                 break;
1215         case DP_GET_HANDLE_NAME:
1216                 reqp->msg_len = sizeof (dp_get_handle_name_t);
1217                 break;
1218         case DP_GET_ALARM_STATE:
1219                 reqp->msg_len = sizeof (dp_get_alarm_state_t);
1220                 break;
1221         case DP_SET_ALARM_STATE:
1222                 reqp->msg_len = sizeof (dp_set_alarm_state_t);
1223                 break;
1224         case DP_GET_SDP_VERSION:
1225                 resp->msg_len = sizeof (dp_get_sdp_version_r_t);
1226                 break;
1227         case DP_GET_CHASSIS_SERIALNUM:
1228                 reqp->msg_len = 0;
1229                 break;
1230         case DP_GET_DATE_TIME:
1231                 reqp->msg_len = 0;
1232                 break;
1233         default:
1234                 return (EINVAL);
1235         }
1236 
1237         rv = rmc_comm_request_response(reqp, resp,
1238             RMCLOMV_DEFAULT_MAX_MBOX_WAIT_TIME);
1239 
1240         if (rv != RCNOERR) {
1241                 /*
1242                  * RMC returned an error or failed to respond.
1243                  * Where the RMC itself is implicated, rmclomv_rmc_error
1244                  * is set non-zero. It is cleared after an error free exchange.
1245                  * Two failure cases are distinguished:
1246                  * RMCLOMV_RMCSTATE_FAILED and RMCLOMV_RMCSTATE_DOWNLOAD.
1247                  */
1248                 switch (rv) {
1249                 case RCENOSOFTSTATE:
1250                         /* invalid/NULL soft state structure */
1251                         return (EIO);
1252                 case RCENODATALINK:
1253                         /*
1254                          * firmware download in progress,
1255                          * can you come back later?
1256                          */
1257                         rmclomv_rmc_error = RMCLOMV_RMCSTATE_DOWNLOAD;
1258                         rmclomv_rmc_state = RMCLOMV_RMCSTATE_DOWNLOAD;
1259                         return (EAGAIN);
1260                 case RCENOMEM:
1261                         /* memory problems */
1262                         return (ENOMEM);
1263                 case RCECANTRESEND:
1264                         /* resend failed */
1265                         rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
1266                         return (EIO);
1267                 case RCEMAXRETRIES:
1268                         /* reply not received - retries exceeded */
1269                         rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
1270                         return (EINTR);
1271                 case RCETIMEOUT:
1272                         /* reply not received - command has timed out */
1273                         rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
1274                         return (EINTR);
1275                 case RCEINVCMD:
1276                         /* data protocol cmd not supported */
1277                         return (ENOTSUP);
1278                 case RCEINVARG:
1279                         /* invalid argument(s) */
1280                         return (ENOTSUP);
1281                 case RCEGENERIC:
1282                         /* generic error */
1283                         rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
1284                         return (EIO);
1285                 default:
1286                         rmclomv_rmc_error = RMCLOMV_RMCSTATE_FAILED;
1287                         return (EIO);
1288                 }
1289         }
1290 
1291         rmclomv_rmc_error = RMCLOMV_RMCERROR_NONE;
1292         return (0);
1293 }
1294 
1295 /*
1296  * validate_section_entry checks that the entry at the specified index
1297  * is valid and not duplicated by an entry above. If these tests fail
1298  * the entry is removed and B_FALSE returned. Otherwise returns B_TRUE.
1299  */
1300 static int
1301 validate_section_entry(rmclomv_cache_section_t *section, int index)
1302 {
1303         int                     i;
1304         rmclomv_cache_entry_t   *entry;
1305 
1306         for (i = index; i < section->num_entries; i++) {
1307                 entry = &section->entry[i];
1308                 if (entry->handle_name.name[0] == '\0') {
1309                         cmn_err(CE_WARN,
1310                             "rmclomv: empty handle_name, handle 0x%x type %x",
1311                             entry->handle, section->sensor_type);
1312                 } else if (entry->ind_mask != 0) {
1313                         continue;       /* skip special entries */
1314                 } else if (entry->handle == DP_NULL_HANDLE) {
1315                         cmn_err(CE_WARN,
1316                             "rmclomv: null handle id for \"%s\" type %x",
1317                             entry->handle_name.name, section->sensor_type);
1318                 } else if (i == index) {
1319                         continue;
1320                 } else if (section->entry[index].handle == entry->handle) {
1321                         cmn_err(CE_WARN,
1322                             "rmclomv: duplicate handle 0x%x type %x",
1323                             entry->handle, section->sensor_type);
1324                 } else if (strcmp(entry->handle_name.name,
1325                     section->entry[index].handle_name.name) == 0) {
1326                         cmn_err(CE_WARN,
1327                             "rmclomv: duplicate handle_name \"%s\", "
1328                             "handle 0x%x type %x", entry->handle_name.name,
1329                             entry->handle, section->sensor_type);
1330                 } else
1331                         continue;
1332 
1333                 /*
1334                  * need to remove the entry at index
1335                  */
1336                 section->num_entries--;
1337 
1338                 for (i = index; i < section->num_entries; i++) {
1339                         section->entry[i] = section->entry[i + 1];
1340                 }
1341 
1342                 return (B_FALSE);
1343         }
1344 
1345         return (B_TRUE);
1346 }
1347 
1348 /*
1349  * Populate a section containing handles with corresponding names
1350  * The supplied section structure must not be publically visible and the
1351  * name cache must not be locked either (because RMC i/o is required).
1352  *
1353  * This is the place where a sanity check is applied. Entries containing
1354  * duplicate handles, duplicate names or empty names are removed and the
1355  * structure is compacted. As a result num_entries may be reduced.
1356  */
1357 static int
1358 add_names_to_section(rmclomv_cache_section_t *section)
1359 {
1360         int                     retval = 0;
1361         int                     ditched = B_FALSE;
1362         int                     index;
1363         dp_get_handle_name_r_t  handle_name_r;
1364         rmclomv_cache_entry_t   *entry;
1365 
1366         for (index = 0; index < section->num_entries; index++) {
1367                 entry = &section->entry[index];
1368                 if (entry->ind_mask != 0)
1369                         continue;       /* skip special entries */
1370                 handle_name_r.handle = entry->handle;
1371                 retval = rmclomv_do_cmd(DP_GET_HANDLE_NAME,
1372                     DP_GET_HANDLE_NAME_R, sizeof (handle_name_r),
1373                     (intptr_t)&handle_name_r, (intptr_t)&handle_name_r);
1374                 if (retval == 0)
1375                         bcopy(handle_name_r.name,
1376                             entry->handle_name.name, DP_MAX_HANDLE_NAME);
1377         }
1378 
1379         /*
1380          * now ditch invalid and duplicate entries
1381          */
1382         for (index = 0; index < section->num_entries; index++) {
1383                 while (validate_section_entry(section, index) == B_FALSE)
1384                         ditched = B_TRUE;
1385         }
1386 
1387         if (ditched)
1388                 cmn_err(CE_WARN, "Retaining %d nodes of type %d",
1389                     section->num_entries, section->sensor_type);
1390 
1391         return (retval);
1392 }
1393 
1394 /*
1395  * The supplied (PSU) cache section is traversed and entries are created
1396  * for the individual indicators belonging to a PSU. These entries are
1397  * placed in a private chain. The caller, subsequently acquires the
1398  * cache lock and copies the chain head to make it public.
1399  * The handle-names for PSU indicators are derived from the parent PSU
1400  * handle-name.
1401  * NOTE: add_names_to_section() may have reduced psu_section->num_entries
1402  *       so DON'T USE psu_resp->num_psus
1403  */
1404 static void
1405 make_psu_subsections(rmclomv_cache_section_t *psu_section,
1406     rmclomv_cache_section_t **chain_head, dp_get_psu_status_r_t *psu_resp)
1407 {
1408         int                     index;
1409         int                     subindex = 0;
1410         rmclomv_cache_section_t *subsection;
1411         rmclomv_cache_entry_t   *src_entry;
1412         rmclomv_cache_entry_t   *dst_entry;
1413 
1414         subsection = create_cache_section(RMCLOMV_VOLT_IND,
1415             RMCLOMV_MAX_VI_PER_PSU * psu_section->num_entries);
1416         for (index = 0; index < psu_section->num_entries; index++) {
1417                 src_entry = &psu_section->entry[index];
1418                 if ((psu_resp->psu_status[index].mask &
1419                     DP_PSU_INPUT_STATUS) != 0) {
1420                         dst_entry = &subsection->entry[subindex++];
1421                         dst_entry->handle = src_entry->handle;
1422                         dst_entry->ind_mask = DP_PSU_INPUT_STATUS;
1423                         (void) snprintf(dst_entry->handle_name.name,
1424                             ENVMON_MAXNAMELEN, "%s.%s",
1425                             src_entry->handle_name.name,
1426                             str_ip_volts_ind);
1427                 }
1428 
1429                 if ((psu_resp->psu_status[index].mask &
1430                     DP_PSU_SEC_INPUT_STATUS) != 0) {
1431                         dst_entry = &subsection->entry[subindex++];
1432                         dst_entry->handle = src_entry->handle;
1433                         dst_entry->ind_mask = DP_PSU_SEC_INPUT_STATUS;
1434                         (void) snprintf(dst_entry->handle_name.name,
1435                             ENVMON_MAXNAMELEN, "%s.%s",
1436                             src_entry->handle_name.name,
1437                             str_ip2_volts_ind);
1438                 }
1439 
1440                 if ((psu_resp->psu_status[index].mask &
1441                     DP_PSU_OUTPUT_STATUS) != 0) {
1442                         dst_entry = &subsection->entry[subindex++];
1443                         dst_entry->handle = src_entry->handle;
1444                         dst_entry->ind_mask = DP_PSU_OUTPUT_STATUS;
1445                         (void) snprintf(dst_entry->handle_name.name,
1446                             ENVMON_MAXNAMELEN, "%s.%s",
1447                             src_entry->handle_name.name,
1448                             str_ff_pok_ind);
1449                 }
1450 
1451                 if ((psu_resp->psu_status[index].mask &
1452                     DP_PSU_OUTPUT_VLO_STATUS) != 0) {
1453                         dst_entry = &subsection->entry[subindex++];
1454                         dst_entry->handle = src_entry->handle;
1455                         dst_entry->ind_mask = DP_PSU_OUTPUT_VLO_STATUS;
1456                         (void) snprintf(dst_entry->handle_name.name,
1457                             ENVMON_MAXNAMELEN, "%s.%s",
1458                             src_entry->handle_name.name,
1459                             str_vlo_volts_ind);
1460                 }
1461 
1462                 if ((psu_resp->psu_status[index].mask &
1463                     DP_PSU_OUTPUT_VHI_STATUS) != 0) {
1464                         dst_entry = &subsection->entry[subindex++];
1465                         dst_entry->handle = src_entry->handle;
1466                         dst_entry->ind_mask = DP_PSU_OUTPUT_VHI_STATUS;
1467                         (void) snprintf(dst_entry->handle_name.name,
1468                             ENVMON_MAXNAMELEN, "%s.%s",
1469                             src_entry->handle_name.name,
1470                             str_vhi_volts_ind);
1471                 }
1472         }
1473         /*
1474          * Adjust number of entries value in cache section
1475          * to match the facts.
1476          */
1477         subsection->num_entries = subindex;
1478         add_section(chain_head, subsection);
1479 
1480         subsection = create_cache_section(RMCLOMV_AMP_IND,
1481             RMCLOMV_MAX_CI_PER_PSU * psu_section->num_entries);
1482         subindex = 0;
1483         for (index = 0; index < psu_section->num_entries; index++) {
1484                 int mask = psu_resp->psu_status[index].mask;
1485                 src_entry = &psu_section->entry[index];
1486                 if ((mask & DP_PSU_OUTPUT_AHI_STATUS) != 0) {
1487                         dst_entry = &subsection->entry[subindex++];
1488                         dst_entry->handle = src_entry->handle;
1489                         dst_entry->ind_mask = DP_PSU_OUTPUT_AHI_STATUS;
1490                         (void) snprintf(dst_entry->handle_name.name,
1491                             ENVMON_MAXNAMELEN, "%s.%s",
1492                             src_entry->handle_name.name,
1493                             str_chi_amps_ind);
1494                 }
1495                 if ((mask & DP_PSU_NR_WARNING) != 0) {
1496                         dst_entry = &subsection->entry[subindex++];
1497                         dst_entry->handle = src_entry->handle;
1498                         dst_entry->ind_mask = DP_PSU_NR_WARNING;
1499                         (void) snprintf(dst_entry->handle_name.name,
1500                             ENVMON_MAXNAMELEN, "%s.%s",
1501                             src_entry->handle_name.name,
1502                             str_chi_nr_ind);
1503                 }
1504         }
1505         subsection->num_entries = subindex;
1506         add_section(chain_head, subsection);
1507 
1508         subsection = create_cache_section(RMCLOMV_TEMP_IND,
1509             psu_section->num_entries);
1510         subindex = 0;
1511         for (index = 0; index < psu_section->num_entries; index++) {
1512                 if ((psu_resp->psu_status[index].mask &
1513                     DP_PSU_OVERTEMP_FAULT) != 0) {
1514                         src_entry = &psu_section->entry[index];
1515                         dst_entry = &subsection->entry[subindex++];
1516                         dst_entry->handle = src_entry->handle;
1517                         dst_entry->ind_mask = DP_PSU_OVERTEMP_FAULT;
1518                         (void) snprintf(dst_entry->handle_name.name,
1519                             ENVMON_MAXNAMELEN, "%s.%s",
1520                             src_entry->handle_name.name,
1521                             str_ot_tmpr_ind);
1522                 }
1523         }
1524         subsection->num_entries = subindex;
1525         add_section(chain_head, subsection);
1526 
1527         subsection = create_cache_section(RMCLOMV_FAN_IND,
1528             RMCLOMV_MAX_FI_PER_PSU * psu_section->num_entries);
1529         subindex = 0;
1530         for (index = 0; index < psu_section->num_entries; index++) {
1531                 int mask = psu_resp->psu_status[index].mask;
1532                 src_entry = &psu_section->entry[index];
1533                 if ((mask & DP_PSU_FAN_FAULT) != 0) {
1534                         dst_entry = &subsection->entry[subindex++];
1535                         dst_entry->handle = src_entry->handle;
1536                         dst_entry->ind_mask = DP_PSU_FAN_FAULT;
1537                         (void) snprintf(dst_entry->handle_name.name,
1538                             ENVMON_MAXNAMELEN, "%s.%s",
1539                             src_entry->handle_name.name, str_fan_ind);
1540                 }
1541                 if ((mask & DP_PSU_PDCT_FAN) != 0) {
1542                         dst_entry = &subsection->entry[subindex++];
1543                         dst_entry->handle = src_entry->handle;
1544                         dst_entry->ind_mask = DP_PSU_PDCT_FAN;
1545                         (void) snprintf(dst_entry->handle_name.name,
1546                             ENVMON_MAXNAMELEN, "%s.%s",
1547                             src_entry->handle_name.name, str_pdct_fan_ind);
1548                 }
1549         }
1550         subsection->num_entries = subindex;
1551         add_section(chain_head, subsection);
1552 }
1553 
1554 static void
1555 refresh_name_cache(int force_fail)
1556 {
1557         union {
1558                 dp_get_volts_t          u_volts_cmd;
1559                 dp_get_temperatures_t   u_temp_cmd;
1560                 dp_get_circuit_brks_t   u_ampi_cmd;
1561                 dp_get_fan_status_t     u_fan_cmd;
1562                 dp_get_psu_status_t     u_psu_cmd;
1563                 dp_get_fru_status_t     u_fru_cmd;
1564                 dp_get_led_state_t      u_led_cmd;
1565                 dp_set_led_state_t      u_setled_cmd;
1566                 dp_get_alarm_state_t    u_alarm_cmd;
1567                 dp_set_alarm_state_t    u_setalarm_cmd;
1568         } rmc_cmdbuf;
1569 
1570 /* defines for accessing union fields */
1571 #define volts_cmd       rmc_cmdbuf.u_volts_cmd
1572 #define temp_cmd        rmc_cmdbuf.u_temp_cmd
1573 #define ampi_cmd        rmc_cmdbuf.u_ampi_cmd
1574 #define fan_cmd         rmc_cmdbuf.u_fan_cmd
1575 #define psu_cmd         rmc_cmdbuf.u_psu_cmd
1576 #define fru_cmd         rmc_cmdbuf.u_fru_cmd
1577 #define led_cmd         rmc_cmdbuf.u_led_cmd
1578 #define setled_cmd      rmc_cmdbuf.u_setled_cmd
1579 #define alarm_cmd       rmc_cmdbuf.u_alarm_cmd
1580 #define setalarm_cmd    rmc_cmdbuf.u_setalarm_cmd
1581 
1582         /*
1583          * Data area to read sensor data into
1584          */
1585         static union {
1586                 char                    reservation[RMCRESBUFLEN];
1587                 dp_get_volts_r_t        u_volts_r;
1588                 dp_get_temperatures_r_t u_temp_r;
1589                 dp_get_circuit_brks_r_t u_ampi_r;
1590                 dp_get_fan_status_r_t   u_fan_r;
1591                 dp_get_psu_status_r_t   u_psu_r;
1592                 dp_get_fru_status_r_t   u_fru_r;
1593                 dp_get_led_state_r_t    u_led_r;
1594                 dp_set_led_state_r_t    u_setled_r;
1595                 dp_get_alarm_state_r_t  u_alarm_r;
1596                 dp_set_alarm_state_r_t  u_setalarm_r;
1597         } rmc_sensbuf;
1598 
1599 /* defines for accessing union fields */
1600 #define volts_r         rmc_sensbuf.u_volts_r
1601 #define temp_r          rmc_sensbuf.u_temp_r
1602 #define ampi_r          rmc_sensbuf.u_ampi_r
1603 #define fan_r           rmc_sensbuf.u_fan_r
1604 #define psu_r           rmc_sensbuf.u_psu_r
1605 #define fru_r           rmc_sensbuf.u_fru_r
1606 #define led_r           rmc_sensbuf.u_led_r
1607 #define setled_r        rmc_sensbuf.u_setled_r
1608 #define alarm_r         rmc_sensbuf.u_alarm_r
1609 #define setalarm_r      rmc_sensbuf.u_setalarm_r
1610 
1611         int                     retval = force_fail;
1612         int                     retval1 = retval;
1613         int                     index;
1614         rmclomv_cache_section_t *my_chain = NULL;
1615         rmclomv_cache_section_t *derived_chain = NULL;
1616         rmclomv_cache_section_t *section;
1617         rmclomv_cache_section_t *psu_section;
1618         rmclomv_cache_section_t *fru_section;
1619         dp_get_sysinfo_r_t      sysinfo;
1620         rmclomv_cache_entry_t   *entry;
1621 
1622         if (retval == 0) {
1623                 retval = rmclomv_do_cmd(DP_GET_SYSINFO, DP_GET_SYSINFO_R,
1624                     sizeof (sysinfo), NULL, (intptr_t)&sysinfo);
1625         }
1626         if (retval == 0) {
1627                 fru_cmd.handle = DP_NULL_HANDLE;
1628                 retval = rmclomv_do_cmd(DP_GET_FRU_STATUS, DP_GET_FRU_STATUS_R,
1629                     RMCRESBUFLEN, (intptr_t)&fru_cmd, (intptr_t)&fru_r);
1630         }
1631         if (retval != 0)
1632                 fru_r.num_frus = 0;
1633 
1634         /*
1635          * Reserve space for special additional entries in the FRU section
1636          */
1637         fru_section = create_cache_section(RMCLOMV_HPU_IND,
1638             RMCLOMV_NUM_SPECIAL_FRUS + fru_r.num_frus);
1639 
1640         /*
1641          * add special entry for RMC itself
1642          */
1643         entry = &fru_section->entry[0];
1644         (void) snprintf(entry->handle_name.name, sizeof (envmon_handle_t),
1645             "SC");
1646         entry->handle = 0;
1647         entry->ind_mask = 1; /* flag as a special entry */
1648 
1649         /*
1650          * populate any other FRU entries
1651          */
1652         for (index = 0; index < fru_r.num_frus; index++) {
1653                 fru_section->entry[RMCLOMV_NUM_SPECIAL_FRUS + index].handle =
1654                     fru_r.fru_status[index].handle;
1655                 fru_section->entry[RMCLOMV_NUM_SPECIAL_FRUS + index].ind_mask =
1656                     0;
1657         }
1658 
1659         my_chain = fru_section;
1660 
1661         if (retval == 0) {
1662                 volts_cmd.handle = DP_NULL_HANDLE;
1663                 retval = rmclomv_do_cmd(DP_GET_VOLTS, DP_GET_VOLTS_R,
1664                     RMCRESBUFLEN, (intptr_t)&volts_cmd, (intptr_t)&volts_r);
1665         }
1666         if (retval == 0) {
1667                 section = create_cache_section(RMCLOMV_VOLT_SENS,
1668                     volts_r.num_volts);
1669                 for (index = 0; index < volts_r.num_volts; index++) {
1670                         section->entry[index].handle =
1671                             volts_r.volt_status[index].handle;
1672                 }
1673                 add_section(&my_chain, section);
1674         }
1675         if (retval == 0) {
1676                 temp_cmd.handle = DP_NULL_HANDLE;
1677                 retval = rmclomv_do_cmd(DP_GET_TEMPERATURES,
1678                     DP_GET_TEMPERATURES_R, RMCRESBUFLEN,
1679                     (intptr_t)&temp_cmd, (intptr_t)&temp_r);
1680         }
1681         if (retval == 0) {
1682                 section = create_cache_section(RMCLOMV_TEMP_SENS,
1683                     temp_r.num_temps);
1684                 for (index = 0; index < temp_r.num_temps; index++) {
1685                         section->entry[index].handle =
1686                             temp_r.temp_status[index].handle;
1687                 }
1688                 add_section(&my_chain, section);
1689         }
1690         if (retval == 0) {
1691                 fan_cmd.handle = DP_NULL_HANDLE;
1692                 retval = rmclomv_do_cmd(DP_GET_FAN_STATUS, DP_GET_FAN_STATUS_R,
1693                     RMCRESBUFLEN, (intptr_t)&fan_cmd, (intptr_t)&fan_r);
1694         }
1695         if (retval == 0) {
1696                 section = create_cache_section(RMCLOMV_FAN_SENS,
1697                     fan_r.num_fans);
1698                 for (index = 0; index < fan_r.num_fans; index++) {
1699                         section->entry[index].handle =
1700                             fan_r.fan_status[index].handle;
1701                 }
1702                 add_section(&my_chain, section);
1703         }
1704         if (retval == 0) {
1705                 ampi_cmd.handle = DP_NULL_HANDLE;
1706                 retval = rmclomv_do_cmd(DP_GET_CIRCUIT_BRKS,
1707                     DP_GET_CIRCUIT_BRKS_R, RMCRESBUFLEN,
1708                     (intptr_t)&ampi_cmd, (intptr_t)&ampi_r);
1709         }
1710         if (retval == 0) {
1711                 section = create_cache_section(RMCLOMV_AMP_IND,
1712                     ampi_r.num_circuit_brks);
1713                 for (index = 0; index < ampi_r.num_circuit_brks; index++) {
1714                         section->entry[index].handle =
1715                             ampi_r.circuit_brk_status[index].handle;
1716                 }
1717                 add_section(&my_chain, section);
1718         }
1719         if (retval == 0) {
1720                 led_cmd.handle = DP_NULL_HANDLE;
1721                 retval = rmclomv_do_cmd(DP_GET_LED_STATE, DP_GET_LED_STATE_R,
1722                     RMCRESBUFLEN, (intptr_t)&led_cmd, (intptr_t)&led_r);
1723         }
1724         if (retval == 0) {
1725                 section = create_cache_section(RMCLOMV_LED_IND,
1726                     led_r.num_leds);
1727                 for (index = 0; index < led_r.num_leds; index++) {
1728                         section->entry[index].handle =
1729                             led_r.led_state[index].handle;
1730                 }
1731                 add_section(&my_chain, section);
1732         }
1733         /*
1734          * The command DP_GET_ALARM_STATE may not be valid on
1735          * some RMC versions, so we ignore the return value
1736          * and proceed
1737          */
1738         if (retval == 0) {
1739                 alarm_cmd.handle = DP_NULL_HANDLE;
1740                 retval1 = rmclomv_do_cmd(DP_GET_ALARM_STATE,
1741                     DP_GET_ALARM_STATE_R, RMCRESBUFLEN,
1742                     (intptr_t)&alarm_cmd, (intptr_t)&alarm_r);
1743                 if ((retval1 == 0) && alarm_r.num_alarms) {
1744                         section = create_cache_section(RMCLOMV_ALARM_IND,
1745                             alarm_r.num_alarms);
1746                         for (index = 0; index < alarm_r.num_alarms; index++) {
1747                                 section->entry[index].handle =
1748                                     alarm_r.alarm_state[index].handle;
1749                         }
1750                         add_section(&my_chain, section);
1751                 }
1752         }
1753         if (retval == 0) {
1754                 psu_cmd.handle = DP_NULL_HANDLE;
1755                 retval = rmclomv_do_cmd(DP_GET_PSU_STATUS, DP_GET_PSU_STATUS_R,
1756                     RMCRESBUFLEN, (intptr_t)&psu_cmd, (intptr_t)&psu_r);
1757         }
1758         if (retval == 0) {
1759                 /*
1760                  * WARNING:
1761                  * =======
1762                  * The PSUs must be probed last so that the response data
1763                  * (psu_r) is available for make_psu_subsections() below.
1764                  * Note that all the responses share the same data area
1765                  * which is declared as a union.
1766                  */
1767                 psu_section = create_cache_section(RMCLOMV_PSU_IND,
1768                     psu_r.num_psus);
1769                 for (index = 0; index < psu_r.num_psus; index++) {
1770                         psu_section->entry[index].handle =
1771                             psu_r.psu_status[index].handle;
1772                 }
1773                 add_section(&my_chain, psu_section);
1774         }
1775         if (retval == 0) {
1776                 for (section = my_chain;
1777                     section != NULL;
1778                     section = section->next_section) {
1779                         retval = add_names_to_section(section);
1780                         if (retval != 0) {
1781                                 break;
1782                         }
1783                 }
1784         }
1785 
1786         /*
1787          * now add nodes derived from PSUs
1788          */
1789         if (retval == 0) {
1790                 make_psu_subsections(psu_section, &derived_chain, &psu_r);
1791                 /*
1792                  * name cache sections all set, exchange new for old
1793                  */
1794                 rmclomv_reset_cache(my_chain, derived_chain, &sysinfo);
1795         } else {
1796                 /*
1797                  * RMC is not responding, ditch any existing cache
1798                  * and just leave the special SC FRU node
1799                  */
1800                 rmclomv_reset_cache(my_chain, NULL, NULL);
1801         }
1802 }
1803 
1804 static void
1805 set_val_unav(envmon_sensor_t *sensor)
1806 {
1807         sensor->value = ENVMON_VAL_UNAVAILABLE;
1808         sensor->lowthresholds.warning = ENVMON_VAL_UNAVAILABLE;
1809         sensor->lowthresholds.shutdown = ENVMON_VAL_UNAVAILABLE;
1810         sensor->lowthresholds.poweroff = ENVMON_VAL_UNAVAILABLE;
1811         sensor->highthresholds.warning = ENVMON_VAL_UNAVAILABLE;
1812         sensor->highthresholds.shutdown = ENVMON_VAL_UNAVAILABLE;
1813         sensor->highthresholds.poweroff = ENVMON_VAL_UNAVAILABLE;
1814 }
1815 
1816 static void
1817 set_fan_unav(envmon_fan_t *fan)
1818 {
1819         fan->speed = ENVMON_VAL_UNAVAILABLE;
1820         fan->units[0] = '\0';
1821         fan->lowthresholds.warning = ENVMON_VAL_UNAVAILABLE;
1822         fan->lowthresholds.shutdown = ENVMON_VAL_UNAVAILABLE;
1823         fan->lowthresholds.poweroff = ENVMON_VAL_UNAVAILABLE;
1824 }
1825 
1826 static int
1827 do_psu_cmd(intptr_t arg, int mode, envmon_indicator_t *env_ind,
1828     dp_get_psu_status_t *rmc_psu, dp_get_psu_status_r_t *rmc_psu_r,
1829     int detector_type)
1830 {
1831         int                     index;
1832         uint16_t                sensor_status;
1833         rmclomv_cache_section_t *section;
1834         uint16_t                indicator_mask;
1835 
1836         if (ddi_copyin((caddr_t)arg, (caddr_t)env_ind,
1837             sizeof (envmon_indicator_t), mode) != 0)
1838                 return (EFAULT);
1839 
1840         /* ensure we've got PSU handles cached */
1841         LOCK_CACHE
1842 
1843         sensor_status = ENVMON_SENSOR_OK;
1844         section = rmclomv_find_section(rmclomv_subcache, detector_type);
1845         if (env_ind->id.name[0] == '\0') {
1846                 /* request for first handle */
1847                 if ((section == NULL) || (section->num_entries == 0))
1848                         env_ind->next_id.name[0] = '\0';
1849                 else
1850                         env_ind->next_id = section->entry[0].handle_name;
1851                 sensor_status = ENVMON_NOT_PRESENT;
1852         } else {
1853                 /* ensure name is properly terminated */
1854                 env_ind->id.name[ENVMON_MAXNAMELEN - 1] = '\0';
1855                 if ((section == NULL) || (get_sensor_by_name(section,
1856                     env_ind->id.name, &index)) != 0) {
1857                         env_ind->next_id.name[0] = '\0';
1858                         sensor_status = ENVMON_NOT_PRESENT;
1859                 } else if (index + 1 < section->num_entries)
1860                         env_ind->next_id =
1861                             section->entry[index + 1].handle_name;
1862                 else
1863                         env_ind->next_id.name[0] = '\0';
1864         }
1865         if (sensor_status == ENVMON_SENSOR_OK) {
1866                 /*
1867                  * user correctly identified a sensor, note its
1868                  * handle value and request the indicator status
1869                  */
1870                 rmc_psu->handle = section->entry[index].handle;
1871                 indicator_mask = section->entry[index].ind_mask;
1872         }
1873 
1874         RELEASE_CACHE
1875 
1876         if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
1877             rmclomv_do_cmd(DP_GET_PSU_STATUS, DP_GET_PSU_STATUS_R,
1878             sizeof (dp_get_psu_status_r_t), (intptr_t)rmc_psu,
1879             (intptr_t)rmc_psu_r) != 0)) {
1880                 sensor_status = ENVMON_INACCESSIBLE;
1881         }
1882         if ((env_ind->sensor_status = sensor_status) == ENVMON_SENSOR_OK) {
1883                 /*
1884                  * copy results into buffer for user
1885                  */
1886                 if ((rmc_psu_r->psu_status[0].flag & DP_PSU_PRESENCE) == 0)
1887                         env_ind->sensor_status |= ENVMON_NOT_PRESENT;
1888                 if (rmc_psu_r->psu_status[0].sensor_status !=
1889                     DP_SENSOR_DATA_AVAILABLE)
1890                         env_ind->sensor_status |= ENVMON_INACCESSIBLE;
1891                 env_ind->condition =
1892                     (rmc_psu_r->psu_status[0].flag & indicator_mask) == 0 ?
1893                     0 : 1;
1894         }
1895 
1896         if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE)
1897                 env_ind->sensor_status = ENVMON_INACCESSIBLE;
1898 
1899         if (ddi_copyout((caddr_t)env_ind, (caddr_t)arg,
1900             sizeof (envmon_indicator_t), mode) != 0)
1901                 return (EFAULT);
1902 
1903         return (0);
1904 }
1905 
1906 /*ARGSUSED*/
1907 static int
1908 rmclomv_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred_p,
1909     int *rval_p)
1910 {
1911         int instance = getminor(dev);
1912         envmon_sysinfo_t lomv_sysinfo;
1913         union {
1914                 envmon_sensor_t         u_env_sensor;
1915                 envmon_indicator_t      u_env_ind;
1916                 envmon_fan_t            u_env_fan;
1917                 envmon_led_info_t       u_env_ledinfo;
1918                 envmon_led_ctl_t        u_env_ledctl;
1919                 envmon_hpu_t            u_env_hpu;
1920                 envmon_alarm_info_t     u_env_alarminfo;
1921                 envmon_alarm_ctl_t      u_env_alarmctl;
1922         } env_buf;
1923 #define env_sensor      env_buf.u_env_sensor
1924 #define env_ind         env_buf.u_env_ind
1925 #define env_fan         env_buf.u_env_fan
1926 #define env_ledinfo     env_buf.u_env_ledinfo
1927 #define env_ledctl      env_buf.u_env_ledctl
1928 #define env_hpu         env_buf.u_env_hpu
1929 #define env_alarminfo   env_buf.u_env_alarminfo
1930 #define env_alarmctl    env_buf.u_env_alarmctl
1931 
1932         union {
1933                 dp_get_volts_t          u_rmc_volts;
1934                 dp_get_temperatures_t   u_rmc_temp;
1935                 dp_get_circuit_brks_t   u_rmc_ampi;
1936                 dp_get_fan_status_t     u_rmc_fan;
1937                 dp_get_psu_status_t     u_rmc_psu;
1938                 dp_get_fru_status_t     u_rmc_fru;
1939                 dp_get_led_state_t      u_rmc_led;
1940                 dp_set_led_state_t      u_rmc_setled;
1941                 dp_get_alarm_state_t    u_rmc_alarm;
1942                 dp_set_alarm_state_t    u_rmc_setalarm;
1943         } rmc_reqbuf;
1944 #define rmc_volts       rmc_reqbuf.u_rmc_volts
1945 #define rmc_temp        rmc_reqbuf.u_rmc_temp
1946 #define rmc_ampi        rmc_reqbuf.u_rmc_ampi
1947 #define rmc_fan         rmc_reqbuf.u_rmc_fan
1948 #define rmc_psu         rmc_reqbuf.u_rmc_psu
1949 #define rmc_fru         rmc_reqbuf.u_rmc_fru
1950 #define rmc_led         rmc_reqbuf.u_rmc_led
1951 #define rmc_setled      rmc_reqbuf.u_rmc_setled
1952 #define rmc_alarm       rmc_reqbuf.u_rmc_alarm
1953 #define rmc_setalarm    rmc_reqbuf.u_rmc_setalarm
1954 
1955         union {
1956                 dp_get_volts_r_t        u_rmc_volts_r;
1957                 dp_get_temperatures_r_t u_rmc_temp_r;
1958                 dp_get_circuit_brks_r_t u_rmc_ampi_r;
1959                 dp_get_fan_status_r_t   u_rmc_fan_r;
1960                 dp_get_psu_status_r_t   u_rmc_psu_r;
1961                 dp_get_fru_status_r_t   u_rmc_fru_r;
1962                 dp_get_led_state_r_t    u_rmc_led_r;
1963                 dp_set_led_state_r_t    u_rmc_setled_r;
1964                 dp_get_alarm_state_r_t  u_rmc_alarm_r;
1965                 dp_set_alarm_state_r_t  u_rmc_setalarm_r;
1966                 dp_get_sdp_version_r_t  u_rmc_sdpversion_r;
1967                 dp_get_serialnum_r_t    u_rmc_serialnum_r;
1968         } rmc_resbuf;
1969 #define rmc_volts_r     rmc_resbuf.u_rmc_volts_r
1970 #define rmc_temp_r      rmc_resbuf.u_rmc_temp_r
1971 #define rmc_ampi_r      rmc_resbuf.u_rmc_ampi_r
1972 #define rmc_fan_r       rmc_resbuf.u_rmc_fan_r
1973 #define rmc_psu_r       rmc_resbuf.u_rmc_psu_r
1974 #define rmc_fru_r       rmc_resbuf.u_rmc_fru_r
1975 #define rmc_led_r       rmc_resbuf.u_rmc_led_r
1976 #define rmc_setled_r    rmc_resbuf.u_rmc_setled_r
1977 #define rmc_alarm_r     rmc_resbuf.u_rmc_alarm_r
1978 #define rmc_setalarm_r  rmc_resbuf.u_rmc_setalarm_r
1979 #define rmc_sdpver_r    rmc_resbuf.u_rmc_sdpversion_r
1980 #define rmc_serialnum_r rmc_resbuf.u_rmc_serialnum_r
1981 
1982         int                     retval = 0;
1983         int                     special = 0;
1984         int                     index;
1985         uint16_t                sensor_status;
1986         rmclomv_cache_section_t *section;
1987         envmon_chassis_t chassis;
1988 
1989         if (instance != 0)
1990                 return (ENXIO);
1991 
1992         switch (cmd) {
1993         case ENVMONIOCSYSINFO:
1994 
1995                 LOCK_CACHE
1996 
1997                 /*
1998                  * A number of OK/not_OK indicators are supported by PSUs
1999                  * (voltage, current, fan, temperature). So the maximum
2000                  * number of such indicators relates to the maximum number
2001                  * of power-supplies.
2002                  */
2003                 if (rmclomv_sysinfo_valid) {
2004                         lomv_sysinfo.maxVoltSens = rmclomv_sysinfo_data.maxVolt;
2005                         lomv_sysinfo.maxVoltInd =
2006                             RMCLOMV_MAX_VI_PER_PSU *
2007                             rmclomv_sysinfo_data.maxPSU;
2008                         /*
2009                          * the ALOM-Solaris interface does not include
2010                          * amp sensors, so we can hard code this value
2011                          */
2012                         lomv_sysinfo.maxAmpSens = 0;
2013                         lomv_sysinfo.maxAmpInd =
2014                             rmclomv_sysinfo_data.maxCircuitBrks +
2015                             (RMCLOMV_MAX_CI_PER_PSU *
2016                             rmclomv_sysinfo_data.maxPSU);
2017                         lomv_sysinfo.maxTempSens = rmclomv_sysinfo_data.maxTemp;
2018                         lomv_sysinfo.maxTempInd =
2019                             (RMCLOMV_MAX_TI_PER_PSU *
2020                             rmclomv_sysinfo_data.maxPSU);
2021                         lomv_sysinfo.maxFanSens = rmclomv_sysinfo_data.maxFan;
2022                         lomv_sysinfo.maxFanInd =
2023                             RMCLOMV_MAX_FI_PER_PSU *
2024                             rmclomv_sysinfo_data.maxPSU;
2025                         lomv_sysinfo.maxLED = rmclomv_sysinfo_data.maxLED;
2026                         lomv_sysinfo.maxHPU = RMCLOMV_NUM_SPECIAL_FRUS +
2027                             rmclomv_sysinfo_data.maxFRU;
2028                 } else {
2029                         bzero(&lomv_sysinfo, sizeof (lomv_sysinfo));
2030                         lomv_sysinfo.maxHPU = 1;        /* just the SC node */
2031                 }
2032 
2033                 RELEASE_CACHE
2034 
2035                 if (ddi_copyout((caddr_t)&lomv_sysinfo, (caddr_t)arg,
2036                     sizeof (lomv_sysinfo), mode) != 0)
2037                         return (EFAULT);
2038                 break;
2039 
2040         case ENVMONIOCVOLTSENSOR:
2041                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_sensor,
2042                     sizeof (envmon_sensor_t), mode) != 0)
2043                         return (EFAULT);
2044 
2045                 /* see if we've got volts handles cached */
2046                 LOCK_CACHE
2047                 sensor_status = ENVMON_SENSOR_OK;
2048 
2049                 if ((rmclomv_cache_valid == B_FALSE) ||
2050                     ((section = rmclomv_find_section(rmclomv_cache,
2051                     RMCLOMV_VOLT_SENS)) == NULL)) {
2052                         env_sensor.next_id.name[0] = '\0';
2053                         sensor_status = ENVMON_NOT_PRESENT;
2054                 } else if (env_sensor.id.name[0] == '\0') {
2055                         /* request for first handle */
2056                         if (section->num_entries == 0)
2057                                 env_sensor.next_id.name[0] = '\0';
2058                         else
2059                                 env_sensor.next_id =
2060                                     section->entry[0].handle_name;
2061                         sensor_status = ENVMON_NOT_PRESENT;
2062                 } else {
2063                         /* ensure name is properly terminated */
2064                         env_sensor.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2065                         if (get_sensor_by_name(section, env_sensor.id.name,
2066                             &index) != 0) {
2067                                 env_sensor.next_id.name[0] = '\0';
2068                                 sensor_status = ENVMON_NOT_PRESENT;
2069                         } else if (index + 1 < section->num_entries)
2070                                 env_sensor.next_id =
2071                                     section->entry[index + 1].handle_name;
2072                         else
2073                                 env_sensor.next_id.name[0] = '\0';
2074                 }
2075                 if (sensor_status == ENVMON_SENSOR_OK) {
2076                         /*
2077                          * user correctly identified a sensor, note its
2078                          * handle value and request the sensor value
2079                          */
2080                         rmc_volts.handle = section->entry[index].handle;
2081                 }
2082                 RELEASE_CACHE
2083                 if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
2084                     rmclomv_do_cmd(DP_GET_VOLTS, DP_GET_VOLTS_R,
2085                     sizeof (rmc_volts_r), (intptr_t)&rmc_volts,
2086                     (intptr_t)&rmc_volts_r) != 0)) {
2087                         sensor_status = ENVMON_INACCESSIBLE;
2088                 }
2089                 if ((sensor_status == ENVMON_SENSOR_OK) &&
2090                     (rmc_volts_r.volt_status[0].sensor_status ==
2091                     DP_SENSOR_NOT_PRESENT)) {
2092                         sensor_status = ENVMON_NOT_PRESENT;
2093                 }
2094                 if ((env_sensor.sensor_status = sensor_status) ==
2095                     ENVMON_SENSOR_OK) {
2096                         /*
2097                          * copy results into buffer for user
2098                          */
2099                         if (rmc_volts_r.volt_status[0].sensor_status !=
2100                             DP_SENSOR_DATA_AVAILABLE)
2101                                 env_sensor.sensor_status = ENVMON_INACCESSIBLE;
2102                         env_sensor.value =
2103                             rmc_volts_r.volt_status[0].reading;
2104                         env_sensor.lowthresholds.warning =
2105                             rmc_volts_r.volt_status[0].low_warning;
2106                         env_sensor.lowthresholds.shutdown =
2107                             rmc_volts_r.volt_status[0].low_soft_shutdown;
2108                         env_sensor.lowthresholds.poweroff =
2109                             rmc_volts_r.volt_status[0].low_hard_shutdown;
2110                         env_sensor.highthresholds.warning =
2111                             rmc_volts_r.volt_status[0].high_warning;
2112                         env_sensor.highthresholds.shutdown =
2113                             rmc_volts_r.volt_status[0].high_soft_shutdown;
2114                         env_sensor.highthresholds.poweroff =
2115                             rmc_volts_r.volt_status[0].high_hard_shutdown;
2116                 }
2117                 if (env_sensor.sensor_status != ENVMON_SENSOR_OK ||
2118                     rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE)
2119                         set_val_unav(&env_sensor);
2120 
2121                 if (ddi_copyout((caddr_t)&env_sensor, (caddr_t)arg,
2122                     sizeof (envmon_sensor_t), mode) != 0)
2123                         return (EFAULT);
2124                 break;
2125 
2126         case ENVMONIOCVOLTIND:
2127                 return (do_psu_cmd(arg, mode, &env_ind, &rmc_psu, &rmc_psu_r,
2128                     RMCLOMV_VOLT_IND));
2129 
2130         case ENVMONIOCTEMPIND:
2131                 return (do_psu_cmd(arg, mode, &env_ind, &rmc_psu, &rmc_psu_r,
2132                     RMCLOMV_TEMP_IND));
2133 
2134         case ENVMONIOCFANIND:
2135                 return (do_psu_cmd(arg, mode, &env_ind, &rmc_psu, &rmc_psu_r,
2136                     RMCLOMV_FAN_IND));
2137 
2138         case ENVMONIOCAMPSENSOR:
2139                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_sensor,
2140                     sizeof (envmon_sensor_t), mode) != 0)
2141                         return (EFAULT);
2142 
2143                 env_sensor.sensor_status = ENVMON_NOT_PRESENT;
2144                 env_sensor.next_id.name[0] = '\0';
2145 
2146                 if (ddi_copyout((caddr_t)&env_sensor, (caddr_t)arg,
2147                     sizeof (envmon_sensor_t), mode) != 0)
2148                         return (EFAULT);
2149                 break;
2150 
2151         case ENVMONIOCTEMPSENSOR:
2152                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_sensor,
2153                     sizeof (envmon_sensor_t), mode) != 0)
2154                         return (EFAULT);
2155 
2156                 /* see if we've got temperature handles cached */
2157                 LOCK_CACHE
2158                 sensor_status = ENVMON_SENSOR_OK;
2159 
2160                 if ((rmclomv_cache_valid == B_FALSE) ||
2161                     ((section = rmclomv_find_section(rmclomv_cache,
2162                     RMCLOMV_TEMP_SENS)) == NULL)) {
2163                         env_sensor.next_id.name[0] = '\0';
2164                         sensor_status = ENVMON_NOT_PRESENT;
2165                 } else if (env_sensor.id.name[0] == '\0') {
2166                         /* request for first handle */
2167                         if (section->num_entries == 0)
2168                                 env_sensor.next_id.name[0] = '\0';
2169                         else
2170                                 env_sensor.next_id =
2171                                     section->entry[0].handle_name;
2172                         sensor_status = ENVMON_NOT_PRESENT;
2173                 } else {
2174                         /* ensure name is properly terminated */
2175                         env_sensor.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2176                         if (get_sensor_by_name(section, env_sensor.id.name,
2177                             &index) != 0) {
2178                                 env_sensor.next_id.name[0] = '\0';
2179                                 sensor_status = ENVMON_NOT_PRESENT;
2180                         } else if (index + 1 < section->num_entries)
2181                                 env_sensor.next_id =
2182                                     section->entry[index + 1].handle_name;
2183                         else
2184                                 env_sensor.next_id.name[0] = '\0';
2185                 }
2186                 if (sensor_status == ENVMON_SENSOR_OK) {
2187                         /*
2188                          * user correctly identified a sensor, note its
2189                          * handle value and request the sensor value
2190                          */
2191                         rmc_temp.handle = section->entry[index].handle;
2192                 }
2193                 RELEASE_CACHE
2194                 if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
2195                     rmclomv_do_cmd(DP_GET_TEMPERATURES, DP_GET_TEMPERATURES_R,
2196                     sizeof (rmc_temp_r), (intptr_t)&rmc_temp,
2197                     (intptr_t)&rmc_temp_r) != 0)) {
2198                         sensor_status = ENVMON_INACCESSIBLE;
2199                 }
2200                 if ((sensor_status == ENVMON_SENSOR_OK) &&
2201                     (rmc_temp_r.temp_status[0].sensor_status ==
2202                     DP_SENSOR_NOT_PRESENT)) {
2203                         sensor_status = ENVMON_NOT_PRESENT;
2204                 }
2205                 if ((env_sensor.sensor_status = sensor_status) ==
2206                     ENVMON_SENSOR_OK) {
2207                         /*
2208                          * copy results into buffer for user
2209                          */
2210                         if (rmc_temp_r.temp_status[0].sensor_status !=
2211                             DP_SENSOR_DATA_AVAILABLE)
2212                                 env_sensor.sensor_status = ENVMON_INACCESSIBLE;
2213                         env_sensor.value =
2214                             rmc_temp_r.temp_status[0].value;
2215                         env_sensor.lowthresholds.warning =
2216                             rmc_temp_r.temp_status[0].low_warning;
2217                         env_sensor.lowthresholds.shutdown =
2218                             rmc_temp_r.temp_status[0].low_soft_shutdown;
2219                         env_sensor.lowthresholds.poweroff =
2220                             rmc_temp_r.temp_status[0].low_hard_shutdown;
2221                         env_sensor.highthresholds.warning =
2222                             rmc_temp_r.temp_status[0].high_warning;
2223                         env_sensor.highthresholds.shutdown =
2224                             rmc_temp_r.temp_status[0].high_soft_shutdown;
2225                         env_sensor.highthresholds.poweroff =
2226                             rmc_temp_r.temp_status[0].high_hard_shutdown;
2227                 }
2228                 if (env_sensor.sensor_status != ENVMON_SENSOR_OK ||
2229                     rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE)
2230                         set_val_unav(&env_sensor);
2231 
2232                 if (ddi_copyout((caddr_t)&env_sensor, (caddr_t)arg,
2233                     sizeof (envmon_sensor_t), mode) != 0)
2234                         return (EFAULT);
2235                 break;
2236 
2237 
2238         case ENVMONIOCFAN:
2239                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_fan,
2240                     sizeof (envmon_fan_t), mode) != 0)
2241                         return (EFAULT);
2242 
2243                 /* see if we've got fan handles cached */
2244                 LOCK_CACHE
2245                 sensor_status = ENVMON_SENSOR_OK;
2246 
2247                 if ((rmclomv_cache_valid == B_FALSE) ||
2248                     ((section = rmclomv_find_section(rmclomv_cache,
2249                     RMCLOMV_FAN_SENS)) == NULL)) {
2250                         env_fan.next_id.name[0] = '\0';
2251                         sensor_status = ENVMON_NOT_PRESENT;
2252                 } else if (env_fan.id.name[0] == '\0') {
2253                         /* request for first handle */
2254                         if (section->num_entries == 0)
2255                                 env_fan.next_id.name[0] = '\0';
2256                         else
2257                                 env_fan.next_id =
2258                                     section->entry[0].handle_name;
2259                         sensor_status = ENVMON_NOT_PRESENT;
2260                 } else {
2261                         /* ensure name is properly terminated */
2262                         env_fan.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2263                         if (get_sensor_by_name(section, env_fan.id.name,
2264                             &index) != 0) {
2265                                 env_fan.next_id.name[0] = '\0';
2266                                 sensor_status = ENVMON_NOT_PRESENT;
2267                         } else if (index + 1 < section->num_entries)
2268                                 env_fan.next_id =
2269                                     section->entry[index + 1].handle_name;
2270                         else
2271                                 env_fan.next_id.name[0] = '\0';
2272                 }
2273                 if (sensor_status == ENVMON_SENSOR_OK) {
2274                         /*
2275                          * user correctly identified a sensor, note its
2276                          * handle value and request the sensor value
2277                          */
2278                         rmc_fan.handle = section->entry[index].handle;
2279                 }
2280                 RELEASE_CACHE
2281                 if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
2282                     rmclomv_do_cmd(DP_GET_FAN_STATUS, DP_GET_FAN_STATUS_R,
2283                     sizeof (rmc_fan_r), (intptr_t)&rmc_fan,
2284                     (intptr_t)&rmc_fan_r) != 0)) {
2285                         sensor_status = ENVMON_INACCESSIBLE;
2286                 }
2287                 if ((sensor_status == ENVMON_SENSOR_OK) &&
2288                     (rmc_fan_r.fan_status[0].sensor_status ==
2289                     DP_SENSOR_NOT_PRESENT)) {
2290                         sensor_status = ENVMON_NOT_PRESENT;
2291                 }
2292                 if ((env_fan.sensor_status = sensor_status) ==
2293                     ENVMON_SENSOR_OK) {
2294                         if ((rmc_fan_r.fan_status[0].flag &
2295                             DP_FAN_PRESENCE) == 0)
2296                                 env_fan.sensor_status = ENVMON_NOT_PRESENT;
2297                         if (rmc_fan_r.fan_status[0].sensor_status !=
2298                             DP_SENSOR_DATA_AVAILABLE)
2299                                 env_fan.sensor_status |= ENVMON_INACCESSIBLE;
2300                         if (env_fan.sensor_status == ENVMON_SENSOR_OK) {
2301                                 /*
2302                                  * copy results into buffer for user
2303                                  */
2304                                 env_fan.speed =
2305                                     rmc_fan_r.fan_status[0].speed;
2306                                 env_fan.lowthresholds.warning =
2307                                     rmc_fan_r.fan_status[0].minspeed;
2308                                 env_fan.lowthresholds.shutdown =
2309                                     ENVMON_VAL_UNAVAILABLE;
2310                                 env_fan.lowthresholds.poweroff =
2311                                     ENVMON_VAL_UNAVAILABLE;
2312                                 if ((rmc_fan_r.fan_status[0].flag &
2313                                     DP_FAN_SPEED_VAL_UNIT) == 0)
2314                                         bcopy(str_rpm, env_fan.units,
2315                                             sizeof (str_rpm));
2316                                 else
2317                                         bcopy(str_percent, env_fan.units,
2318                                             sizeof (str_percent));
2319                         }
2320                 }
2321                 if (env_fan.sensor_status != ENVMON_SENSOR_OK ||
2322                     rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE)
2323                         set_fan_unav(&env_fan);
2324 
2325                 if (ddi_copyout((caddr_t)&env_fan, (caddr_t)arg,
2326                     sizeof (envmon_fan_t), mode) != 0)
2327                         return (EFAULT);
2328                 break;
2329 
2330         case ENVMONIOCAMPIND:
2331                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_ind,
2332                     sizeof (envmon_indicator_t), mode) != 0)
2333                         return (EFAULT);
2334 
2335                 /* see if we've got amp indicator handles cached */
2336                 LOCK_CACHE
2337                 sensor_status = ENVMON_SENSOR_OK;
2338 
2339                 if ((rmclomv_cache_valid == B_FALSE) ||
2340                     ((section = rmclomv_find_section(rmclomv_cache,
2341                     RMCLOMV_AMP_IND)) == NULL)) {
2342                         RELEASE_CACHE
2343                         return (do_psu_cmd(arg, mode, &env_ind, &rmc_psu,
2344                             &rmc_psu_r, RMCLOMV_AMP_IND));
2345                 } else if (env_ind.id.name[0] == '\0') {
2346                         /* request for first handle */
2347                         if (section->num_entries == 0) {
2348                                 RELEASE_CACHE
2349                                 return (do_psu_cmd(arg, mode, &env_ind,
2350                                     &rmc_psu, &rmc_psu_r, RMCLOMV_AMP_IND));
2351                         }
2352                         env_ind.next_id = section->entry[0].handle_name;
2353                         sensor_status = ENVMON_NOT_PRESENT;
2354                 } else {
2355                         /* ensure name is properly terminated */
2356                         env_ind.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2357                         if (get_sensor_by_name(section, env_ind.id.name,
2358                             &index) != 0) {
2359                                 RELEASE_CACHE
2360                                 return (do_psu_cmd(arg, mode, &env_ind,
2361                                     &rmc_psu, &rmc_psu_r, RMCLOMV_AMP_IND));
2362                         }
2363                         if (index + 1 < section->num_entries) {
2364                                 env_ind.next_id =
2365                                     section->entry[index + 1].handle_name;
2366                         } else {
2367                                 rmclomv_cache_section_t *sub_section =
2368                                     rmclomv_find_section(rmclomv_subcache,
2369                                     RMCLOMV_AMP_IND);
2370                                 if ((sub_section == NULL) ||
2371                                     (sub_section->num_entries == 0))
2372                                         env_ind.next_id.name[0] = '\0';
2373                                 else
2374                                         env_ind.next_id =
2375                                             sub_section->entry[0].handle_name;
2376                         }
2377                 }
2378                 if (sensor_status == ENVMON_SENSOR_OK) {
2379                         /*
2380                          * user correctly identified an indicator, note its
2381                          * handle value and request the indicator status
2382                          */
2383                         rmc_ampi.handle = section->entry[index].handle;
2384                 }
2385                 RELEASE_CACHE
2386                 if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
2387                     rmclomv_do_cmd(DP_GET_CIRCUIT_BRKS, DP_GET_CIRCUIT_BRKS_R,
2388                     sizeof (rmc_ampi_r), (intptr_t)&rmc_ampi,
2389                     (intptr_t)&rmc_ampi_r) != 0)) {
2390                         sensor_status = ENVMON_INACCESSIBLE;
2391                 }
2392                 if ((sensor_status == ENVMON_SENSOR_OK) &&
2393                     (rmc_ampi_r.circuit_brk_status[0].sensor_status ==
2394                     DP_SENSOR_NOT_PRESENT)) {
2395                         sensor_status = ENVMON_NOT_PRESENT;
2396                 }
2397                 if ((env_ind.sensor_status = sensor_status) ==
2398                     ENVMON_SENSOR_OK) {
2399                         /*
2400                          * copy results into buffer for user
2401                          */
2402                         if (rmc_ampi_r.circuit_brk_status[0].sensor_status !=
2403                             DP_SENSOR_DATA_AVAILABLE)
2404                                 env_ind.sensor_status = ENVMON_INACCESSIBLE;
2405                         env_ind.condition =
2406                             rmc_ampi_r.circuit_brk_status[0].status;
2407                 }
2408 
2409                 /*
2410                  * If rmclomv_rmc_error is set there is no way
2411                  * that we read information from RSC. Just copy
2412                  * out an inaccessible evironmental.
2413                  */
2414                 if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE) {
2415                         env_ind.sensor_status = ENVMON_INACCESSIBLE;
2416                         env_ind.condition = ENVMON_INACCESSIBLE;
2417                 }
2418 
2419                 if (ddi_copyout((caddr_t)&env_ind, (caddr_t)arg,
2420                     sizeof (envmon_indicator_t), mode) != 0)
2421                         return (EFAULT);
2422                 break;
2423 
2424         case ENVMONIOCHPU:
2425                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_hpu,
2426                     sizeof (envmon_hpu_t), mode) != 0)
2427                         return (EFAULT);
2428 
2429                 /* see if we've got hpu handles cached */
2430                 LOCK_CACHE
2431 
2432                 if ((rmclomv_cache_valid == B_FALSE) ||
2433                     ((section = rmclomv_find_section(rmclomv_cache,
2434                     RMCLOMV_HPU_IND)) == NULL)) {
2435                         RELEASE_CACHE
2436                         return (EAGAIN);
2437                 }
2438 
2439                 /*
2440                  * At this point the cache is locked and section points to
2441                  * the section relating to hpus.
2442                  */
2443                 sensor_status = ENVMON_SENSOR_OK;
2444                 if (env_hpu.id.name[0] == '\0') {
2445                         /* request for first handle */
2446                         if (section->num_entries == 0)
2447                                 env_hpu.next_id.name[0] = '\0';
2448                         else
2449                                 env_hpu.next_id =
2450                                     section->entry[0].handle_name;
2451                         sensor_status = ENVMON_NOT_PRESENT;
2452                 } else {
2453                         /* ensure name is properly terminated */
2454                         env_hpu.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2455                         if (get_sensor_by_name(section, env_hpu.id.name,
2456                             &index) != 0) {
2457                                 env_hpu.next_id.name[0] = '\0';
2458                                 sensor_status = ENVMON_NOT_PRESENT;
2459                         } else if (index + 1 < section->num_entries)
2460                                 env_hpu.next_id =
2461                                     section->entry[index + 1].handle_name;
2462                         else
2463                                 env_hpu.next_id.name[0] = '\0';
2464                 }
2465                 if (sensor_status == ENVMON_SENSOR_OK) {
2466                         /*
2467                          * user correctly identified an hpu, note its
2468                          * handle value and request the hpu status
2469                          */
2470                         rmc_fru.handle = section->entry[index].handle;
2471                         special = section->entry[index].ind_mask;
2472                 }
2473                 RELEASE_CACHE
2474                 if ((env_hpu.sensor_status = sensor_status) ==
2475                     ENVMON_SENSOR_OK) {
2476                         env_hpu.fru_status = ENVMON_FRU_PRESENT;
2477 
2478                         if (special != 0) {
2479                                 /* this is the pseudo SC node */
2480                                 mutex_enter(&rmclomv_state_lock);
2481                                 switch (rmclomv_rmc_state) {
2482                                 case RMCLOMV_RMCSTATE_OK:
2483                                         break;
2484                                 case RMCLOMV_RMCSTATE_FAILED:
2485                                         env_hpu.fru_status = ENVMON_FRU_FAULT;
2486                                         break;
2487                                 case RMCLOMV_RMCSTATE_DOWNLOAD:
2488                                         env_hpu.fru_status =
2489                                             ENVMON_FRU_DOWNLOAD;
2490                                         break;
2491                                 default:
2492                                         env_hpu.sensor_status =
2493                                             ENVMON_INACCESSIBLE;
2494                                         break;
2495                                 }
2496                                 mutex_exit(&rmclomv_state_lock);
2497                         } else if (rmclomv_rmc_error ||
2498                             rmclomv_do_cmd(DP_GET_FRU_STATUS,
2499                             DP_GET_FRU_STATUS_R, sizeof (rmc_fru_r),
2500                             (intptr_t)&rmc_fru, (intptr_t)&rmc_fru_r) != 0) {
2501                                 env_hpu.sensor_status = ENVMON_INACCESSIBLE;
2502                         } else {
2503                                 /*
2504                                  * copy results into buffer for user
2505                                  */
2506                                 if (rmc_fru_r.fru_status[0].presence == 0) {
2507                                         env_hpu.sensor_status =
2508                                             ENVMON_NOT_PRESENT;
2509                                         env_hpu.fru_status =
2510                                             ENVMON_FRU_NOT_PRESENT;
2511                                 } else if (rmc_fru_r.fru_status[0].sensor_status
2512                                     != DP_SENSOR_DATA_AVAILABLE) {
2513                                         env_hpu.sensor_status =
2514                                             ENVMON_INACCESSIBLE;
2515                                 } else {
2516                                         uint8_t status =
2517                                             rmc_fru_r.fru_status[0].status;
2518                                         if (status == DP_FRU_STATUS_UNKNOWN) {
2519                                                 env_hpu.sensor_status =
2520                                                     ENVMON_INACCESSIBLE;
2521                                         } else if (status != DP_FRU_STATUS_OK) {
2522                                                 env_hpu.fru_status =
2523                                                     ENVMON_FRU_FAULT;
2524                                         }
2525                                 }
2526                         }
2527                 }
2528 
2529                 /*
2530                  * If rmclomv_rmc_error is set there is no way
2531                  * that we read information from RSC. Just copy
2532                  * out an inaccessible environmental.
2533                  */
2534                 if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE) {
2535                         env_hpu.sensor_status = ENVMON_INACCESSIBLE;
2536                         env_hpu.fru_status = ENVMON_INACCESSIBLE;
2537                 }
2538 
2539                 if (ddi_copyout((caddr_t)&env_hpu, (caddr_t)arg,
2540                     sizeof (envmon_hpu_t), mode) != 0)
2541                         return (EFAULT);
2542                 break;
2543 
2544         case ENVMONIOCGETLED:
2545                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_ledinfo,
2546                     sizeof (envmon_led_info_t), mode) != 0)
2547                         return (EFAULT);
2548 
2549                 /* see if we've got LED handles cached */
2550                 LOCK_CACHE
2551                 sensor_status = ENVMON_SENSOR_OK;
2552 
2553                 if ((rmclomv_cache_valid == B_FALSE) ||
2554                     ((section = rmclomv_find_section(rmclomv_cache,
2555                     RMCLOMV_LED_IND)) == NULL)) {
2556                         env_ledinfo.next_id.name[0] = '\0';
2557                         sensor_status = ENVMON_NOT_PRESENT;
2558                 } else if (env_ledinfo.id.name[0] == '\0') {
2559                         /* request for first handle */
2560                         if (section->num_entries == 0)
2561                                 env_ledinfo.next_id.name[0] = '\0';
2562                         else
2563                                 env_ledinfo.next_id =
2564                                     section->entry[0].handle_name;
2565                         sensor_status = ENVMON_NOT_PRESENT;
2566                 } else {
2567                         /* ensure name is properly terminated */
2568                         env_ledinfo.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2569                         if (get_sensor_by_name(section, env_ledinfo.id.name,
2570                             &index) != 0) {
2571                                 env_ledinfo.next_id.name[0] = '\0';
2572                                 sensor_status = ENVMON_NOT_PRESENT;
2573                         } else if (index + 1 < section->num_entries)
2574                                 env_ledinfo.next_id =
2575                                     section->entry[index + 1].handle_name;
2576                         else
2577                                 env_ledinfo.next_id.name[0] = '\0';
2578                 }
2579                 if (sensor_status == ENVMON_SENSOR_OK) {
2580                         /*
2581                          * user correctly identified a LED, note its
2582                          * handle value and request the LED status
2583                          */
2584                         rmc_led.handle = section->entry[index].handle;
2585                 }
2586                 RELEASE_CACHE
2587                 if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
2588                     rmclomv_do_cmd(DP_GET_LED_STATE, DP_GET_LED_STATE_R,
2589                     sizeof (rmc_led_r), (intptr_t)&rmc_led,
2590                     (intptr_t)&rmc_led_r) != 0)) {
2591                         sensor_status = ENVMON_INACCESSIBLE;
2592                 }
2593                 if ((sensor_status == ENVMON_SENSOR_OK) &&
2594                     (rmc_led_r.led_state[0].sensor_status ==
2595                     DP_SENSOR_NOT_PRESENT)) {
2596                         sensor_status = ENVMON_NOT_PRESENT;
2597                 }
2598                 if ((env_ledinfo.sensor_status = sensor_status) ==
2599                     ENVMON_SENSOR_OK) {
2600                         /*
2601                          * copy results into buffer for user
2602                          * start with some defaults then override
2603                          */
2604                         env_ledinfo.sensor_status = ENVMON_SENSOR_OK;
2605                         env_ledinfo.led_state = ENVMON_LED_OFF;
2606                         env_ledinfo.led_color = ENVMON_LED_CLR_NONE;
2607 
2608                         if (rmc_led_r.led_state[0].sensor_status !=
2609                             DP_SENSOR_DATA_AVAILABLE)
2610                                 env_ledinfo.sensor_status = ENVMON_INACCESSIBLE;
2611                         else {
2612                                 dp_led_state_t ledState;
2613                                 ledState = rmc_led_r.led_state[0];
2614                                 env_ledinfo.led_color = (int8_t)ledState.colour;
2615 
2616                                 switch (ledState.state) {
2617                                 case (rsci8)DP_LED_OFF:
2618                                         break;
2619                                 case (rsci8)DP_LED_ON:
2620                                         env_ledinfo.led_state = ENVMON_LED_ON;
2621                                         break;
2622                                 case (rsci8)DP_LED_BLINKING:
2623                                         env_ledinfo.led_state =
2624                                             ENVMON_LED_BLINKING;
2625                                         break;
2626                                 case (rsci8)DP_LED_FLASHING:
2627                                         env_ledinfo.led_state =
2628                                             ENVMON_LED_FLASHING;
2629                                         break;
2630                                 default:
2631                                         break;
2632                                 }
2633                         }
2634                 }
2635 
2636                 /*
2637                  * If rmclomv_rmc_error is set there is no way
2638                  * that we read information from RSC. Just copy
2639                  * out an inaccessible environmental.
2640                  */
2641                 if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE) {
2642                         env_ledinfo.sensor_status = ENVMON_INACCESSIBLE;
2643                         env_ledinfo.led_state = ENVMON_INACCESSIBLE;
2644                 }
2645 
2646                 if (ddi_copyout((caddr_t)&env_ledinfo, (caddr_t)arg,
2647                     sizeof (envmon_led_info_t), mode) != 0)
2648                         return (EFAULT);
2649                 break;
2650 
2651         case ENVMONIOCSETLED:
2652                 if ((mode & FWRITE) == 0)
2653                         return (EACCES);
2654                 if (drv_priv(cred_p) != 0)
2655                         return (EPERM);
2656                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_ledctl,
2657                     sizeof (envmon_led_ctl_t), mode) != 0)
2658                         return (EFAULT);
2659                 if (env_ledctl.led_state < RMCLOMV_MIN_LED_STATE ||
2660                     env_ledctl.led_state > RMCLOMV_MAX_LED_STATE)
2661                         return (EINVAL);
2662                 /*
2663                  * Ensure name is properly terminated.
2664                  */
2665                 env_ledctl.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2666 
2667                 /* see if we've got LED handles cached */
2668                 LOCK_CACHE
2669 
2670                 if ((rmclomv_cache_valid == B_FALSE) ||
2671                     ((section = rmclomv_find_section(rmclomv_cache,
2672                     RMCLOMV_LED_IND)) == NULL) ||
2673                     (get_sensor_by_name(section, env_ledctl.id.name,
2674                     &index) != 0)) {
2675                         RELEASE_CACHE
2676                         return (EINVAL);        /* no such LED */
2677                 }
2678                 /*
2679                  * user correctly identified a LED, note its handle value
2680                  */
2681                 rmc_setled.handle = section->entry[index].handle;
2682                 RELEASE_CACHE
2683                 switch (env_ledctl.led_state) {
2684                 case ENVMON_LED_ON:
2685                         rmc_setled.state = DP_LED_ON;
2686                         break;
2687                 case ENVMON_LED_BLINKING:
2688                         rmc_setled.state = DP_LED_BLINKING;
2689                         break;
2690                 case ENVMON_LED_FLASHING:
2691                         rmc_setled.state = DP_LED_FLASHING;
2692                         break;
2693                 default:
2694                         rmc_setled.state = DP_LED_OFF;
2695                         break;
2696                 }
2697                 retval = rmclomv_do_cmd(DP_SET_LED_STATE, DP_SET_LED_STATE_R,
2698                     sizeof (rmc_setled_r), (intptr_t)&rmc_setled,
2699                     (intptr_t)&rmc_setled_r);
2700 
2701                 if (retval != 0) {
2702                         break;
2703                 }
2704 
2705                 if (rmc_setled_r.status != 0) {
2706                         cmn_err(CE_WARN, "ENVMONIOCSETLED: \"%s\" status: 0x%x",
2707                             env_ledctl.id.name, rmc_setled_r.status);
2708                         return (EIO);
2709                 }
2710                 break;
2711 
2712         case ENVMONIOCGETKEYSW:
2713         {
2714                 enum rmc_keyswitch_pos  rmc_pos = real_key_position;
2715                 envmon_keysw_pos_t      envmon_pos;
2716 
2717                 /*
2718                  * Yes, I know this is ugly, but the V210 has no keyswitch,
2719                  * even though the ALOM returns a value for it
2720                  */
2721                 if (strcmp(platform, "SUNW,Sun-Fire-V210") == 0) {
2722                         return (ENOTSUP);
2723                 }
2724 
2725                 switch (rmc_pos) {
2726 
2727                 case RMC_KEYSWITCH_POS_NORMAL:
2728                         envmon_pos = ENVMON_KEYSW_POS_NORMAL;
2729                         break;
2730                 case RMC_KEYSWITCH_POS_DIAG:
2731                         envmon_pos = ENVMON_KEYSW_POS_DIAG;
2732                         break;
2733                 case RMC_KEYSWITCH_POS_LOCKED:
2734                         envmon_pos = ENVMON_KEYSW_POS_LOCKED;
2735                         break;
2736                 case RMC_KEYSWITCH_POS_OFF:
2737                         envmon_pos = ENVMON_KEYSW_POS_OFF;
2738                         break;
2739                 default:
2740                         envmon_pos = ENVMON_KEYSW_POS_UNKNOWN;
2741                         break;
2742                 }
2743 
2744                 if (ddi_copyout((caddr_t)&envmon_pos, (caddr_t)arg,
2745                     sizeof (envmon_pos), mode) != 0)
2746                         return (EFAULT);
2747                 break;
2748         }
2749 
2750         case ENVMONIOCGETALARM:
2751                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_alarminfo,
2752                     sizeof (envmon_alarm_info_t), mode) != 0)
2753                         return (EFAULT);
2754 
2755                 /* see if we've got ALARM handles cached */
2756                 LOCK_CACHE
2757                 sensor_status = ENVMON_SENSOR_OK;
2758 
2759                 if ((rmclomv_cache_valid == B_FALSE) ||
2760                     ((section = rmclomv_find_section(rmclomv_cache,
2761                     RMCLOMV_ALARM_IND)) == NULL)) {
2762                         env_alarminfo.next_id.name[0] = '\0';
2763                         sensor_status = ENVMON_NOT_PRESENT;
2764                 } else if (env_alarminfo.id.name[0] == '\0') {
2765                         /* request for first handle */
2766                         if (section->num_entries == 0)
2767                                 env_alarminfo.next_id.name[0] = '\0';
2768                         else
2769                                 env_alarminfo.next_id =
2770                                     section->entry[0].handle_name;
2771                         sensor_status = ENVMON_NOT_PRESENT;
2772                 } else {
2773                         /* ensure name is properly terminated */
2774                         env_alarminfo.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2775                         if (get_sensor_by_name(section, env_alarminfo.id.name,
2776                             &index) != 0) {
2777                                 env_alarminfo.next_id.name[0] = '\0';
2778                                 sensor_status = ENVMON_NOT_PRESENT;
2779                         } else if (index + 1 < section->num_entries)
2780                                 env_alarminfo.next_id =
2781                                     section->entry[index + 1].handle_name;
2782                         else
2783                                 env_alarminfo.next_id.name[0] = '\0';
2784                 }
2785                 if (sensor_status == ENVMON_SENSOR_OK) {
2786                         /*
2787                          * user correctly identified a ALARM, note its
2788                          * handle value and request the ALARM status
2789                          */
2790                         rmc_alarm.handle = section->entry[index].handle;
2791                 }
2792                 RELEASE_CACHE
2793                 if ((sensor_status == ENVMON_SENSOR_OK) &&
2794                     (rmclomv_rmc_error ||
2795                     rmclomv_do_cmd(DP_GET_ALARM_STATE, DP_GET_ALARM_STATE_R,
2796                     sizeof (rmc_alarm_r), (intptr_t)&rmc_alarm,
2797                     (intptr_t)&rmc_alarm_r) != 0)) {
2798                         sensor_status = ENVMON_INACCESSIBLE;
2799                 }
2800                 if ((env_alarminfo.sensor_status = sensor_status) ==
2801                     ENVMON_SENSOR_OK) {
2802                         /*
2803                          * copy results into buffer for user
2804                          * start with some defaults then override
2805                          */
2806                         env_alarminfo.sensor_status = ENVMON_SENSOR_OK;
2807                         env_alarminfo.alarm_state = ENVMON_ALARM_OFF;
2808 
2809                         if (rmc_alarm_r.alarm_state[0].sensor_status !=
2810                             DP_SENSOR_DATA_AVAILABLE)
2811                                 env_alarminfo.sensor_status =
2812                                     ENVMON_INACCESSIBLE;
2813                         else {
2814                                 dp_alarm_state_t alarmState;
2815                                 alarmState = rmc_alarm_r.alarm_state[0];
2816 
2817                                 switch (alarmState.state) {
2818                                 case DP_ALARM_OFF:
2819                                         break;
2820                                 case DP_ALARM_ON:
2821                                         env_alarminfo.alarm_state =
2822                                             ENVMON_ALARM_ON;
2823                                         break;
2824                                 default:
2825                                         break;
2826                                 }
2827                         }
2828                 }
2829 
2830                 /*
2831                  * If rmclomv_rmc_error is set there is no way
2832                  * that we read information from RSC. Just copy
2833                  * out an inaccessible environmental.
2834                  */
2835                 if (rmclomv_rmc_error != RMCLOMV_RMCERROR_NONE) {
2836                         env_alarminfo.sensor_status = ENVMON_INACCESSIBLE;
2837                         env_alarminfo.alarm_state = ENVMON_INACCESSIBLE;
2838                 }
2839 
2840                 if (ddi_copyout((caddr_t)&env_alarminfo, (caddr_t)arg,
2841                     sizeof (envmon_alarm_info_t), mode) != 0)
2842                         return (EFAULT);
2843                 break;
2844 
2845         case ENVMONIOCSETALARM:
2846                 if ((mode & FWRITE) == 0)
2847                         return (EACCES);
2848                 if (drv_priv(cred_p) != 0)
2849                         return (EPERM);
2850                 if (ddi_copyin((caddr_t)arg, (caddr_t)&env_alarmctl,
2851                     sizeof (envmon_alarm_ctl_t), mode) != 0)
2852                         return (EFAULT);
2853                 if (env_alarmctl.alarm_state < RMCLOMV_MIN_ALARM_STATE ||
2854                     env_alarmctl.alarm_state > RMCLOMV_MAX_ALARM_STATE)
2855                         return (EINVAL);
2856                 /*
2857                  * Ensure name is properly terminated.
2858                  */
2859                 env_alarmctl.id.name[ENVMON_MAXNAMELEN - 1] = '\0';
2860 
2861                 /* see if we've got ALARM handles cached */
2862                 LOCK_CACHE
2863 
2864                 if ((rmclomv_cache_valid == B_FALSE) ||
2865                     ((section = rmclomv_find_section(rmclomv_cache,
2866                     RMCLOMV_ALARM_IND)) == NULL) ||
2867                     (get_sensor_by_name(section, env_alarmctl.id.name,
2868                     &index) != 0)) {
2869                         RELEASE_CACHE
2870                         return (EINVAL);        /* no such ALARM */
2871                 }
2872                 /*
2873                  * user correctly identified a ALARM, note its handle value
2874                  */
2875                 rmc_setalarm.handle = section->entry[index].handle;
2876                 RELEASE_CACHE
2877                 rmc_setalarm.state = (rsci8)env_alarmctl.alarm_state;
2878                 retval = rmclomv_do_cmd(DP_SET_ALARM_STATE,
2879                     DP_SET_ALARM_STATE_R,
2880                     sizeof (rmc_setalarm_r),
2881                     (intptr_t)&rmc_setalarm,
2882                     (intptr_t)&rmc_setalarm_r);
2883 
2884                 if (retval != 0) {
2885                         break;
2886                 }
2887 
2888                 if (rmc_setalarm_r.status != 0) {
2889                         cmn_err(CE_WARN, "ENVMONIOCSETALARM: \"%s\" status: "
2890                             "0x%x", env_alarmctl.id.name,
2891                             rmc_setalarm_r.status);
2892                         return (EIO);
2893                 }
2894                 break;
2895 
2896         case ENVMONIOCCHASSISSERIALNUM:
2897                 retval = rmclomv_do_cmd(DP_GET_SDP_VERSION,
2898                     DP_GET_SDP_VERSION_R, sizeof (rmc_sdpver_r),
2899                     NULL, (intptr_t)&rmc_sdpver_r);
2900 
2901                 if (retval != 0) {
2902                         cmn_err(CE_WARN, "DP_GET_SDP_VERSION failed, ret=%d\n",
2903                             retval);
2904                         break;
2905                 } else if (rmc_sdpver_r.version < SDP_RESPONDS_TO_ALL_CMDS) {
2906                         retval = ENOTSUP;
2907                         break;
2908                 }
2909                 retval = rmclomv_do_cmd(DP_GET_CHASSIS_SERIALNUM,
2910                     DP_GET_CHASSIS_SERIALNUM_R, sizeof (rmc_serialnum_r),
2911                     NULL, (intptr_t)&rmc_serialnum_r);
2912 
2913                 if (retval != 0) {
2914                         break;
2915                 }
2916                 bcopy(rmc_serialnum_r.chassis_serial_number,
2917                     chassis.serial_number,
2918                     sizeof (rmc_serialnum_r.chassis_serial_number));
2919 
2920                 if (ddi_copyout((caddr_t)&chassis, (caddr_t)arg,
2921                     sizeof (chassis), mode) != 0) {
2922                         return (EFAULT);
2923                 }
2924                 sensor_status = ENVMON_SENSOR_OK;
2925                 break;
2926 
2927         default:
2928                 retval = ENOTSUP;
2929                 break;
2930         }
2931 
2932         return (retval);
2933 }
2934 
2935 /* ARGSUSED */
2936 static void
2937 rmclomv_checkrmc(caddr_t arg)
2938 {
2939         callb_cpr_t             cprinfo;
2940         int                     err;
2941         int                     retries;
2942         int                     state;
2943         dp_get_sysinfo_r_t      sysinfo;
2944 
2945         CALLB_CPR_INIT(&cprinfo, &rmclomv_checkrmc_lock, callb_generic_cpr,
2946             "rmclomv_checkrmc");
2947 
2948         mutex_enter(&rmclomv_checkrmc_lock);
2949         for (;;) {
2950                 /*
2951                  * Initial entry to this for loop is made with
2952                  * rmclomv_checkrmc_sig set to RMCLOMV_PROCESS_NOW. So the
2953                  * following while loop drops through the first time. A
2954                  * timeout call is made just before polling the RMC. Its
2955                  * interrupt routine sustains this loop by injecting additional
2956                  * state changes and cv events.
2957                  */
2958                 /*
2959                  * Wait for someone to tell me to continue.
2960                  */
2961                 while (rmclomv_checkrmc_sig == RMCLOMV_CHECKRMC_WAIT) {
2962                         CALLB_CPR_SAFE_BEGIN(&cprinfo);
2963                         cv_wait(&rmclomv_checkrmc_sig_cv,
2964                             &rmclomv_checkrmc_lock);
2965                         CALLB_CPR_SAFE_END(&cprinfo, &rmclomv_checkrmc_lock);
2966                 }
2967 
2968                 mutex_exit(&rmclomv_checkrmc_lock);
2969                 /*
2970                  * mustn't hold same lock as timeout called with
2971                  * when cancelling timer
2972                  */
2973                 if (timer_id != 0) {
2974                         (void) untimeout(timer_id);
2975                         timer_id = 0;
2976                 }
2977                 mutex_enter(&rmclomv_checkrmc_lock);
2978 
2979                 /* RMCLOMV_CHECKRMC_EXITNOW implies signal by _detach(). */
2980                 if (rmclomv_checkrmc_sig == RMCLOMV_CHECKRMC_EXITNOW) {
2981                         rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_WAIT;
2982 
2983                         /* rmclomv_checkrmc_lock is held at this point! */
2984                         CALLB_CPR_EXIT(&cprinfo);
2985 
2986                         thread_exit();
2987                         /* NOTREACHED */
2988                 }
2989 
2990                 rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_WAIT;
2991 
2992                 /*
2993                  * If the RMC is not responding, rmclomv_do_cmd() takes a
2994                  * long time and eventually times out. We conclude that the
2995                  * RMC is broken if it doesn't respond to a number of polls
2996                  * made 60 secs apart. So that the rmclomv_do_cmd() time-out
2997                  * period isn't added to our 60 second timer, make the
2998                  * timeout() call before calling rmclomv_do_cmd().
2999                  */
3000                 if (timer_id == 0) {
3001                         timer_id = timeout(rmclomv_checkrmc_wakeup, NULL,
3002                             60 * drv_usectohz(1000000));
3003                 }
3004 
3005                 mutex_exit(&rmclomv_checkrmc_lock);
3006 
3007                 err = rmclomv_do_cmd(DP_GET_SYSINFO, DP_GET_SYSINFO_R,
3008                     sizeof (sysinfo), NULL, (intptr_t)&sysinfo);
3009                 if (err == 0) {
3010                         mutex_enter(&rmclomv_state_lock);
3011                         state = rmclomv_rmc_state;
3012                         /* successful poll, reset fail count */
3013                         rmclomv_rmcfailcount = 0;
3014                         mutex_exit(&rmclomv_state_lock);
3015 
3016                         if (state != RMCLOMV_RMCSTATE_OK) {
3017                                 rmclomv_refresh_wakeup();
3018                         }
3019                 }
3020                 if ((err != 0) &&
3021                     (rmclomv_rmc_error != RMCLOMV_RMCSTATE_DOWNLOAD)) {
3022                         /*
3023                          * Failed response or no response from RMC.
3024                          * Count the failure.
3025                          * If threshold exceeded, send a DR event.
3026                          */
3027                         mutex_enter(&rmclomv_state_lock);
3028                         retries = rmclomv_rmcfailcount;
3029                         state = rmclomv_rmc_state;
3030                         if (retries == RMCLOMV_RMCFAILTHRESHOLD)
3031                                 rmclomv_rmc_state = RMCLOMV_RMCSTATE_FAILED;
3032                         if (rmclomv_rmcfailcount <= RMCLOMV_RMCFAILTHRESHOLD)
3033                                 rmclomv_rmcfailcount++;
3034                         mutex_exit(&rmclomv_state_lock);
3035 
3036                         if (retries == RMCLOMV_RMCFAILTHRESHOLD) {
3037                                 cmn_err(CE_WARN, "SC %s responding",
3038                                     state == RMCLOMV_RMCSTATE_OK ?
3039                                     "has stopped" : "is not");
3040                                 refresh_name_cache(B_TRUE);
3041                                 rmclomv_dr_data_handler(str_sc, SE_NO_HINT);
3042                         }
3043                 }
3044 
3045                 /*
3046                  * Re-enter the lock to prepare for another iteration.
3047                  * We must have the lock here to protect rmclomv_checkrmc_sig.
3048                  */
3049                 mutex_enter(&rmclomv_checkrmc_lock);
3050         }
3051 }
3052 
3053 static void
3054 rmclomv_checkrmc_start(void)
3055 {
3056         kthread_t *tp;
3057 
3058         mutex_enter(&rmclomv_checkrmc_lock);
3059 
3060         if (rmclomv_checkrmc_tid == 0) {
3061                 rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_PROCESSNOW;
3062 
3063                 tp = thread_create(NULL, 0, rmclomv_checkrmc, NULL, 0,
3064                     &p0, TS_RUN, maxclsyspri);
3065                 rmclomv_checkrmc_tid = tp->t_did;
3066         }
3067 
3068         mutex_exit(&rmclomv_checkrmc_lock);
3069 }
3070 
3071 static void
3072 rmclomv_checkrmc_destroy(void)
3073 {
3074         kt_did_t tid;
3075 
3076         mutex_enter(&rmclomv_checkrmc_lock);
3077         tid = rmclomv_checkrmc_tid;
3078         if (tid != 0) {
3079                 rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_EXITNOW;
3080                 cv_signal(&rmclomv_checkrmc_sig_cv);
3081                 rmclomv_checkrmc_tid = 0;
3082         }
3083         mutex_exit(&rmclomv_checkrmc_lock);
3084 
3085         /*
3086          * Wait for rmclomv_checkrmc() to finish
3087          */
3088         if (tid != 0)
3089                 thread_join(tid);
3090 }
3091 
3092 /*ARGSUSED*/
3093 static void
3094 rmclomv_checkrmc_wakeup(void *arg)
3095 {
3096         mutex_enter(&rmclomv_checkrmc_lock);
3097 
3098         if (rmclomv_checkrmc_sig != RMCLOMV_CHECKRMC_EXITNOW)
3099                 rmclomv_checkrmc_sig = RMCLOMV_CHECKRMC_PROCESSNOW;
3100         cv_signal(&rmclomv_checkrmc_sig_cv);
3101 
3102         mutex_exit(&rmclomv_checkrmc_lock);
3103 }
3104 
3105 /* ARGSUSED */
3106 static void
3107 rmclomv_refresh(caddr_t arg)
3108 {
3109         void                    (*plat_nodename_set_fun)(void);
3110         sig_state_t             *current_sgn_p;
3111         callb_cpr_t             cprinfo;
3112         int                     state;
3113         int                     tmp_checkrmc_sig;
3114 
3115         CALLB_CPR_INIT(&cprinfo, &rmclomv_refresh_lock, callb_generic_cpr,
3116             "rmclomv_refresh");
3117 
3118         /*
3119          * Wait until the rmclomv_checkrmc() thread has had a chance to
3120          * run its main loop.  This is done so that rmclomv_refresh will
3121          * only run its main loop once at start of day; otherwise, it may
3122          * run twice and generate warning messages when redundantly populating
3123          * its internal cache.
3124          */
3125         do {
3126                 delay(drv_usectohz(DELAY_TIME));
3127                 mutex_enter(&rmclomv_checkrmc_lock);
3128                 tmp_checkrmc_sig = rmclomv_checkrmc_sig;
3129                 mutex_exit(&rmclomv_checkrmc_lock);
3130         } while (tmp_checkrmc_sig != RMCLOMV_CHECKRMC_WAIT);
3131 
3132         mutex_enter(&rmclomv_refresh_lock);
3133         for (;;) {
3134 
3135                 /*
3136                  * Wait for someone to tell me to continue.
3137                  */
3138                 while (rmclomv_refresh_sig == RMCLOMV_REFRESH_WAIT) {
3139                         CALLB_CPR_SAFE_BEGIN(&cprinfo);
3140                         cv_wait(&rmclomv_refresh_sig_cv, &rmclomv_refresh_lock);
3141                         CALLB_CPR_SAFE_END(&cprinfo, &rmclomv_refresh_lock);
3142                 }
3143 
3144                 /* RMCLOMV_REFRESH_EXITNOW implies signal by _detach(). */
3145                 if (rmclomv_refresh_sig == RMCLOMV_REFRESH_EXITNOW) {
3146                         rmclomv_refresh_sig = RMCLOMV_REFRESH_WAIT;
3147 
3148                         /* rmclomv_refresh_lock is held at this point! */
3149                         CALLB_CPR_EXIT(&cprinfo);
3150 
3151                         thread_exit();
3152                         /* NOTREACHED */
3153                 }
3154 
3155                 ASSERT(rmclomv_refresh_sig == RMCLOMV_REFRESH_PROCESSNOW);
3156                 rmclomv_refresh_sig = RMCLOMV_REFRESH_WAIT;
3157 
3158                 mutex_exit(&rmclomv_refresh_lock);
3159 
3160                 refresh_name_cache(B_FALSE);
3161 
3162                 /*
3163                  * We're not going to access rmclomv_sysinfo_data here,
3164                  * so there's no point in locking it before reading
3165                  * rmclomv_sysinfo_valid. Also this avoids holding two
3166                  * locks at once and the concommitant worry about deadlocks.
3167                  */
3168                 if (rmclomv_sysinfo_valid) {
3169                         /*
3170                          * We've just successfully read the RMC sysinfo
3171                          * so the RMC must be operational. Update its
3172                          * state and if it was previously not OK, refresh
3173                          * nodename, CPU signatures and watchdog settings.
3174                          */
3175                         mutex_enter(&rmclomv_state_lock);
3176                         rmclomv_rmcfailcount = 0;
3177                         state = rmclomv_rmc_state;
3178                         rmclomv_rmc_state = RMCLOMV_RMCSTATE_OK;
3179                         mutex_exit(&rmclomv_state_lock);
3180 
3181                         if (state != RMCLOMV_RMCSTATE_OK) {
3182                                 rmclomv_dr_data_handler(str_sc, SE_NO_HINT);
3183                                 if (state == RMCLOMV_RMCSTATE_FAILED) {
3184                                         cmn_err(CE_NOTE, "SC recovered");
3185                                 }
3186                         }
3187 
3188                         if (utsname.nodename[0] != 0) {
3189                                 plat_nodename_set_fun =
3190                                     (void (*)(void))modgetsymvalue(
3191                                     "plat_nodename_set", 0);
3192                                 if (plat_nodename_set_fun != NULL)
3193                                         plat_nodename_set_fun();
3194                         }
3195 
3196                         current_sgn_p = (sig_state_t *)modgetsymvalue(
3197                             "current_sgn", 0);
3198 
3199                         /*
3200                          * Delay before calling CPU_SIGNATURE, to allow
3201                          * any pending asynchronous communications (i.e.
3202                          * plat_timesync()) to complete.  This helps to
3203                          * prevent the situation where the message associated
3204                          * with the CPU_SIGNATURE state cannot be sent to the
3205                          * system controller.
3206                          */
3207                         if ((current_sgn_p != NULL) &&
3208                             (current_sgn_p->state_t.sig != 0)) {
3209                                 delay(drv_usectohz(CPU_SIGNATURE_DELAY_TIME));
3210                                 CPU_SIGNATURE(current_sgn_p->state_t.sig,
3211                                     current_sgn_p->state_t.state,
3212                                     current_sgn_p->state_t.sub_state, -1);
3213 
3214                                 if (!(boothowto & RB_DEBUG)) {
3215                                         /*
3216                                          * Delay before calling
3217                                          * send_watchdog_msg, to allow
3218                                          * CPU_SIGNATURE() time to
3219                                          * complete; this increases the
3220                                          * chances of successfully sending
3221                                          * the watchdog message to the
3222                                          * system controller.
3223                                          */
3224                                         delay(drv_usectohz(
3225                                             CPU_SIGNATURE_DELAY_TIME));
3226                                         send_watchdog_msg(last_watchdog_msg);
3227                                 }
3228                         }
3229                 }
3230 
3231                 /*
3232                  * update keyswitch value in case it changed while the
3233                  * RMC was out of action
3234                  */
3235                 LOCK_CACHE
3236                 if (rmclomv_sysinfo_valid) {
3237                         real_key_position = rmclomv_sysinfo_data.keyswitch;
3238                         if ((real_key_position != RMC_KEYSWITCH_POS_UNKNOWN) &&
3239                             (real_key_position <= RMC_KEYSWITCH_POS_OFF)) {
3240                                 key_position = real_key_position;
3241                         } else {
3242                                 /* treat unknown key position as locked */
3243                                 key_position = RMC_KEYSWITCH_POS_LOCKED;
3244                         }
3245                 } else {
3246                         /* treat unreadable key position as locked */
3247                         key_position = RMC_KEYSWITCH_POS_LOCKED;
3248                         real_key_position = RMC_KEYSWITCH_POS_UNKNOWN;
3249                 }
3250                 RELEASE_CACHE
3251 
3252                 /*
3253                  * Re-enter the lock to prepare for another iteration.
3254                  * We must have the lock here to protect rmclomv_refresh_sig.
3255                  */
3256                 mutex_enter(&rmclomv_refresh_lock);
3257         }
3258 }
3259 
3260 static void
3261 rmclomv_refresh_start(void)
3262 {
3263         kthread_t *tp;
3264 
3265         mutex_enter(&rmclomv_refresh_lock);
3266 
3267         if (rmclomv_refresh_tid == 0) {
3268                 rmclomv_refresh_sig = RMCLOMV_REFRESH_PROCESSNOW;
3269 
3270                 tp = thread_create(NULL, 0, rmclomv_refresh, NULL, 0,
3271                     &p0, TS_RUN, maxclsyspri);
3272                 rmclomv_refresh_tid = tp->t_did;
3273         }
3274 
3275         mutex_exit(&rmclomv_refresh_lock);
3276 }
3277 
3278 static void
3279 rmclomv_refresh_destroy(void)
3280 {
3281         kt_did_t tid;
3282 
3283         mutex_enter(&rmclomv_refresh_lock);
3284         tid = rmclomv_refresh_tid;
3285         if (tid != 0) {
3286                 rmclomv_refresh_sig = RMCLOMV_REFRESH_EXITNOW;
3287                 cv_signal(&rmclomv_refresh_sig_cv);
3288                 rmclomv_refresh_tid = 0;
3289         }
3290         mutex_exit(&rmclomv_refresh_lock);
3291 
3292         /*
3293          * Wait for rmclomv_refresh() to finish
3294          */
3295         if (tid != 0)
3296                 thread_join(tid);
3297 }
3298 
3299 static void
3300 rmclomv_refresh_wakeup(void)
3301 {
3302         mutex_enter(&rmclomv_refresh_lock);
3303 
3304         if (rmclomv_refresh_sig != RMCLOMV_REFRESH_EXITNOW)
3305                 rmclomv_refresh_sig = RMCLOMV_REFRESH_PROCESSNOW;
3306         cv_signal(&rmclomv_refresh_sig_cv);
3307 
3308         mutex_exit(&rmclomv_refresh_lock);
3309 }
3310 
3311 static void
3312 send_watchdog_msg(int msg)
3313 {
3314         rmc_comm_msg_t request;
3315         dp_set_host_watchdog_t watchdog_msg;
3316 
3317         if (rmclomv_watchdog_mode)
3318                 return;
3319 
3320         watchdog_msg.enable = msg;
3321         request.msg_type = DP_SET_HOST_WATCHDOG;
3322         request.msg_len = sizeof (watchdog_msg);
3323         request.msg_buf = (caddr_t)&watchdog_msg;
3324         (void) rmc_comm_request_nowait(&request, (msg == 1) ?
3325             RMC_COMM_DREQ_URGENT : 0);
3326 }
3327 
3328 /*ARGSUSED*/
3329 static uint_t
3330 rmc_set_watchdog_timer(uint_t timeoutval)
3331 {
3332         ASSERT(MUTEX_HELD(&tod_lock));
3333 
3334         if ((watchdog_enable == 0) || (watchdog_available == 0)) {
3335                 return (0);
3336         }
3337 
3338         /*
3339          * If boothowto has RB_DEBUG set we never want to set the watchdog
3340          * support on.
3341          */
3342         if (boothowto & RB_DEBUG) {
3343                 return (0);
3344         }
3345 
3346         /*
3347          * When the watchdog is shut off last_watchdog_msg goes from a
3348          * 0 to a 1. So we must test to see that last_watchdog_msg is
3349          * set to 1 indicating that watchdog was shut off and
3350          * After which we set last_watchdog_msg back to 0 so that we do not
3351          * run this code
3352          * again.
3353          */
3354         if (last_watchdog_msg == 1) {
3355                 send_watchdog_msg(0);
3356                 last_watchdog_msg = 0;
3357         }
3358 
3359         pmugpio_watchdog_pat();
3360 
3361         watchdog_activated = 1;
3362 
3363         return (1);
3364 }
3365 
3366 static uint_t
3367 rmc_clear_watchdog_timer(void)
3368 {
3369         ASSERT(MUTEX_HELD(&tod_lock));
3370         if ((watchdog_activated == 0) || (boothowto & RB_DEBUG))
3371                 return (0);
3372 
3373         send_watchdog_msg(1);
3374         last_watchdog_msg = 1;
3375         watchdog_activated = 0;
3376 
3377         return (0);
3378 }
3379 
3380 static void
3381 plat_timesync(void *arg)
3382 {
3383         timestruc_t now;
3384         todinfo_t tod;
3385         rmc_comm_msg_t request;
3386         dp_set_date_time_t set_time_msg;
3387         int retval;
3388         timestruc_t ts;
3389         dp_get_date_time_r_t *date_and_time_info;
3390         int buffer[DATE_TIME_MSG_SIZE];
3391 
3392         /* Is the system coming up? */
3393         if (arg != NULL) {
3394                 /* Request the time from the RMC clock. */
3395                 retval = rmclomv_do_cmd(DP_GET_DATE_TIME, DP_GET_DATE_TIME_R,
3396                     DATE_TIME_MSG_SIZE, NULL, (intptr_t)&buffer);
3397 
3398                 /*
3399                  * If we were able to get the time lets set the local clock.
3400                  * The time returned from RMC is in Unix time format.
3401                  *
3402                  * If we couldn't get the time we'll accept the drift so as not
3403                  * to cause congestion on the I2C bus or cause boot
3404                  * performance regressions.
3405                  */
3406                 if (retval == RCNOERR) {
3407                         date_and_time_info = (dp_get_date_time_r_t *)buffer;
3408                         ts.tv_sec = date_and_time_info->current_datetime;
3409                         ts.tv_nsec = 0;
3410                         mutex_enter(&tod_lock);
3411                         tod_set(ts);
3412                         set_hrestime(&ts);
3413                         mutex_exit(&tod_lock);
3414                 }
3415         }
3416 
3417         gethrestime(&now);
3418         mutex_enter(&tod_lock);
3419         tod = utc_to_tod(now.tv_sec);
3420         mutex_exit(&tod_lock);
3421 
3422         set_time_msg.year       = tod.tod_year;
3423         set_time_msg.month      = tod.tod_month - 1;
3424         set_time_msg.day        = tod.tod_day;
3425         set_time_msg.hour       = tod.tod_hour;
3426         set_time_msg.minute     = tod.tod_min;
3427         set_time_msg.second     = tod.tod_sec;
3428 
3429         request.msg_type = DP_SET_DATE_TIME;
3430         request.msg_len = sizeof (set_time_msg);
3431         request.msg_buf = (caddr_t)&set_time_msg;
3432 
3433         (void) rmc_comm_request_nowait(&request, 0);
3434 
3435         mutex_enter(&timesync_lock);
3436         if (timesync_interval != 0)
3437                 timesync_tid = timeout(plat_timesync, NULL, timesync_interval);
3438         mutex_exit(&timesync_lock);
3439 }
3440 
3441 /*
3442  * Interfaces to get/set alarm relays from outside
3443  */
3444 int
3445 rmclomv_alarm_get(int alarm_type, int *alarm_state)
3446 {
3447         rmclomv_cache_section_t *section;
3448         int                     index;
3449         uint16_t                sensor_status;
3450         dp_get_alarm_state_t    u_rmc_alarm;
3451         dp_get_alarm_state_r_t  u_rmc_alarm_r;
3452 
3453         /* see if we've got ALARM handles cached */
3454         LOCK_CACHE
3455         sensor_status = ENVMON_SENSOR_OK;
3456 
3457         if ((rmclomv_cache_valid == B_FALSE) ||
3458             ((section = rmclomv_find_section(rmclomv_cache,
3459             RMCLOMV_ALARM_IND)) == NULL)) {
3460                 sensor_status = ENVMON_NOT_PRESENT;
3461         }
3462         if (sensor_status == ENVMON_SENSOR_OK) {
3463                 /*
3464                  * user correctly identified a ALARM, note its
3465                  * handle value and request the ALARM status
3466                  */
3467                 index = alarm_type;
3468                 if (index >= section->num_entries)
3469                         sensor_status = ENVMON_INACCESSIBLE;
3470                 else
3471                         u_rmc_alarm.handle = section->entry[index].handle;
3472         }
3473         RELEASE_CACHE
3474         if ((sensor_status == ENVMON_SENSOR_OK) && (rmclomv_rmc_error ||
3475             rmclomv_do_cmd(DP_GET_ALARM_STATE, DP_GET_ALARM_STATE_R,
3476             sizeof (u_rmc_alarm_r), (intptr_t)&u_rmc_alarm,
3477             (intptr_t)&u_rmc_alarm_r) != 0)) {
3478                 sensor_status = ENVMON_INACCESSIBLE;
3479         }
3480         if (sensor_status == ENVMON_SENSOR_OK) {
3481                 /*
3482                  * copy results into buffer for user
3483                  * start with some defaults then override
3484                  */
3485                 *alarm_state = 0;
3486 
3487                 if (u_rmc_alarm_r.alarm_state[0].sensor_status !=
3488                     DP_SENSOR_DATA_AVAILABLE)
3489                         return (ENXIO);
3490                 else {
3491                         dp_alarm_state_t alarmState;
3492                         alarmState = u_rmc_alarm_r.alarm_state[0];
3493 
3494                         switch (alarmState.state) {
3495                         case DP_ALARM_OFF:
3496                                 break;
3497                         case DP_ALARM_ON:
3498                                 *alarm_state = 1;
3499                                 break;
3500                         default:
3501                                 break;
3502                         }
3503                 }
3504         } else
3505                 return (ENXIO);
3506 
3507         return (0);
3508 }
3509 
3510 int
3511 rmclomv_alarm_set(int alarm_type, int new_state)
3512 {
3513         rmclomv_cache_section_t *section;
3514         int                     index;
3515         uint16_t                sensor_status;
3516         dp_set_alarm_state_t    u_rmc_setalarm;
3517         dp_set_alarm_state_r_t  u_rmc_setalarm_r;
3518 
3519         /* see if we've got ALARM handles cached */
3520         LOCK_CACHE
3521         sensor_status = ENVMON_SENSOR_OK;
3522 
3523         if ((rmclomv_cache_valid == B_FALSE) ||
3524             ((section = rmclomv_find_section(rmclomv_cache,
3525             RMCLOMV_ALARM_IND)) == NULL)) {
3526                 sensor_status = ENVMON_NOT_PRESENT;
3527         }
3528         if (sensor_status == ENVMON_SENSOR_OK) {
3529                 /*
3530                  * user correctly identified a ALARM, note its
3531                  * handle value and request the ALARM status
3532                  */
3533                 index = alarm_type;
3534                 if (index >= section->num_entries)
3535                         sensor_status = ENVMON_INACCESSIBLE;
3536                 else {
3537                         u_rmc_setalarm.handle = section->entry[index].handle;
3538                         u_rmc_setalarm.state = new_state;
3539                 }
3540         }
3541         RELEASE_CACHE
3542         if ((sensor_status == ENVMON_SENSOR_OK) &&
3543             (rmclomv_rmc_error ||
3544             rmclomv_do_cmd(DP_SET_ALARM_STATE, DP_SET_ALARM_STATE_R,
3545             sizeof (u_rmc_setalarm_r), (intptr_t)&u_rmc_setalarm,
3546             (intptr_t)&u_rmc_setalarm_r) != 0)) {
3547                 sensor_status = ENVMON_INACCESSIBLE;
3548         }
3549 
3550         if (u_rmc_setalarm_r.status != DP_SET_ALARM_OK) {
3551                 return (EIO);
3552         }
3553 
3554         if (sensor_status != ENVMON_SENSOR_OK) {
3555                 return (ENXIO);
3556         }
3557 
3558         return (0);
3559 }