1 /* $NetBSD: ses.c,v 1.12 2001/11/13 06:56:41 lukem Exp $ */ 2 /* 3 * Copyright (C) 2000 National Aeronautics & Space Administration 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. The name of the author may not be used to endorse or promote products 12 * derived from this software without specific prior written permission 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 * 25 * Author: mjacob@nas.nasa.gov 26 */ 27 28 #include <sys/cdefs.h> 29 __KERNEL_RCSID(0, "$NetBSD: ses.c,v 1.12 2001/11/13 06:56:41 lukem Exp $"); 30 31 #include "opt_scsi.h" 32 33 #include <sys/types.h> 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/kernel.h> 37 #include <sys/file.h> 38 #include <sys/stat.h> 39 #include <sys/ioctl.h> 40 #include <sys/scsiio.h> 41 #include <sys/buf.h> 42 #include <sys/uio.h> 43 #include <sys/malloc.h> 44 #include <sys/errno.h> 45 #include <sys/device.h> 46 #include <sys/disklabel.h> 47 #include <sys/disk.h> 48 #include <sys/proc.h> 49 #include <sys/conf.h> 50 #include <sys/vnode.h> 51 #include <machine/stdarg.h> 52 53 #include <dev/scsipi/scsipi_all.h> 54 #include <dev/scsipi/scsi_all.h> 55 #include <dev/scsipi/scsipi_disk.h> 56 #include <dev/scsipi/scsi_disk.h> 57 #include <dev/scsipi/scsiconf.h> 58 #include <dev/scsipi/ses.h> 59 60 /* 61 * Platform Independent Driver Internal Definitions for SES devices. 62 */ 63 typedef enum { 64 SES_NONE, 65 SES_SES_SCSI2, 66 SES_SES, 67 SES_SES_PASSTHROUGH, 68 SES_SEN, 69 SES_SAFT 70 } enctyp; 71 72 struct ses_softc; 73 typedef struct ses_softc ses_softc_t; 74 typedef struct { 75 int (*softc_init) __P((ses_softc_t *, int)); 76 int (*init_enc) __P((ses_softc_t *)); 77 int (*get_encstat) __P((ses_softc_t *, int)); 78 int (*set_encstat) __P((ses_softc_t *, ses_encstat, int)); 79 int (*get_objstat) __P((ses_softc_t *, ses_objstat *, int)); 80 int (*set_objstat) __P((ses_softc_t *, ses_objstat *, int)); 81 } encvec; 82 83 #define ENCI_SVALID 0x80 84 85 typedef struct { 86 uint32_t 87 enctype : 8, /* enclosure type */ 88 subenclosure : 8, /* subenclosure id */ 89 svalid : 1, /* enclosure information valid */ 90 priv : 15; /* private data, per object */ 91 uint8_t encstat[4]; /* state && stats */ 92 } encobj; 93 94 #define SEN_ID "UNISYS SUN_SEN" 95 #define SEN_ID_LEN 24 96 97 static enctyp ses_type __P((struct scsipi_inquiry_data *)); 98 99 100 /* Forward reference to Enclosure Functions */ 101 static int ses_softc_init __P((ses_softc_t *, int)); 102 static int ses_init_enc __P((ses_softc_t *)); 103 static int ses_get_encstat __P((ses_softc_t *, int)); 104 static int ses_set_encstat __P((ses_softc_t *, uint8_t, int)); 105 static int ses_get_objstat __P((ses_softc_t *, ses_objstat *, int)); 106 static int ses_set_objstat __P((ses_softc_t *, ses_objstat *, int)); 107 108 static int safte_softc_init __P((ses_softc_t *, int)); 109 static int safte_init_enc __P((ses_softc_t *)); 110 static int safte_get_encstat __P((ses_softc_t *, int)); 111 static int safte_set_encstat __P((ses_softc_t *, uint8_t, int)); 112 static int safte_get_objstat __P((ses_softc_t *, ses_objstat *, int)); 113 static int safte_set_objstat __P((ses_softc_t *, ses_objstat *, int)); 114 115 /* 116 * Platform implementation defines/functions for SES internal kernel stuff 117 */ 118 119 #define STRNCMP strncmp 120 #define PRINTF printf 121 #define SES_LOG ses_log 122 #if defined(DEBUG) || defined(SCSIDEBUG) 123 #define SES_VLOG ses_log 124 #else 125 #define SES_VLOG if (0) ses_log 126 #endif 127 #define SES_MALLOC(amt) malloc(amt, M_DEVBUF, M_NOWAIT) 128 #define SES_FREE(ptr, amt) free(ptr, M_DEVBUF) 129 #define MEMZERO(dest, amt) memset(dest, 0, amt) 130 #define MEMCPY(dest, src, amt) memcpy(dest, src, amt) 131 #define RECEIVE_DIAGNOSTIC 0x1c 132 #define SEND_DIAGNOSTIC 0x1d 133 #define WRITE_BUFFER 0x3b 134 #define READ_BUFFER 0x3c 135 136 int sesopen __P((dev_t, int, int, struct proc *)); 137 int sesclose __P((dev_t, int, int, struct proc *)); 138 int sesioctl __P((dev_t, u_long, caddr_t, int, struct proc *)); 139 140 static int ses_runcmd __P((struct ses_softc *, char *, int, char *, int *)); 141 static void ses_log __P((struct ses_softc *, const char *, ...)) 142 __attribute__((__format__(__printf__, 2, 3))); 143 144 /* 145 * General NetBSD kernel stuff. 146 */ 147 148 struct ses_softc { 149 struct device sc_device; 150 struct scsipi_periph *sc_periph; 151 enctyp ses_type; /* type of enclosure */ 152 encvec ses_vec; /* vector to handlers */ 153 void * ses_private; /* per-type private data */ 154 encobj * ses_objmap; /* objects */ 155 u_int32_t ses_nobjects; /* number of objects */ 156 ses_encstat ses_encstat; /* overall status */ 157 u_int8_t ses_flags; 158 }; 159 #define SES_FLAG_INVALID 0x01 160 #define SES_FLAG_OPEN 0x02 161 #define SES_FLAG_INITIALIZED 0x04 162 163 #define SESUNIT(x) (minor((x))) 164 165 static int ses_match __P((struct device *, struct cfdata *, void *)); 166 static void ses_attach __P((struct device *, struct device *, void *)); 167 static enctyp ses_device_type __P((struct scsipibus_attach_args *)); 168 169 struct cfattach ses_ca = { 170 sizeof (struct ses_softc), ses_match, ses_attach 171 }; 172 extern struct cfdriver ses_cd; 173 174 const struct scsipi_periphsw ses_switch = { 175 NULL, 176 NULL, 177 NULL, 178 NULL 179 }; 180 181 182 int 183 ses_match(parent, match, aux) 184 struct device *parent; 185 struct cfdata *match; 186 void *aux; 187 { 188 struct scsipibus_attach_args *sa = aux; 189 190 switch (ses_device_type(sa)) { 191 case SES_SES: 192 case SES_SES_SCSI2: 193 case SES_SEN: 194 case SES_SAFT: 195 case SES_SES_PASSTHROUGH: 196 /* 197 * For these devices, it's a perfect match. 198 */ 199 return (24); 200 default: 201 return (0); 202 } 203 } 204 205 206 /* 207 * Complete the attachment. 208 * 209 * We have to repeat the rerun of INQUIRY data as above because 210 * it's not until the return from the match routine that we have 211 * the softc available to set stuff in. 212 */ 213 void 214 ses_attach(parent, self, aux) 215 struct device *parent; 216 struct device *self; 217 void *aux; 218 { 219 char *tname; 220 struct ses_softc *softc = (void *)self; 221 struct scsipibus_attach_args *sa = aux; 222 struct scsipi_periph *periph = sa->sa_periph; 223 224 SC_DEBUG(periph, SCSIPI_DB2, ("ssattach: ")); 225 softc->sc_periph = periph; 226 periph->periph_dev = &softc->sc_device; 227 periph->periph_switch = &ses_switch; 228 periph->periph_openings = 1; 229 230 softc->ses_type = ses_device_type(sa); 231 switch (softc->ses_type) { 232 case SES_SES: 233 case SES_SES_SCSI2: 234 case SES_SES_PASSTHROUGH: 235 softc->ses_vec.softc_init = ses_softc_init; 236 softc->ses_vec.init_enc = ses_init_enc; 237 softc->ses_vec.get_encstat = ses_get_encstat; 238 softc->ses_vec.set_encstat = ses_set_encstat; 239 softc->ses_vec.get_objstat = ses_get_objstat; 240 softc->ses_vec.set_objstat = ses_set_objstat; 241 break; 242 case SES_SAFT: 243 softc->ses_vec.softc_init = safte_softc_init; 244 softc->ses_vec.init_enc = safte_init_enc; 245 softc->ses_vec.get_encstat = safte_get_encstat; 246 softc->ses_vec.set_encstat = safte_set_encstat; 247 softc->ses_vec.get_objstat = safte_get_objstat; 248 softc->ses_vec.set_objstat = safte_set_objstat; 249 break; 250 case SES_SEN: 251 break; 252 case SES_NONE: 253 default: 254 break; 255 } 256 257 switch (softc->ses_type) { 258 default: 259 case SES_NONE: 260 tname = "No SES device"; 261 break; 262 case SES_SES_SCSI2: 263 tname = "SCSI-2 SES Device"; 264 break; 265 case SES_SES: 266 tname = "SCSI-3 SES Device"; 267 break; 268 case SES_SES_PASSTHROUGH: 269 tname = "SES Passthrough Device"; 270 break; 271 case SES_SEN: 272 tname = "UNISYS SEN Device (NOT HANDLED YET)"; 273 break; 274 case SES_SAFT: 275 tname = "SAF-TE Compliant Device"; 276 break; 277 } 278 printf("\n%s: %s\n", softc->sc_device.dv_xname, tname); 279 } 280 281 282 static enctyp 283 ses_device_type(sa) 284 struct scsipibus_attach_args *sa; 285 { 286 struct scsipi_inquiry_data *inqp = sa->sa_inqptr; 287 288 if (inqp == NULL) 289 return (SES_NONE); 290 291 return (ses_type(inqp)); 292 } 293 294 int 295 sesopen(dev, flags, fmt, p) 296 dev_t dev; 297 int flags; 298 int fmt; 299 struct proc *p; 300 { 301 struct ses_softc *softc; 302 int error, unit; 303 304 unit = SESUNIT(dev); 305 if (unit >= ses_cd.cd_ndevs) 306 return (ENXIO); 307 softc = ses_cd.cd_devs[unit]; 308 if (softc == NULL) 309 return (ENXIO); 310 311 if (softc->ses_flags & SES_FLAG_INVALID) { 312 error = ENXIO; 313 goto out; 314 } 315 if (softc->ses_flags & SES_FLAG_OPEN) { 316 error = EBUSY; 317 goto out; 318 } 319 if (softc->ses_vec.softc_init == NULL) { 320 error = ENXIO; 321 goto out; 322 } 323 error = scsipi_adapter_addref( 324 softc->sc_periph->periph_channel->chan_adapter); 325 if (error != 0) 326 goto out; 327 328 329 softc->ses_flags |= SES_FLAG_OPEN; 330 if ((softc->ses_flags & SES_FLAG_INITIALIZED) == 0) { 331 error = (*softc->ses_vec.softc_init)(softc, 1); 332 if (error) 333 softc->ses_flags &= ~SES_FLAG_OPEN; 334 else 335 softc->ses_flags |= SES_FLAG_INITIALIZED; 336 } 337 338 out: 339 return (error); 340 } 341 342 int 343 sesclose(dev, flags, fmt, p) 344 dev_t dev; 345 int flags; 346 int fmt; 347 struct proc *p; 348 { 349 struct ses_softc *softc; 350 int unit; 351 352 unit = SESUNIT(dev); 353 if (unit >= ses_cd.cd_ndevs) 354 return (ENXIO); 355 softc = ses_cd.cd_devs[unit]; 356 if (softc == NULL) 357 return (ENXIO); 358 359 scsipi_wait_drain(softc->sc_periph); 360 scsipi_adapter_delref(softc->sc_periph->periph_channel->chan_adapter); 361 softc->ses_flags &= ~SES_FLAG_OPEN; 362 return (0); 363 } 364 365 int 366 sesioctl(dev, cmd, arg_addr, flag, p) 367 dev_t dev; 368 u_long cmd; 369 caddr_t arg_addr; 370 int flag; 371 struct proc *p; 372 { 373 ses_encstat tmp; 374 ses_objstat objs; 375 ses_object obj, *uobj; 376 struct ses_softc *ssc = ses_cd.cd_devs[SESUNIT(dev)]; 377 void *addr; 378 int error, i; 379 380 381 if (arg_addr) 382 addr = *((caddr_t *) arg_addr); 383 else 384 addr = NULL; 385 386 SC_DEBUG(ssc->sc_periph, SCSIPI_DB2, ("sesioctl 0x%lx ", cmd)); 387 388 /* 389 * Now check to see whether we're initialized or not. 390 */ 391 if ((ssc->ses_flags & SES_FLAG_INITIALIZED) == 0) { 392 return (ENODEV); 393 } 394 395 error = 0; 396 397 /* 398 * If this command can change the device's state, 399 * we must have the device open for writing. 400 */ 401 switch (cmd) { 402 case SESIOC_GETNOBJ: 403 case SESIOC_GETOBJMAP: 404 case SESIOC_GETENCSTAT: 405 case SESIOC_GETOBJSTAT: 406 break; 407 default: 408 if ((flag & FWRITE) == 0) { 409 return (EBADF); 410 } 411 } 412 413 switch (cmd) { 414 case SESIOC_GETNOBJ: 415 error = copyout(&ssc->ses_nobjects, addr, 416 sizeof (ssc->ses_nobjects)); 417 break; 418 419 case SESIOC_GETOBJMAP: 420 for (uobj = addr, i = 0; i != ssc->ses_nobjects; i++, uobj++) { 421 obj.obj_id = i; 422 obj.subencid = ssc->ses_objmap[i].subenclosure; 423 obj.object_type = ssc->ses_objmap[i].enctype; 424 error = copyout(&obj, uobj, sizeof (ses_object)); 425 if (error) { 426 break; 427 } 428 } 429 break; 430 431 case SESIOC_GETENCSTAT: 432 error = (*ssc->ses_vec.get_encstat)(ssc, 1); 433 if (error) 434 break; 435 tmp = ssc->ses_encstat & ~ENCI_SVALID; 436 error = copyout(&tmp, addr, sizeof (ses_encstat)); 437 ssc->ses_encstat = tmp; 438 break; 439 440 case SESIOC_SETENCSTAT: 441 error = copyin(addr, &tmp, sizeof (ses_encstat)); 442 if (error) 443 break; 444 error = (*ssc->ses_vec.set_encstat)(ssc, tmp, 1); 445 break; 446 447 case SESIOC_GETOBJSTAT: 448 error = copyin(addr, &objs, sizeof (ses_objstat)); 449 if (error) 450 break; 451 if (objs.obj_id >= ssc->ses_nobjects) { 452 error = EINVAL; 453 break; 454 } 455 error = (*ssc->ses_vec.get_objstat)(ssc, &objs, 1); 456 if (error) 457 break; 458 error = copyout(&objs, addr, sizeof (ses_objstat)); 459 /* 460 * Always (for now) invalidate entry. 461 */ 462 ssc->ses_objmap[objs.obj_id].svalid = 0; 463 break; 464 465 case SESIOC_SETOBJSTAT: 466 error = copyin(addr, &objs, sizeof (ses_objstat)); 467 if (error) 468 break; 469 470 if (objs.obj_id >= ssc->ses_nobjects) { 471 error = EINVAL; 472 break; 473 } 474 error = (*ssc->ses_vec.set_objstat)(ssc, &objs, 1); 475 476 /* 477 * Always (for now) invalidate entry. 478 */ 479 ssc->ses_objmap[objs.obj_id].svalid = 0; 480 break; 481 482 case SESIOC_INIT: 483 484 error = (*ssc->ses_vec.init_enc)(ssc); 485 break; 486 487 default: 488 error = scsipi_do_ioctl(ssc->sc_periph, 489 dev, cmd, addr, flag, p); 490 break; 491 } 492 return (error); 493 } 494 495 static int 496 ses_runcmd(struct ses_softc *ssc, char *cdb, int cdbl, char *dptr, int *dlenp) 497 { 498 struct scsipi_generic sgen; 499 int dl, flg, error; 500 501 if (dptr) { 502 if ((dl = *dlenp) < 0) { 503 dl = -dl; 504 flg = XS_CTL_DATA_OUT; 505 } else { 506 flg = XS_CTL_DATA_IN; 507 } 508 } else { 509 dl = 0; 510 flg = 0; 511 } 512 513 if (cdbl > sizeof (struct scsipi_generic)) { 514 cdbl = sizeof (struct scsipi_generic); 515 } 516 memcpy(&sgen, cdb, cdbl); 517 #ifndef SCSIDEBUG 518 flg |= XS_CTL_SILENT; 519 #endif 520 error = scsipi_command(ssc->sc_periph, &sgen, cdbl, 521 (u_char *) dptr, dl, SCSIPIRETRIES, 30000, NULL, flg); 522 523 if (error == 0 && dptr) 524 *dlenp = 0; 525 526 return (error); 527 } 528 529 #ifdef __STDC__ 530 static void 531 ses_log(struct ses_softc *ssc, const char *fmt, ...) 532 { 533 va_list ap; 534 535 printf("%s: ", ssc->sc_device.dv_xname); 536 va_start(ap, fmt); 537 vprintf(fmt, ap); 538 va_end(ap); 539 } 540 #else 541 static void 542 ses_log(ssc, fmt, va_alist) 543 struct ses_softc *ssc; 544 char *fmt; 545 va_dcl 546 { 547 va_list ap; 548 549 printf("%s: ", ssc->sc_device.dv_xname); 550 va_start(ap, fmt); 551 vprintf(fmt, ap); 552 va_end(ap); 553 } 554 #endif 555 556 /* 557 * The code after this point runs on many platforms, 558 * so forgive the slightly awkward and nonconforming 559 * appearance. 560 */ 561 562 /* 563 * Is this a device that supports enclosure services? 564 * 565 * It's a a pretty simple ruleset- if it is device type 0x0D (13), it's 566 * an SES device. If it happens to be an old UNISYS SEN device, we can 567 * handle that too. 568 */ 569 570 #define SAFTE_START 44 571 #define SAFTE_END 50 572 #define SAFTE_LEN SAFTE_END-SAFTE_START 573 574 static enctyp 575 ses_type(inqp) 576 struct scsipi_inquiry_data *inqp; 577 { 578 size_t given_len = inqp->additional_length + 4; 579 580 if (given_len < 8+SEN_ID_LEN) 581 return (SES_NONE); 582 583 if ((inqp->device & SID_TYPE) == T_ENCLOSURE) { 584 if (STRNCMP(inqp->vendor, SEN_ID, SEN_ID_LEN) == 0) { 585 return (SES_SEN); 586 } else if ((inqp->version & SID_ANSII) > 2) { 587 return (SES_SES); 588 } else { 589 return (SES_SES_SCSI2); 590 } 591 return (SES_NONE); 592 } 593 594 #ifdef SES_ENABLE_PASSTHROUGH 595 if ((inqp->flags2 & SID_EncServ) && (inqp->version & SID_ANSII) >= 2) { 596 /* 597 * PassThrough Device. 598 */ 599 return (SES_SES_PASSTHROUGH); 600 } 601 #endif 602 603 /* 604 * The comparison is short for a reason- 605 * some vendors were chopping it short. 606 */ 607 608 if (given_len < SAFTE_END - 2) { 609 return (SES_NONE); 610 } 611 612 if (STRNCMP((char *)&inqp->vendor_specific[8], "SAF-TE", 613 SAFTE_LEN - 2) == 0) { 614 return (SES_SAFT); 615 } 616 617 return (SES_NONE); 618 } 619 620 /* 621 * SES Native Type Device Support 622 */ 623 624 /* 625 * SES Diagnostic Page Codes 626 */ 627 628 typedef enum { 629 SesConfigPage = 0x1, 630 SesControlPage, 631 #define SesStatusPage SesControlPage 632 SesHelpTxt, 633 SesStringOut, 634 #define SesStringIn SesStringOut 635 SesThresholdOut, 636 #define SesThresholdIn SesThresholdOut 637 SesArrayControl, 638 #define SesArrayStatus SesArrayControl 639 SesElementDescriptor, 640 SesShortStatus 641 } SesDiagPageCodes; 642 643 /* 644 * minimal amounts 645 */ 646 647 /* 648 * Minimum amount of data, starting from byte 0, to have 649 * the config header. 650 */ 651 #define SES_CFGHDR_MINLEN 12 652 653 /* 654 * Minimum amount of data, starting from byte 0, to have 655 * the config header and one enclosure header. 656 */ 657 #define SES_ENCHDR_MINLEN 48 658 659 /* 660 * Take this value, subtract it from VEnclen and you know 661 * the length of the vendor unique bytes. 662 */ 663 #define SES_ENCHDR_VMIN 36 664 665 /* 666 * SES Data Structures 667 */ 668 669 typedef struct { 670 uint32_t GenCode; /* Generation Code */ 671 uint8_t Nsubenc; /* Number of Subenclosures */ 672 } SesCfgHdr; 673 674 typedef struct { 675 uint8_t Subencid; /* SubEnclosure Identifier */ 676 uint8_t Ntypes; /* # of supported types */ 677 uint8_t VEnclen; /* Enclosure Descriptor Length */ 678 } SesEncHdr; 679 680 typedef struct { 681 uint8_t encWWN[8]; /* XXX- Not Right Yet */ 682 uint8_t encVid[8]; 683 uint8_t encPid[16]; 684 uint8_t encRev[4]; 685 uint8_t encVen[1]; 686 } SesEncDesc; 687 688 typedef struct { 689 uint8_t enc_type; /* type of element */ 690 uint8_t enc_maxelt; /* maximum supported */ 691 uint8_t enc_subenc; /* in SubEnc # N */ 692 uint8_t enc_tlen; /* Type Descriptor Text Length */ 693 } SesThdr; 694 695 typedef struct { 696 uint8_t comstatus; 697 uint8_t comstat[3]; 698 } SesComStat; 699 700 struct typidx { 701 int ses_tidx; 702 int ses_oidx; 703 }; 704 705 struct sscfg { 706 uint8_t ses_ntypes; /* total number of types supported */ 707 708 /* 709 * We need to keep a type index as well as an 710 * object index for each object in an enclosure. 711 */ 712 struct typidx *ses_typidx; 713 714 /* 715 * We also need to keep track of the number of elements 716 * per type of element. This is needed later so that we 717 * can find precisely in the returned status data the 718 * status for the Nth element of the Kth type. 719 */ 720 uint8_t * ses_eltmap; 721 }; 722 723 724 /* 725 * (de)canonicalization defines 726 */ 727 #define sbyte(x, byte) ((((uint32_t)(x)) >> (byte * 8)) & 0xff) 728 #define sbit(x, bit) (((uint32_t)(x)) << bit) 729 #define sset8(outp, idx, sval) (((uint8_t *)(outp))[idx++]) = sbyte(sval, 0) 730 731 #define sset16(outp, idx, sval) \ 732 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 1), \ 733 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 0) 734 735 736 #define sset24(outp, idx, sval) \ 737 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 2), \ 738 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 1), \ 739 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 0) 740 741 742 #define sset32(outp, idx, sval) \ 743 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 3), \ 744 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 2), \ 745 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 1), \ 746 (((uint8_t *)(outp))[idx++]) = sbyte(sval, 0) 747 748 #define gbyte(x, byte) ((((uint32_t)(x)) & 0xff) << (byte * 8)) 749 #define gbit(lv, in, idx, shft, mask) lv = ((in[idx] >> shft) & mask) 750 #define sget8(inp, idx, lval) lval = (((uint8_t *)(inp))[idx++]) 751 #define gget8(inp, idx, lval) lval = (((uint8_t *)(inp))[idx]) 752 753 #define sget16(inp, idx, lval) \ 754 lval = gbyte((((uint8_t *)(inp))[idx]), 1) | \ 755 (((uint8_t *)(inp))[idx+1]), idx += 2 756 757 #define gget16(inp, idx, lval) \ 758 lval = gbyte((((uint8_t *)(inp))[idx]), 1) | \ 759 (((uint8_t *)(inp))[idx+1]) 760 761 #define sget24(inp, idx, lval) \ 762 lval = gbyte((((uint8_t *)(inp))[idx]), 2) | \ 763 gbyte((((uint8_t *)(inp))[idx+1]), 1) | \ 764 (((uint8_t *)(inp))[idx+2]), idx += 3 765 766 #define gget24(inp, idx, lval) \ 767 lval = gbyte((((uint8_t *)(inp))[idx]), 2) | \ 768 gbyte((((uint8_t *)(inp))[idx+1]), 1) | \ 769 (((uint8_t *)(inp))[idx+2]) 770 771 #define sget32(inp, idx, lval) \ 772 lval = gbyte((((uint8_t *)(inp))[idx]), 3) | \ 773 gbyte((((uint8_t *)(inp))[idx+1]), 2) | \ 774 gbyte((((uint8_t *)(inp))[idx+2]), 1) | \ 775 (((uint8_t *)(inp))[idx+3]), idx += 4 776 777 #define gget32(inp, idx, lval) \ 778 lval = gbyte((((uint8_t *)(inp))[idx]), 3) | \ 779 gbyte((((uint8_t *)(inp))[idx+1]), 2) | \ 780 gbyte((((uint8_t *)(inp))[idx+2]), 1) | \ 781 (((uint8_t *)(inp))[idx+3]) 782 783 #define SCSZ 0x2000 784 #define CFLEN (256 + SES_ENCHDR_MINLEN) 785 786 /* 787 * Routines specific && private to SES only 788 */ 789 790 static int ses_getconfig(ses_softc_t *); 791 static int ses_getputstat(ses_softc_t *, int, SesComStat *, int, int); 792 static int ses_cfghdr(uint8_t *, int, SesCfgHdr *); 793 static int ses_enchdr(uint8_t *, int, uint8_t, SesEncHdr *); 794 static int ses_encdesc(uint8_t *, int, uint8_t, SesEncDesc *); 795 static int ses_getthdr(uint8_t *, int, int, SesThdr *); 796 static int ses_decode(char *, int, uint8_t *, int, int, SesComStat *); 797 static int ses_encode(char *, int, uint8_t *, int, int, SesComStat *); 798 799 static int 800 ses_softc_init(ses_softc_t *ssc, int doinit) 801 { 802 if (doinit == 0) { 803 struct sscfg *cc; 804 if (ssc->ses_nobjects) { 805 SES_FREE(ssc->ses_objmap, 806 ssc->ses_nobjects * sizeof (encobj)); 807 ssc->ses_objmap = NULL; 808 } 809 if ((cc = ssc->ses_private) != NULL) { 810 if (cc->ses_eltmap && cc->ses_ntypes) { 811 SES_FREE(cc->ses_eltmap, cc->ses_ntypes); 812 cc->ses_eltmap = NULL; 813 cc->ses_ntypes = 0; 814 } 815 if (cc->ses_typidx && ssc->ses_nobjects) { 816 SES_FREE(cc->ses_typidx, 817 ssc->ses_nobjects * sizeof (struct typidx)); 818 cc->ses_typidx = NULL; 819 } 820 SES_FREE(cc, sizeof (struct sscfg)); 821 ssc->ses_private = NULL; 822 } 823 ssc->ses_nobjects = 0; 824 return (0); 825 } 826 if (ssc->ses_private == NULL) { 827 ssc->ses_private = SES_MALLOC(sizeof (struct sscfg)); 828 } 829 if (ssc->ses_private == NULL) { 830 return (ENOMEM); 831 } 832 ssc->ses_nobjects = 0; 833 ssc->ses_encstat = 0; 834 return (ses_getconfig(ssc)); 835 } 836 837 static int 838 ses_init_enc(ses_softc_t *ssc) 839 { 840 return (0); 841 } 842 843 static int 844 ses_get_encstat(ses_softc_t *ssc, int slpflag) 845 { 846 SesComStat ComStat; 847 int status; 848 849 if ((status = ses_getputstat(ssc, -1, &ComStat, slpflag, 1)) != 0) { 850 return (status); 851 } 852 ssc->ses_encstat = ComStat.comstatus | ENCI_SVALID; 853 return (0); 854 } 855 856 static int 857 ses_set_encstat(ses_softc_t *ssc, uint8_t encstat, int slpflag) 858 { 859 SesComStat ComStat; 860 int status; 861 862 ComStat.comstatus = encstat & 0xf; 863 if ((status = ses_getputstat(ssc, -1, &ComStat, slpflag, 0)) != 0) { 864 return (status); 865 } 866 ssc->ses_encstat = encstat & 0xf; /* note no SVALID set */ 867 return (0); 868 } 869 870 static int 871 ses_get_objstat(ses_softc_t *ssc, ses_objstat *obp, int slpflag) 872 { 873 int i = (int)obp->obj_id; 874 875 if (ssc->ses_objmap[i].svalid == 0) { 876 SesComStat ComStat; 877 int err = ses_getputstat(ssc, i, &ComStat, slpflag, 1); 878 if (err) 879 return (err); 880 ssc->ses_objmap[i].encstat[0] = ComStat.comstatus; 881 ssc->ses_objmap[i].encstat[1] = ComStat.comstat[0]; 882 ssc->ses_objmap[i].encstat[2] = ComStat.comstat[1]; 883 ssc->ses_objmap[i].encstat[3] = ComStat.comstat[2]; 884 ssc->ses_objmap[i].svalid = 1; 885 } 886 obp->cstat[0] = ssc->ses_objmap[i].encstat[0]; 887 obp->cstat[1] = ssc->ses_objmap[i].encstat[1]; 888 obp->cstat[2] = ssc->ses_objmap[i].encstat[2]; 889 obp->cstat[3] = ssc->ses_objmap[i].encstat[3]; 890 return (0); 891 } 892 893 static int 894 ses_set_objstat(ses_softc_t *ssc, ses_objstat *obp, int slpflag) 895 { 896 SesComStat ComStat; 897 int err; 898 /* 899 * If this is clear, we don't do diddly. 900 */ 901 if ((obp->cstat[0] & SESCTL_CSEL) == 0) { 902 return (0); 903 } 904 ComStat.comstatus = obp->cstat[0]; 905 ComStat.comstat[0] = obp->cstat[1]; 906 ComStat.comstat[1] = obp->cstat[2]; 907 ComStat.comstat[2] = obp->cstat[3]; 908 err = ses_getputstat(ssc, (int)obp->obj_id, &ComStat, slpflag, 0); 909 ssc->ses_objmap[(int)obp->obj_id].svalid = 0; 910 return (err); 911 } 912 913 static int 914 ses_getconfig(ses_softc_t *ssc) 915 { 916 struct sscfg *cc; 917 SesCfgHdr cf; 918 SesEncHdr hd; 919 SesEncDesc *cdp; 920 SesThdr thdr; 921 int err, amt, i, nobj, ntype, maxima; 922 char storage[CFLEN], *sdata; 923 static char cdb[6] = { 924 RECEIVE_DIAGNOSTIC, 0x1, SesConfigPage, SCSZ >> 8, SCSZ & 0xff, 0 925 }; 926 927 cc = ssc->ses_private; 928 if (cc == NULL) { 929 return (ENXIO); 930 } 931 932 sdata = SES_MALLOC(SCSZ); 933 if (sdata == NULL) 934 return (ENOMEM); 935 936 amt = SCSZ; 937 err = ses_runcmd(ssc, cdb, 6, sdata, &amt); 938 if (err) { 939 SES_FREE(sdata, SCSZ); 940 return (err); 941 } 942 amt = SCSZ - amt; 943 944 if (ses_cfghdr((uint8_t *) sdata, amt, &cf)) { 945 SES_LOG(ssc, "Unable to parse SES Config Header\n"); 946 SES_FREE(sdata, SCSZ); 947 return (EIO); 948 } 949 if (amt < SES_ENCHDR_MINLEN) { 950 SES_LOG(ssc, "runt enclosure length (%d)\n", amt); 951 SES_FREE(sdata, SCSZ); 952 return (EIO); 953 } 954 955 SES_VLOG(ssc, "GenCode %x %d Subenclosures\n", cf.GenCode, cf.Nsubenc); 956 957 /* 958 * Now waltz through all the subenclosures toting up the 959 * number of types available in each. For this, we only 960 * really need the enclosure header. However, we get the 961 * enclosure descriptor for debug purposes, as well 962 * as self-consistency checking purposes. 963 */ 964 965 maxima = cf.Nsubenc + 1; 966 cdp = (SesEncDesc *) storage; 967 for (ntype = i = 0; i < maxima; i++) { 968 MEMZERO((caddr_t)cdp, sizeof (*cdp)); 969 if (ses_enchdr((uint8_t *) sdata, amt, i, &hd)) { 970 SES_LOG(ssc, "Cannot Extract Enclosure Header %d\n", i); 971 SES_FREE(sdata, SCSZ); 972 return (EIO); 973 } 974 SES_VLOG(ssc, " SubEnclosure ID %d, %d Types With this ID, En" 975 "closure Length %d\n", hd.Subencid, hd.Ntypes, hd.VEnclen); 976 977 if (ses_encdesc((uint8_t *)sdata, amt, i, cdp)) { 978 SES_LOG(ssc, "Can't get Enclosure Descriptor %d\n", i); 979 SES_FREE(sdata, SCSZ); 980 return (EIO); 981 } 982 SES_VLOG(ssc, " WWN: %02x%02x%02x%02x%02x%02x%02x%02x\n", 983 cdp->encWWN[0], cdp->encWWN[1], cdp->encWWN[2], 984 cdp->encWWN[3], cdp->encWWN[4], cdp->encWWN[5], 985 cdp->encWWN[6], cdp->encWWN[7]); 986 ntype += hd.Ntypes; 987 } 988 989 /* 990 * Now waltz through all the types that are available, getting 991 * the type header so we can start adding up the number of 992 * objects available. 993 */ 994 for (nobj = i = 0; i < ntype; i++) { 995 if (ses_getthdr((uint8_t *)sdata, amt, i, &thdr)) { 996 SES_LOG(ssc, "Can't get Enclosure Type Header %d\n", i); 997 SES_FREE(sdata, SCSZ); 998 return (EIO); 999 } 1000 SES_LOG(ssc, " Type Desc[%d]: Type 0x%x, MaxElt %d, In Subenc " 1001 "%d, Text Length %d\n", i, thdr.enc_type, thdr.enc_maxelt, 1002 thdr.enc_subenc, thdr.enc_tlen); 1003 nobj += thdr.enc_maxelt; 1004 } 1005 1006 1007 /* 1008 * Now allocate the object array and type map. 1009 */ 1010 1011 ssc->ses_objmap = SES_MALLOC(nobj * sizeof (encobj)); 1012 cc->ses_typidx = SES_MALLOC(nobj * sizeof (struct typidx)); 1013 cc->ses_eltmap = SES_MALLOC(ntype); 1014 1015 if (ssc->ses_objmap == NULL || cc->ses_typidx == NULL || 1016 cc->ses_eltmap == NULL) { 1017 if (ssc->ses_objmap) { 1018 SES_FREE(ssc->ses_objmap, (nobj * sizeof (encobj))); 1019 ssc->ses_objmap = NULL; 1020 } 1021 if (cc->ses_typidx) { 1022 SES_FREE(cc->ses_typidx, 1023 (nobj * sizeof (struct typidx))); 1024 cc->ses_typidx = NULL; 1025 } 1026 if (cc->ses_eltmap) { 1027 SES_FREE(cc->ses_eltmap, ntype); 1028 cc->ses_eltmap = NULL; 1029 } 1030 SES_FREE(sdata, SCSZ); 1031 return (ENOMEM); 1032 } 1033 MEMZERO(ssc->ses_objmap, nobj * sizeof (encobj)); 1034 MEMZERO(cc->ses_typidx, nobj * sizeof (struct typidx)); 1035 MEMZERO(cc->ses_eltmap, ntype); 1036 cc->ses_ntypes = (uint8_t) ntype; 1037 ssc->ses_nobjects = nobj; 1038 1039 /* 1040 * Now waltz through the # of types again to fill in the types 1041 * (and subenclosure ids) of the allocated objects. 1042 */ 1043 nobj = 0; 1044 for (i = 0; i < ntype; i++) { 1045 int j; 1046 if (ses_getthdr((uint8_t *)sdata, amt, i, &thdr)) { 1047 continue; 1048 } 1049 cc->ses_eltmap[i] = thdr.enc_maxelt; 1050 for (j = 0; j < thdr.enc_maxelt; j++) { 1051 cc->ses_typidx[nobj].ses_tidx = i; 1052 cc->ses_typidx[nobj].ses_oidx = j; 1053 ssc->ses_objmap[nobj].subenclosure = thdr.enc_subenc; 1054 ssc->ses_objmap[nobj++].enctype = thdr.enc_type; 1055 } 1056 } 1057 SES_FREE(sdata, SCSZ); 1058 return (0); 1059 } 1060 1061 static int 1062 ses_getputstat(ses_softc_t *ssc, int objid, SesComStat *sp, int slp, int in) 1063 { 1064 struct sscfg *cc; 1065 int err, amt, bufsiz, tidx, oidx; 1066 char cdb[6], *sdata; 1067 1068 cc = ssc->ses_private; 1069 if (cc == NULL) { 1070 return (ENXIO); 1071 } 1072 1073 /* 1074 * If we're just getting overall enclosure status, 1075 * we only need 2 bytes of data storage. 1076 * 1077 * If we're getting anything else, we know how much 1078 * storage we need by noting that starting at offset 1079 * 8 in returned data, all object status bytes are 4 1080 * bytes long, and are stored in chunks of types(M) 1081 * and nth+1 instances of type M. 1082 */ 1083 if (objid == -1) { 1084 bufsiz = 2; 1085 } else { 1086 bufsiz = (ssc->ses_nobjects * 4) + (cc->ses_ntypes * 4) + 8; 1087 } 1088 sdata = SES_MALLOC(bufsiz); 1089 if (sdata == NULL) 1090 return (ENOMEM); 1091 1092 cdb[0] = RECEIVE_DIAGNOSTIC; 1093 cdb[1] = 1; 1094 cdb[2] = SesStatusPage; 1095 cdb[3] = bufsiz >> 8; 1096 cdb[4] = bufsiz & 0xff; 1097 cdb[5] = 0; 1098 amt = bufsiz; 1099 err = ses_runcmd(ssc, cdb, 6, sdata, &amt); 1100 if (err) { 1101 SES_FREE(sdata, bufsiz); 1102 return (err); 1103 } 1104 amt = bufsiz - amt; 1105 1106 if (objid == -1) { 1107 tidx = -1; 1108 oidx = -1; 1109 } else { 1110 tidx = cc->ses_typidx[objid].ses_tidx; 1111 oidx = cc->ses_typidx[objid].ses_oidx; 1112 } 1113 if (in) { 1114 if (ses_decode(sdata, amt, cc->ses_eltmap, tidx, oidx, sp)) { 1115 err = ENODEV; 1116 } 1117 } else { 1118 if (ses_encode(sdata, amt, cc->ses_eltmap, tidx, oidx, sp)) { 1119 err = ENODEV; 1120 } else { 1121 cdb[0] = SEND_DIAGNOSTIC; 1122 cdb[1] = 0x10; 1123 cdb[2] = 0; 1124 cdb[3] = bufsiz >> 8; 1125 cdb[4] = bufsiz & 0xff; 1126 cdb[5] = 0; 1127 amt = -bufsiz; 1128 err = ses_runcmd(ssc, cdb, 6, sdata, &amt); 1129 } 1130 } 1131 SES_FREE(sdata, bufsiz); 1132 return (0); 1133 } 1134 1135 1136 /* 1137 * Routines to parse returned SES data structures. 1138 * Architecture and compiler independent. 1139 */ 1140 1141 static int 1142 ses_cfghdr(uint8_t *buffer, int buflen, SesCfgHdr *cfp) 1143 { 1144 if (buflen < SES_CFGHDR_MINLEN) { 1145 return (-1); 1146 } 1147 gget8(buffer, 1, cfp->Nsubenc); 1148 gget32(buffer, 4, cfp->GenCode); 1149 return (0); 1150 } 1151 1152 static int 1153 ses_enchdr(uint8_t *buffer, int amt, uint8_t SubEncId, SesEncHdr *chp) 1154 { 1155 int s, off = 8; 1156 for (s = 0; s < SubEncId; s++) { 1157 if (off + 3 > amt) 1158 return (-1); 1159 off += buffer[off+3] + 4; 1160 } 1161 if (off + 3 > amt) { 1162 return (-1); 1163 } 1164 gget8(buffer, off+1, chp->Subencid); 1165 gget8(buffer, off+2, chp->Ntypes); 1166 gget8(buffer, off+3, chp->VEnclen); 1167 return (0); 1168 } 1169 1170 static int 1171 ses_encdesc(uint8_t *buffer, int amt, uint8_t SubEncId, SesEncDesc *cdp) 1172 { 1173 int s, e, enclen, off = 8; 1174 for (s = 0; s < SubEncId; s++) { 1175 if (off + 3 > amt) 1176 return (-1); 1177 off += buffer[off+3] + 4; 1178 } 1179 if (off + 3 > amt) { 1180 return (-1); 1181 } 1182 gget8(buffer, off+3, enclen); 1183 off += 4; 1184 if (off >= amt) 1185 return (-1); 1186 1187 e = off + enclen; 1188 if (e > amt) { 1189 e = amt; 1190 } 1191 MEMCPY(cdp, &buffer[off], e - off); 1192 return (0); 1193 } 1194 1195 static int 1196 ses_getthdr(uint8_t *buffer, int amt, int nth, SesThdr *thp) 1197 { 1198 int s, off = 8; 1199 1200 if (amt < SES_CFGHDR_MINLEN) { 1201 return (-1); 1202 } 1203 for (s = 0; s < buffer[1]; s++) { 1204 if (off + 3 > amt) 1205 return (-1); 1206 off += buffer[off+3] + 4; 1207 } 1208 if (off + 3 > amt) { 1209 return (-1); 1210 } 1211 off += buffer[off+3] + 4 + (nth * 4); 1212 if (amt < (off + 4)) 1213 return (-1); 1214 1215 gget8(buffer, off++, thp->enc_type); 1216 gget8(buffer, off++, thp->enc_maxelt); 1217 gget8(buffer, off++, thp->enc_subenc); 1218 gget8(buffer, off, thp->enc_tlen); 1219 return (0); 1220 } 1221 1222 /* 1223 * This function needs a little explanation. 1224 * 1225 * The arguments are: 1226 * 1227 * 1228 * char *b, int amt 1229 * 1230 * These describes the raw input SES status data and length. 1231 * 1232 * uint8_t *ep 1233 * 1234 * This is a map of the number of types for each element type 1235 * in the enclosure. 1236 * 1237 * int elt 1238 * 1239 * This is the element type being sought. If elt is -1, 1240 * then overall enclosure status is being sought. 1241 * 1242 * int elm 1243 * 1244 * This is the ordinal Mth element of type elt being sought. 1245 * 1246 * SesComStat *sp 1247 * 1248 * This is the output area to store the status for 1249 * the Mth element of type Elt. 1250 */ 1251 1252 static int 1253 ses_decode(char *b, int amt, uint8_t *ep, int elt, int elm, SesComStat *sp) 1254 { 1255 int idx, i; 1256 1257 /* 1258 * If it's overall enclosure status being sought, get that. 1259 * We need at least 2 bytes of status data to get that. 1260 */ 1261 if (elt == -1) { 1262 if (amt < 2) 1263 return (-1); 1264 gget8(b, 1, sp->comstatus); 1265 sp->comstat[0] = 0; 1266 sp->comstat[1] = 0; 1267 sp->comstat[2] = 0; 1268 return (0); 1269 } 1270 1271 /* 1272 * Check to make sure that the Mth element is legal for type Elt. 1273 */ 1274 1275 if (elm >= ep[elt]) 1276 return (-1); 1277 1278 /* 1279 * Starting at offset 8, start skipping over the storage 1280 * for the element types we're not interested in. 1281 */ 1282 for (idx = 8, i = 0; i < elt; i++) { 1283 idx += ((ep[i] + 1) * 4); 1284 } 1285 1286 /* 1287 * Skip over Overall status for this element type. 1288 */ 1289 idx += 4; 1290 1291 /* 1292 * And skip to the index for the Mth element that we're going for. 1293 */ 1294 idx += (4 * elm); 1295 1296 /* 1297 * Make sure we haven't overflowed the buffer. 1298 */ 1299 if (idx+4 > amt) 1300 return (-1); 1301 1302 /* 1303 * Retrieve the status. 1304 */ 1305 gget8(b, idx++, sp->comstatus); 1306 gget8(b, idx++, sp->comstat[0]); 1307 gget8(b, idx++, sp->comstat[1]); 1308 gget8(b, idx++, sp->comstat[2]); 1309 #if 0 1310 PRINTF("Get Elt 0x%x Elm 0x%x (idx %d)\n", elt, elm, idx-4); 1311 #endif 1312 return (0); 1313 } 1314 1315 /* 1316 * This is the mirror function to ses_decode, but we set the 'select' 1317 * bit for the object which we're interested in. All other objects, 1318 * after a status fetch, should have that bit off. Hmm. It'd be easy 1319 * enough to ensure this, so we will. 1320 */ 1321 1322 static int 1323 ses_encode(char *b, int amt, uint8_t *ep, int elt, int elm, SesComStat *sp) 1324 { 1325 int idx, i; 1326 1327 /* 1328 * If it's overall enclosure status being sought, get that. 1329 * We need at least 2 bytes of status data to get that. 1330 */ 1331 if (elt == -1) { 1332 if (amt < 2) 1333 return (-1); 1334 i = 0; 1335 sset8(b, i, 0); 1336 sset8(b, i, sp->comstatus & 0xf); 1337 #if 0 1338 PRINTF("set EncStat %x\n", sp->comstatus); 1339 #endif 1340 return (0); 1341 } 1342 1343 /* 1344 * Check to make sure that the Mth element is legal for type Elt. 1345 */ 1346 1347 if (elm >= ep[elt]) 1348 return (-1); 1349 1350 /* 1351 * Starting at offset 8, start skipping over the storage 1352 * for the element types we're not interested in. 1353 */ 1354 for (idx = 8, i = 0; i < elt; i++) { 1355 idx += ((ep[i] + 1) * 4); 1356 } 1357 1358 /* 1359 * Skip over Overall status for this element type. 1360 */ 1361 idx += 4; 1362 1363 /* 1364 * And skip to the index for the Mth element that we're going for. 1365 */ 1366 idx += (4 * elm); 1367 1368 /* 1369 * Make sure we haven't overflowed the buffer. 1370 */ 1371 if (idx+4 > amt) 1372 return (-1); 1373 1374 /* 1375 * Set the status. 1376 */ 1377 sset8(b, idx, sp->comstatus); 1378 sset8(b, idx, sp->comstat[0]); 1379 sset8(b, idx, sp->comstat[1]); 1380 sset8(b, idx, sp->comstat[2]); 1381 idx -= 4; 1382 1383 #if 0 1384 PRINTF("Set Elt 0x%x Elm 0x%x (idx %d) with %x %x %x %x\n", 1385 elt, elm, idx, sp->comstatus, sp->comstat[0], 1386 sp->comstat[1], sp->comstat[2]); 1387 #endif 1388 1389 /* 1390 * Now make sure all other 'Select' bits are off. 1391 */ 1392 for (i = 8; i < amt; i += 4) { 1393 if (i != idx) 1394 b[i] &= ~0x80; 1395 } 1396 /* 1397 * And make sure the INVOP bit is clear. 1398 */ 1399 b[2] &= ~0x10; 1400 1401 return (0); 1402 } 1403 1404 /* 1405 * SAF-TE Type Device Emulation 1406 */ 1407 1408 static int safte_getconfig(ses_softc_t *); 1409 static int safte_rdstat(ses_softc_t *, int);; 1410 static int set_objstat_sel(ses_softc_t *, ses_objstat *, int); 1411 static int wrbuf16(ses_softc_t *, uint8_t, uint8_t, uint8_t, uint8_t, int); 1412 static void wrslot_stat(ses_softc_t *, int); 1413 static int perf_slotop(ses_softc_t *, uint8_t, uint8_t, int); 1414 1415 #define ALL_ENC_STAT (SES_ENCSTAT_CRITICAL | SES_ENCSTAT_UNRECOV | \ 1416 SES_ENCSTAT_NONCRITICAL | SES_ENCSTAT_INFO) 1417 /* 1418 * SAF-TE specific defines- Mandatory ones only... 1419 */ 1420 1421 /* 1422 * READ BUFFER ('get' commands) IDs- placed in offset 2 of cdb 1423 */ 1424 #define SAFTE_RD_RDCFG 0x00 /* read enclosure configuration */ 1425 #define SAFTE_RD_RDESTS 0x01 /* read enclosure status */ 1426 #define SAFTE_RD_RDDSTS 0x04 /* read drive slot status */ 1427 1428 /* 1429 * WRITE BUFFER ('set' commands) IDs- placed in offset 0 of databuf 1430 */ 1431 #define SAFTE_WT_DSTAT 0x10 /* write device slot status */ 1432 #define SAFTE_WT_SLTOP 0x12 /* perform slot operation */ 1433 #define SAFTE_WT_FANSPD 0x13 /* set fan speed */ 1434 #define SAFTE_WT_ACTPWS 0x14 /* turn on/off power supply */ 1435 #define SAFTE_WT_GLOBAL 0x15 /* send global command */ 1436 1437 1438 #define SAFT_SCRATCH 64 1439 #define NPSEUDO_THERM 16 1440 #define NPSEUDO_ALARM 1 1441 struct scfg { 1442 /* 1443 * Cached Configuration 1444 */ 1445 uint8_t Nfans; /* Number of Fans */ 1446 uint8_t Npwr; /* Number of Power Supplies */ 1447 uint8_t Nslots; /* Number of Device Slots */ 1448 uint8_t DoorLock; /* Door Lock Installed */ 1449 uint8_t Ntherm; /* Number of Temperature Sensors */ 1450 uint8_t Nspkrs; /* Number of Speakers */ 1451 uint8_t Nalarm; /* Number of Alarms (at least one) */ 1452 /* 1453 * Cached Flag Bytes for Global Status 1454 */ 1455 uint8_t flag1; 1456 uint8_t flag2; 1457 /* 1458 * What object index ID is where various slots start. 1459 */ 1460 uint8_t pwroff; 1461 uint8_t slotoff; 1462 #define SAFT_ALARM_OFFSET(cc) (cc)->slotoff - 1 1463 }; 1464 1465 #define SAFT_FLG1_ALARM 0x1 1466 #define SAFT_FLG1_GLOBFAIL 0x2 1467 #define SAFT_FLG1_GLOBWARN 0x4 1468 #define SAFT_FLG1_ENCPWROFF 0x8 1469 #define SAFT_FLG1_ENCFANFAIL 0x10 1470 #define SAFT_FLG1_ENCPWRFAIL 0x20 1471 #define SAFT_FLG1_ENCDRVFAIL 0x40 1472 #define SAFT_FLG1_ENCDRVWARN 0x80 1473 1474 #define SAFT_FLG2_LOCKDOOR 0x4 1475 #define SAFT_PRIVATE sizeof (struct scfg) 1476 1477 static const char safte_2little[] = "Too Little Data Returned (%d) at line %d\n"; 1478 #define SAFT_BAIL(r, x, k, l) \ 1479 if (r >= x) { \ 1480 SES_LOG(ssc, safte_2little, x, __LINE__);\ 1481 SES_FREE(k, l); \ 1482 return (EIO); \ 1483 } 1484 1485 1486 int 1487 safte_softc_init(ses_softc_t *ssc, int doinit) 1488 { 1489 int err, i, r; 1490 struct scfg *cc; 1491 1492 if (doinit == 0) { 1493 if (ssc->ses_nobjects) { 1494 if (ssc->ses_objmap) { 1495 SES_FREE(ssc->ses_objmap, 1496 ssc->ses_nobjects * sizeof (encobj)); 1497 ssc->ses_objmap = NULL; 1498 } 1499 ssc->ses_nobjects = 0; 1500 } 1501 if (ssc->ses_private) { 1502 SES_FREE(ssc->ses_private, SAFT_PRIVATE); 1503 ssc->ses_private = NULL; 1504 } 1505 return (0); 1506 } 1507 1508 if (ssc->ses_private == NULL) { 1509 ssc->ses_private = SES_MALLOC(SAFT_PRIVATE); 1510 if (ssc->ses_private == NULL) { 1511 return (ENOMEM); 1512 } 1513 MEMZERO(ssc->ses_private, SAFT_PRIVATE); 1514 } 1515 1516 ssc->ses_nobjects = 0; 1517 ssc->ses_encstat = 0; 1518 1519 if ((err = safte_getconfig(ssc)) != 0) { 1520 return (err); 1521 } 1522 1523 /* 1524 * The number of objects here, as well as that reported by the 1525 * READ_BUFFER/GET_CONFIG call, are the over-temperature flags (15) 1526 * that get reported during READ_BUFFER/READ_ENC_STATUS. 1527 */ 1528 cc = ssc->ses_private; 1529 ssc->ses_nobjects = cc->Nfans + cc->Npwr + cc->Nslots + cc->DoorLock + 1530 cc->Ntherm + cc->Nspkrs + NPSEUDO_THERM + NPSEUDO_ALARM; 1531 ssc->ses_objmap = (encobj *) 1532 SES_MALLOC(ssc->ses_nobjects * sizeof (encobj)); 1533 if (ssc->ses_objmap == NULL) { 1534 return (ENOMEM); 1535 } 1536 MEMZERO(ssc->ses_objmap, ssc->ses_nobjects * sizeof (encobj)); 1537 1538 r = 0; 1539 /* 1540 * Note that this is all arranged for the convenience 1541 * in later fetches of status. 1542 */ 1543 for (i = 0; i < cc->Nfans; i++) 1544 ssc->ses_objmap[r++].enctype = SESTYP_FAN; 1545 cc->pwroff = (uint8_t) r; 1546 for (i = 0; i < cc->Npwr; i++) 1547 ssc->ses_objmap[r++].enctype = SESTYP_POWER; 1548 for (i = 0; i < cc->DoorLock; i++) 1549 ssc->ses_objmap[r++].enctype = SESTYP_DOORLOCK; 1550 for (i = 0; i < cc->Nspkrs; i++) 1551 ssc->ses_objmap[r++].enctype = SESTYP_ALARM; 1552 for (i = 0; i < cc->Ntherm; i++) 1553 ssc->ses_objmap[r++].enctype = SESTYP_THERM; 1554 for (i = 0; i < NPSEUDO_THERM; i++) 1555 ssc->ses_objmap[r++].enctype = SESTYP_THERM; 1556 ssc->ses_objmap[r++].enctype = SESTYP_ALARM; 1557 cc->slotoff = (uint8_t) r; 1558 for (i = 0; i < cc->Nslots; i++) 1559 ssc->ses_objmap[r++].enctype = SESTYP_DEVICE; 1560 return (0); 1561 } 1562 1563 int 1564 safte_init_enc(ses_softc_t *ssc) 1565 { 1566 int err, amt; 1567 char *sdata; 1568 static char cdb0[6] = { SEND_DIAGNOSTIC }; 1569 static char cdb[10] = 1570 { WRITE_BUFFER, 1, 0, 0, 0, 0, 0, 0, 16, 0 }; 1571 1572 sdata = SES_MALLOC(SAFT_SCRATCH); 1573 if (sdata == NULL) 1574 return (ENOMEM); 1575 1576 err = ses_runcmd(ssc, cdb0, 6, NULL, 0); 1577 if (err) { 1578 SES_FREE(sdata, SAFT_SCRATCH); 1579 return (err); 1580 } 1581 sdata[0] = SAFTE_WT_GLOBAL; 1582 MEMZERO(&sdata[1], 15); 1583 amt = -SAFT_SCRATCH; 1584 err = ses_runcmd(ssc, cdb, 10, sdata, &amt); 1585 SES_FREE(sdata, SAFT_SCRATCH); 1586 return (err); 1587 } 1588 1589 int 1590 safte_get_encstat(ses_softc_t *ssc, int slpflg) 1591 { 1592 return (safte_rdstat(ssc, slpflg)); 1593 } 1594 1595 int 1596 safte_set_encstat(ses_softc_t *ssc, uint8_t encstat, int slpflg) 1597 { 1598 struct scfg *cc = ssc->ses_private; 1599 if (cc == NULL) 1600 return (0); 1601 /* 1602 * Since SAF-TE devices aren't necessarily sticky in terms 1603 * of state, make our soft copy of enclosure status 'sticky'- 1604 * that is, things set in enclosure status stay set (as implied 1605 * by conditions set in reading object status) until cleared. 1606 */ 1607 ssc->ses_encstat &= ~ALL_ENC_STAT; 1608 ssc->ses_encstat |= (encstat & ALL_ENC_STAT); 1609 ssc->ses_encstat |= ENCI_SVALID; 1610 cc->flag1 &= ~(SAFT_FLG1_ALARM|SAFT_FLG1_GLOBFAIL|SAFT_FLG1_GLOBWARN); 1611 if ((encstat & (SES_ENCSTAT_CRITICAL|SES_ENCSTAT_UNRECOV)) != 0) { 1612 cc->flag1 |= SAFT_FLG1_ALARM|SAFT_FLG1_GLOBFAIL; 1613 } else if ((encstat & SES_ENCSTAT_NONCRITICAL) != 0) { 1614 cc->flag1 |= SAFT_FLG1_GLOBWARN; 1615 } 1616 return (wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, cc->flag2, 0, slpflg)); 1617 } 1618 1619 int 1620 safte_get_objstat(ses_softc_t *ssc, ses_objstat *obp, int slpflg) 1621 { 1622 int i = (int)obp->obj_id; 1623 1624 if ((ssc->ses_encstat & ENCI_SVALID) == 0 || 1625 (ssc->ses_objmap[i].svalid) == 0) { 1626 int err = safte_rdstat(ssc, slpflg); 1627 if (err) 1628 return (err); 1629 } 1630 obp->cstat[0] = ssc->ses_objmap[i].encstat[0]; 1631 obp->cstat[1] = ssc->ses_objmap[i].encstat[1]; 1632 obp->cstat[2] = ssc->ses_objmap[i].encstat[2]; 1633 obp->cstat[3] = ssc->ses_objmap[i].encstat[3]; 1634 return (0); 1635 } 1636 1637 1638 int 1639 safte_set_objstat(ses_softc_t *ssc, ses_objstat *obp, int slp) 1640 { 1641 int idx, err; 1642 encobj *ep; 1643 struct scfg *cc; 1644 1645 1646 SES_VLOG(ssc, "safte_set_objstat(%d): %x %x %x %x\n", 1647 (int)obp->obj_id, obp->cstat[0], obp->cstat[1], obp->cstat[2], 1648 obp->cstat[3]); 1649 1650 /* 1651 * If this is clear, we don't do diddly. 1652 */ 1653 if ((obp->cstat[0] & SESCTL_CSEL) == 0) { 1654 return (0); 1655 } 1656 1657 err = 0; 1658 /* 1659 * Check to see if the common bits are set and do them first. 1660 */ 1661 if (obp->cstat[0] & ~SESCTL_CSEL) { 1662 err = set_objstat_sel(ssc, obp, slp); 1663 if (err) 1664 return (err); 1665 } 1666 1667 cc = ssc->ses_private; 1668 if (cc == NULL) 1669 return (0); 1670 1671 idx = (int)obp->obj_id; 1672 ep = &ssc->ses_objmap[idx]; 1673 1674 switch (ep->enctype) { 1675 case SESTYP_DEVICE: 1676 { 1677 uint8_t slotop = 0; 1678 /* 1679 * XXX: I should probably cache the previous state 1680 * XXX: of SESCTL_DEVOFF so that when it goes from 1681 * XXX: true to false I can then set PREPARE FOR OPERATION 1682 * XXX: flag in PERFORM SLOT OPERATION write buffer command. 1683 */ 1684 if (obp->cstat[2] & (SESCTL_RQSINS|SESCTL_RQSRMV)) { 1685 slotop |= 0x2; 1686 } 1687 if (obp->cstat[2] & SESCTL_RQSID) { 1688 slotop |= 0x4; 1689 } 1690 err = perf_slotop(ssc, (uint8_t) idx - (uint8_t) cc->slotoff, 1691 slotop, slp); 1692 if (err) 1693 return (err); 1694 if (obp->cstat[3] & SESCTL_RQSFLT) { 1695 ep->priv |= 0x2; 1696 } else { 1697 ep->priv &= ~0x2; 1698 } 1699 if (ep->priv & 0xc6) { 1700 ep->priv &= ~0x1; 1701 } else { 1702 ep->priv |= 0x1; /* no errors */ 1703 } 1704 wrslot_stat(ssc, slp); 1705 break; 1706 } 1707 case SESTYP_POWER: 1708 if (obp->cstat[3] & SESCTL_RQSTFAIL) { 1709 cc->flag1 |= SAFT_FLG1_ENCPWRFAIL; 1710 } else { 1711 cc->flag1 &= ~SAFT_FLG1_ENCPWRFAIL; 1712 } 1713 err = wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, 1714 cc->flag2, 0, slp); 1715 if (err) 1716 return (err); 1717 if (obp->cstat[3] & SESCTL_RQSTON) { 1718 (void) wrbuf16(ssc, SAFTE_WT_ACTPWS, 1719 idx - cc->pwroff, 0, 0, slp); 1720 } else { 1721 (void) wrbuf16(ssc, SAFTE_WT_ACTPWS, 1722 idx - cc->pwroff, 0, 1, slp); 1723 } 1724 break; 1725 case SESTYP_FAN: 1726 if (obp->cstat[3] & SESCTL_RQSTFAIL) { 1727 cc->flag1 |= SAFT_FLG1_ENCFANFAIL; 1728 } else { 1729 cc->flag1 &= ~SAFT_FLG1_ENCFANFAIL; 1730 } 1731 err = wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, 1732 cc->flag2, 0, slp); 1733 if (err) 1734 return (err); 1735 if (obp->cstat[3] & SESCTL_RQSTON) { 1736 uint8_t fsp; 1737 if ((obp->cstat[3] & 0x7) == 7) { 1738 fsp = 4; 1739 } else if ((obp->cstat[3] & 0x7) == 6) { 1740 fsp = 3; 1741 } else if ((obp->cstat[3] & 0x7) == 4) { 1742 fsp = 2; 1743 } else { 1744 fsp = 1; 1745 } 1746 (void) wrbuf16(ssc, SAFTE_WT_FANSPD, idx, fsp, 0, slp); 1747 } else { 1748 (void) wrbuf16(ssc, SAFTE_WT_FANSPD, idx, 0, 0, slp); 1749 } 1750 break; 1751 case SESTYP_DOORLOCK: 1752 if (obp->cstat[3] & 0x1) { 1753 cc->flag2 &= ~SAFT_FLG2_LOCKDOOR; 1754 } else { 1755 cc->flag2 |= SAFT_FLG2_LOCKDOOR; 1756 } 1757 (void) wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, 1758 cc->flag2, 0, slp); 1759 break; 1760 case SESTYP_ALARM: 1761 /* 1762 * On all nonzero but the 'muted' bit, we turn on the alarm, 1763 */ 1764 obp->cstat[3] &= ~0xa; 1765 if (obp->cstat[3] & 0x40) { 1766 cc->flag2 &= ~SAFT_FLG1_ALARM; 1767 } else if (obp->cstat[3] != 0) { 1768 cc->flag2 |= SAFT_FLG1_ALARM; 1769 } else { 1770 cc->flag2 &= ~SAFT_FLG1_ALARM; 1771 } 1772 ep->priv = obp->cstat[3]; 1773 (void) wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, 1774 cc->flag2, 0, slp); 1775 break; 1776 default: 1777 break; 1778 } 1779 ep->svalid = 0; 1780 return (0); 1781 } 1782 1783 static int 1784 safte_getconfig(ses_softc_t *ssc) 1785 { 1786 struct scfg *cfg; 1787 int err, amt; 1788 char *sdata; 1789 static char cdb[10] = 1790 { READ_BUFFER, 1, SAFTE_RD_RDCFG, 0, 0, 0, 0, 0, SAFT_SCRATCH, 0 }; 1791 1792 cfg = ssc->ses_private; 1793 if (cfg == NULL) 1794 return (ENXIO); 1795 1796 sdata = SES_MALLOC(SAFT_SCRATCH); 1797 if (sdata == NULL) 1798 return (ENOMEM); 1799 1800 amt = SAFT_SCRATCH; 1801 err = ses_runcmd(ssc, cdb, 10, sdata, &amt); 1802 if (err) { 1803 SES_FREE(sdata, SAFT_SCRATCH); 1804 return (err); 1805 } 1806 amt = SAFT_SCRATCH - amt; 1807 if (amt < 6) { 1808 SES_LOG(ssc, "too little data (%d) for configuration\n", amt); 1809 SES_FREE(sdata, SAFT_SCRATCH); 1810 return (EIO); 1811 } 1812 SES_VLOG(ssc, "Nfans %d Npwr %d Nslots %d Lck %d Ntherm %d Nspkrs %d\n", 1813 sdata[0], sdata[1], sdata[2], sdata[3], sdata[4], sdata[5]); 1814 cfg->Nfans = sdata[0]; 1815 cfg->Npwr = sdata[1]; 1816 cfg->Nslots = sdata[2]; 1817 cfg->DoorLock = sdata[3]; 1818 cfg->Ntherm = sdata[4]; 1819 cfg->Nspkrs = sdata[5]; 1820 cfg->Nalarm = NPSEUDO_ALARM; 1821 SES_FREE(sdata, SAFT_SCRATCH); 1822 return (0); 1823 } 1824 1825 static int 1826 safte_rdstat(ses_softc_t *ssc, int slpflg) 1827 { 1828 int err, oid, r, i, hiwater, nitems, amt; 1829 uint16_t tempflags; 1830 size_t buflen; 1831 uint8_t status, oencstat; 1832 char *sdata, cdb[10]; 1833 struct scfg *cc = ssc->ses_private; 1834 1835 1836 /* 1837 * The number of objects overstates things a bit, 1838 * both for the bogus 'thermometer' entries and 1839 * the drive status (which isn't read at the same 1840 * time as the enclosure status), but that's okay. 1841 */ 1842 buflen = 4 * cc->Nslots; 1843 if (ssc->ses_nobjects > buflen) 1844 buflen = ssc->ses_nobjects; 1845 sdata = SES_MALLOC(buflen); 1846 if (sdata == NULL) 1847 return (ENOMEM); 1848 1849 cdb[0] = READ_BUFFER; 1850 cdb[1] = 1; 1851 cdb[2] = SAFTE_RD_RDESTS; 1852 cdb[3] = 0; 1853 cdb[4] = 0; 1854 cdb[5] = 0; 1855 cdb[6] = 0; 1856 cdb[7] = (buflen >> 8) & 0xff; 1857 cdb[8] = buflen & 0xff; 1858 cdb[9] = 0; 1859 amt = buflen; 1860 err = ses_runcmd(ssc, cdb, 10, sdata, &amt); 1861 if (err) { 1862 SES_FREE(sdata, buflen); 1863 return (err); 1864 } 1865 hiwater = buflen - amt; 1866 1867 1868 /* 1869 * invalidate all status bits. 1870 */ 1871 for (i = 0; i < ssc->ses_nobjects; i++) 1872 ssc->ses_objmap[i].svalid = 0; 1873 oencstat = ssc->ses_encstat & ALL_ENC_STAT; 1874 ssc->ses_encstat = 0; 1875 1876 1877 /* 1878 * Now parse returned buffer. 1879 * If we didn't get enough data back, 1880 * that's considered a fatal error. 1881 */ 1882 oid = r = 0; 1883 1884 for (nitems = i = 0; i < cc->Nfans; i++) { 1885 SAFT_BAIL(r, hiwater, sdata, buflen); 1886 /* 1887 * 0 = Fan Operational 1888 * 1 = Fan is malfunctioning 1889 * 2 = Fan is not present 1890 * 0x80 = Unknown or Not Reportable Status 1891 */ 1892 ssc->ses_objmap[oid].encstat[1] = 0; /* resvd */ 1893 ssc->ses_objmap[oid].encstat[2] = 0; /* resvd */ 1894 switch ((int)(uint8_t)sdata[r]) { 1895 case 0: 1896 nitems++; 1897 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 1898 /* 1899 * We could get fancier and cache 1900 * fan speeds that we have set, but 1901 * that isn't done now. 1902 */ 1903 ssc->ses_objmap[oid].encstat[3] = 7; 1904 break; 1905 1906 case 1: 1907 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_CRIT; 1908 /* 1909 * FAIL and FAN STOPPED synthesized 1910 */ 1911 ssc->ses_objmap[oid].encstat[3] = 0x40; 1912 /* 1913 * Enclosure marked with CRITICAL error 1914 * if only one fan or no thermometers, 1915 * else the NONCRITICAL error is set. 1916 */ 1917 if (cc->Nfans == 1 || cc->Ntherm == 0) 1918 ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; 1919 else 1920 ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; 1921 break; 1922 case 2: 1923 ssc->ses_objmap[oid].encstat[0] = 1924 SES_OBJSTAT_NOTINSTALLED; 1925 ssc->ses_objmap[oid].encstat[3] = 0; 1926 /* 1927 * Enclosure marked with CRITICAL error 1928 * if only one fan or no thermometers, 1929 * else the NONCRITICAL error is set. 1930 */ 1931 if (cc->Nfans == 1) 1932 ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; 1933 else 1934 ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; 1935 break; 1936 case 0x80: 1937 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNKNOWN; 1938 ssc->ses_objmap[oid].encstat[3] = 0; 1939 ssc->ses_encstat |= SES_ENCSTAT_INFO; 1940 break; 1941 default: 1942 ssc->ses_objmap[oid].encstat[0] = 1943 SES_OBJSTAT_UNSUPPORTED; 1944 SES_LOG(ssc, "Unknown fan%d status 0x%x\n", i, 1945 sdata[r] & 0xff); 1946 break; 1947 } 1948 ssc->ses_objmap[oid++].svalid = 1; 1949 r++; 1950 } 1951 1952 /* 1953 * No matter how you cut it, no cooling elements when there 1954 * should be some there is critical. 1955 */ 1956 if (cc->Nfans && nitems == 0) { 1957 ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; 1958 } 1959 1960 1961 for (i = 0; i < cc->Npwr; i++) { 1962 SAFT_BAIL(r, hiwater, sdata, buflen); 1963 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNKNOWN; 1964 ssc->ses_objmap[oid].encstat[1] = 0; /* resvd */ 1965 ssc->ses_objmap[oid].encstat[2] = 0; /* resvd */ 1966 ssc->ses_objmap[oid].encstat[3] = 0x20; /* requested on */ 1967 switch ((uint8_t)sdata[r]) { 1968 case 0x00: /* pws operational and on */ 1969 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 1970 break; 1971 case 0x01: /* pws operational and off */ 1972 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 1973 ssc->ses_objmap[oid].encstat[3] = 0x10; 1974 ssc->ses_encstat |= SES_ENCSTAT_INFO; 1975 break; 1976 case 0x10: /* pws is malfunctioning and commanded on */ 1977 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_CRIT; 1978 ssc->ses_objmap[oid].encstat[3] = 0x61; 1979 ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; 1980 break; 1981 1982 case 0x11: /* pws is malfunctioning and commanded off */ 1983 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_NONCRIT; 1984 ssc->ses_objmap[oid].encstat[3] = 0x51; 1985 ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; 1986 break; 1987 case 0x20: /* pws is not present */ 1988 ssc->ses_objmap[oid].encstat[0] = 1989 SES_OBJSTAT_NOTINSTALLED; 1990 ssc->ses_objmap[oid].encstat[3] = 0; 1991 ssc->ses_encstat |= SES_ENCSTAT_INFO; 1992 break; 1993 case 0x21: /* pws is present */ 1994 /* 1995 * This is for enclosures that cannot tell whether the 1996 * device is on or malfunctioning, but know that it is 1997 * present. Just fall through. 1998 */ 1999 /* FALLTHROUGH */ 2000 case 0x80: /* Unknown or Not Reportable Status */ 2001 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNKNOWN; 2002 ssc->ses_objmap[oid].encstat[3] = 0; 2003 ssc->ses_encstat |= SES_ENCSTAT_INFO; 2004 break; 2005 default: 2006 SES_LOG(ssc, "unknown power supply %d status (0x%x)\n", 2007 i, sdata[r] & 0xff); 2008 break; 2009 } 2010 ssc->ses_objmap[oid++].svalid = 1; 2011 r++; 2012 } 2013 2014 /* 2015 * Skip over Slot SCSI IDs 2016 */ 2017 r += cc->Nslots; 2018 2019 /* 2020 * We always have doorlock status, no matter what, 2021 * but we only save the status if we have one. 2022 */ 2023 SAFT_BAIL(r, hiwater, sdata, buflen); 2024 if (cc->DoorLock) { 2025 /* 2026 * 0 = Door Locked 2027 * 1 = Door Unlocked, or no Lock Installed 2028 * 0x80 = Unknown or Not Reportable Status 2029 */ 2030 ssc->ses_objmap[oid].encstat[1] = 0; 2031 ssc->ses_objmap[oid].encstat[2] = 0; 2032 switch ((uint8_t)sdata[r]) { 2033 case 0: 2034 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 2035 ssc->ses_objmap[oid].encstat[3] = 0; 2036 break; 2037 case 1: 2038 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 2039 ssc->ses_objmap[oid].encstat[3] = 1; 2040 break; 2041 case 0x80: 2042 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNKNOWN; 2043 ssc->ses_objmap[oid].encstat[3] = 0; 2044 ssc->ses_encstat |= SES_ENCSTAT_INFO; 2045 break; 2046 default: 2047 ssc->ses_objmap[oid].encstat[0] = 2048 SES_OBJSTAT_UNSUPPORTED; 2049 SES_LOG(ssc, "unknown lock status 0x%x\n", 2050 sdata[r] & 0xff); 2051 break; 2052 } 2053 ssc->ses_objmap[oid++].svalid = 1; 2054 } 2055 r++; 2056 2057 /* 2058 * We always have speaker status, no matter what, 2059 * but we only save the status if we have one. 2060 */ 2061 SAFT_BAIL(r, hiwater, sdata, buflen); 2062 if (cc->Nspkrs) { 2063 ssc->ses_objmap[oid].encstat[1] = 0; 2064 ssc->ses_objmap[oid].encstat[2] = 0; 2065 if (sdata[r] == 1) { 2066 /* 2067 * We need to cache tone urgency indicators. 2068 * Someday. 2069 */ 2070 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_NONCRIT; 2071 ssc->ses_objmap[oid].encstat[3] = 0x8; 2072 ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; 2073 } else if (sdata[r] == 0) { 2074 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 2075 ssc->ses_objmap[oid].encstat[3] = 0; 2076 } else { 2077 ssc->ses_objmap[oid].encstat[0] = 2078 SES_OBJSTAT_UNSUPPORTED; 2079 ssc->ses_objmap[oid].encstat[3] = 0; 2080 SES_LOG(ssc, "unknown spkr status 0x%x\n", 2081 sdata[r] & 0xff); 2082 } 2083 ssc->ses_objmap[oid++].svalid = 1; 2084 } 2085 r++; 2086 2087 for (i = 0; i < cc->Ntherm; i++) { 2088 SAFT_BAIL(r, hiwater, sdata, buflen); 2089 /* 2090 * Status is a range from -10 to 245 deg Celsius, 2091 * which we need to normalize to -20 to -245 according 2092 * to the latest SCSI spec, which makes little 2093 * sense since this would overflow an 8bit value. 2094 * Well, still, the base normalization is -20, 2095 * not -10, so we have to adjust. 2096 * 2097 * So what's over and under temperature? 2098 * Hmm- we'll state that 'normal' operating 2099 * is 10 to 40 deg Celsius. 2100 */ 2101 2102 /* 2103 * Actually.... All of the units that people out in the world 2104 * seem to have do not come even close to setting a value that 2105 * complies with this spec. 2106 * 2107 * The closest explanation I could find was in an 2108 * LSI-Logic manual, which seemed to indicate that 2109 * this value would be set by whatever the I2C code 2110 * would interpolate from the output of an LM75 2111 * temperature sensor. 2112 * 2113 * This means that it is impossible to use the actual 2114 * numeric value to predict anything. But we don't want 2115 * to lose the value. So, we'll propagate the *uncorrected* 2116 * value and set SES_OBJSTAT_NOTAVAIL. We'll depend on the 2117 * temperature flags for warnings. 2118 */ 2119 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_NOTAVAIL; 2120 ssc->ses_objmap[oid].encstat[1] = 0; 2121 ssc->ses_objmap[oid].encstat[2] = sdata[r]; 2122 ssc->ses_objmap[oid].encstat[3] = 0;; 2123 ssc->ses_objmap[oid++].svalid = 1; 2124 r++; 2125 } 2126 2127 /* 2128 * Now, for "pseudo" thermometers, we have two bytes 2129 * of information in enclosure status- 16 bits. Actually, 2130 * the MSB is a single TEMP ALERT flag indicating whether 2131 * any other bits are set, but, thanks to fuzzy thinking, 2132 * in the SAF-TE spec, this can also be set even if no 2133 * other bits are set, thus making this really another 2134 * binary temperature sensor. 2135 */ 2136 2137 SAFT_BAIL(r, hiwater, sdata, buflen); 2138 tempflags = sdata[r++]; 2139 SAFT_BAIL(r, hiwater, sdata, buflen); 2140 tempflags |= (tempflags << 8) | sdata[r++]; 2141 2142 for (i = 0; i < NPSEUDO_THERM; i++) { 2143 ssc->ses_objmap[oid].encstat[1] = 0; 2144 if (tempflags & (1 << (NPSEUDO_THERM - i - 1))) { 2145 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_CRIT; 2146 ssc->ses_objmap[4].encstat[2] = 0xff; 2147 /* 2148 * Set 'over temperature' failure. 2149 */ 2150 ssc->ses_objmap[oid].encstat[3] = 8; 2151 ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; 2152 } else { 2153 /* 2154 * We used to say 'not available' and synthesize a 2155 * nominal 30 deg (C)- that was wrong. Actually, 2156 * Just say 'OK', and use the reserved value of 2157 * zero. 2158 */ 2159 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 2160 ssc->ses_objmap[oid].encstat[2] = 0; 2161 ssc->ses_objmap[oid].encstat[3] = 0; 2162 } 2163 ssc->ses_objmap[oid++].svalid = 1; 2164 } 2165 2166 /* 2167 * Get alarm status. 2168 */ 2169 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 2170 ssc->ses_objmap[oid].encstat[3] = ssc->ses_objmap[oid].priv; 2171 ssc->ses_objmap[oid++].svalid = 1; 2172 2173 /* 2174 * Now get drive slot status 2175 */ 2176 cdb[2] = SAFTE_RD_RDDSTS; 2177 amt = buflen; 2178 err = ses_runcmd(ssc, cdb, 10, sdata, &amt); 2179 if (err) { 2180 SES_FREE(sdata, buflen); 2181 return (err); 2182 } 2183 hiwater = buflen - amt; 2184 for (r = i = 0; i < cc->Nslots; i++, r += 4) { 2185 SAFT_BAIL(r+3, hiwater, sdata, buflen); 2186 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNSUPPORTED; 2187 ssc->ses_objmap[oid].encstat[1] = (uint8_t) i; 2188 ssc->ses_objmap[oid].encstat[2] = 0; 2189 ssc->ses_objmap[oid].encstat[3] = 0; 2190 status = sdata[r+3]; 2191 if ((status & 0x1) == 0) { /* no device */ 2192 ssc->ses_objmap[oid].encstat[0] = 2193 SES_OBJSTAT_NOTINSTALLED; 2194 } else { 2195 ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; 2196 } 2197 if (status & 0x2) { 2198 ssc->ses_objmap[oid].encstat[2] = 0x8; 2199 } 2200 if ((status & 0x4) == 0) { 2201 ssc->ses_objmap[oid].encstat[3] = 0x10; 2202 } 2203 ssc->ses_objmap[oid++].svalid = 1; 2204 } 2205 /* see comment below about sticky enclosure status */ 2206 ssc->ses_encstat |= ENCI_SVALID | oencstat; 2207 SES_FREE(sdata, buflen); 2208 return (0); 2209 } 2210 2211 static int 2212 set_objstat_sel(ses_softc_t *ssc, ses_objstat *obp, int slp) 2213 { 2214 int idx; 2215 encobj *ep; 2216 struct scfg *cc = ssc->ses_private; 2217 2218 if (cc == NULL) 2219 return (0); 2220 2221 idx = (int)obp->obj_id; 2222 ep = &ssc->ses_objmap[idx]; 2223 2224 switch (ep->enctype) { 2225 case SESTYP_DEVICE: 2226 if (obp->cstat[0] & SESCTL_PRDFAIL) { 2227 ep->priv |= 0x40; 2228 } 2229 /* SESCTL_RSTSWAP has no correspondence in SAF-TE */ 2230 if (obp->cstat[0] & SESCTL_DISABLE) { 2231 ep->priv |= 0x80; 2232 /* 2233 * Hmm. Try to set the 'No Drive' flag. 2234 * Maybe that will count as a 'disable'. 2235 */ 2236 } 2237 if (ep->priv & 0xc6) { 2238 ep->priv &= ~0x1; 2239 } else { 2240 ep->priv |= 0x1; /* no errors */ 2241 } 2242 wrslot_stat(ssc, slp); 2243 break; 2244 case SESTYP_POWER: 2245 /* 2246 * Okay- the only one that makes sense here is to 2247 * do the 'disable' for a power supply. 2248 */ 2249 if (obp->cstat[0] & SESCTL_DISABLE) { 2250 (void) wrbuf16(ssc, SAFTE_WT_ACTPWS, 2251 idx - cc->pwroff, 0, 0, slp); 2252 } 2253 break; 2254 case SESTYP_FAN: 2255 /* 2256 * Okay- the only one that makes sense here is to 2257 * set fan speed to zero on disable. 2258 */ 2259 if (obp->cstat[0] & SESCTL_DISABLE) { 2260 /* remember- fans are the first items, so idx works */ 2261 (void) wrbuf16(ssc, SAFTE_WT_FANSPD, idx, 0, 0, slp); 2262 } 2263 break; 2264 case SESTYP_DOORLOCK: 2265 /* 2266 * Well, we can 'disable' the lock. 2267 */ 2268 if (obp->cstat[0] & SESCTL_DISABLE) { 2269 cc->flag2 &= ~SAFT_FLG2_LOCKDOOR; 2270 (void) wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, 2271 cc->flag2, 0, slp); 2272 } 2273 break; 2274 case SESTYP_ALARM: 2275 /* 2276 * Well, we can 'disable' the alarm. 2277 */ 2278 if (obp->cstat[0] & SESCTL_DISABLE) { 2279 cc->flag2 &= ~SAFT_FLG1_ALARM; 2280 ep->priv |= 0x40; /* Muted */ 2281 (void) wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, 2282 cc->flag2, 0, slp); 2283 } 2284 break; 2285 default: 2286 break; 2287 } 2288 ep->svalid = 0; 2289 return (0); 2290 } 2291 2292 /* 2293 * This function handles all of the 16 byte WRITE BUFFER commands. 2294 */ 2295 static int 2296 wrbuf16(ses_softc_t *ssc, uint8_t op, uint8_t b1, uint8_t b2, 2297 uint8_t b3, int slp) 2298 { 2299 int err, amt; 2300 char *sdata; 2301 struct scfg *cc = ssc->ses_private; 2302 static char cdb[10] = { WRITE_BUFFER, 1, 0, 0, 0, 0, 0, 0, 16, 0 }; 2303 2304 if (cc == NULL) 2305 return (0); 2306 2307 sdata = SES_MALLOC(16); 2308 if (sdata == NULL) 2309 return (ENOMEM); 2310 2311 SES_VLOG(ssc, "saf_wrbuf16 %x %x %x %x\n", op, b1, b2, b3); 2312 2313 sdata[0] = op; 2314 sdata[1] = b1; 2315 sdata[2] = b2; 2316 sdata[3] = b3; 2317 MEMZERO(&sdata[4], 12); 2318 amt = -16; 2319 err = ses_runcmd(ssc, cdb, 10, sdata, &amt); 2320 SES_FREE(sdata, 16); 2321 return (err); 2322 } 2323 2324 /* 2325 * This function updates the status byte for the device slot described. 2326 * 2327 * Since this is an optional SAF-TE command, there's no point in 2328 * returning an error. 2329 */ 2330 static void 2331 wrslot_stat(ses_softc_t *ssc, int slp) 2332 { 2333 int i, amt; 2334 encobj *ep; 2335 char cdb[10], *sdata; 2336 struct scfg *cc = ssc->ses_private; 2337 2338 if (cc == NULL) 2339 return; 2340 2341 SES_VLOG(ssc, "saf_wrslot\n"); 2342 cdb[0] = WRITE_BUFFER; 2343 cdb[1] = 1; 2344 cdb[2] = 0; 2345 cdb[3] = 0; 2346 cdb[4] = 0; 2347 cdb[5] = 0; 2348 cdb[6] = 0; 2349 cdb[7] = 0; 2350 cdb[8] = cc->Nslots * 3 + 1; 2351 cdb[9] = 0; 2352 2353 sdata = SES_MALLOC(cc->Nslots * 3 + 1); 2354 if (sdata == NULL) 2355 return; 2356 MEMZERO(sdata, cc->Nslots * 3 + 1); 2357 2358 sdata[0] = SAFTE_WT_DSTAT; 2359 for (i = 0; i < cc->Nslots; i++) { 2360 ep = &ssc->ses_objmap[cc->slotoff + i]; 2361 SES_VLOG(ssc, "saf_wrslot %d <- %x\n", i, ep->priv & 0xff); 2362 sdata[1 + (3 * i)] = ep->priv & 0xff; 2363 } 2364 amt = -(cc->Nslots * 3 + 1); 2365 (void) ses_runcmd(ssc, cdb, 10, sdata, &amt); 2366 SES_FREE(sdata, cc->Nslots * 3 + 1); 2367 } 2368 2369 /* 2370 * This function issues the "PERFORM SLOT OPERATION" command. 2371 */ 2372 static int 2373 perf_slotop(ses_softc_t *ssc, uint8_t slot, uint8_t opflag, int slp) 2374 { 2375 int err, amt; 2376 char *sdata; 2377 struct scfg *cc = ssc->ses_private; 2378 static char cdb[10] = 2379 { WRITE_BUFFER, 1, 0, 0, 0, 0, 0, 0, SAFT_SCRATCH, 0 }; 2380 2381 if (cc == NULL) 2382 return (0); 2383 2384 sdata = SES_MALLOC(SAFT_SCRATCH); 2385 if (sdata == NULL) 2386 return (ENOMEM); 2387 MEMZERO(sdata, SAFT_SCRATCH); 2388 2389 sdata[0] = SAFTE_WT_SLTOP; 2390 sdata[1] = slot; 2391 sdata[2] = opflag; 2392 SES_VLOG(ssc, "saf_slotop slot %d op %x\n", slot, opflag); 2393 amt = -SAFT_SCRATCH; 2394 err = ses_runcmd(ssc, cdb, 10, sdata, &amt); 2395 SES_FREE(sdata, SAFT_SCRATCH); 2396 return (err); 2397 } 2398