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(×ync_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(×ync_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(×ync_lock); 512 tid = timesync_tid; 513 timesync_tid = 0; 514 timesync_interval = 0; 515 mutex_exit(×ync_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 = §ion->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 = §ion->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)&i_cmd, (intptr_t)&i_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(×ync_lock); 3436 if (timesync_interval != 0) 3437 timesync_tid = timeout(plat_timesync, NULL, timesync_interval); 3438 mutex_exit(×ync_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 } 3560