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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 /* 30 * Cherrystone platform specific environment monitoring policies 31 */ 32 33 #include <syslog.h> 34 #include <unistd.h> 35 #include <stdio.h> 36 #include <libintl.h> 37 #include <string.h> 38 #include <stdlib.h> 39 #include <errno.h> 40 #include <fcntl.h> 41 #include <sys/types.h> 42 #include <sys/time.h> 43 #include <sys/time_impl.h> 44 #include <sys/signal.h> 45 #include <sys/devctl.h> 46 #include <libdevinfo.h> 47 #include <libdevice.h> 48 #include <picl.h> 49 #include <picltree.h> 50 #include <sys/i2c/clients/i2c_client.h> 51 #include <hbaapi.h> 52 #include <limits.h> 53 #include <sys/systeminfo.h> 54 55 #include <psvc_objects.h> 56 57 /* Device paths for power supply hotplug handling */ 58 #define SEG5_ADDR 0x30 59 #define EBUS_DEV_NAME "/devices/pci@9,700000/ebus@1/" 60 #define SEG5_DEV_NAME EBUS_DEV_NAME "i2c@1,30/" 61 #define SEG5_ADDR_DEV_FMT EBUS_DEV_NAME "i2c@1,%x:devctl" 62 63 #define QLC_NODE "/pci@9,600000/SUNW,qlc@2" 64 65 #define DISK_DRV "ssd" 66 #define MAX_DISKS 2 67 #define WWN_SIZE 8 68 #define ONBOARD_CONTR "../../devices/pci@9,600000/SUNW,qlc@2/fp@0,0:fc" 69 70 /* Bit masks so we don't "wedge" the inputs */ 71 #define PCF8574_BIT_WRITE_VALUE(byte, bit, value)\ 72 ((value << bit) | (byte & (~(0x01 << bit)))) 73 74 #define PDB_MUST_BE_1 0xBF 75 #define PSU_MUST_BE_1 0x7F 76 #define DISKBP_MUST_BE_1 0x0F 77 78 /*LINTLIBRARY*/ 79 80 #define PSVC_MAX_STR_LEN 32 81 82 #define PS_MAX_FAULT_SENSORS 3 83 84 /* 85 * Keep track of the power supply's fail status for reporting if/when 86 * they go good. 87 * ID's: 88 * O PSx_FAULT_SENSOR 89 * 1 Doesn't matter -- only need 0 to be PSx_FAULT_SENSOR 90 * 2 Doesn't matter 91 */ 92 static char *ps_prev_id[2][3] = 93 {{NULL, NULL, NULL}, {NULL, NULL, NULL}}; 94 static int ps_prev_failed[2][3] = {{0, 0, 0}, {0, 0, 0}}; 95 96 /* 97 * Keep track of the power supply's previous presence 98 * because PSVC doesn't do that for us. 99 */ 100 static boolean_t ps_prev_present[2]; 101 static boolean_t ps_present[2]; 102 103 /* Local Routines for the environmental policies */ 104 static int ac_unplugged(psvc_opaque_t, char *); 105 static int ac_power_check(psvc_opaque_t, char *, char *); 106 107 /* 108 * The I2C bus is noisy, and the state may be incorrectly reported as 109 * having changed. When the state changes, we attempt to confirm by 110 * retrying. If any retries indicate that the state has not changed, we 111 * assume the state change(s) were incorrect and the state has not changed. 112 * The following variables are used to store the tuneable values read in 113 * from the optional i2cparam.conf file for this shared object library. 114 */ 115 static int n_retry_fan = PSVC_NUM_OF_RETRIES; 116 static int retry_sleep_fan = 1; 117 static int n_retry_ps_status = PSVC_NUM_OF_RETRIES; 118 static int retry_sleep_ps_status = 1; 119 static int n_retry_pshp = PSVC_NUM_OF_RETRIES; 120 static int retry_sleep_pshp = 1; 121 static int n_retry_diskhp = PSVC_NUM_OF_RETRIES; 122 static int retry_sleep_diskhp = 1; 123 static int n_retry_temp_shutdown = PSVC_NUM_OF_RETRIES; 124 static int retry_sleep_temp_shutdown = 1; 125 static int n_retry_fsp_fault = PSVC_NUM_OF_RETRIES; 126 static int retry_sleep_fsp_fault = 1; 127 128 typedef struct { 129 int *pvar; 130 char *texttag; 131 } i2c_noise_param_t; 132 133 static i2c_noise_param_t i2cparams[] = { 134 &n_retry_fan, "n_retry_fan", 135 &retry_sleep_fan, "retry_sleep_fan", 136 &n_retry_ps_status, "n_retry_ps_status", 137 &retry_sleep_ps_status, "retry_sleep_ps_status", 138 &n_retry_pshp, "n_retry_pshp", 139 &retry_sleep_pshp, "retry_sleep_pshp", 140 &n_retry_diskhp, "n_retry_diskhp", 141 &retry_sleep_diskhp, "retry_sleep_diskhp", 142 &n_retry_temp_shutdown, "n_retry_temp_shutdown", 143 &retry_sleep_temp_shutdown, "retry_sleep_temp_shutdown", 144 &n_retry_fsp_fault, "n_retry_fsp_fault", 145 &retry_sleep_fsp_fault, "retry_sleep_fsp_fault", 146 NULL, NULL 147 }; 148 149 #pragma init(i2cparams_load) 150 151 static void 152 i2cparams_debug(i2c_noise_param_t *pi2cparams, char *platform, 153 int usingDefaults) 154 { 155 char s[128]; 156 i2c_noise_param_t *p; 157 158 if (!usingDefaults) { 159 (void) snprintf(s, sizeof (s), 160 "# Values from /usr/platform/%s/lib/i2cparam.conf\n", 161 platform); 162 syslog(LOG_WARNING, "%s", s); 163 } else { 164 /* no file - we're using the defaults */ 165 (void) snprintf(s, sizeof (s), 166 "# No /usr/platform/%s/lib/i2cparam.conf file, using defaults\n", 167 platform); 168 } 169 (void) fputs(s, stdout); 170 p = pi2cparams; 171 while (p->pvar != NULL) { 172 (void) snprintf(s, sizeof (s), "%s %d\n", p->texttag, 173 *(p->pvar)); 174 if (!usingDefaults) 175 syslog(LOG_WARNING, "%s", s); 176 (void) fputs(s, stdout); 177 p++; 178 } 179 } 180 181 static void 182 i2cparams_load(void) 183 { 184 FILE *fp; 185 char filename[PATH_MAX]; 186 char platform[64]; 187 char s[128]; 188 char var[128]; 189 int val; 190 i2c_noise_param_t *p; 191 192 if (sysinfo(SI_PLATFORM, platform, sizeof (platform)) == -1) { 193 syslog(LOG_ERR, "sysinfo error %s\n", strerror(errno)); 194 return; 195 } 196 (void) snprintf(filename, sizeof (filename), 197 "/usr/platform/%s/lib/i2cparam.conf", platform); 198 /* read thru the i2cparam.conf file and set variables */ 199 if ((fp = fopen(filename, "r")) != NULL) { 200 while (fgets(s, sizeof (s), fp) != NULL) { 201 if (s[0] == '#') /* skip comment lines */ 202 continue; 203 /* try to find a string match and get the value */ 204 if (sscanf(s, "%127s %d", var, &val) != 2) 205 continue; 206 if (val < 1) 207 val = 1; /* clamp min value */ 208 p = &(i2cparams[0]); 209 while (p->pvar != NULL) { 210 if (strncmp(p->texttag, var, sizeof (var)) == 211 0) { 212 *(p->pvar) = val; 213 break; 214 } 215 p++; 216 } 217 } 218 (void) fclose(fp); 219 } 220 /* output the values of the parameters */ 221 i2cparams_debug(&(i2cparams[0]), platform, ((fp == NULL)? 1 : 0)); 222 } 223 224 /* 225 * Create an I2C device node. 226 */ 227 static int 228 create_i2c_node(char *nd_name, char *nd_compat, int nd_nexi, int *nd_reg) 229 { 230 devctl_ddef_t ddef_hdl = NULL; 231 devctl_hdl_t bus_hdl = NULL; 232 devctl_hdl_t dev_hdl = NULL; 233 char buf[MAXPATHLEN]; 234 char dev_path[MAXPATHLEN]; 235 int rv = PSVC_FAILURE; 236 237 (void) snprintf(buf, sizeof (buf), SEG5_ADDR_DEV_FMT, nd_nexi); 238 bus_hdl = devctl_bus_acquire(buf, 0); 239 if (bus_hdl == NULL) 240 goto bad; 241 242 /* device definition properties */ 243 ddef_hdl = devctl_ddef_alloc(nd_name, 0); 244 (void) devctl_ddef_string(ddef_hdl, "compatible", nd_compat); 245 (void) devctl_ddef_int_array(ddef_hdl, "reg", 2, nd_reg); 246 247 /* create the device node */ 248 if (devctl_bus_dev_create(bus_hdl, ddef_hdl, 0, &dev_hdl)) 249 goto bad; 250 251 if (devctl_get_pathname(dev_hdl, dev_path, MAXPATHLEN) == NULL) 252 goto bad; 253 254 #ifdef DEBUG 255 syslog(LOG_ERR, "PSVC: create_i2c_node: Device node created: (%s)", 256 dev_path); 257 #endif 258 rv = PSVC_SUCCESS; 259 bad: 260 if (dev_hdl) devctl_release(dev_hdl); 261 if (ddef_hdl) devctl_ddef_free(ddef_hdl); 262 if (bus_hdl) devctl_release(bus_hdl); 263 return (rv); 264 } 265 266 /* 267 * Delete an I2C device node given the device path. 268 */ 269 static void 270 delete_i2c_node(char *nd) 271 { 272 int rv; 273 devctl_hdl_t dev_hdl; 274 275 dev_hdl = devctl_device_acquire(nd, 0); 276 if (dev_hdl == NULL) { 277 return; 278 } 279 280 rv = devctl_device_remove(dev_hdl); 281 if (rv != DDI_SUCCESS) 282 perror(nd); 283 #ifdef DEBUG 284 else 285 syslog(LOG_ERR, "Device node deleted: (%s)", nd); 286 #endif 287 devctl_release(dev_hdl); 288 } 289 290 291 /* PCF8574 Reset Function */ 292 static int 293 send_pcf8574_reset(psvc_opaque_t hdlp, char *reset_dev) 294 { 295 int err; 296 uint8_t reset_bits[2] = {0x7F, 0xFF}; 297 int i; 298 for (i = 0; i < 2; i++) { 299 err = psvc_set_attr(hdlp, reset_dev, PSVC_GPIO_VALUE_ATTR, 300 &reset_bits[i]); 301 if (err != PSVC_SUCCESS) { 302 #ifdef DEBUG 303 syslog(LOG_ERR, 304 gettext("Reset to %s with 0x%x failed"), 305 reset_dev, reset_bits[i]); 306 #endif 307 return (err); 308 } 309 } 310 /* Need to give u-code a chance to update */ 311 sleep(3); 312 return (err); 313 } 314 315 static int 316 pcf8574_write_bit(psvc_opaque_t hdlp, char *id, uint8_t bit_num, 317 uint8_t bit_val, uint8_t write_must_be_1) 318 { 319 int rv = PSVC_FAILURE; 320 uint8_t byte; 321 322 rv = psvc_get_attr(hdlp, id, PSVC_GPIO_VALUE_ATTR, &byte); 323 if (rv != PSVC_SUCCESS) 324 return (rv); 325 326 byte = PCF8574_BIT_WRITE_VALUE(byte, bit_num, bit_val); 327 byte |= write_must_be_1; 328 rv = psvc_set_attr(hdlp, id, PSVC_GPIO_VALUE_ATTR, &byte); 329 return (rv); 330 } 331 332 /* 333 * To enable the i2c bus, we must toggle bit 6 on the PDB's 334 * PCF8574 (0x4C) high->low->high 335 */ 336 static int 337 pdb_enable_i2c(psvc_opaque_t hdlp) 338 { 339 int rv = PSVC_SUCCESS, i; 340 int bit_vals[3] = {1, 0, 1}; 341 int bit_num = 6; 342 343 for (i = 0; i < 3; i++) { 344 rv = pcf8574_write_bit(hdlp, "PDB_PORT", bit_num, bit_vals[i], 345 PDB_MUST_BE_1); 346 if (rv != PSVC_SUCCESS) { 347 goto bad; 348 } 349 } 350 return (rv); 351 bad: 352 #ifdef DEBUG 353 syslog(LOG_ERR, gettext("PDB I2C Bus Enabling Failed")); 354 #endif 355 return (rv); 356 } 357 358 int32_t 359 psvc_init_disk_bp_policy_0(psvc_opaque_t hdlp, char *id) 360 { 361 uint8_t reset = 0xFF; 362 return (psvc_set_attr(hdlp, id, PSVC_GPIO_VALUE_ATTR, 363 &reset)); 364 } 365 366 int32_t 367 pcf8574_init_policy_0(psvc_opaque_t hdlp, char *id) 368 { 369 return (send_pcf8574_reset(hdlp, id)); 370 } 371 372 static int32_t 373 check_fan(psvc_opaque_t hdlp, char *tray_id, char *fan_id, boolean_t *fault_on) 374 { 375 int status; 376 int speed; 377 int low_thresh; 378 boolean_t have_fault = 0; 379 char *tach_id; 380 char state[PSVC_MAX_STR_LEN]; 381 char prev_state[PSVC_MAX_STR_LEN]; 382 char fault_state[PSVC_MAX_STR_LEN]; 383 int retry; 384 385 /* Get this fan object's corresponding fan tach */ 386 status = psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_ID_ATTR, 387 &tach_id, PSVC_FAN_SPEED_TACHOMETER, 0); 388 if (status != PSVC_SUCCESS) 389 return (status); 390 391 /* Get the low fan speed threshold */ 392 status = psvc_get_attr(hdlp, tach_id, PSVC_LO_WARN_ATTR, &low_thresh); 393 if (status != PSVC_SUCCESS) 394 return (status); 395 396 retry = 0; 397 do { 398 if (retry) 399 (void) sleep(retry_sleep_fan); 400 /* Get the fan speed */ 401 status = psvc_get_attr(hdlp, tach_id, PSVC_SENSOR_VALUE_ATTR, 402 &speed); 403 if (status != PSVC_SUCCESS) 404 return (status); 405 406 if (speed <= low_thresh) { /* We see a fault */ 407 strlcpy(fault_state, "DEVICE_FAIL", 408 sizeof (fault_state)); 409 strlcpy(state, PSVC_ERROR, sizeof (state)); 410 have_fault = 1; 411 } else { /* Fault gone? */ 412 strlcpy(fault_state, PSVC_NO_FAULT, 413 sizeof (fault_state)); 414 strlcpy(state, PSVC_OK, sizeof (state)); 415 have_fault = 0; 416 } 417 retry++; 418 } while ((retry < n_retry_fan) && (speed <= low_thresh)); 419 420 /* Assign new states to the fan object */ 421 status = psvc_set_attr(hdlp, fan_id, PSVC_FAULTID_ATTR, fault_state); 422 if (status != PSVC_SUCCESS) 423 return (status); 424 status = psvc_set_attr(hdlp, fan_id, PSVC_STATE_ATTR, state); 425 if (status != PSVC_SUCCESS) 426 return (status); 427 428 /* Get state and previous state */ 429 status = psvc_get_attr(hdlp, fan_id, PSVC_STATE_ATTR, state); 430 if (status != PSVC_SUCCESS) 431 return (status); 432 status = psvc_get_attr(hdlp, fan_id, PSVC_PREV_STATE_ATTR, prev_state); 433 if (status != PSVC_SUCCESS) 434 return (status); 435 436 /* Display notices */ 437 if (strcmp(state, PSVC_OK) != 0) { 438 syslog(LOG_ERR, gettext("WARNING: %s (%s) failure detected"), 439 tray_id, fan_id); 440 } else { 441 if (strcmp(state, prev_state) != 0) { 442 syslog(LOG_ERR, gettext("NOTICE: Device %s (%s) OK"), 443 tray_id, fan_id); 444 } 445 } 446 447 *fault_on |= have_fault; 448 return (PSVC_SUCCESS); 449 } 450 451 /* 452 * This policy acts on fan trays. It looks at each of its fans 453 * and checks the speeds. If the fan speed is less than the threshold, 454 * then indicate: console, log, LED. 455 */ 456 int32_t 457 psvc_fan_fault_check_policy_0(psvc_opaque_t hdlp, char *id) 458 { 459 int fan_count; 460 int led_count; 461 int err, i; 462 char *led_id; 463 char *fan_id; 464 char led_state[PSVC_MAX_STR_LEN]; 465 char state[PSVC_MAX_STR_LEN]; 466 char prev_state[PSVC_MAX_STR_LEN]; 467 boolean_t fault_on = 0; 468 469 /* Get the number of fans associated with this fan tray. */ 470 err = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &fan_count, 471 PSVC_FAN_TRAY_FANS); 472 if (err != PSVC_SUCCESS) 473 return (err); 474 475 for (i = 0; i < fan_count; i++) { 476 err = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, 477 &fan_id, PSVC_FAN_TRAY_FANS, i); 478 if (err != PSVC_SUCCESS) 479 return (err); 480 481 err = check_fan(hdlp, id, fan_id, &fault_on); 482 if (err != PSVC_SUCCESS) 483 return (err); 484 } 485 486 if (fault_on) { 487 strlcpy(led_state, PSVC_LED_ON, sizeof (led_state)); 488 err = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, PSVC_ERROR); 489 if (err != PSVC_SUCCESS) 490 return (err); 491 492 } else { 493 strlcpy(led_state, PSVC_LED_OFF, sizeof (led_state)); 494 err = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, PSVC_OK); 495 if (err != PSVC_SUCCESS) 496 return (err); 497 } 498 499 err = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state); 500 if (err != PSVC_SUCCESS) 501 return (err); 502 err = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR, prev_state); 503 if (err != PSVC_SUCCESS) 504 return (err); 505 506 /* 507 * Set leds according to the fan tray's states. 508 * (we only do this if there is a change of state in order 509 * to reduce i2c traffic) 510 */ 511 if (strcmp(state, prev_state) != 0) { 512 err = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, 513 &led_count, PSVC_DEV_FAULT_LED); 514 if (err != PSVC_SUCCESS) 515 return (err); 516 for (i = 0; i < led_count; i++) { 517 err = psvc_get_attr(hdlp, id, 518 PSVC_ASSOC_ID_ATTR, &led_id, 519 PSVC_DEV_FAULT_LED, i); 520 if (err != PSVC_SUCCESS) 521 return (err); 522 err = psvc_set_attr(hdlp, led_id, 523 PSVC_LED_STATE_ATTR, led_state); 524 if (err != PSVC_SUCCESS) 525 return (err); 526 err = psvc_get_attr(hdlp, led_id, 527 PSVC_LED_STATE_ATTR, led_state); 528 if (err != PSVC_SUCCESS) 529 return (err); 530 } 531 } 532 return (err); 533 } 534 535 static int32_t 536 check_cpu_temp_fault(psvc_opaque_t hdlp, char *cpu, int32_t cpu_count) 537 { 538 char *sensorid; 539 int32_t sensor_count; 540 int32_t status = PSVC_SUCCESS; 541 int32_t i; 542 char fault[PSVC_MAX_STR_LEN]; 543 int retry; 544 545 psvc_get_attr(hdlp, cpu, PSVC_ASSOC_MATCHES_ATTR, &sensor_count, 546 PSVC_DEV_TEMP_SENSOR); 547 for (i = 0; i < sensor_count; ++i) { 548 status = psvc_get_attr(hdlp, cpu, PSVC_ASSOC_ID_ATTR, 549 &sensorid, PSVC_DEV_TEMP_SENSOR, i); 550 if (status == PSVC_FAILURE) 551 return (status); 552 553 retry = 0; 554 do { 555 if (retry) 556 (void) sleep(retry_sleep_temp_shutdown); 557 status = psvc_get_attr(hdlp, sensorid, 558 PSVC_FAULTID_ATTR, fault); 559 if (status == PSVC_FAILURE) 560 return (status); 561 retry++; 562 } while (((strcmp(fault, PSVC_TEMP_LO_SHUT) == 0) || 563 (strcmp(fault, PSVC_TEMP_HI_SHUT) == 0)) && 564 (retry < n_retry_temp_shutdown)); 565 566 if ((strcmp(fault, PSVC_TEMP_HI_SHUT) == 0) || 567 (strcmp(fault, PSVC_TEMP_LO_SHUT) == 0)) { 568 system("shutdown -y -g 60 -i 5 \"OVERTEMP condition\""); 569 } 570 } 571 572 return (status); 573 } 574 575 int32_t 576 psvc_shutdown_policy_0(psvc_opaque_t hdlp, char *id) 577 { 578 int32_t cpu_count; 579 char *cpuid; 580 int32_t i; 581 boolean_t present; 582 int32_t status = PSVC_SUCCESS; 583 584 psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &cpu_count, 585 PSVC_CPU); 586 for (i = 0; i < cpu_count; ++i) { 587 588 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &cpuid, 589 PSVC_CPU, i); 590 if (status == PSVC_FAILURE) 591 return (status); 592 593 status = psvc_get_attr(hdlp, cpuid, 594 PSVC_PRESENCE_ATTR, &present); 595 if (status == PSVC_FAILURE && present == PSVC_PRESENT) 596 return (status); 597 if (present == PSVC_PRESENT) { 598 status = check_cpu_temp_fault(hdlp, cpuid, cpu_count); 599 if (status == PSVC_FAILURE && errno != ENODEV) 600 return (status); 601 } 602 } 603 604 return (PSVC_SUCCESS); 605 } 606 607 /* 608 * Checks device specified by the PSVC_DEV_FAULT_SENSOR association 609 * for errors, and if there is, then report and turn on the FSP Fault 610 * Led. 611 */ 612 int32_t 613 psvc_fsp_device_fault_check_policy_0(psvc_opaque_t hdlp, char *id) 614 { 615 int32_t status; 616 int32_t i; 617 int32_t device_count = 0; 618 char device_state[PSVC_MAX_STR_LEN]; 619 char *device_id; 620 int32_t failed_count = 0; 621 static int32_t led_on = 0; 622 int retry; 623 624 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, 625 &device_count, PSVC_DEV_FAULT_SENSOR); 626 if (status != PSVC_SUCCESS) 627 return (status); 628 629 for (i = 0; i < device_count; i++) { 630 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, 631 &device_id, PSVC_DEV_FAULT_SENSOR, i); 632 if (status != PSVC_SUCCESS) 633 return (status); 634 635 retry = 0; 636 do { 637 if (retry) 638 (void) sleep(retry_sleep_fsp_fault); 639 status = psvc_get_attr(hdlp, device_id, PSVC_STATE_ATTR, 640 device_state); 641 if (status != PSVC_SUCCESS) 642 return (status); 643 644 if (strcmp(device_state, PSVC_OK) != 0 && 645 strcmp(device_state, PSVC_HOTPLUGGED) != 0 && 646 strcmp(device_state, "NO AC POWER") != 0 && 647 strlen(device_state) != 0) { 648 failed_count++; 649 } 650 retry++; 651 } while ((retry < n_retry_fsp_fault) && (failed_count)); 652 } 653 if (failed_count == 0 && led_on) { 654 syslog(LOG_ERR, gettext("%s has turned OFF"), id); 655 status = psvc_set_attr(hdlp, id, PSVC_LED_STATE_ATTR, 656 PSVC_LED_OFF); 657 led_on = 0; 658 } 659 660 if (failed_count > 0 && ! led_on) { 661 syslog(LOG_ERR, 662 gettext("%s has turned ON"), id); 663 status = psvc_set_attr(hdlp, id, PSVC_LED_STATE_ATTR, 664 PSVC_LED_ON); 665 led_on = 1; 666 } 667 668 return (PSVC_SUCCESS); 669 } 670 671 /* Power Supply Policy Helper and Worker Functions */ 672 static void 673 ps_reset_prev_failed(int index) 674 { 675 int i; 676 /* Reset the power supply's failure information */ 677 for (i = 0; i < 3; i++) { 678 ps_prev_id[index][i] = NULL; 679 ps_prev_failed[index][i] = 0; 680 } 681 682 } 683 static int 684 check_i2c_access(psvc_opaque_t hdlp, char *id) 685 { 686 int rv; 687 char state[PSVC_MAX_STR_LEN]; 688 char ps_fault_sensor[PSVC_MAX_STR_LEN]; 689 690 snprintf(ps_fault_sensor, sizeof (ps_fault_sensor), 691 "%s_FAULT_SENSOR", id); 692 693 rv = psvc_get_attr(hdlp, ps_fault_sensor, PSVC_SWITCH_STATE_ATTR, 694 &state); 695 return (rv); 696 } 697 698 /* 699 * This routine takes in the PSVC handle pointer, the PS name, and the 700 * instance number (0 or 1). It simply make a psvc_get call to get the 701 * presence of each of the children under the PS. This call will set the 702 * presence state of the child device if it was not there when the system 703 * was booted. 704 */ 705 static int 706 handle_ps_hotplug_children_presence(psvc_opaque_t hdlp, char *id) 707 { 708 char *child_add_on[4] = {"_RESET", "_LOGICAL_STATE", "_AC_IN_SENSOR", 709 "_FAULT_SENSOR"}; 710 int add_ons = 4; 711 char addon_id[PICL_PROPNAMELEN_MAX]; 712 char *sensor_id; 713 int32_t status = PSVC_SUCCESS; 714 boolean_t presence; 715 int j; 716 717 /* Go through the add on list and set presence */ 718 for (j = 0; j < add_ons; j++) { 719 snprintf(addon_id, sizeof (addon_id), "%s%s", id, 720 child_add_on[j]); 721 status = psvc_get_attr(hdlp, addon_id, PSVC_PRESENCE_ATTR, 722 &presence); 723 if (status != PSVC_SUCCESS) 724 return (status); 725 } 726 727 /* Go through each PS's fault sensors */ 728 for (j = 0; j < PS_MAX_FAULT_SENSORS; j++) { 729 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, 730 &(sensor_id), PSVC_DEV_FAULT_SENSOR, j); 731 if (status != PSVC_SUCCESS) 732 return (status); 733 status = psvc_get_attr(hdlp, sensor_id, PSVC_PRESENCE_ATTR, 734 &presence); 735 if (status != PSVC_SUCCESS) 736 return (status); 737 } 738 739 /* Go through each PS's onboard i2c hardware */ 740 for (j = 0; j < 2; j++) { 741 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, 742 &(sensor_id), PSVC_PHYSICAL_DEVICE, j); 743 if (status != PSVC_SUCCESS) 744 return (status); 745 status = psvc_get_attr(hdlp, sensor_id, PSVC_PRESENCE_ATTR, 746 &presence); 747 if (status != PSVC_SUCCESS) 748 return (status); 749 } 750 751 return (status); 752 } 753 754 static int 755 handle_ps_hotplug(psvc_opaque_t hdlp, char *id, boolean_t present) 756 { 757 int32_t status = PSVC_SUCCESS; 758 int32_t instance; 759 picl_nodehdl_t parent_node; 760 picl_nodehdl_t child_node; 761 char info[PSVC_MAX_STR_LEN]; 762 char ps_logical_state[PICL_PROPNAMELEN_MAX]; 763 char parent_path[PICL_PROPNAMELEN_MAX]; 764 char ps_path[PICL_PROPNAMELEN_MAX]; 765 static int fruprom_addr[2][2] = { {0, 0xa2}, {0, 0xa0} }; 766 static int pcf8574_addr[2][2] = { {0, 0x72}, {0, 0x70} }; 767 char dev_path[MAXPATHLEN]; 768 769 /* Convert name to node and parent path */ 770 psvcplugin_lookup(id, parent_path, &child_node); 771 772 /* 773 * Get the power supply's instance. 774 * Used to index the xxx_addr arrays 775 */ 776 status = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance); 777 if (status != PSVC_SUCCESS) 778 return (status); 779 780 if (present == PSVC_PRESENT && !ps_prev_present[instance]) { 781 /* Service Power Supply Insertion */ 782 syslog(LOG_ERR, gettext("Device %s inserted"), id); 783 784 /* PICL Tree Maintenance */ 785 ptree_get_node_by_path(parent_path, &parent_node); 786 ptree_add_node(parent_node, child_node); 787 snprintf(ps_path, sizeof (ps_path), "%s/%s", parent_path, id); 788 psvcplugin_add_children(ps_path); 789 790 /* 791 * This code to update the presences of power supply 792 * child devices in the event that picld was started 793 * without a power supply present. This call makes 794 * the devices available after that initial insertion. 795 */ 796 status = handle_ps_hotplug_children_presence(hdlp, id); 797 798 /* 799 * Device Tree Maintenance 800 * Add the devinfo tree node entry for the pcf8574 and seeprom 801 * and attach their drivers. 802 */ 803 status |= create_i2c_node("ioexp", "i2c-pcf8574", SEG5_ADDR, 804 pcf8574_addr[instance]); 805 status |= create_i2c_node("fru", "i2c-at24c64", SEG5_ADDR, 806 fruprom_addr[instance]); 807 } else { 808 /* Service Power Supply Removal */ 809 syslog(LOG_ERR, gettext("Device %s removed"), id); 810 811 /* Reset the power supply's failure information */ 812 ps_reset_prev_failed(instance); 813 814 /* PICL Tree Maintenance */ 815 if (ptree_delete_node(child_node) != PICL_SUCCESS) 816 syslog(LOG_ERR, "ptree_delete_node failed!"); 817 818 /* 819 * The hardcoded subscript in pcf8574_add[instance][1] 820 * refers to the address. We are appending the address to 821 * device path. Both elements are used when creating 822 * the i2c node (above). 823 */ 824 snprintf(dev_path, sizeof (dev_path), 825 SEG5_DEV_NAME"ioexp@0,%x:pcf8574", 826 pcf8574_addr[instance][1]); 827 delete_i2c_node(dev_path); 828 829 snprintf(dev_path, sizeof (dev_path), 830 SEG5_DEV_NAME"fru@0,%x:fru", fruprom_addr[instance][1]); 831 delete_i2c_node(dev_path); 832 } 833 834 snprintf(ps_logical_state, sizeof (ps_logical_state), 835 "%s_LOGICAL_STATE", id); 836 837 strlcpy(info, PSVC_OK, sizeof (info)); 838 status |= psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, info); 839 status |= psvc_set_attr(hdlp, ps_logical_state, PSVC_STATE_ATTR, info); 840 841 strlcpy(info, PSVC_NO_FAULT, sizeof (info)); 842 status |= psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, info); 843 844 /* Enable the i2c connection to the power supply */ 845 status |= pdb_enable_i2c(hdlp); 846 return (status); 847 } 848 849 /* 850 * check_ps_state() Checks for: 851 * 852 * - Failure bits: 853 * Power Supply Fan Failure 854 * Power Supply Temperature Failure 855 * Power Supply Generic Fault 856 * Power Supply AC Cord Plugged In 857 * 858 * - If we see a "bad" state we will report an error. 859 * 860 * - "Bad" states: 861 * Fault bit shows fault. 862 * Temperature fault shows fault. 863 * Fan fault shows fault. 864 * AC power NOT okay to supply. 865 * 866 * - If we see that the AC Cord is not plugged in, then the the other 867 * failure bits are invalid. 868 * 869 * - Send pcf8574_reset at the end of the policy if we see 870 * any "bad" states. 871 */ 872 static int32_t 873 check_ps_state(psvc_opaque_t hdlp, char *id) 874 { 875 int32_t sensor_count; 876 int32_t status = PSVC_SUCCESS; 877 int32_t i; 878 int32_t fault_on = 0; 879 char *sensor_id; 880 char ps_ok_sensor[PICL_PROPNAMELEN_MAX]; 881 char ps_logical_state[PICL_PROPNAMELEN_MAX]; 882 char ps_reset[PICL_PROPNAMELEN_MAX]; 883 char previous_state[PSVC_MAX_STR_LEN]; 884 char state[PSVC_MAX_STR_LEN]; 885 char fault[PSVC_MAX_STR_LEN]; 886 int ps_okay = 1; /* Keep track of the PDB PS OK Bit */ 887 int instance; 888 int retry; 889 890 /* Logical state id */ 891 snprintf(ps_logical_state, sizeof (ps_logical_state), 892 "%s_LOGICAL_STATE", id); 893 894 /* 895 * ac_power_check updates the Power Supply state with "NO AC POWER" if 896 * the power cord is out OR PSVC_OK if the power cord is in. 897 */ 898 status = ac_power_check(hdlp, id, ps_logical_state); 899 if (status == PSVC_FAILURE) 900 return (status); 901 902 /* 903 * After running ac_power_check we now need to get the current state 904 * of the PS. If the power supply state is "NO AC POWER" then we do 905 * not need to check for failures and we return. 906 */ 907 status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state); 908 if (status != PSVC_SUCCESS) 909 return (status); 910 911 if (strcmp(state, "NO AC POWER") == 0) 912 return (status); 913 914 status = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR, previous_state); 915 if (status != PSVC_SUCCESS) 916 return (status); 917 918 snprintf(ps_ok_sensor, sizeof (ps_ok_sensor), "%s_OK_SENSOR", id); 919 retry = 0; 920 do { 921 if (retry) 922 (void) sleep(retry_sleep_ps_status); 923 /* Handle the PDB P/S OK Bit */ 924 status = psvc_get_attr(hdlp, ps_ok_sensor, 925 PSVC_SWITCH_STATE_ATTR, state); 926 if (status != PSVC_SUCCESS) 927 return (status); 928 retry++; 929 } while ((retry < n_retry_ps_status) && 930 (strcmp(previous_state, state))); 931 932 933 /* 934 * If there is a change of state (current state differs from 935 * previous state, then assign the error values. 936 */ 937 if (strcmp(previous_state, state) != 0) { 938 if (strcmp(state, PSVC_SWITCH_OFF) == 0) { 939 strlcpy(state, PSVC_ERROR, sizeof (state)); 940 strlcpy(fault, "DEVICE_FAIL", sizeof (fault)); 941 fault_on = 1; 942 syslog(LOG_ERR, gettext( 943 "Device %s: Failure Detected -- %s " 944 "shutdown!"), id, id); 945 ps_okay = 0; 946 } else { 947 strlcpy(state, PSVC_OK, sizeof (state)); 948 strlcpy(fault, PSVC_NO_FAULT, sizeof (fault)); 949 } 950 951 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state); 952 if (status != PSVC_SUCCESS) 953 return (status); 954 955 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, fault); 956 if (status != PSVC_SUCCESS) 957 return (status); 958 } 959 960 status = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance); 961 if (status != PSVC_SUCCESS) 962 return (status); 963 964 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &sensor_count, 965 PSVC_DEV_FAULT_SENSOR); 966 if (status != PSVC_SUCCESS) { 967 return (status); 968 } 969 970 /* Handle the power supply fail bits. */ 971 for (i = 0; i < sensor_count; i++) { 972 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, 973 &sensor_id, PSVC_DEV_FAULT_SENSOR, i); 974 if (status != PSVC_SUCCESS) 975 return (status); 976 977 retry = 0; 978 do { 979 if (retry) 980 (void) sleep(retry_sleep_ps_status); 981 status = psvc_get_attr(hdlp, sensor_id, 982 PSVC_SWITCH_STATE_ATTR, state); 983 if (status != PSVC_SUCCESS) 984 return (status); 985 retry++; 986 } while ((retry < n_retry_ps_status) && 987 (strcmp(state, PSVC_SWITCH_ON) == 0)); 988 989 if (strcmp(state, PSVC_SWITCH_ON) == 0) { 990 if (ps_prev_id[instance][i] == NULL) 991 ps_prev_id[instance][i] = sensor_id; 992 993 if (ps_prev_failed[instance][i] != 1) 994 ps_prev_failed[instance][i] = 1; 995 fault_on = 1; 996 /* 997 * The first sensor in the list is: 998 * PSx_DEV_FAULT_SENSOR. If this is on, we do not 999 * want to merely report that it's on, but rather 1000 * report that there was a fault detected, thus 1001 * improving diagnosability. 1002 */ 1003 if (i == 0) { 1004 /* 1005 * Don't notify if the PDB PS OKAY Bit is 1006 * "0" 1007 */ 1008 if (ps_okay) 1009 syslog(LOG_ERR, gettext( 1010 "Device %s: Fault Detected"), 1011 id); 1012 } else { 1013 syslog(LOG_ERR, gettext("Warning %s: %s is ON"), 1014 id, sensor_id); 1015 } 1016 } 1017 } 1018 1019 status = psvc_get_attr(hdlp, ps_logical_state, 1020 PSVC_STATE_ATTR, state); 1021 if (status != PSVC_SUCCESS) 1022 return (status); 1023 1024 status = psvc_get_attr(hdlp, ps_logical_state, 1025 PSVC_PREV_STATE_ATTR, previous_state); 1026 if (status != PSVC_SUCCESS) 1027 return (status); 1028 1029 /* 1030 * If we encountered a fault of any kind (something before 1031 * has set 'fault_on' to '1') then we want to send the reset 1032 * signal to the power supply's PCF8574 and also set 1033 * 'ps_logical_state' to "ERROR" so that the FSP General Fault 1034 * LED will light. 1035 */ 1036 if (fault_on) { 1037 if (ps_okay) { 1038 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, 1039 PSVC_GEN_FAULT); 1040 if (status != PSVC_SUCCESS) 1041 return (status); 1042 } 1043 status = psvc_set_attr(hdlp, ps_logical_state, 1044 PSVC_STATE_ATTR, PSVC_ERROR); 1045 if (status != PSVC_SUCCESS) 1046 return (status); 1047 /* 1048 * "id" is in the form of "PSx", We need to make it 1049 * PSx_RESET. 1050 */ 1051 snprintf(ps_reset, sizeof (ps_reset), "%s_RESET", id); 1052 status = send_pcf8574_reset(hdlp, ps_reset); 1053 return (status); 1054 } 1055 1056 /* 1057 * There was no fault encountered so we want to 1058 * set 'ps_logical_state' to "OK" 1059 */ 1060 if (strcmp(state, PSVC_OK) != 0) { 1061 for (i = 0; i < 3; i++) { 1062 char *sensor = ps_prev_id[instance][i]; 1063 int *prev_failed = &ps_prev_failed[instance][i]; 1064 if (sensor == NULL) 1065 continue; 1066 if (*prev_failed == 0) 1067 continue; 1068 *prev_failed = 0; 1069 if (i == 0) { 1070 /* 1071 * Don't notifiy if we have a power supply 1072 * failure (PDB PS OKAY == 0 1073 */ 1074 if (ps_okay) 1075 syslog(LOG_ERR, gettext( 1076 "Notice %s: Fault Cleared"), 1077 id); 1078 } else { 1079 syslog(LOG_ERR, gettext("Notice %s: %s is OFF"), 1080 id, sensor); 1081 } 1082 } 1083 1084 status = psvc_set_attr(hdlp, ps_logical_state, 1085 PSVC_STATE_ATTR, PSVC_OK); 1086 if (status != PSVC_SUCCESS) 1087 return (status); 1088 syslog(LOG_ERR, gettext("Device %s Okay"), id); 1089 } 1090 1091 return (PSVC_SUCCESS); 1092 } 1093 1094 /* 1095 * This routine takes in a handle pointer and a Power Supply id. It then gets 1096 * the switch state for the PSx_AC_IN_SENSOR. If the switch is OFF the cord is 1097 * unplugged and we return a true (1). If the switch is ON then the cord is 1098 * plugged in and we return a false (0). If the get_attr call fails we return 1099 * PSVC_FAILURE (-1). 1100 */ 1101 static int 1102 ac_unplugged(psvc_opaque_t hdlp, char *id) 1103 { 1104 int32_t status = PSVC_SUCCESS; 1105 char ac_sensor_id[PICL_PROPNAMELEN_MAX]; 1106 char ac_switch_state[PSVC_MAX_STR_LEN]; 1107 1108 snprintf(ac_sensor_id, sizeof (ac_sensor_id), "%s_AC_IN_SENSOR", id); 1109 1110 status = psvc_get_attr(hdlp, ac_sensor_id, PSVC_SWITCH_STATE_ATTR, 1111 ac_switch_state); 1112 if (status == PSVC_FAILURE) { 1113 return (status); 1114 } 1115 1116 if (strcmp(ac_switch_state, PSVC_SWITCH_OFF) == 0) { 1117 return (1); 1118 } else { 1119 return (0); 1120 } 1121 } 1122 1123 /* 1124 * This routine expects a handle pointer, a Power Supply ID, and a PS logical 1125 * state switch ID. It check to see if the power cord has been removed from or 1126 * inserted to the power supply. It then updates the PS state accordingly. 1127 */ 1128 static int 1129 ac_power_check(psvc_opaque_t hdlp, char *id, char *ps_logical_state) 1130 { 1131 int32_t status = PSVC_SUCCESS; 1132 int32_t sensor_count; 1133 char *sensor_id; 1134 char state[PSVC_MAX_STR_LEN]; 1135 int unplugged, i; 1136 1137 status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state); 1138 if (status != PSVC_SUCCESS) 1139 return (status); 1140 1141 /* 1142 * Check for AC Power Cord. ac_unplugged will return true if the PS is 1143 * unplugged, a false is the PS is plugged in, and PSVC_FAILURE if the 1144 * call to get the state fails. 1145 */ 1146 unplugged = ac_unplugged(hdlp, id); 1147 if (status == PSVC_FAILURE) { 1148 return (status); 1149 } 1150 1151 /* 1152 * If power cord is not in, then we set the fault and error 1153 * states to "". 1154 * If power cord is in, then we check the devices. 1155 */ 1156 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &sensor_count, 1157 PSVC_DEV_FAULT_SENSOR); 1158 if (status != PSVC_SUCCESS) { 1159 return (status); 1160 } 1161 1162 if ((unplugged) && (strcmp(state, "NO AC POWER") != 0)) { 1163 /* set id's state to "NO AC POWER" */ 1164 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, 1165 "NO AC POWER"); 1166 if (status != PSVC_SUCCESS) 1167 return (status); 1168 /* 1169 * Set this state so that the FSP Fault LED lights 1170 * when there is no AC Power to the power supply. 1171 */ 1172 status = psvc_set_attr(hdlp, ps_logical_state, PSVC_STATE_ATTR, 1173 PSVC_ERROR); 1174 if (status != PSVC_SUCCESS) 1175 return (status); 1176 1177 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, 1178 "NO AC POWER"); 1179 if (status != PSVC_SUCCESS) 1180 return (status); 1181 1182 syslog(LOG_ERR, gettext("Device %s AC UNAVAILABLE"), id); 1183 1184 /* Set fault sensor states to "" */ 1185 for (i = 0; i < sensor_count; ++i) { 1186 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, 1187 &sensor_id, PSVC_DEV_FAULT_SENSOR, i); 1188 if (status != PSVC_SUCCESS) 1189 return (status); 1190 1191 status = psvc_set_attr(hdlp, sensor_id, 1192 PSVC_FAULTID_ATTR, ""); 1193 if (status != PSVC_SUCCESS) 1194 return (status); 1195 } 1196 } 1197 1198 /* Power cord is plugged in */ 1199 if ((!unplugged) && (strcmp(state, "NO AC POWER") == 0)) { 1200 /* Default the state to "OK" */ 1201 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, 1202 PSVC_OK); 1203 if (status != PSVC_SUCCESS) 1204 return (status); 1205 /* Default the PS_LOGICAL_STATE to "OK" */ 1206 status = psvc_set_attr(hdlp, ps_logical_state, PSVC_STATE_ATTR, 1207 PSVC_OK); 1208 if (status != PSVC_SUCCESS) 1209 return (status); 1210 /* Display message */ 1211 syslog(LOG_ERR, gettext("Device %s AC AVAILABLE"), id); 1212 } 1213 1214 return (status); 1215 } 1216 1217 int32_t 1218 psvc_init_ps_presence(psvc_opaque_t hdlp, char *id) 1219 { 1220 int err; 1221 int instance; 1222 boolean_t presence; 1223 1224 err = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance); 1225 err |= psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence); 1226 ps_prev_present[instance] = ps_present[instance] = presence; 1227 return (err); 1228 } 1229 1230 int32_t 1231 psvc_ps_monitor_policy_0(psvc_opaque_t hdlp, char *id) 1232 { 1233 int err; 1234 int instance; 1235 static int failed_last_time[2] = {0, 0}; 1236 int retry; 1237 1238 err = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance); 1239 if (err != PSVC_SUCCESS) 1240 return (err); 1241 1242 /* copy current presence to previous presence */ 1243 ps_prev_present[instance] = ps_present[instance]; 1244 1245 retry = 0; 1246 do { 1247 if (retry) 1248 (void) sleep(retry_sleep_pshp); 1249 /* Get new presence */ 1250 err = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, 1251 &ps_present[instance]); 1252 if (err != PSVC_SUCCESS) 1253 goto out; 1254 retry++; 1255 } while ((retry < n_retry_pshp) && 1256 (ps_present[instance] != ps_prev_present[instance])); 1257 1258 /* Sustained Hotplug detected */ 1259 if (ps_present[instance] != ps_prev_present[instance]) { 1260 err = handle_ps_hotplug(hdlp, id, ps_present[instance]); 1261 return (err); 1262 } 1263 1264 /* If our power supply is not present, we're done */ 1265 if (!ps_present[instance]) 1266 return (PSVC_SUCCESS); 1267 1268 err = check_i2c_access(hdlp, id); 1269 if (err != PSVC_SUCCESS) { 1270 /* Quickie hotplug */ 1271 if (ps_present[instance] == PSVC_PRESENT && 1272 ps_prev_present[instance] == PSVC_PRESENT) { 1273 syslog(LOG_ERR, "Device %s removed", id); 1274 /* Reset prev_failed information */ 1275 ps_reset_prev_failed(instance); 1276 ps_prev_present[instance] = 0; 1277 handle_ps_hotplug(hdlp, id, ps_present[instance]); 1278 /* We ignore the error on a quickie hotplug */ 1279 return (PSVC_SUCCESS); 1280 } 1281 /* There was an actual i2c access error */ 1282 goto out; 1283 } 1284 1285 err = check_ps_state(hdlp, id); 1286 if (err != PSVC_SUCCESS) 1287 goto out; 1288 1289 failed_last_time[instance] = 0; 1290 return (err); 1291 1292 out: 1293 if (! failed_last_time[instance]) { 1294 /* 1295 * We ignore the error condition the first time thru 1296 * because the PS could have been removed after (or 1297 * during) our call to check_ps_hotplug(). 1298 * 1299 * If the problem is still there the next time, then 1300 * we'll raise a flag. 1301 * 1302 * The instance determines which power supply the policy 1303 * errored on. For instance PS0 might have failed and then 1304 * PS1 might have failed, but we'll display a warning 1305 * even though there might not be anything actually wrong. 1306 * The instance keeps track of which failure occurred so 1307 * we warn on the corresponding occurrence of errors. 1308 */ 1309 failed_last_time[instance] = 1; 1310 return (PSVC_SUCCESS); 1311 } 1312 return (err); 1313 } 1314 1315 static int 1316 light_disk_fault_leds(psvc_opaque_t hdlp, char *id, boolean_t disk_presence) 1317 { 1318 int err; 1319 int bit_nums[MAX_DISKS] = {6, 7}; 1320 uint8_t led_masks[MAX_DISKS] = {0x40, 0x80}; 1321 int instance; 1322 int bit_value; 1323 char state[PSVC_MAX_STR_LEN]; 1324 uint8_t byte; 1325 1326 if (disk_presence != PSVC_PRESENT) 1327 return (PSVC_SUCCESS); 1328 1329 err = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance); 1330 if (err != PSVC_SUCCESS) 1331 return (err); 1332 1333 err = psvc_get_attr(hdlp, "DISK_PORT", PSVC_GPIO_VALUE_ATTR, 1334 &byte); 1335 if (err != PSVC_SUCCESS) 1336 return (err); 1337 1338 err = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state); 1339 if (err != PSVC_SUCCESS) 1340 return (err); 1341 if (strcmp(state, PSVC_OK) == 0 || strcmp(state, "") == 0) { /* OK */ 1342 if (byte & led_masks[instance]) { /* Led is OFF */ 1343 return (err); /* Done. */ 1344 } else { /* Led is ON, Turn if OFF */ 1345 bit_value = 1; /* Active Low */ 1346 err = pcf8574_write_bit(hdlp, "DISK_PORT", 1347 bit_nums[instance], bit_value, 1348 DISKBP_MUST_BE_1); 1349 if (err != PSVC_SUCCESS) 1350 return (err); 1351 } 1352 } else { /* Disk is NOT OK */ 1353 if (byte & led_masks[instance]) { /* Led is OFF, Turn it ON */ 1354 bit_value = 0; /* Active Low */ 1355 err = pcf8574_write_bit(hdlp, "DISK_PORT", 1356 bit_nums[instance], bit_value, 1357 DISKBP_MUST_BE_1); 1358 if (err != PSVC_SUCCESS) 1359 return (err); 1360 } else { 1361 return (err); /* Done. */ 1362 } 1363 } 1364 return (err); 1365 } 1366 1367 int 1368 verify_disk_wwn(char *wwn) 1369 { 1370 HBA_PORTATTRIBUTES hbaPortAttrs, discPortAttrs; 1371 HBA_HANDLE handle; 1372 HBA_STATUS status; 1373 HBA_ADAPTERATTRIBUTES hbaAttrs; 1374 HBA_UINT32 numberOfAdapters, hbaCount, hbaPort, discPort; 1375 char adaptername[256]; 1376 char vwwn[WWN_SIZE * 2]; 1377 char OSDeviceName[PATH_MAX + 1]; 1378 int count, linksize; 1379 1380 /* Load common lib */ 1381 status = HBA_LoadLibrary(); 1382 if (status != HBA_STATUS_OK) { 1383 (void) HBA_FreeLibrary(); 1384 return (HBA_STATUS_ERROR); 1385 } 1386 1387 /* 1388 * Since devfs can store multiple instances 1389 * of a target the validity of the WWN of a disk is 1390 * verified with an actual probe of internal disks 1391 */ 1392 1393 /* Cycle through FC-AL Adapters and search for WWN */ 1394 numberOfAdapters = HBA_GetNumberOfAdapters(); 1395 for (hbaCount = 0; hbaCount < numberOfAdapters; hbaCount++) { 1396 if ((status = HBA_GetAdapterName(hbaCount, adaptername)) != 1397 HBA_STATUS_OK) 1398 continue; 1399 1400 handle = HBA_OpenAdapter(adaptername); 1401 if (handle == 0) 1402 continue; 1403 1404 /* Get Adapter Attributes */ 1405 if ((status = HBA_GetAdapterAttributes(handle, 1406 &hbaAttrs)) != HBA_STATUS_OK) { 1407 HBA_CloseAdapter(handle); 1408 continue; 1409 } 1410 1411 /* Get Adapter's Port Attributes */ 1412 for (hbaPort = 0; 1413 hbaPort < hbaAttrs.NumberOfPorts; hbaPort++) { 1414 if ((status = HBA_GetAdapterPortAttributes(handle, 1415 hbaPort, &hbaPortAttrs)) != HBA_STATUS_OK) 1416 continue; 1417 1418 /* 1419 * Verify whether this is onboard controller. 1420 * HBAAPI provides path of symbol link to 1421 * to the qlc node therefore readlink() is 1422 * needed to obtain hard link 1423 */ 1424 linksize = readlink(hbaPortAttrs.OSDeviceName, 1425 OSDeviceName, PATH_MAX); 1426 1427 /* 1428 * If readlink does not return size of onboard 1429 * controller than don't bother checking device 1430 */ 1431 if ((linksize + 1) != sizeof (ONBOARD_CONTR)) 1432 continue; 1433 1434 OSDeviceName[linksize] = '\0'; 1435 if (strcmp(OSDeviceName, ONBOARD_CONTR) != 0) 1436 continue; 1437 1438 /* Get Discovered Port Attributes */ 1439 for (discPort = 0; 1440 discPort < hbaPortAttrs.NumberofDiscoveredPorts; 1441 discPort++) { 1442 status = HBA_GetDiscoveredPortAttributes( 1443 handle, hbaPort, discPort, 1444 &discPortAttrs); 1445 if (status != HBA_STATUS_OK) 1446 continue; 1447 1448 /* Get target info */ 1449 for (count = 0; count < WWN_SIZE; count++) 1450 (void) sprintf(&vwwn[count * 2], 1451 "%2.2x", 1452 discPortAttrs.NodeWWN.wwn[count]); 1453 1454 if (strcmp(wwn, vwwn) == 0) { 1455 HBA_CloseAdapter(handle); 1456 (void) HBA_FreeLibrary(); 1457 return (HBA_STATUS_OK); 1458 } 1459 1460 } 1461 } 1462 HBA_CloseAdapter(handle); 1463 } 1464 (void) HBA_FreeLibrary(); 1465 return (HBA_STATUS_ERROR_ILLEGAL_WWN); 1466 } 1467 1468 static int 1469 light_disk_ok2remove_leds(psvc_opaque_t hdlp, boolean_t *disk_present) 1470 { 1471 di_node_t node; 1472 di_node_t root_node; 1473 di_minor_t min_node; 1474 int *prop; 1475 int n; 1476 int target; 1477 int rv; 1478 int disk_online = 0; 1479 static int prev_online[MAX_DISKS] = {-1, -1}; 1480 int bit_nums[MAX_DISKS] = {4, 5}; 1481 int bit_val; 1482 int count; 1483 char *dev_path; 1484 char wwn[WWN_SIZE * 2]; 1485 uchar_t *prop_wwn; 1486 1487 root_node = di_init("/", DINFOCPYALL); 1488 if (root_node == DI_NODE_NIL) 1489 return (PSVC_FAILURE); 1490 1491 for (node = di_drv_first_node(DISK_DRV, root_node); 1492 node != DI_NODE_NIL; 1493 node = di_drv_next_node(node)) { 1494 n = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "target", &prop); 1495 if (n == -1) 1496 continue; 1497 target = *prop; 1498 if (target < 0 || target > 1) 1499 continue; 1500 1501 if (! disk_present[target]) 1502 continue; 1503 1504 dev_path = di_devfs_path(node); 1505 if (memcmp(dev_path, QLC_NODE, (sizeof (QLC_NODE) - 1)) != 0) { 1506 /* 1507 * This isn't our FC-AL controller, so this 1508 * must be an external disk on Loop B. Skip it. 1509 */ 1510 di_devfs_path_free(dev_path); 1511 continue; 1512 } 1513 di_devfs_path_free(dev_path); 1514 1515 /* 1516 * Verify if disk is valid by checking WWN 1517 * because devfs retains stale data. 1518 */ 1519 n = di_prop_lookup_bytes(DDI_DEV_T_ANY, node, 1520 "node-wwn", &prop_wwn); 1521 if (n == -1) 1522 continue; 1523 1524 for (count = 0; count < WWN_SIZE; count++) 1525 (void) sprintf(&wwn[count * 2], "%2.2x", 1526 prop_wwn[count]); 1527 1528 n = verify_disk_wwn(wwn); 1529 if (n == HBA_STATUS_ERROR_ILLEGAL_WWN) 1530 continue; 1531 1532 min_node = di_minor_next(node, DI_MINOR_NIL); 1533 disk_online = (min_node != DI_MINOR_NIL); 1534 if ((disk_online == 0) && (prev_online[target] == 1)) { 1535 /* Light Led */ 1536 bit_val = 0; 1537 rv = pcf8574_write_bit(hdlp, "DISK_PORT", 1538 bit_nums[target], bit_val, DISKBP_MUST_BE_1); 1539 if (rv != PSVC_SUCCESS) 1540 goto done; 1541 } else if ((prev_online[target] == 0) && (disk_online == 1)) { 1542 /* Unlight Led */ 1543 bit_val = 1; 1544 rv = pcf8574_write_bit(hdlp, "DISK_PORT", 1545 bit_nums[target], bit_val, DISKBP_MUST_BE_1); 1546 if (rv != PSVC_SUCCESS) 1547 goto done; 1548 } 1549 if (disk_online != prev_online[target]) 1550 prev_online[target] = disk_online; 1551 } 1552 done: 1553 di_fini(root_node); 1554 return (rv); 1555 } 1556 1557 static int 1558 check_disk_fault(psvc_opaque_t hdlp, char *id, boolean_t disk_presence) 1559 { 1560 int32_t status = PSVC_SUCCESS; 1561 int32_t fault_on = 0; 1562 char *sensor_id; 1563 char disk_state[PSVC_MAX_STR_LEN]; 1564 char state[PSVC_MAX_STR_LEN]; 1565 char fault[PSVC_MAX_STR_LEN]; 1566 boolean_t change_of_state = 0; 1567 1568 if (disk_presence != PSVC_PRESENT) 1569 return (PSVC_SUCCESS); 1570 1571 status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, disk_state); 1572 if (status != PSVC_SUCCESS) 1573 return (status); 1574 1575 status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, 1576 &sensor_id, PSVC_DEV_FAULT_SENSOR, 0); 1577 if (status != PSVC_SUCCESS) 1578 return (status); 1579 1580 status = psvc_get_attr(hdlp, sensor_id, PSVC_SWITCH_STATE_ATTR, state); 1581 if (status != PSVC_SUCCESS) 1582 return (status); 1583 1584 /* Fault detected */ 1585 if (strcmp(state, PSVC_SWITCH_ON) == 0) { 1586 strlcpy(state, PSVC_ERROR, sizeof (state)); 1587 strlcpy(fault, PSVC_GEN_FAULT, sizeof (fault)); 1588 fault_on = 1; 1589 } else { /* No fault detected */ 1590 if (strcmp(disk_state, PSVC_OK) != 0) 1591 change_of_state = 1; 1592 strlcpy(state, PSVC_OK, sizeof (state)); 1593 strlcpy(fault, PSVC_NO_FAULT, sizeof (fault)); 1594 } 1595 1596 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state); 1597 if (status != PSVC_SUCCESS) 1598 return (status); 1599 1600 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, fault); 1601 if (status != PSVC_SUCCESS) 1602 return (status); 1603 1604 if (fault_on) { 1605 syslog(LOG_ERR, gettext("Fault detected: %s"), id); 1606 1607 } else { 1608 if (change_of_state) 1609 syslog(LOG_ERR, gettext("Notice: %s okay"), id); 1610 } 1611 return (PSVC_SUCCESS); 1612 } 1613 1614 static int 1615 check_disk_hotplug(psvc_opaque_t hdlp, char *id, boolean_t *disk_presence, 1616 int disk_instance) 1617 { 1618 boolean_t presence; 1619 boolean_t previous_presence; 1620 int32_t status = PSVC_SUCCESS; 1621 char label[PSVC_MAX_STR_LEN]; 1622 uint8_t disk_leds[MAX_DISKS][2] = {{4, 6}, {5, 7}}; 1623 int retry; 1624 1625 status = psvc_get_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR, 1626 &previous_presence); 1627 if (status != PSVC_SUCCESS) 1628 return (status); 1629 1630 retry = 0; 1631 do { 1632 if (retry) 1633 (void) sleep(retry_sleep_diskhp); 1634 status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, 1635 &presence); 1636 if (status != PSVC_SUCCESS) 1637 return (status); 1638 retry++; 1639 } while ((retry < n_retry_diskhp) && 1640 (presence != previous_presence)); 1641 1642 *disk_presence = presence; 1643 1644 if (presence != previous_presence) { 1645 char parent_path[PICL_PROPNAMELEN_MAX]; 1646 picl_nodehdl_t child_node; 1647 1648 status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label); 1649 if (status != PSVC_SUCCESS) 1650 return (status); 1651 1652 /* return parent path and node for an object */ 1653 psvcplugin_lookup(id, parent_path, &child_node); 1654 1655 if (presence == PSVC_PRESENT) { 1656 picl_nodehdl_t parent_node; 1657 char state[PSVC_MAX_STR_LEN]; 1658 char fault[PSVC_MAX_STR_LEN]; 1659 1660 syslog(LOG_ERR, gettext("Device %s inserted"), label); 1661 strlcpy(state, PSVC_OK, sizeof (state)); 1662 status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, 1663 state); 1664 if (status != PSVC_SUCCESS) 1665 return (status); 1666 1667 strlcpy(fault, PSVC_NO_FAULT, sizeof (fault)); 1668 status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, 1669 fault); 1670 if (status != PSVC_SUCCESS) { 1671 return (status); 1672 } 1673 1674 status = ptree_get_node_by_path(parent_path, 1675 &parent_node); 1676 if (status != PICL_SUCCESS) 1677 return (PSVC_FAILURE); 1678 status = ptree_add_node(parent_node, child_node); 1679 if (status != PICL_SUCCESS) 1680 return (PSVC_FAILURE); 1681 } else { 1682 /* 1683 * Disk Removed so we need to turn off these LEDs: 1684 * DISKx_FLT_LED 1685 * DISKx_REMOVE_LED 1686 */ 1687 int i; 1688 int bit_val = 1; /* Active Low */ 1689 for (i = 0; i < 2; i++) { 1690 status = pcf8574_write_bit(hdlp, "DISK_PORT", 1691 disk_leds[disk_instance][i], bit_val, 1692 DISKBP_MUST_BE_1); 1693 if (status != PSVC_SUCCESS) 1694 syslog(LOG_ERR, "Failed in turning off" 1695 " %d's LEDs", id); 1696 } 1697 syslog(LOG_ERR, gettext("Device %s removed"), label); 1698 ptree_delete_node(child_node); 1699 } 1700 } 1701 1702 status = psvc_set_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR, &presence); 1703 if (status != PSVC_SUCCESS) 1704 return (status); 1705 1706 return (status); 1707 } 1708 1709 int32_t 1710 psvc_disk_monitor_policy_0(psvc_opaque_t hdlp, char *id) 1711 { 1712 int rv, err, i; 1713 char *disks[MAX_DISKS] = {"DISK0", "DISK1"}; 1714 int saved_errno = 0; 1715 boolean_t disk_present[MAX_DISKS] = {0, 0}; 1716 1717 for (i = 0; i < MAX_DISKS; i++) { 1718 err = check_disk_hotplug(hdlp, disks[i], &disk_present[i], i); 1719 if (err) saved_errno = errno; 1720 rv = err; 1721 1722 err = check_disk_fault(hdlp, disks[i], disk_present[i]); 1723 if (err) saved_errno = errno; 1724 rv |= err; 1725 1726 err |= light_disk_fault_leds(hdlp, disks[i], disk_present[i]); 1727 if (err) saved_errno = errno; 1728 rv |= err; 1729 } 1730 1731 err = light_disk_ok2remove_leds(hdlp, disk_present); 1732 if (err) saved_errno = errno; 1733 rv |= err; 1734 1735 errno = saved_errno; 1736 return (rv); 1737 } 1738 1739 /* 1740 * Read in temperature thresholds from FRU Prom and update the 1741 * default values. 1742 */ 1743 1744 #define START_OFFSET 0x1800 /* Last 2K of SEEPROM */ 1745 #define NUM_SEG_OFFSET 0x1805 /* Number of segments */ 1746 #define SEG_TABLE_OFFSET 0x1806 /* Segment description tables */ 1747 1748 static int32_t 1749 read_sc_segment(psvc_opaque_t hdlp, char *id, char *fru_id, int offset) 1750 { 1751 static int thresh_names[] = { 1752 PSVC_HW_LO_SHUT_ATTR, 1753 PSVC_LO_SHUT_ATTR, 1754 PSVC_LO_WARN_ATTR, 1755 PSVC_NOT_USED, /* LOW MODE */ 1756 PSVC_OPTIMAL_TEMP_ATTR, 1757 PSVC_HI_WARN_ATTR, 1758 PSVC_HI_SHUT_ATTR, 1759 PSVC_HW_HI_SHUT_ATTR 1760 }; 1761 int8_t amb_temp_array[8]; 1762 int i; 1763 fru_info_t fru_info; 1764 int err; 1765 1766 fru_info.buf_start = offset + 8; 1767 fru_info.buf = amb_temp_array; 1768 fru_info.read_size = 8; 1769 1770 err = psvc_get_attr(hdlp, fru_id, PSVC_FRU_INFO_ATTR, &fru_info); 1771 if (err != PSVC_SUCCESS) 1772 return (err); 1773 1774 for (i = 0; i < 8; i++) { 1775 int32_t temp = amb_temp_array[i]; 1776 if (thresh_names[i] == PSVC_NOT_USED) 1777 continue; 1778 err = psvc_set_attr(hdlp, id, thresh_names[i], &temp); 1779 if (err != PSVC_SUCCESS) 1780 return (err); 1781 } 1782 return (PSVC_SUCCESS); 1783 } 1784 1785 int32_t 1786 update_disk_bp_temp_thresholds(psvc_opaque_t hdlp, char *id) 1787 { 1788 1789 char *fru; 1790 fru_info_t fru_info; 1791 int16_t seg_offset; 1792 int8_t byte; 1793 int8_t seg_count; 1794 char seg_name[2]; 1795 int current_offset, i, err; 1796 1797 err = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &fru, PSVC_FRU, 0); 1798 if (err != PSVC_SUCCESS) 1799 return (err); 1800 1801 /* Sanity Check */ 1802 fru_info.buf_start = START_OFFSET; 1803 fru_info.buf = &byte; 1804 fru_info.read_size = 1; 1805 1806 err = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR, &fru_info); 1807 if (err != PSVC_SUCCESS) 1808 return (err); 1809 if (*fru_info.buf != 8) { 1810 syslog(LOG_ERR, "Notice: FRU Prom %s not programmed", fru); 1811 } 1812 /* Should do CRC Check on fru */ 1813 1814 /* Get Segment Count */ 1815 fru_info.buf_start = NUM_SEG_OFFSET; 1816 fru_info.buf = &seg_count; 1817 fru_info.read_size = 1; 1818 1819 err = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR, &fru_info); 1820 if (err != PSVC_SUCCESS) 1821 return (err); 1822 1823 current_offset = SEG_TABLE_OFFSET; 1824 for (i = 0; i < seg_count; i++) { 1825 fru_info.buf_start = current_offset; 1826 fru_info.buf = seg_name; 1827 fru_info.read_size = 2; 1828 err = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR, &fru_info); 1829 if (err != PSVC_SUCCESS) 1830 return (err); 1831 1832 if (memcmp(seg_name, "SC", 2) == 0) { 1833 current_offset += 6; /* Skip over description */ 1834 fru_info.buf_start = current_offset; 1835 fru_info.buf = (char *)&seg_offset; 1836 fru_info.read_size = 2; 1837 psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR, 1838 &fru_info); 1839 return (read_sc_segment(hdlp, id, fru, seg_offset)); 1840 } 1841 current_offset += 10; 1842 } 1843 1844 return (PSVC_SUCCESS); 1845 } 1846