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