diff options
Diffstat (limited to 'sys/scsi')
| -rw-r--r-- | sys/scsi/files.scsi | 6 | ||||
| -rw-r--r-- | sys/scsi/ses.c | 2449 | ||||
| -rw-r--r-- | sys/scsi/ses.h | 175 |
3 files changed, 2629 insertions, 1 deletions
diff --git a/sys/scsi/files.scsi b/sys/scsi/files.scsi index feeadd36fab..0eed8b3a20a 100644 --- a/sys/scsi/files.scsi +++ b/sys/scsi/files.scsi @@ -1,4 +1,4 @@ -# $OpenBSD: files.scsi,v 1.8 1999/07/25 10:53:11 deraadt Exp $ +# $OpenBSD: files.scsi,v 1.9 2000/02/21 08:24:00 mjacob Exp $ # $NetBSD: files.scsi,v 1.4 1996/05/16 04:01:08 mycroft Exp $ # # Config.new file and device description for machine-independent SCSI code. @@ -29,6 +29,10 @@ file scsi/sd.c sd needs-flag file scsi/sd_atapi.c sd needs-flag file scsi/sd_scsi.c sd needs-flag +device ses: disk +attach ses at scsibus +file scsi/ses.c ses needs-flag + device st: tape attach st at scsibus file scsi/st.c st needs-flag diff --git a/sys/scsi/ses.c b/sys/scsi/ses.c new file mode 100644 index 00000000000..03656019f52 --- /dev/null +++ b/sys/scsi/ses.c @@ -0,0 +1,2449 @@ +/* $OpenBSD: ses.c,v 1.1 2000/02/21 08:23:30 mjacob Exp $ */ +/* $NetBSD: ses.c,v 1.3 2000/01/21 21:19:57 mjacob Exp $ */ +/* + * Copyright (C) 2000 National Aeronautics & Space Administration + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Author: mjacob@nas.nasa.gov + */ + + +#ifdef __NetBSD__ +#include "opt_scsi.h" +#endif + +#include <sys/types.h> +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/ioctl.h> +#include <sys/scsiio.h> +#include <sys/buf.h> +#include <sys/uio.h> +#include <sys/malloc.h> +#include <sys/errno.h> +#include <sys/device.h> +#include <sys/disklabel.h> +#include <sys/disk.h> +#include <sys/proc.h> +#include <sys/conf.h> +#include <sys/vnode.h> +#include <machine/stdarg.h> + +#ifdef __NetBSD__ +#include <dev/scsipi/scsipi_all.h> +#include <dev/scsipi/scsi_all.h> +#include <dev/scsipi/scsipi_disk.h> +#include <dev/scsipi/scsi_disk.h> +#include <dev/scsipi/scsiconf.h> +#include <dev/scsipi/ses.h> +#else +#include <scsi/scsi_all.h> +#include <scsi/scsi_disk.h> +#include <scsi/scsiconf.h> +#include <scsi/ses.h> +#define scsipi_link scsi_link +#define scsipibus_attach_args scsibus_attach_args +#define scsipi_device scsi_device +#define sa_inqptr sa_inqbuf +#define SCSIPIRETRIES 4 +#define scsipi_generic scsi_generic +#define scsipi_command scsi_scsi_cmd +#define scsipi_inquiry_data scsi_inquiry_data +#define scsipi_do_ioctl scsi_do_ioctl +#define scsipi_wait_drain(x) +#define scsipi_adapter_addref(x) 0 +#define scsipi_adapter_delref(x) +#define XS_CTL_DATA_IN SCSI_DATA_IN +#define XS_CTL_DATA_OUT SCSI_DATA_OUT +#define XS_CTL_DISCOVERY SCSI_AUTOCONF +#define XS_CTL_SILENT SCSI_SILENT +#endif + +/* + * Platform Independent Driver Internal Definitions for SES devices. + */ +typedef enum { + SES_NONE, + SES_SES_SCSI2, + SES_SES, + SES_SES_PASSTHROUGH, + SES_SEN, + SES_SAFT +} enctyp; + +struct ses_softc; +typedef struct ses_softc ses_softc_t; +typedef struct { + int (*softc_init) __P((ses_softc_t *, int)); + int (*init_enc) __P((ses_softc_t *)); + int (*get_encstat) __P((ses_softc_t *, int)); + int (*set_encstat) __P((ses_softc_t *, ses_encstat, int)); + int (*get_objstat) __P((ses_softc_t *, ses_objstat *, int)); + int (*set_objstat) __P((ses_softc_t *, ses_objstat *, int)); +} encvec; + +#define ENCI_SVALID 0x80 + +typedef struct { + uint32_t + enctype : 8, /* enclosure type */ + subenclosure : 8, /* subenclosure id */ + svalid : 1, /* enclosure information valid */ + priv : 15; /* private data, per object */ + uint8_t encstat[4]; /* state && stats */ +} encobj; + +#define SEN_ID "UNISYS SUN_SEN" +#define SEN_ID_LEN 24 + +static enctyp ses_type __P((void *, int)); + + +/* Forward reference to Enclosure Functions */ +static int ses_softc_init __P((ses_softc_t *, int)); +static int ses_init_enc __P((ses_softc_t *)); +static int ses_get_encstat __P((ses_softc_t *, int)); +static int ses_set_encstat __P((ses_softc_t *, uint8_t, int)); +static int ses_get_objstat __P((ses_softc_t *, ses_objstat *, int)); +static int ses_set_objstat __P((ses_softc_t *, ses_objstat *, int)); + +static int safte_softc_init __P((ses_softc_t *, int)); +static int safte_init_enc __P((ses_softc_t *)); +static int safte_get_encstat __P((ses_softc_t *, int)); +static int safte_set_encstat __P((ses_softc_t *, uint8_t, int)); +static int safte_get_objstat __P((ses_softc_t *, ses_objstat *, int)); +static int safte_set_objstat __P((ses_softc_t *, ses_objstat *, int)); + +/* + * Platform implementation defines/functions for SES internal kernel stuff + */ + +#define STRNCMP strncmp +#define PRINTF printf +#define SES_LOG ses_log +#if defined(DEBUG) +#define SES_DLOG ses_log +#else +#define SES_DLOG if (0) ses_log +#endif +#if defined(DEBUG) || defined(SCSIDEBUG) +#define SES_VLOG ses_log +#else +#define SES_VLOG if (0) ses_log +#endif +#define SES_MALLOC(amt) malloc(amt, M_DEVBUF, M_NOWAIT) +#define SES_FREE(ptr, amt) free(ptr, M_DEVBUF) +#define MEMZERO bzero +#define MEMCPY(dest, src, amt) bcopy(src, dest, amt) +#define RECEIVE_DIAGNOSTIC 0x1c +#define SEND_DIAGNOSTIC 0x1d +#define WRITE_BUFFER 0x3b +#define READ_BUFFER 0x3c + +int sesopen __P((dev_t, int, int, struct proc *)); +int sesclose __P((dev_t, int, int, struct proc *)); +int sesioctl __P((dev_t, u_long, caddr_t, int, struct proc *)); + +static int ses_runcmd __P((struct ses_softc *, char *, int, char *, int *)); +static void ses_log __P((struct ses_softc *, const char *, ...)); + +/* + * General NetBSD kernel stuff. + */ + +struct ses_softc { + struct device sc_device; + struct scsipi_link *sc_link; + enctyp ses_type; /* type of enclosure */ + encvec ses_vec; /* vector to handlers */ + void * ses_private; /* per-type private data */ + encobj * ses_objmap; /* objects */ + u_int32_t ses_nobjects; /* number of objects */ + ses_encstat ses_encstat; /* overall status */ + u_int8_t ses_flags; +}; +#define SES_FLAG_INVALID 0x01 +#define SES_FLAG_OPEN 0x02 +#define SES_FLAG_INITIALIZED 0x04 + +#define SESUNIT(x) (minor((x))) + +#ifdef __NetBSD__ +#define MATCHTYPE struct cfdata +#else +#define MATCHTYPE void +#endif + +static int ses_match __P((struct device *, MATCHTYPE *, void *)); +static void ses_attach __P((struct device *, struct device *, void *)); +static enctyp ses_device_type __P((struct scsipibus_attach_args *)); + +struct cfattach ses_ca = { + sizeof (struct ses_softc), ses_match, ses_attach +}; + +#ifdef __NetBSD__ +extern struct cfdriver ses_cd; +#else +struct cfdriver ses_cd = { + NULL, "ses", DV_DULL +}; +#endif + +struct scsipi_device ses_switch = { + NULL, + NULL, + NULL, + NULL +}; + + +int +ses_match(parent, matcharg, aux) + struct device *parent; + MATCHTYPE *matcharg; + void *aux; +{ + struct scsipibus_attach_args *sa = aux; + matcharg = matcharg; + switch (ses_device_type(sa)) { + case SES_SES: + case SES_SES_SCSI2: + case SES_SEN: + case SES_SAFT: + case SES_SES_PASSTHROUGH: + /* + * For these devices, it's a perfect match. + */ + return (24); + default: + return (0); + } +} + + +/* + * Complete the attachment. + * + * We have to repeat the rerun of INQUIRY data as above because + * it's not until the return from the match routine that we have + * the softc available to set stuff in. + */ +void +ses_attach(parent, self, aux) + struct device *parent; + struct device *self; + void *aux; +{ + char *tname; + struct ses_softc *softc = (void *)self; + struct scsipibus_attach_args *sa = aux; + struct scsipi_link *sc_link = sa->sa_sc_link; + + SC_DEBUG(sc_link, SDEV_DB2, ("ssattach: ")); + softc->sc_link = sa->sa_sc_link; + sc_link->device = &ses_switch; + sc_link->device_softc = softc; + sc_link->openings = 1; + + softc->ses_type = ses_device_type(sa); + switch (softc->ses_type) { + case SES_SES: + case SES_SES_SCSI2: + case SES_SES_PASSTHROUGH: + softc->ses_vec.softc_init = ses_softc_init; + softc->ses_vec.init_enc = ses_init_enc; + softc->ses_vec.get_encstat = ses_get_encstat; + softc->ses_vec.set_encstat = ses_set_encstat; + softc->ses_vec.get_objstat = ses_get_objstat; + softc->ses_vec.set_objstat = ses_set_objstat; + break; + case SES_SAFT: + softc->ses_vec.softc_init = safte_softc_init; + softc->ses_vec.init_enc = safte_init_enc; + softc->ses_vec.get_encstat = safte_get_encstat; + softc->ses_vec.set_encstat = safte_set_encstat; + softc->ses_vec.get_objstat = safte_get_objstat; + softc->ses_vec.set_objstat = safte_set_objstat; + break; + case SES_SEN: + break; + case SES_NONE: + default: + break; + } + + switch (softc->ses_type) { + default: + case SES_NONE: + tname = "No SES device"; + break; + case SES_SES_SCSI2: + tname = "SCSI-2 SES Device"; + break; + case SES_SES: + tname = "SCSI-3 SES Device"; + break; + case SES_SES_PASSTHROUGH: + tname = "SES Passthrough Device"; + break; + case SES_SEN: + tname = "UNISYS SEN Device (NOT HANDLED YET)"; + break; + case SES_SAFT: + tname = "SAF-TE Compliant Device"; + break; + } + printf("\n%s: %s\n", softc->sc_device.dv_xname, tname); +} + + +#define NETBSD_SAFTE_END 50 + +static enctyp +ses_device_type(sa) + struct scsipibus_attach_args *sa; +{ + struct scsipi_inquiry_data *inqp = sa->sa_inqptr; + int length; + + if (inqp == NULL) + return (SES_NONE); + +#ifdef __NetBSD__ + /* + * If we can get longer data to check for the + * presence of a SAF-TE device, try and do so. + * + * Because we do deferred target attach in NetBSD, + * we don't have to run this as a polled command. + */ + + if (inqp->additional_length >= NETBSD_SAFTE_END-4) { + size_t amt = inqp->additional_length + 4; + struct scsipi_generic cmd; + static u_char more[64]; + + bzero(&cmd, sizeof(cmd)); + cmd.opcode = INQUIRY; + cmd.bytes[3] = amt; + if (scsipi_command(sa->sa_sc_link, &cmd, 6, more, amt, + SCSIPIRETRIES, 10000, NULL, + XS_CTL_DATA_IN | XS_CTL_DISCOVERY) == 0) { + length = amt; + inqp = (struct scsipi_inquiry_data *) more; + } + } else +#endif + length = sizeof (struct scsipi_inquiry_data); + return (ses_type(inqp, length)); +} + +int +sesopen(dev, flags, fmt, p) + dev_t dev; + int flags; + int fmt; + struct proc *p; +{ + struct ses_softc *softc; + int error, unit; + + unit = SESUNIT(dev); + if (unit >= ses_cd.cd_ndevs) + return (ENXIO); + softc = ses_cd.cd_devs[unit]; + if (softc == NULL) + return (ENXIO); + + if (softc->ses_flags & SES_FLAG_INVALID) { + error = ENXIO; + goto out; + } + if (softc->ses_flags & SES_FLAG_OPEN) { + error = EBUSY; + goto out; + } + if (softc->ses_vec.softc_init == NULL) { + error = ENXIO; + goto out; + } + error = scsipi_adapter_addref(softc->sc_link); + if (error != 0) + goto out; + + + softc->ses_flags |= SES_FLAG_OPEN; + if ((softc->ses_flags & SES_FLAG_INITIALIZED) == 0) { + error = (*softc->ses_vec.softc_init)(softc, 1); + if (error) + softc->ses_flags &= ~SES_FLAG_OPEN; + else + softc->ses_flags |= SES_FLAG_INITIALIZED; + } + +out: + return (error); +} + +int +sesclose(dev, flags, fmt, p) + dev_t dev; + int flags; + int fmt; + struct proc *p; +{ + struct ses_softc *softc; + int unit; + + unit = SESUNIT(dev); + if (unit >= ses_cd.cd_ndevs) + return (ENXIO); + softc = ses_cd.cd_devs[unit]; + if (softc == NULL) + return (ENXIO); + + scsipi_wait_drain(softc->sc_link); + scsipi_adapter_delref(softc->sc_link); + softc->ses_flags &= ~SES_FLAG_OPEN; + return (0); +} + +int +sesioctl(dev, cmd, arg_addr, flag, p) + dev_t dev; + u_long cmd; + caddr_t arg_addr; + int flag; + struct proc *p; +{ + ses_encstat tmp; + ses_objstat objs; + ses_object obj, *uobj; + struct ses_softc *ssc = ses_cd.cd_devs[SESUNIT(dev)]; + void *addr; + int error, i; + + + if (arg_addr) + addr = *((caddr_t *) arg_addr); + else + addr = NULL; + + SC_DEBUG(ssc->sc_link, SDEV_DB2, ("sesioctl 0x%lx ", cmd)); + + /* + * Now check to see whether we're initialized or not. + */ + if ((ssc->ses_flags & SES_FLAG_INITIALIZED) == 0) { + return (ENODEV); + } + + error = 0; + + /* + * If this command can change the device's state, + * we must have the device open for writing. + */ + switch (cmd) { + case SESIOC_GETNOBJ: + case SESIOC_GETOBJMAP: + case SESIOC_GETENCSTAT: + case SESIOC_GETOBJSTAT: + break; + default: + if ((flag & FWRITE) == 0) { + return (EBADF); + } + } + + switch (cmd) { + case SESIOC_GETNOBJ: + error = copyout(&ssc->ses_nobjects, addr, + sizeof (ssc->ses_nobjects)); + break; + + case SESIOC_GETOBJMAP: + for (uobj = addr, i = 0; i != ssc->ses_nobjects; i++, uobj++) { + obj.obj_id = i; + obj.subencid = ssc->ses_objmap[i].subenclosure; + obj.object_type = ssc->ses_objmap[i].enctype; + error = copyout(&obj, uobj, sizeof (ses_object)); + if (error) { + break; + } + } + break; + + case SESIOC_GETENCSTAT: + error = (*ssc->ses_vec.get_encstat)(ssc, 1); + if (error) + break; + tmp = ssc->ses_encstat & ~ENCI_SVALID; + error = copyout(&tmp, addr, sizeof (ses_encstat)); + ssc->ses_encstat = tmp; + break; + + case SESIOC_SETENCSTAT: + error = copyin(addr, &tmp, sizeof (ses_encstat)); + if (error) + break; + error = (*ssc->ses_vec.set_encstat)(ssc, tmp, 1); + break; + + case SESIOC_GETOBJSTAT: + error = copyin(addr, &objs, sizeof (ses_objstat)); + if (error) + break; + if (objs.obj_id >= ssc->ses_nobjects) { + error = EINVAL; + break; + } + error = (*ssc->ses_vec.get_objstat)(ssc, &objs, 1); + if (error) + break; + error = copyout(&objs, addr, sizeof (ses_objstat)); + /* + * Always (for now) invalidate entry. + */ + ssc->ses_objmap[objs.obj_id].svalid = 0; + break; + + case SESIOC_SETOBJSTAT: + error = copyin(addr, &objs, sizeof (ses_objstat)); + if (error) + break; + + if (objs.obj_id >= ssc->ses_nobjects) { + error = EINVAL; + break; + } + error = (*ssc->ses_vec.set_objstat)(ssc, &objs, 1); + + /* + * Always (for now) invalidate entry. + */ + ssc->ses_objmap[objs.obj_id].svalid = 0; + break; + + case SESIOC_INIT: + + error = (*ssc->ses_vec.init_enc)(ssc); + break; + + default: + error = scsipi_do_ioctl(ssc->sc_link, dev, cmd, addr, flag, p); + break; + } + return (error); +} + +static int +ses_runcmd(struct ses_softc *ssc, char *cdb, int cdbl, char *dptr, int *dlenp) +{ + struct scsipi_generic sgen; + int dl, flg, error; + + if (dptr) { + if ((dl = *dlenp) < 0) { + dl = -dl; + flg = XS_CTL_DATA_OUT; + } else { + flg = XS_CTL_DATA_IN; + } + } else { + dl = 0; + flg = 0; + } + + if (cdbl > sizeof (struct scsipi_generic)) { + cdbl = sizeof (struct scsipi_generic); + } + bcopy(cdb, &sgen, cdbl); +#ifndef SCSIDEBUG + flg |= XS_CTL_SILENT; +#endif + error = scsipi_command(ssc->sc_link, &sgen, cdbl, + (u_char *) dptr, dl, SCSIPIRETRIES, 30000, NULL, flg); + + if (error == 0 && dptr) + *dlenp = 0; + + return (error); +} + +#ifdef __STDC__ +static void +ses_log(struct ses_softc *ssc, const char *fmt, ...) +{ + va_list ap; + + printf("%s: ", ssc->sc_device.dv_xname); + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); +} +#else +static void +ses_log(ssc, fmt, va_alist) + struct ses_softc *ssc; + char *fmt; + va_dcl +{ + va_list ap; + + printf("%s: ", ssc->sc_device.dv_xname); + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); +} +#endif + +/* + * The code after this point runs on many platforms, + * so forgive the slightly awkward and nonconforming + * appearance. + */ + +/* + * Is this a device that supports enclosure services? + * + * It's a a pretty simple ruleset- if it is device type 0x0D (13), it's + * an SES device. If it happens to be an old UNISYS SEN device, we can + * handle that too. + */ + +#define SAFTE_START 44 +#define SAFTE_END 50 +#define SAFTE_LEN SAFTE_END-SAFTE_START + +static enctyp +ses_type(void *buf, int buflen) +{ + unsigned char *iqd = buf; + + if (buflen < 8+SEN_ID_LEN) + return (SES_NONE); + + if ((iqd[0] & 0x1f) == T_ENCLOSURE) { + if (STRNCMP(&iqd[8], SEN_ID, SEN_ID_LEN) == 0) { + return (SES_SEN); + } else if ((iqd[2] & 0x7) > 2) { + return (SES_SES); + } else { + return (SES_SES_SCSI2); + } + return (SES_NONE); + } + +#ifdef SES_ENABLE_PASSTHROUGH + if ((iqd[6] & 0x40) && (iqd[2] & 0x7) >= 2) { + /* + * PassThrough Device. + */ + return (SES_SES_PASSTHROUGH); + } +#endif + + /* + * The comparison is short for a reason- + * some vendors were chopping it short. + */ + + if (buflen < SAFTE_END - 2) { + return (SES_NONE); + } + + if (STRNCMP((char *)&iqd[SAFTE_START], "SAF-TE", SAFTE_LEN - 2) == 0) { + return (SES_SAFT); + } + return (SES_NONE); +} + +/* + * SES Native Type Device Support + */ + +/* + * SES Diagnostic Page Codes + */ + +typedef enum { + SesConfigPage = 0x1, + SesControlPage, +#define SesStatusPage SesControlPage + SesHelpTxt, + SesStringOut, +#define SesStringIn SesStringOut + SesThresholdOut, +#define SesThresholdIn SesThresholdOut + SesArrayControl, +#define SesArrayStatus SesArrayControl + SesElementDescriptor, + SesShortStatus +} SesDiagPageCodes; + +/* + * minimal amounts + */ + +/* + * Minimum amount of data, starting from byte 0, to have + * the config header. + */ +#define SES_CFGHDR_MINLEN 12 + +/* + * Minimum amount of data, starting from byte 0, to have + * the config header and one enclosure header. + */ +#define SES_ENCHDR_MINLEN 48 + +/* + * Take this value, subtract it from VEnclen and you know + * the length of the vendor unique bytes. + */ +#define SES_ENCHDR_VMIN 36 + +/* + * SES Data Structures + */ + +typedef struct { + uint32_t GenCode; /* Generation Code */ + uint8_t Nsubenc; /* Number of Subenclosures */ +} SesCfgHdr; + +typedef struct { + uint8_t Subencid; /* SubEnclosure Identifier */ + uint8_t Ntypes; /* # of supported types */ + uint8_t VEnclen; /* Enclosure Descriptor Length */ +} SesEncHdr; + +typedef struct { + uint8_t encWWN[8]; /* XXX- Not Right Yet */ + uint8_t encVid[8]; + uint8_t encPid[16]; + uint8_t encRev[4]; + uint8_t encVen[1]; +} SesEncDesc; + +typedef struct { + uint8_t enc_type; /* type of element */ + uint8_t enc_maxelt; /* maximum supported */ + uint8_t enc_subenc; /* in SubEnc # N */ + uint8_t enc_tlen; /* Type Descriptor Text Length */ +} SesThdr; + +typedef struct { + uint8_t comstatus; + uint8_t comstat[3]; +} SesComStat; + +struct typidx { + int ses_tidx; + int ses_oidx; +}; + +struct sscfg { + uint8_t ses_ntypes; /* total number of types supported */ + + /* + * We need to keep a type index as well as an + * object index for each object in an enclosure. + */ + struct typidx *ses_typidx; + + /* + * We also need to keep track of the number of elements + * per type of element. This is needed later so that we + * can find precisely in the returned status data the + * status for the Nth element of the Kth type. + */ + uint8_t * ses_eltmap; +}; + + +/* + * (de)canonicalization defines + */ +#define sbyte(x, byte) ((((uint32_t)(x)) >> (byte * 8)) & 0xff) +#define sbit(x, bit) (((uint32_t)(x)) << bit) +#define sset8(outp, idx, sval) (((uint8_t *)(outp))[idx++]) = sbyte(sval, 0) + +#define sset16(outp, idx, sval) \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 1), \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 0) + + +#define sset24(outp, idx, sval) \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 2), \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 1), \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 0) + + +#define sset32(outp, idx, sval) \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 3), \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 2), \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 1), \ + (((uint8_t *)(outp))[idx++]) = sbyte(sval, 0) + +#define gbyte(x, byte) ((((uint32_t)(x)) & 0xff) << (byte * 8)) +#define gbit(lv, in, idx, shft, mask) lv = ((in[idx] >> shft) & mask) +#define sget8(inp, idx, lval) lval = (((uint8_t *)(inp))[idx++]) +#define gget8(inp, idx, lval) lval = (((uint8_t *)(inp))[idx]) + +#define sget16(inp, idx, lval) \ + lval = gbyte((((uint8_t *)(inp))[idx]), 1) | \ + (((uint8_t *)(inp))[idx+1]), idx += 2 + +#define gget16(inp, idx, lval) \ + lval = gbyte((((uint8_t *)(inp))[idx]), 1) | \ + (((uint8_t *)(inp))[idx+1]) + +#define sget24(inp, idx, lval) \ + lval = gbyte((((uint8_t *)(inp))[idx]), 2) | \ + gbyte((((uint8_t *)(inp))[idx+1]), 1) | \ + (((uint8_t *)(inp))[idx+2]), idx += 3 + +#define gget24(inp, idx, lval) \ + lval = gbyte((((uint8_t *)(inp))[idx]), 2) | \ + gbyte((((uint8_t *)(inp))[idx+1]), 1) | \ + (((uint8_t *)(inp))[idx+2]) + +#define sget32(inp, idx, lval) \ + lval = gbyte((((uint8_t *)(inp))[idx]), 3) | \ + gbyte((((uint8_t *)(inp))[idx+1]), 2) | \ + gbyte((((uint8_t *)(inp))[idx+2]), 1) | \ + (((uint8_t *)(inp))[idx+3]), idx += 4 + +#define gget32(inp, idx, lval) \ + lval = gbyte((((uint8_t *)(inp))[idx]), 3) | \ + gbyte((((uint8_t *)(inp))[idx+1]), 2) | \ + gbyte((((uint8_t *)(inp))[idx+2]), 1) | \ + (((uint8_t *)(inp))[idx+3]) + +#define SCSZ 0x2000 +#define CFLEN (256 + SES_ENCHDR_MINLEN) + +/* + * Routines specific && private to SES only + */ + +static int ses_getconfig(ses_softc_t *); +static int ses_getputstat(ses_softc_t *, int, SesComStat *, int, int); +static int ses_cfghdr(uint8_t *, int, SesCfgHdr *); +static int ses_enchdr(uint8_t *, int, uint8_t, SesEncHdr *); +static int ses_encdesc(uint8_t *, int, uint8_t, SesEncDesc *); +static int ses_getthdr(uint8_t *, int, int, SesThdr *); +static int ses_decode(char *, int, uint8_t *, int, int, SesComStat *); +static int ses_encode(char *, int, uint8_t *, int, int, SesComStat *); + +static int +ses_softc_init(ses_softc_t *ssc, int doinit) +{ + if (doinit == 0) { + struct sscfg *cc; + if (ssc->ses_nobjects) { + SES_FREE(ssc->ses_objmap, + ssc->ses_nobjects * sizeof (encobj)); + ssc->ses_objmap = NULL; + } + if ((cc = ssc->ses_private) != NULL) { + if (cc->ses_eltmap && cc->ses_ntypes) { + SES_FREE(cc->ses_eltmap, cc->ses_ntypes); + cc->ses_eltmap = NULL; + cc->ses_ntypes = 0; + } + if (cc->ses_typidx && ssc->ses_nobjects) { + SES_FREE(cc->ses_typidx, + ssc->ses_nobjects * sizeof (struct typidx)); + cc->ses_typidx = NULL; + } + SES_FREE(cc, sizeof (struct sscfg)); + ssc->ses_private = NULL; + } + ssc->ses_nobjects = 0; + return (0); + } + if (ssc->ses_private == NULL) { + ssc->ses_private = SES_MALLOC(sizeof (struct sscfg)); + } + if (ssc->ses_private == NULL) { + return (ENOMEM); + } + ssc->ses_nobjects = 0; + ssc->ses_encstat = 0; + return (ses_getconfig(ssc)); +} + +static int +ses_init_enc(ses_softc_t *ssc) +{ + return (0); +} + +static int +ses_get_encstat(ses_softc_t *ssc, int slpflag) +{ + SesComStat ComStat; + int status; + + if ((status = ses_getputstat(ssc, -1, &ComStat, slpflag, 1)) != 0) { + return (status); + } + ssc->ses_encstat = ComStat.comstatus | ENCI_SVALID; + return (0); +} + +static int +ses_set_encstat(ses_softc_t *ssc, uint8_t encstat, int slpflag) +{ + SesComStat ComStat; + int status; + + ComStat.comstatus = encstat & 0xf; + if ((status = ses_getputstat(ssc, -1, &ComStat, slpflag, 0)) != 0) { + return (status); + } + ssc->ses_encstat = encstat & 0xf; /* note no SVALID set */ + return (0); +} + +static int +ses_get_objstat(ses_softc_t *ssc, ses_objstat *obp, int slpflag) +{ + int i = (int)obp->obj_id; + + if (ssc->ses_objmap[i].svalid == 0) { + SesComStat ComStat; + int err = ses_getputstat(ssc, i, &ComStat, slpflag, 1); + if (err) + return (err); + ssc->ses_objmap[i].encstat[0] = ComStat.comstatus; + ssc->ses_objmap[i].encstat[1] = ComStat.comstat[0]; + ssc->ses_objmap[i].encstat[2] = ComStat.comstat[1]; + ssc->ses_objmap[i].encstat[3] = ComStat.comstat[2]; + ssc->ses_objmap[i].svalid = 1; + } + obp->cstat[0] = ssc->ses_objmap[i].encstat[0]; + obp->cstat[1] = ssc->ses_objmap[i].encstat[1]; + obp->cstat[2] = ssc->ses_objmap[i].encstat[2]; + obp->cstat[3] = ssc->ses_objmap[i].encstat[3]; + return (0); +} + +static int +ses_set_objstat(ses_softc_t *ssc, ses_objstat *obp, int slpflag) +{ + SesComStat ComStat; + int err; + /* + * If this is clear, we don't do diddly. + */ + if ((obp->cstat[0] & SESCTL_CSEL) == 0) { + return (0); + } + ComStat.comstatus = obp->cstat[0]; + ComStat.comstat[0] = obp->cstat[1]; + ComStat.comstat[1] = obp->cstat[2]; + ComStat.comstat[2] = obp->cstat[3]; + err = ses_getputstat(ssc, (int)obp->obj_id, &ComStat, slpflag, 0); + ssc->ses_objmap[(int)obp->obj_id].svalid = 0; + return (err); +} + +static int +ses_getconfig(ses_softc_t *ssc) +{ + struct sscfg *cc; + SesCfgHdr cf; + SesEncHdr hd; + SesEncDesc *cdp; + SesThdr thdr; + int err, amt, i, nobj, ntype, maxima; + char storage[CFLEN], *sdata; + static char cdb[6] = { + RECEIVE_DIAGNOSTIC, 0x1, SesConfigPage, SCSZ >> 8, SCSZ & 0xff, 0 + }; + + cc = ssc->ses_private; + if (cc == NULL) { + return (ENXIO); + } + + sdata = SES_MALLOC(SCSZ); + if (sdata == NULL) + return (ENOMEM); + + amt = SCSZ; + err = ses_runcmd(ssc, cdb, 6, sdata, &amt); + if (err) { + SES_FREE(sdata, SCSZ); + return (err); + } + amt = SCSZ - amt; + + if (ses_cfghdr((uint8_t *) sdata, amt, &cf)) { + SES_LOG(ssc, "Unable to parse SES Config Header\n"); + SES_FREE(sdata, SCSZ); + return (EIO); + } + if (amt < SES_ENCHDR_MINLEN) { + SES_LOG(ssc, "runt enclosure length (%d)\n", amt); + SES_FREE(sdata, SCSZ); + return (EIO); + } + + SES_VLOG(ssc, "GenCode %x %d Subenclosures\n", cf.GenCode, cf.Nsubenc); + + /* + * Now waltz through all the subenclosures toting up the + * number of types available in each. For this, we only + * really need the enclosure header. However, we get the + * enclosure descriptor for debug purposes, as well + * as self-consistency checking purposes. + */ + + maxima = cf.Nsubenc + 1; + cdp = (SesEncDesc *) storage; + for (ntype = i = 0; i < maxima; i++) { + MEMZERO((caddr_t)cdp, sizeof (*cdp)); + if (ses_enchdr((uint8_t *) sdata, amt, i, &hd)) { + SES_LOG(ssc, "Cannot Extract Enclosure Header %d\n", i); + SES_FREE(sdata, SCSZ); + return (EIO); + } + SES_VLOG(ssc, " SubEnclosure ID %d, %d Types With this ID, En" + "closure Length %d\n", hd.Subencid, hd.Ntypes, hd.VEnclen); + + if (ses_encdesc((uint8_t *)sdata, amt, i, cdp)) { + SES_LOG(ssc, "Can't get Enclosure Descriptor %d\n", i); + SES_FREE(sdata, SCSZ); + return (EIO); + } + SES_VLOG(ssc, " WWN: %02x%02x%02x%02x%02x%02x%02x%02x\n", + cdp->encWWN[0], cdp->encWWN[1], cdp->encWWN[2], + cdp->encWWN[3], cdp->encWWN[4], cdp->encWWN[5], + cdp->encWWN[6], cdp->encWWN[7]); + ntype += hd.Ntypes; + } + + /* + * Now waltz through all the types that are available, getting + * the type header so we can start adding up the number of + * objects available. + */ + for (nobj = i = 0; i < ntype; i++) { + if (ses_getthdr((uint8_t *)sdata, amt, i, &thdr)) { + SES_LOG(ssc, "Can't get Enclosure Type Header %d\n", i); + SES_FREE(sdata, SCSZ); + return (EIO); + } + SES_LOG(ssc, " Type Desc[%d]: Type 0x%x, MaxElt %d, In Subenc " + "%d, Text Length %d\n", i, thdr.enc_type, thdr.enc_maxelt, + thdr.enc_subenc, thdr.enc_tlen); + nobj += thdr.enc_maxelt; + } + + + /* + * Now allocate the object array and type map. + */ + + ssc->ses_objmap = SES_MALLOC(nobj * sizeof (encobj)); + cc->ses_typidx = SES_MALLOC(nobj * sizeof (struct typidx)); + cc->ses_eltmap = SES_MALLOC(ntype); + + if (ssc->ses_objmap == NULL || cc->ses_typidx == NULL || + cc->ses_eltmap == NULL) { + if (ssc->ses_objmap) { + SES_FREE(ssc->ses_objmap, (nobj * sizeof (encobj))); + ssc->ses_objmap = NULL; + } + if (cc->ses_typidx) { + SES_FREE(cc->ses_typidx, + (nobj * sizeof (struct typidx))); + cc->ses_typidx = NULL; + } + if (cc->ses_eltmap) { + SES_FREE(cc->ses_eltmap, ntype); + cc->ses_eltmap = NULL; + } + SES_FREE(sdata, SCSZ); + return (ENOMEM); + } + MEMZERO(ssc->ses_objmap, nobj * sizeof (encobj)); + MEMZERO(cc->ses_typidx, nobj * sizeof (struct typidx)); + MEMZERO(cc->ses_eltmap, ntype); + cc->ses_ntypes = (uint8_t) ntype; + ssc->ses_nobjects = nobj; + + /* + * Now waltz through the # of types again to fill in the types + * (and subenclosure ids) of the allocated objects. + */ + nobj = 0; + for (i = 0; i < ntype; i++) { + int j; + if (ses_getthdr((uint8_t *)sdata, amt, i, &thdr)) { + continue; + } + cc->ses_eltmap[i] = thdr.enc_maxelt; + for (j = 0; j < thdr.enc_maxelt; j++) { + cc->ses_typidx[nobj].ses_tidx = i; + cc->ses_typidx[nobj].ses_oidx = j; + ssc->ses_objmap[nobj].subenclosure = thdr.enc_subenc; + ssc->ses_objmap[nobj++].enctype = thdr.enc_type; + } + } + SES_FREE(sdata, SCSZ); + return (0); +} + +static int +ses_getputstat(ses_softc_t *ssc, int objid, SesComStat *sp, int slp, int in) +{ + struct sscfg *cc; + int err, amt, bufsiz, tidx, oidx; + char cdb[6], *sdata; + + cc = ssc->ses_private; + if (cc == NULL) { + return (ENXIO); + } + + /* + * If we're just getting overall enclosure status, + * we only need 2 bytes of data storage. + * + * If we're getting anything else, we know how much + * storage we need by noting that starting at offset + * 8 in returned data, all object status bytes are 4 + * bytes long, and are stored in chunks of types(M) + * and nth+1 instances of type M. + */ + if (objid == -1) { + bufsiz = 2; + } else { + bufsiz = (ssc->ses_nobjects * 4) + (cc->ses_ntypes * 4) + 8; + } + sdata = SES_MALLOC(bufsiz); + if (sdata == NULL) + return (ENOMEM); + + cdb[0] = RECEIVE_DIAGNOSTIC; + cdb[1] = 1; + cdb[2] = SesStatusPage; + cdb[3] = bufsiz >> 8; + cdb[4] = bufsiz & 0xff; + cdb[5] = 0; + amt = bufsiz; + err = ses_runcmd(ssc, cdb, 6, sdata, &amt); + if (err) { + SES_FREE(sdata, bufsiz); + return (err); + } + amt = bufsiz - amt; + + if (objid == -1) { + tidx = -1; + oidx = -1; + } else { + tidx = cc->ses_typidx[objid].ses_tidx; + oidx = cc->ses_typidx[objid].ses_oidx; + } + if (in) { + if (ses_decode(sdata, amt, cc->ses_eltmap, tidx, oidx, sp)) { + err = ENODEV; + } + } else { + if (ses_encode(sdata, amt, cc->ses_eltmap, tidx, oidx, sp)) { + err = ENODEV; + } else { + cdb[0] = SEND_DIAGNOSTIC; + cdb[1] = 0x10; + cdb[2] = 0; + cdb[3] = bufsiz >> 8; + cdb[4] = bufsiz & 0xff; + cdb[5] = 0; + amt = -bufsiz; + err = ses_runcmd(ssc, cdb, 6, sdata, &amt); + } + } + SES_FREE(sdata, bufsiz); + return (0); +} + + +/* + * Routines to parse returned SES data structures. + * Architecture and compiler independent. + */ + +static int +ses_cfghdr(uint8_t *buffer, int buflen, SesCfgHdr *cfp) +{ + if (buflen < SES_CFGHDR_MINLEN) { + return (-1); + } + gget8(buffer, 1, cfp->Nsubenc); + gget32(buffer, 4, cfp->GenCode); + return (0); +} + +static int +ses_enchdr(uint8_t *buffer, int amt, uint8_t SubEncId, SesEncHdr *chp) +{ + int s, off = 8; + for (s = 0; s < SubEncId; s++) { + if (off + 3 > amt) + return (-1); + off += buffer[off+3] + 4; + } + if (off + 3 > amt) { + return (-1); + } + gget8(buffer, off+1, chp->Subencid); + gget8(buffer, off+2, chp->Ntypes); + gget8(buffer, off+3, chp->VEnclen); + return (0); +} + +static int +ses_encdesc(uint8_t *buffer, int amt, uint8_t SubEncId, SesEncDesc *cdp) +{ + int s, e, enclen, off = 8; + for (s = 0; s < SubEncId; s++) { + if (off + 3 > amt) + return (-1); + off += buffer[off+3] + 4; + } + if (off + 3 > amt) { + return (-1); + } + gget8(buffer, off+3, enclen); + off += 4; + if (off >= amt) + return (-1); + + e = off + enclen; + if (e > amt) { + e = amt; + } + MEMCPY(cdp, &buffer[off], e - off); + return (0); +} + +static int +ses_getthdr(uint8_t *buffer, int amt, int nth, SesThdr *thp) +{ + int s, off = 8; + + if (amt < SES_CFGHDR_MINLEN) { + return (-1); + } + for (s = 0; s < buffer[1]; s++) { + if (off + 3 > amt) + return (-1); + off += buffer[off+3] + 4; + } + if (off + 3 > amt) { + return (-1); + } + off += buffer[off+3] + 4 + (nth * 4); + if (amt < (off + 4)) + return (-1); + + gget8(buffer, off++, thp->enc_type); + gget8(buffer, off++, thp->enc_maxelt); + gget8(buffer, off++, thp->enc_subenc); + gget8(buffer, off, thp->enc_tlen); + return (0); +} + +/* + * This function needs a little explanation. + * + * The arguments are: + * + * + * char *b, int amt + * + * These describes the raw input SES status data and length. + * + * uint8_t *ep + * + * This is a map of the number of types for each element type + * in the enclosure. + * + * int elt + * + * This is the element type being sought. If elt is -1, + * then overall enclosure status is being sought. + * + * int elm + * + * This is the ordinal Mth element of type elt being sought. + * + * SesComStat *sp + * + * This is the output area to store the status for + * the Mth element of type Elt. + */ + +static int +ses_decode(char *b, int amt, uint8_t *ep, int elt, int elm, SesComStat *sp) +{ + int idx, i; + + /* + * If it's overall enclosure status being sought, get that. + * We need at least 2 bytes of status data to get that. + */ + if (elt == -1) { + if (amt < 2) + return (-1); + gget8(b, 1, sp->comstatus); + sp->comstat[0] = 0; + sp->comstat[1] = 0; + sp->comstat[2] = 0; + return (0); + } + + /* + * Check to make sure that the Mth element is legal for type Elt. + */ + + if (elm >= ep[elt]) + return (-1); + + /* + * Starting at offset 8, start skipping over the storage + * for the element types we're not interested in. + */ + for (idx = 8, i = 0; i < elt; i++) { + idx += ((ep[i] + 1) * 4); + } + + /* + * Skip over Overall status for this element type. + */ + idx += 4; + + /* + * And skip to the index for the Mth element that we're going for. + */ + idx += (4 * elm); + + /* + * Make sure we haven't overflowed the buffer. + */ + if (idx+4 > amt) + return (-1); + + /* + * Retrieve the status. + */ + gget8(b, idx++, sp->comstatus); + gget8(b, idx++, sp->comstat[0]); + gget8(b, idx++, sp->comstat[1]); + gget8(b, idx++, sp->comstat[2]); +#if 0 + PRINTF("Get Elt 0x%x Elm 0x%x (idx %d)\n", elt, elm, idx-4); +#endif + return (0); +} + +/* + * This is the mirror function to ses_decode, but we set the 'select' + * bit for the object which we're interested in. All other objects, + * after a status fetch, should have that bit off. Hmm. It'd be easy + * enough to ensure this, so we will. + */ + +static int +ses_encode(char *b, int amt, uint8_t *ep, int elt, int elm, SesComStat *sp) +{ + int idx, i; + + /* + * If it's overall enclosure status being sought, get that. + * We need at least 2 bytes of status data to get that. + */ + if (elt == -1) { + if (amt < 2) + return (-1); + i = 0; + sset8(b, i, 0); + sset8(b, i, sp->comstatus & 0xf); +#if 0 + PRINTF("set EncStat %x\n", sp->comstatus); +#endif + return (0); + } + + /* + * Check to make sure that the Mth element is legal for type Elt. + */ + + if (elm >= ep[elt]) + return (-1); + + /* + * Starting at offset 8, start skipping over the storage + * for the element types we're not interested in. + */ + for (idx = 8, i = 0; i < elt; i++) { + idx += ((ep[i] + 1) * 4); + } + + /* + * Skip over Overall status for this element type. + */ + idx += 4; + + /* + * And skip to the index for the Mth element that we're going for. + */ + idx += (4 * elm); + + /* + * Make sure we haven't overflowed the buffer. + */ + if (idx+4 > amt) + return (-1); + + /* + * Set the status. + */ + sset8(b, idx, sp->comstatus); + sset8(b, idx, sp->comstat[0]); + sset8(b, idx, sp->comstat[1]); + sset8(b, idx, sp->comstat[2]); + idx -= 4; + +#if 0 + PRINTF("Set Elt 0x%x Elm 0x%x (idx %d) with %x %x %x %x\n", + elt, elm, idx, sp->comstatus, sp->comstat[0], + sp->comstat[1], sp->comstat[2]); +#endif + + /* + * Now make sure all other 'Select' bits are off. + */ + for (i = 8; i < amt; i += 4) { + if (i != idx) + b[i] &= ~0x80; + } + /* + * And make sure the INVOP bit is clear. + */ + b[2] &= ~0x10; + + return (0); +} + +/* + * SAF-TE Type Device Emulation + */ + +static int safte_getconfig(ses_softc_t *); +static int safte_rdstat(ses_softc_t *, int);; +static int set_objstat_sel(ses_softc_t *, ses_objstat *, int); +static int wrbuf16(ses_softc_t *, uint8_t, uint8_t, uint8_t, uint8_t, int); +static void wrslot_stat(ses_softc_t *, int); +static int perf_slotop(ses_softc_t *, uint8_t, uint8_t, int); + +#define ALL_ENC_STAT (SES_ENCSTAT_CRITICAL | SES_ENCSTAT_UNRECOV | \ + SES_ENCSTAT_NONCRITICAL | SES_ENCSTAT_INFO) +/* + * SAF-TE specific defines- Mandatory ones only... + */ + +/* + * READ BUFFER ('get' commands) IDs- placed in offset 2 of cdb + */ +#define SAFTE_RD_RDCFG 0x00 /* read enclosure configuration */ +#define SAFTE_RD_RDESTS 0x01 /* read enclosure status */ +#define SAFTE_RD_RDDSTS 0x04 /* read drive slot status */ + +/* + * WRITE BUFFER ('set' commands) IDs- placed in offset 0 of databuf + */ +#define SAFTE_WT_DSTAT 0x10 /* write device slot status */ +#define SAFTE_WT_SLTOP 0x12 /* perform slot operation */ +#define SAFTE_WT_FANSPD 0x13 /* set fan speed */ +#define SAFTE_WT_ACTPWS 0x14 /* turn on/off power supply */ +#define SAFTE_WT_GLOBAL 0x15 /* send global command */ + + +#define SAFT_SCRATCH 64 +#define NPSEUDO_THERM 16 +#define NPSEUDO_ALARM 1 +struct scfg { + /* + * Cached Configuration + */ + uint8_t Nfans; /* Number of Fans */ + uint8_t Npwr; /* Number of Power Supplies */ + uint8_t Nslots; /* Number of Device Slots */ + uint8_t DoorLock; /* Door Lock Installed */ + uint8_t Ntherm; /* Number of Temperature Sensors */ + uint8_t Nspkrs; /* Number of Speakers */ + uint8_t Nalarm; /* Number of Alarms (at least one) */ + /* + * Cached Flag Bytes for Global Status + */ + uint8_t flag1; + uint8_t flag2; + /* + * What object index ID is where various slots start. + */ + uint8_t pwroff; + uint8_t slotoff; +#define SAFT_ALARM_OFFSET(cc) (cc)->slotoff - 1 +}; + +#define SAFT_FLG1_ALARM 0x1 +#define SAFT_FLG1_GLOBFAIL 0x2 +#define SAFT_FLG1_GLOBWARN 0x4 +#define SAFT_FLG1_ENCPWROFF 0x8 +#define SAFT_FLG1_ENCFANFAIL 0x10 +#define SAFT_FLG1_ENCPWRFAIL 0x20 +#define SAFT_FLG1_ENCDRVFAIL 0x40 +#define SAFT_FLG1_ENCDRVWARN 0x80 + +#define SAFT_FLG2_LOCKDOOR 0x4 +#define SAFT_PRIVATE sizeof (struct scfg) + +static char *safte_2little = "Too Little Data Returned (%d) at line %d\n"; +#define SAFT_BAIL(r, x, k, l) \ + if (r >= x) { \ + SES_LOG(ssc, safte_2little, x, __LINE__);\ + SES_FREE(k, l); \ + return (EIO); \ + } + + +int +safte_softc_init(ses_softc_t *ssc, int doinit) +{ + int err, i, r; + struct scfg *cc; + + if (doinit == 0) { + if (ssc->ses_nobjects) { + if (ssc->ses_objmap) { + SES_FREE(ssc->ses_objmap, + ssc->ses_nobjects * sizeof (encobj)); + ssc->ses_objmap = NULL; + } + ssc->ses_nobjects = 0; + } + if (ssc->ses_private) { + SES_FREE(ssc->ses_private, SAFT_PRIVATE); + ssc->ses_private = NULL; + } + return (0); + } + + if (ssc->ses_private == NULL) { + ssc->ses_private = SES_MALLOC(SAFT_PRIVATE); + if (ssc->ses_private == NULL) { + return (ENOMEM); + } + MEMZERO(ssc->ses_private, SAFT_PRIVATE); + } + + ssc->ses_nobjects = 0; + ssc->ses_encstat = 0; + + if ((err = safte_getconfig(ssc)) != 0) { + return (err); + } + + /* + * The number of objects here, as well as that reported by the + * READ_BUFFER/GET_CONFIG call, are the over-temperature flags (15) + * that get reported during READ_BUFFER/READ_ENC_STATUS. + */ + cc = ssc->ses_private; + ssc->ses_nobjects = cc->Nfans + cc->Npwr + cc->Nslots + cc->DoorLock + + cc->Ntherm + cc->Nspkrs + NPSEUDO_THERM + NPSEUDO_ALARM; + ssc->ses_objmap = (encobj *) + SES_MALLOC(ssc->ses_nobjects * sizeof (encobj)); + if (ssc->ses_objmap == NULL) { + return (ENOMEM); + } + MEMZERO(ssc->ses_objmap, ssc->ses_nobjects * sizeof (encobj)); + + r = 0; + /* + * Note that this is all arranged for the convenience + * in later fetches of status. + */ + for (i = 0; i < cc->Nfans; i++) + ssc->ses_objmap[r++].enctype = SESTYP_FAN; + cc->pwroff = (uint8_t) r; + for (i = 0; i < cc->Npwr; i++) + ssc->ses_objmap[r++].enctype = SESTYP_POWER; + for (i = 0; i < cc->DoorLock; i++) + ssc->ses_objmap[r++].enctype = SESTYP_DOORLOCK; + for (i = 0; i < cc->Nspkrs; i++) + ssc->ses_objmap[r++].enctype = SESTYP_ALARM; + for (i = 0; i < cc->Ntherm; i++) + ssc->ses_objmap[r++].enctype = SESTYP_THERM; + for (i = 0; i < NPSEUDO_THERM; i++) + ssc->ses_objmap[r++].enctype = SESTYP_THERM; + ssc->ses_objmap[r++].enctype = SESTYP_ALARM; + cc->slotoff = (uint8_t) r; + for (i = 0; i < cc->Nslots; i++) + ssc->ses_objmap[r++].enctype = SESTYP_DEVICE; + return (0); +} + +int +safte_init_enc(ses_softc_t *ssc) +{ + int err; + static char cdb0[6] = { SEND_DIAGNOSTIC }; + + err = ses_runcmd(ssc, cdb0, 6, NULL, 0); + if (err) { + return (err); + } + DELAY(5000); + err = wrbuf16(ssc, SAFTE_WT_GLOBAL, 0, 0, 0, 1); + return (err); +} + +int +safte_get_encstat(ses_softc_t *ssc, int slpflg) +{ + return (safte_rdstat(ssc, slpflg)); +} + +int +safte_set_encstat(ses_softc_t *ssc, uint8_t encstat, int slpflg) +{ + struct scfg *cc = ssc->ses_private; + if (cc == NULL) + return (0); + /* + * Since SAF-TE devices aren't necessarily sticky in terms + * of state, make our soft copy of enclosure status 'sticky'- + * that is, things set in enclosure status stay set (as implied + * by conditions set in reading object status) until cleared. + */ + ssc->ses_encstat &= ~ALL_ENC_STAT; + ssc->ses_encstat |= (encstat & ALL_ENC_STAT); + ssc->ses_encstat |= ENCI_SVALID; + cc->flag1 &= ~(SAFT_FLG1_ALARM|SAFT_FLG1_GLOBFAIL|SAFT_FLG1_GLOBWARN); + if ((encstat & (SES_ENCSTAT_CRITICAL|SES_ENCSTAT_UNRECOV)) != 0) { + cc->flag1 |= SAFT_FLG1_ALARM|SAFT_FLG1_GLOBFAIL; + } else if ((encstat & SES_ENCSTAT_NONCRITICAL) != 0) { + cc->flag1 |= SAFT_FLG1_GLOBWARN; + } + return (wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, cc->flag2, 0, slpflg)); +} + +int +safte_get_objstat(ses_softc_t *ssc, ses_objstat *obp, int slpflg) +{ + int i = (int)obp->obj_id; + + if ((ssc->ses_encstat & ENCI_SVALID) == 0 || + (ssc->ses_objmap[i].svalid) == 0) { + int err = safte_rdstat(ssc, slpflg); + if (err) + return (err); + } + obp->cstat[0] = ssc->ses_objmap[i].encstat[0]; + obp->cstat[1] = ssc->ses_objmap[i].encstat[1]; + obp->cstat[2] = ssc->ses_objmap[i].encstat[2]; + obp->cstat[3] = ssc->ses_objmap[i].encstat[3]; + return (0); +} + + +int +safte_set_objstat(ses_softc_t *ssc, ses_objstat *obp, int slp) +{ + int idx, err; + encobj *ep; + struct scfg *cc; + + + SES_DLOG(ssc, "safte_set_objstat(%d): %x %x %x %x\n", + (int)obp->obj_id, obp->cstat[0], obp->cstat[1], obp->cstat[2], + obp->cstat[3]); + + /* + * If this is clear, we don't do diddly. + */ + if ((obp->cstat[0] & SESCTL_CSEL) == 0) { + return (0); + } + + err = 0; + /* + * Check to see if the common bits are set and do them first. + */ + if (obp->cstat[0] & ~SESCTL_CSEL) { + err = set_objstat_sel(ssc, obp, slp); + if (err) + return (err); + } + + cc = ssc->ses_private; + if (cc == NULL) + return (0); + + idx = (int)obp->obj_id; + ep = &ssc->ses_objmap[idx]; + + switch (ep->enctype) { + case SESTYP_DEVICE: + { + uint8_t slotop = 0; + /* + * XXX: I should probably cache the previous state + * XXX: of SESCTL_DEVOFF so that when it goes from + * XXX: true to false I can then set PREPARE FOR OPERATION + * XXX: flag in PERFORM SLOT OPERATION write buffer command. + */ + if (obp->cstat[2] & (SESCTL_RQSINS|SESCTL_RQSRMV)) { + slotop |= 0x2; + } + if (obp->cstat[2] & SESCTL_RQSID) { + slotop |= 0x4; + } + err = perf_slotop(ssc, (uint8_t) idx - (uint8_t) cc->slotoff, + slotop, slp); + if (err) + return (err); + if (obp->cstat[3] & SESCTL_RQSFLT) { + ep->priv |= 0x2; + } else { + ep->priv &= ~0x2; + } + if (ep->priv & 0xc6) { + ep->priv &= ~0x1; + } else { + ep->priv |= 0x1; /* no errors */ + } + wrslot_stat(ssc, slp); + break; + } + case SESTYP_POWER: + if (obp->cstat[3] & SESCTL_RQSTFAIL) { + cc->flag1 |= SAFT_FLG1_ENCPWRFAIL; + } else { + cc->flag1 &= ~SAFT_FLG1_ENCPWRFAIL; + } + err = wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, + cc->flag2, 0, slp); + if (err) + return (err); + if (obp->cstat[3] & SESCTL_RQSTON) { + (void) wrbuf16(ssc, SAFTE_WT_ACTPWS, + idx - cc->pwroff, 0, 0, slp); + } else { + (void) wrbuf16(ssc, SAFTE_WT_ACTPWS, + idx - cc->pwroff, 0, 1, slp); + } + break; + case SESTYP_FAN: + if (obp->cstat[3] & SESCTL_RQSTFAIL) { + cc->flag1 |= SAFT_FLG1_ENCFANFAIL; + } else { + cc->flag1 &= ~SAFT_FLG1_ENCFANFAIL; + } + err = wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, + cc->flag2, 0, slp); + if (err) + return (err); + if (obp->cstat[3] & SESCTL_RQSTON) { + uint8_t fsp; + if ((obp->cstat[3] & 0x7) == 7) { + fsp = 4; + } else if ((obp->cstat[3] & 0x7) == 6) { + fsp = 3; + } else if ((obp->cstat[3] & 0x7) == 4) { + fsp = 2; + } else { + fsp = 1; + } + (void) wrbuf16(ssc, SAFTE_WT_FANSPD, idx, fsp, 0, slp); + } else { + (void) wrbuf16(ssc, SAFTE_WT_FANSPD, idx, 0, 0, slp); + } + break; + case SESTYP_DOORLOCK: + if (obp->cstat[3] & 0x1) { + cc->flag2 &= ~SAFT_FLG2_LOCKDOOR; + } else { + cc->flag2 |= SAFT_FLG2_LOCKDOOR; + } + (void) wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, + cc->flag2, 0, slp); + break; + case SESTYP_ALARM: + /* + * On all nonzero but the 'muted' bit, we turn on the alarm, + */ + obp->cstat[3] &= ~0xa; + if (obp->cstat[3] & 0x40) { + cc->flag2 &= ~SAFT_FLG1_ALARM; + } else if (obp->cstat[3] != 0) { + cc->flag2 |= SAFT_FLG1_ALARM; + } else { + cc->flag2 &= ~SAFT_FLG1_ALARM; + } + ep->priv = obp->cstat[3]; + (void) wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, + cc->flag2, 0, slp); + break; + default: + break; + } + ep->svalid = 0; + return (0); +} + +static int +safte_getconfig(ses_softc_t *ssc) +{ + struct scfg *cfg; + int err, amt; + char *sdata; + static char cdb[10] = + { READ_BUFFER, 1, SAFTE_RD_RDCFG, 0, 0, 0, 0, 0, SAFT_SCRATCH, 0 }; + + cfg = ssc->ses_private; + if (cfg == NULL) + return (ENXIO); + + sdata = SES_MALLOC(SAFT_SCRATCH); + if (sdata == NULL) + return (ENOMEM); + + amt = SAFT_SCRATCH; + err = ses_runcmd(ssc, cdb, 10, sdata, &amt); + if (err) { + SES_FREE(sdata, SAFT_SCRATCH); + return (err); + } + amt = SAFT_SCRATCH - amt; + if (amt < 6) { + SES_LOG(ssc, "too little data (%d) for configuration\n", amt); + SES_FREE(sdata, SAFT_SCRATCH); + return (EIO); + } + SES_VLOG(ssc, "Nfans %d Npwr %d Nslots %d Lck %d Ntherm %d Nspkrs %d\n", + sdata[0], sdata[1], sdata[2], sdata[3], sdata[4], sdata[5]); + cfg->Nfans = sdata[0]; + cfg->Npwr = sdata[1]; + cfg->Nslots = sdata[2]; + cfg->DoorLock = sdata[3]; + cfg->Ntherm = sdata[4]; + cfg->Nspkrs = sdata[5]; + cfg->Nalarm = NPSEUDO_ALARM; + SES_FREE(sdata, SAFT_SCRATCH); + return (0); +} + +static int +safte_rdstat(ses_softc_t *ssc, int slpflg) +{ + int err, oid, r, i, hiwater, nitems, amt; + uint16_t tempflags; + size_t buflen; + uint8_t status, oencstat; + char *sdata, cdb[10]; + struct scfg *cc = ssc->ses_private; + + + /* + * The number of objects overstates things a bit, + * both for the bogus 'thermometer' entries and + * the drive status (which isn't read at the same + * time as the enclosure status), but that's okay. + */ + buflen = 4 * cc->Nslots; + if (ssc->ses_nobjects > buflen) + buflen = ssc->ses_nobjects; + sdata = SES_MALLOC(buflen); + if (sdata == NULL) + return (ENOMEM); + + cdb[0] = READ_BUFFER; + cdb[1] = 1; + cdb[2] = SAFTE_RD_RDESTS; + cdb[3] = 0; + cdb[4] = 0; + cdb[5] = 0; + cdb[6] = 0; + cdb[7] = (buflen >> 8) & 0xff; + cdb[8] = buflen & 0xff; + cdb[9] = 0; + amt = buflen; + err = ses_runcmd(ssc, cdb, 10, sdata, &amt); + if (err) { + SES_FREE(sdata, buflen); + return (err); + } + hiwater = buflen - amt; + + + /* + * invalidate all status bits. + */ + for (i = 0; i < ssc->ses_nobjects; i++) + ssc->ses_objmap[i].svalid = 0; + oencstat = ssc->ses_encstat & ALL_ENC_STAT; + ssc->ses_encstat = 0; + + + /* + * Now parse returned buffer. + * If we didn't get enough data back, + * that's considered a fatal error. + */ + oid = r = 0; + + for (nitems = i = 0; i < cc->Nfans; i++) { + SAFT_BAIL(r, hiwater, sdata, buflen); + /* + * 0 = Fan Operational + * 1 = Fan is malfunctioning + * 2 = Fan is not present + * 0x80 = Unknown or Not Reportable Status + */ + ssc->ses_objmap[oid].encstat[1] = 0; /* resvd */ + ssc->ses_objmap[oid].encstat[2] = 0; /* resvd */ + switch ((int)(uint8_t)sdata[r]) { + case 0: + nitems++; + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + /* + * We could get fancier and cache + * fan speeds that we have set, but + * that isn't done now. + */ + ssc->ses_objmap[oid].encstat[3] = 7; + break; + + case 1: + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_CRIT; + /* + * FAIL and FAN STOPPED synthesized + */ + ssc->ses_objmap[oid].encstat[3] = 0x40; + /* + * Enclosure marked with CRITICAL error + * if only one fan or no thermometers, + * else the NONCRITICAL error is set. + */ + if (cc->Nfans == 1 || cc->Ntherm == 0) + ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; + else + ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; + break; + case 2: + ssc->ses_objmap[oid].encstat[0] = + SES_OBJSTAT_NOTINSTALLED; + ssc->ses_objmap[oid].encstat[3] = 0; + /* + * Enclosure marked with CRITICAL error + * if only one fan or no thermometers, + * else the NONCRITICAL error is set. + */ + if (cc->Nfans == 1) + ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; + else + ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; + break; + case 0x80: + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNKNOWN; + ssc->ses_objmap[oid].encstat[3] = 0; + ssc->ses_encstat |= SES_ENCSTAT_INFO; + break; + default: + ssc->ses_objmap[oid].encstat[0] = + SES_OBJSTAT_UNSUPPORTED; + SES_LOG(ssc, "Unknown fan%d status 0x%x\n", i, + sdata[r] & 0xff); + break; + } + ssc->ses_objmap[oid++].svalid = 1; + r++; + } + + /* + * No matter how you cut it, no cooling elements when there + * should be some there is critical. + */ + if (cc->Nfans && nitems == 0) { + ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; + } + + + for (i = 0; i < cc->Npwr; i++) { + SAFT_BAIL(r, hiwater, sdata, buflen); + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNKNOWN; + ssc->ses_objmap[oid].encstat[1] = 0; /* resvd */ + ssc->ses_objmap[oid].encstat[2] = 0; /* resvd */ + ssc->ses_objmap[oid].encstat[3] = 0x20; /* requested on */ + switch ((uint8_t)sdata[r]) { + case 0x00: /* pws operational and on */ + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + break; + case 0x01: /* pws operational and off */ + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + ssc->ses_objmap[oid].encstat[3] = 0x10; + ssc->ses_encstat |= SES_ENCSTAT_INFO; + break; + case 0x10: /* pws is malfunctioning and commanded on */ + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_CRIT; + ssc->ses_objmap[oid].encstat[3] = 0x61; + ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; + break; + + case 0x11: /* pws is malfunctioning and commanded off */ + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_NONCRIT; + ssc->ses_objmap[oid].encstat[3] = 0x51; + ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; + break; + case 0x20: /* pws is not present */ + ssc->ses_objmap[oid].encstat[0] = + SES_OBJSTAT_NOTINSTALLED; + ssc->ses_objmap[oid].encstat[3] = 0; + ssc->ses_encstat |= SES_ENCSTAT_INFO; + break; + case 0x21: /* pws is present */ + /* + * This is for enclosures that cannot tell whether the + * device is on or malfunctioning, but know that it is + * present. Just fall through. + */ + /* FALLTHROUGH */ + case 0x80: /* Unknown or Not Reportable Status */ + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNKNOWN; + ssc->ses_objmap[oid].encstat[3] = 0; + ssc->ses_encstat |= SES_ENCSTAT_INFO; + break; + default: + SES_LOG(ssc, "unknown power supply %d status (0x%x)\n", + i, sdata[r] & 0xff); + break; + } + ssc->ses_objmap[oid++].svalid = 1; + r++; + } + + /* + * Skip over Slot SCSI IDs + */ + r += cc->Nslots; + + /* + * We always have doorlock status, no matter what, + * but we only save the status if we have one. + */ + SAFT_BAIL(r, hiwater, sdata, buflen); + if (cc->DoorLock) { + /* + * 0 = Door Locked + * 1 = Door Unlocked, or no Lock Installed + * 0x80 = Unknown or Not Reportable Status + */ + ssc->ses_objmap[oid].encstat[1] = 0; + ssc->ses_objmap[oid].encstat[2] = 0; + switch ((uint8_t)sdata[r]) { + case 0: + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + ssc->ses_objmap[oid].encstat[3] = 0; + break; + case 1: + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + ssc->ses_objmap[oid].encstat[3] = 1; + break; + case 0x80: + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNKNOWN; + ssc->ses_objmap[oid].encstat[3] = 0; + ssc->ses_encstat |= SES_ENCSTAT_INFO; + break; + default: + ssc->ses_objmap[oid].encstat[0] = + SES_OBJSTAT_UNSUPPORTED; + SES_LOG(ssc, "unknown lock status 0x%x\n", + sdata[r] & 0xff); + break; + } + ssc->ses_objmap[oid++].svalid = 1; + } + r++; + + /* + * We always have speaker status, no matter what, + * but we only save the status if we have one. + */ + SAFT_BAIL(r, hiwater, sdata, buflen); + if (cc->Nspkrs) { + ssc->ses_objmap[oid].encstat[1] = 0; + ssc->ses_objmap[oid].encstat[2] = 0; + if (sdata[r] == 1) { + /* + * We need to cache tone urgency indicators. + * Someday. + */ + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_NONCRIT; + ssc->ses_objmap[oid].encstat[3] = 0x8; + ssc->ses_encstat |= SES_ENCSTAT_NONCRITICAL; + } else if (sdata[r] == 0) { + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + ssc->ses_objmap[oid].encstat[3] = 0; + } else { + ssc->ses_objmap[oid].encstat[0] = + SES_OBJSTAT_UNSUPPORTED; + ssc->ses_objmap[oid].encstat[3] = 0; + SES_LOG(ssc, "unknown spkr status 0x%x\n", + sdata[r] & 0xff); + } + ssc->ses_objmap[oid++].svalid = 1; + } + r++; + + for (i = 0; i < cc->Ntherm; i++) { + SAFT_BAIL(r, hiwater, sdata, buflen); + /* + * Status is a range from -10 to 245 deg Celsius, + * which we need to normalize to -20 to -245 according + * to the latest SCSI spec, which makes little + * sense since this would overflow an 8bit value. + * Well, still, the base normalization is -20, + * not -10, so we have to adjust. + * + * So what's over and under temperature? + * Hmm- we'll state that 'normal' operating + * is 10 to 40 deg Celsius. + */ + ssc->ses_objmap[oid].encstat[1] = 0; + ssc->ses_objmap[oid].encstat[2] = + ((unsigned int) sdata[r]) - 10; + if (sdata[r] < 20) { + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_CRIT; + /* + * Set 'under temperature' failure. + */ + ssc->ses_objmap[oid].encstat[3] = 2; + ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; + } else if (sdata[r] > 30) { + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_CRIT; + /* + * Set 'over temperature' failure. + */ + ssc->ses_objmap[oid].encstat[3] = 8; + ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; + } else { + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + } + ssc->ses_objmap[oid++].svalid = 1; + r++; + } + + /* + * Now, for "pseudo" thermometers, we have two bytes + * of information in enclosure status- 16 bits. Actually, + * the MSB is a single TEMP ALERT flag indicating whether + * any other bits are set, but, thanks to fuzzy thinking, + * in the SAF-TE spec, this can also be set even if no + * other bits are set, thus making this really another + * binary temperature sensor. + */ + + SAFT_BAIL(r, hiwater, sdata, buflen); + tempflags = sdata[r++]; + SAFT_BAIL(r, hiwater, sdata, buflen); + tempflags |= (tempflags << 8) | sdata[r++]; + + for (i = 0; i < NPSEUDO_THERM; i++) { + ssc->ses_objmap[oid].encstat[1] = 0; + if (tempflags & (1 << (NPSEUDO_THERM - i - 1))) { + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_CRIT; + ssc->ses_objmap[4].encstat[2] = 0xff; + /* + * Set 'over temperature' failure. + */ + ssc->ses_objmap[oid].encstat[3] = 8; + ssc->ses_encstat |= SES_ENCSTAT_CRITICAL; + } else { + /* + * We used to say 'not available' and synthesize a + * nominal 30 deg (C)- that was wrong. Actually, + * Just say 'OK', and use the reserved value of + * zero. + */ + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + ssc->ses_objmap[oid].encstat[2] = 0; + ssc->ses_objmap[oid].encstat[3] = 0; + } + ssc->ses_objmap[oid++].svalid = 1; + } + + /* + * Get alarm status. + */ + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + ssc->ses_objmap[oid].encstat[3] = ssc->ses_objmap[oid].priv; + ssc->ses_objmap[oid++].svalid = 1; + + /* + * Now get drive slot status + */ + cdb[2] = SAFTE_RD_RDDSTS; + amt = buflen; + err = ses_runcmd(ssc, cdb, 10, sdata, &amt); + if (err) { + SES_FREE(sdata, buflen); + return (err); + } + hiwater = buflen - amt; + for (r = i = 0; i < cc->Nslots; i++, r += 4) { + SAFT_BAIL(r+3, hiwater, sdata, buflen); + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_UNSUPPORTED; + ssc->ses_objmap[oid].encstat[1] = (uint8_t) i; + ssc->ses_objmap[oid].encstat[2] = 0; + ssc->ses_objmap[oid].encstat[3] = 0; + status = sdata[r+3]; + if ((status & 0x1) == 0) { /* no device */ + ssc->ses_objmap[oid].encstat[0] = + SES_OBJSTAT_NOTINSTALLED; + } else { + ssc->ses_objmap[oid].encstat[0] = SES_OBJSTAT_OK; + } + if (status & 0x2) { + ssc->ses_objmap[oid].encstat[2] = 0x8; + } + if ((status & 0x4) == 0) { + ssc->ses_objmap[oid].encstat[3] = 0x10; + } + ssc->ses_objmap[oid++].svalid = 1; + } + /* see comment below about sticky enclosure status */ + ssc->ses_encstat |= ENCI_SVALID | oencstat; + SES_FREE(sdata, buflen); + return (0); +} + +static int +set_objstat_sel(ses_softc_t *ssc, ses_objstat *obp, int slp) +{ + int idx; + encobj *ep; + struct scfg *cc = ssc->ses_private; + + if (cc == NULL) + return (0); + + idx = (int)obp->obj_id; + ep = &ssc->ses_objmap[idx]; + + switch (ep->enctype) { + case SESTYP_DEVICE: + if (obp->cstat[0] & SESCTL_PRDFAIL) { + ep->priv |= 0x40; + } + /* SESCTL_RSTSWAP has no correspondence in SAF-TE */ + if (obp->cstat[0] & SESCTL_DISABLE) { + ep->priv |= 0x80; + /* + * Hmm. Try to set the 'No Drive' flag. + * Maybe that will count as a 'disable'. + */ + } + if (ep->priv & 0xc6) { + ep->priv &= ~0x1; + } else { + ep->priv |= 0x1; /* no errors */ + } + wrslot_stat(ssc, slp); + break; + case SESTYP_POWER: + /* + * Okay- the only one that makes sense here is to + * do the 'disable' for a power supply. + */ + if (obp->cstat[0] & SESCTL_DISABLE) { + (void) wrbuf16(ssc, SAFTE_WT_ACTPWS, + idx - cc->pwroff, 0, 0, slp); + } + break; + case SESTYP_FAN: + /* + * Okay- the only one that makes sense here is to + * set fan speed to zero on disable. + */ + if (obp->cstat[0] & SESCTL_DISABLE) { + /* remember- fans are the first items, so idx works */ + (void) wrbuf16(ssc, SAFTE_WT_FANSPD, idx, 0, 0, slp); + } + break; + case SESTYP_DOORLOCK: + /* + * Well, we can 'disable' the lock. + */ + if (obp->cstat[0] & SESCTL_DISABLE) { + cc->flag2 &= ~SAFT_FLG2_LOCKDOOR; + (void) wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, + cc->flag2, 0, slp); + } + break; + case SESTYP_ALARM: + /* + * Well, we can 'disable' the alarm. + */ + if (obp->cstat[0] & SESCTL_DISABLE) { + cc->flag2 &= ~SAFT_FLG1_ALARM; + ep->priv |= 0x40; /* Muted */ + (void) wrbuf16(ssc, SAFTE_WT_GLOBAL, cc->flag1, + cc->flag2, 0, slp); + } + break; + default: + break; + } + ep->svalid = 0; + return (0); +} + +/* + * This function handles all of the 16 byte WRITE BUFFER commands. + */ +static int +wrbuf16(ses_softc_t *ssc, uint8_t op, uint8_t b1, uint8_t b2, + uint8_t b3, int slp) +{ + int err, amt; + char *sdata; + struct scfg *cc = ssc->ses_private; + static char cdb[10] = { WRITE_BUFFER, 1, 0, 0, 0, 0, 0, 0, 16, 0 }; + + if (cc == NULL) + return (0); + + sdata = SES_MALLOC(16); + if (sdata == NULL) + return (ENOMEM); + + SES_DLOG(ssc, "saf_wrbuf16 %x %x %x %x\n", op, b1, b2, b3); + + sdata[0] = op; + sdata[1] = b1; + sdata[2] = b2; + sdata[3] = b3; + MEMZERO(&sdata[4], 12); + amt = -16; + err = ses_runcmd(ssc, cdb, 10, sdata, &amt); + SES_FREE(sdata, 16); + return (err); +} + +/* + * This function updates the status byte for the device slot described. + * + * Since this is an optional SAF-TE command, there's no point in + * returning an error. + */ +static void +wrslot_stat(ses_softc_t *ssc, int slp) +{ + int i, amt; + encobj *ep; + char cdb[10], *sdata; + struct scfg *cc = ssc->ses_private; + + if (cc == NULL) + return; + + SES_DLOG(ssc, "saf_wrslot\n"); + cdb[0] = WRITE_BUFFER; + cdb[1] = 1; + cdb[2] = 0; + cdb[3] = 0; + cdb[4] = 0; + cdb[5] = 0; + cdb[6] = 0; + cdb[7] = 0; + cdb[8] = cc->Nslots * 3 + 1; + cdb[9] = 0; + + sdata = SES_MALLOC(cc->Nslots * 3 + 1); + if (sdata == NULL) + return; + MEMZERO(sdata, cc->Nslots * 3 + 1); + + sdata[0] = SAFTE_WT_DSTAT; + for (i = 0; i < cc->Nslots; i++) { + ep = &ssc->ses_objmap[cc->slotoff + i]; + SES_DLOG(ssc, "saf_wrslot %d <- %x\n", i, ep->priv & 0xff); + sdata[1 + (3 * i)] = ep->priv & 0xff; + } + amt = -(cc->Nslots * 3 + 1); + (void) ses_runcmd(ssc, cdb, 10, sdata, &amt); + SES_FREE(sdata, cc->Nslots * 3 + 1); +} + +/* + * This function issues the "PERFORM SLOT OPERATION" command. + */ +static int +perf_slotop(ses_softc_t *ssc, uint8_t slot, uint8_t opflag, int slp) +{ + int err, amt; + char *sdata; + struct scfg *cc = ssc->ses_private; + static char cdb[10] = + { WRITE_BUFFER, 1, 0, 0, 0, 0, 0, 0, SAFT_SCRATCH, 0 }; + + if (cc == NULL) + return (0); + + sdata = SES_MALLOC(SAFT_SCRATCH); + if (sdata == NULL) + return (ENOMEM); + MEMZERO(sdata, SAFT_SCRATCH); + + sdata[0] = SAFTE_WT_SLTOP; + sdata[1] = slot; + sdata[2] = opflag; + SES_DLOG(ssc, "saf_slotop slot %d op %x\n", slot, opflag); + amt = -SAFT_SCRATCH; + err = ses_runcmd(ssc, cdb, 10, sdata, &amt); + SES_FREE(sdata, SAFT_SCRATCH); + return (err); +} diff --git a/sys/scsi/ses.h b/sys/scsi/ses.h new file mode 100644 index 00000000000..62923ced112 --- /dev/null +++ b/sys/scsi/ses.h @@ -0,0 +1,175 @@ +/* $OpenBSD: ses.h,v 1.1 2000/02/21 08:23:30 mjacob Exp $ */ +/* $NetBSD: ses.h,v 1.1 2000/01/20 17:07:41 mjacob Exp $ */ +/* + * Copyright (C) 2000 National Aeronautics & Space Administration + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +#define SESIOC (('s' - 040) << 8) +#define SESIOC_GETNOBJ _IO(SESIOC, 1) +#define SESIOC_GETOBJMAP _IO(SESIOC, 2) +#define SESIOC_GETENCSTAT _IO(SESIOC, 3) +#define SESIOC_SETENCSTAT _IO(SESIOC, 4) +#define SESIOC_GETOBJSTAT _IO(SESIOC, 5) +#define SESIOC_SETOBJSTAT _IO(SESIOC, 6) +#define SESIOC_GETTEXT _IO(SESIOC, 7) +#define SESIOC_INIT _IO(SESIOC, 8) + +/* + * Platform Independent Definitions for SES devices. + */ +/* + * SCSI Based Environmental Services Application Defines + * + * Based almost entirely on SCSI-3 SES Revision 8A specification, + * but slightly abstracted as the underlying device may in fact + * be a SAF-TE or vendor unique device. + */ +/* + * SES Driver Operations: + * (The defines themselves are platform and access method specific) + * + * SESIOC_GETNOBJ + * SESIOC_GETOBJMAP + * SESIOC_GETENCSTAT + * SESIOC_SETENCSTAT + * SESIOC_GETOBJSTAT + * SESIOC_SETOBJSTAT + * SESIOC_INIT + * + * + * An application finds out how many objects an SES instance + * is managing by performing a SESIOC_GETNOBJ operation. It then + * performs a SESIOC_GETOBJMAP to get the map that contains the + * object identifiers for all objects (see ses_object below). + * This information is static. + * + * The application may perform SESIOC_GETOBJSTAT operations to retrieve + * status on an object (see the ses_objstat structure below), SESIOC_SETOBJSTAT + * operations to set status for an object. + * + * Similarly overall enclosure status me be fetched or set via + * SESIOC_GETENCSTAT or SESIOC_SETENCSTAT operations (see ses_encstat below). + * + * Readers should note that there is nothing that requires either a set + * or a clear operation to actually latch and do anything in the target. + * + * A SESIOC_INIT operation causes the enclosure to be initialized. + */ + +typedef struct { + unsigned int obj_id; /* Object Identifier */ + unsigned char subencid; /* SubEnclosure ID */ + unsigned char object_type; /* Object Type */ +} ses_object; + +/* Object Types */ +#define SESTYP_UNSPECIFIED 0x00 +#define SESTYP_DEVICE 0x01 +#define SESTYP_POWER 0x02 +#define SESTYP_FAN 0x03 +#define SESTYP_THERM 0x04 +#define SESTYP_DOORLOCK 0x05 +#define SESTYP_ALARM 0x06 +#define SESTYP_ESCC 0x07 /* Enclosure SCC */ +#define SESTYP_SCC 0x08 /* SCC */ +#define SESTYP_NVRAM 0x09 +#define SESTYP_UPS 0x0b +#define SESTYP_DISPLAY 0x0c +#define SESTYP_KEYPAD 0x0d +#define SESTYP_SCSIXVR 0x0f +#define SESTYP_LANGUAGE 0x10 +#define SESTYP_COMPORT 0x11 +#define SESTYP_VOM 0x12 +#define SESTYP_AMMETER 0x13 +#define SESTYP_SCSI_TGT 0x14 +#define SESTYP_SCSI_INI 0x15 +#define SESTYP_SUBENC 0x16 + +/* + * Overall Enclosure Status + */ +typedef unsigned char ses_encstat; +#define SES_ENCSTAT_UNRECOV 0x1 +#define SES_ENCSTAT_CRITICAL 0x2 +#define SES_ENCSTAT_NONCRITICAL 0x4 +#define SES_ENCSTAT_INFO 0x8 + +/* + * Object Status + */ +typedef struct { + unsigned int obj_id; + unsigned char cstat[4]; +} ses_objstat; + +/* Summary SES Status Defines, Common Status Codes */ +#define SES_OBJSTAT_UNSUPPORTED 0 +#define SES_OBJSTAT_OK 1 +#define SES_OBJSTAT_CRIT 2 +#define SES_OBJSTAT_NONCRIT 3 +#define SES_OBJSTAT_UNRECOV 4 +#define SES_OBJSTAT_NOTINSTALLED 5 +#define SES_OBJSTAT_UNKNOWN 6 +#define SES_OBJSTAT_NOTAVAIL 7 + +/* + * For control pages, cstat[0] is the same for the + * enclosure and is common across all device types. + * + * If SESCTL_CSEL is set, then PRDFAIL, DISABLE and RSTSWAP + * are checked, otherwise bits that are specific to the device + * type in the other 3 bytes of cstat or checked. + */ +#define SESCTL_CSEL 0x80 +#define SESCTL_PRDFAIL 0x40 +#define SESCTL_DISABLE 0x20 +#define SESCTL_RSTSWAP 0x10 + + +/* Control bits, Device Elements, byte 2 */ +#define SESCTL_DRVLCK 0x40 /* "DO NOT REMOVE" */ +#define SESCTL_RQSINS 0x08 /* RQST INSERT */ +#define SESCTL_RQSRMV 0x04 /* RQST REMOVE */ +#define SESCTL_RQSID 0x02 /* RQST IDENT */ +/* Control bits, Device Elements, byte 3 */ +#define SESCTL_RQSFLT 0x20 /* RQST FAULT */ +#define SESCTL_DEVOFF 0x10 /* DEVICE OFF */ + +/* Control bits, Generic, byte 3 */ +#define SESCTL_RQSTFAIL 0x40 +#define SESCTL_RQSTON 0x20 + +/* + * Getting text for an object type is a little + * trickier because it's string data that can + * go up to 64 KBytes. Build this union and + * fill the obj_id with the id of the object who's + * help text you want, and if text is available, + * obj_text will be filled in, null terminated. + */ + +typedef union { + unsigned int obj_id; + char obj_text[1]; +} ses_hlptxt; |