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