sys/cam/scsi/scsi_enc.c

   1 /*-
   2  * Copyright (c) 2000 Matthew Jacob
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions, and the following disclaimer,
  10  *    without modification, immediately at the beginning of the file.
  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 AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  18  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31
  32 #include <sys/conf.h>
  33 #include <sys/errno.h>
  34 #include <sys/fcntl.h>
  35 #include <sys/kernel.h>
  36 #include <sys/kthread.h>
  37 #include <sys/lock.h>
  38 #include <sys/malloc.h>
  39 #include <sys/mutex.h>
  40 #include <sys/queue.h>
  41 #include <sys/sx.h>
  42 #include <sys/systm.h>
  43 #include <sys/sysctl.h>
  44 #include <sys/types.h>
  45
  46 #include <machine/stdarg.h>
  47
  48 #include <cam/cam.h>
  49 #include <cam/cam_ccb.h>
  50 #include <cam/cam_debug.h>
  51 #include <cam/cam_periph.h>
  52 #include <cam/cam_xpt_periph.h>
  53
  54 #include <cam/scsi/scsi_all.h>
  55 #include <cam/scsi/scsi_message.h>
  56 #include <cam/scsi/scsi_enc.h>
  57 #include <cam/scsi/scsi_enc_internal.h>
  58
  59 #include <opt_ses.h>
  60
  61 MALLOC_DEFINE(M_SCSIENC, "SCSI ENC", "SCSI ENC buffers");
  62
  63 /* Enclosure type independent driver */
  64
  65 static  d_open_t        enc_open;
  66 static  d_close_t       enc_close;
  67 static  d_ioctl_t       enc_ioctl;
  68 static  periph_init_t   enc_init;
  69 static  periph_ctor_t   enc_ctor;
  70 static  periph_oninv_t  enc_oninvalidate;
  71 static  periph_dtor_t   enc_dtor;
  72
  73 static void enc_async(void *, uint32_t, struct cam_path *, void *);
  74 static enctyp enc_type(struct ccb_getdev *);
  75
  76 SYSCTL_NODE(_kern_cam, OID_AUTO, enc, CTLFLAG_RD, 0,
  77             "CAM Enclosure Services driver");
  78
  79 static struct periph_driver encdriver = {
  80         enc_init, "ses",
  81         TAILQ_HEAD_INITIALIZER(encdriver.units), /* generation */ 0
  82 };
  83
  84 PERIPHDRIVER_DECLARE(enc, encdriver);
  85
  86 static struct cdevsw enc_cdevsw = {
  87         .d_version =    D_VERSION,
  88         .d_open =       enc_open,
  89         .d_close =      enc_close,
  90         .d_ioctl =      enc_ioctl,
  91         .d_name =       "ses",
  92         .d_flags =      D_TRACKCLOSE,
  93 };
  94
  95 static void
  96 enc_init(void)
  97 {
  98         cam_status status;
  99
 100         /*
 101          * Install a global async callback.  This callback will
 102          * receive async callbacks like "new device found".
 103          */
 104         status = xpt_register_async(AC_FOUND_DEVICE, enc_async, NULL, NULL);
 105
 106         if (status != CAM_REQ_CMP) {
 107                 printf("enc: Failed to attach master async callback "
 108                        "due to status 0x%x!\n", status);
 109         }
 110 }
 111
 112 static void
 113 enc_devgonecb(void *arg)
 114 {
 115         struct cam_periph *periph;
 116         struct enc_softc  *enc;
 117         struct mtx *mtx;
 118         int i;
 119
 120         periph = (struct cam_periph *)arg;
 121         mtx = cam_periph_mtx(periph);
 122         mtx_lock(mtx);
 123         enc = (struct enc_softc *)periph->softc;
 124
 125         /*
 126          * When we get this callback, we will get no more close calls from
 127          * devfs.  So if we have any dangling opens, we need to release the
 128          * reference held for that particular context.
 129          */
 130         for (i = 0; i < enc->open_count; i++)
 131                 cam_periph_release_locked(periph);
 132
 133         enc->open_count = 0;
 134
 135         /*
 136          * Release the reference held for the device node, it is gone now.
 137          */
 138         cam_periph_release_locked(periph);
 139
 140         /*
 141          * We reference the lock directly here, instead of using
 142          * cam_periph_unlock().  The reason is that the final call to
 143          * cam_periph_release_locked() above could result in the periph
 144          * getting freed.  If that is the case, dereferencing the periph
 145          * with a cam_periph_unlock() call would cause a page fault.
 146          */
 147         mtx_unlock(mtx);
 148 }
 149
 150 static void
 151 enc_oninvalidate(struct cam_periph *periph)
 152 {
 153         struct enc_softc *enc;
 154
 155         enc = periph->softc;
 156
 157         enc->enc_flags |= ENC_FLAG_INVALID;
 158
 159         /* If the sub-driver has an invalidate routine, call it */
 160         if (enc->enc_vec.softc_invalidate != NULL)
 161                 enc->enc_vec.softc_invalidate(enc);
 162
 163         /*
 164          * Unregister any async callbacks.
 165          */
 166         xpt_register_async(0, enc_async, periph, periph->path);
 167
 168         /*
 169          * Shutdown our daemon.
 170          */
 171         enc->enc_flags |= ENC_FLAG_SHUTDOWN;
 172         if (enc->enc_daemon != NULL) {
 173                 /* Signal the ses daemon to terminate. */
 174                 wakeup(enc->enc_daemon);
 175         }
 176         callout_drain(&enc->status_updater);
 177
 178         destroy_dev_sched_cb(enc->enc_dev, enc_devgonecb, periph);
 179 }
 180
 181 static void
 182 enc_dtor(struct cam_periph *periph)
 183 {
 184         struct enc_softc *enc;
 185
 186         enc = periph->softc;
 187
 188         /* If the sub-driver has a cleanup routine, call it */
 189         if (enc->enc_vec.softc_cleanup != NULL)
 190                 enc->enc_vec.softc_cleanup(enc);
 191
 192         if (enc->enc_boot_hold_ch.ich_func != NULL) {
 193                 config_intrhook_disestablish(&enc->enc_boot_hold_ch);
 194                 enc->enc_boot_hold_ch.ich_func = NULL;
 195         }
 196
 197         ENC_FREE(enc);
 198 }
 199
 200 static void
 201 enc_async(void *callback_arg, uint32_t code, struct cam_path *path, void *arg)
 202 {
 203         struct cam_periph *periph;
 204
 205         periph = (struct cam_periph *)callback_arg;
 206
 207         switch(code) {
 208         case AC_FOUND_DEVICE:
 209         {
 210                 struct ccb_getdev *cgd;
 211                 cam_status status;
 212                 path_id_t path_id;
 213
 214                 cgd = (struct ccb_getdev *)arg;
 215                 if (arg == NULL) {
 216                         break;
 217                 }
 218
 219                 if (enc_type(cgd) == ENC_NONE) {
 220                         /*
 221                          * Schedule announcement of the ENC bindings for
 222                          * this device if it is managed by a SEP.
 223                          */
 224                         path_id = xpt_path_path_id(path);
 225                         xpt_lock_buses();
 226                         TAILQ_FOREACH(periph, &encdriver.units, unit_links) {
 227                                 struct enc_softc *softc;
 228
 229                                 softc = (struct enc_softc *)periph->softc;
 230                                 if (xpt_path_path_id(periph->path) != path_id
 231                                  || softc == NULL
 232                                  || (softc->enc_flags & ENC_FLAG_INITIALIZED)
 233                                   == 0
 234                                  || softc->enc_vec.device_found == NULL)
 235                                         continue;
 236
 237                                 softc->enc_vec.device_found(softc);
 238                         }
 239                         xpt_unlock_buses();
 240                         return;
 241                 }
 242
 243                 status = cam_periph_alloc(enc_ctor, enc_oninvalidate,
 244                     enc_dtor, NULL, "ses", CAM_PERIPH_BIO,
 245                     path, enc_async, AC_FOUND_DEVICE, cgd);
 246
 247                 if (status != CAM_REQ_CMP && status != CAM_REQ_INPROG) {
 248                         printf("enc_async: Unable to probe new device due to "
 249                             "status 0x%x\n", status);
 250                 }
 251                 break;
 252         }
 253         default:
 254                 cam_periph_async(periph, code, path, arg);
 255                 break;
 256         }
 257 }
 258
 259 static int
 260 enc_open(struct cdev *dev, int flags, int fmt, struct thread *td)
 261 {
 262         struct cam_periph *periph;
 263         struct enc_softc *softc;
 264         int error = 0;
 265
 266         periph = (struct cam_periph *)dev->si_drv1;
 267         if (periph == NULL) {
 268                 return (ENXIO);
 269         }
 270
 271         if (cam_periph_acquire(periph) != CAM_REQ_CMP)
 272                 return (ENXIO);
 273
 274         cam_periph_lock(periph);
 275
 276         softc = (struct enc_softc *)periph->softc;
 277
 278         if ((softc->enc_flags & ENC_FLAG_INITIALIZED) == 0) {
 279                 error = ENXIO;
 280                 goto out;
 281         }
 282         if (softc->enc_flags & ENC_FLAG_INVALID) {
 283                 error = ENXIO;
 284                 goto out;
 285         }
 286 out:
 287         if (error != 0)
 288                 cam_periph_release_locked(periph);
 289         else
 290                 softc->open_count++;
 291
 292         cam_periph_unlock(periph);
 293
 294         return (error);
 295 }
 296
 297 static int
 298 enc_close(struct cdev *dev, int flag, int fmt, struct thread *td)
 299 {
 300         struct cam_periph *periph;
 301         struct enc_softc  *enc;
 302         struct mtx *mtx;
 303
 304         periph = (struct cam_periph *)dev->si_drv1;
 305         if (periph == NULL)
 306                 return (ENXIO);
 307         mtx = cam_periph_mtx(periph);
 308         mtx_lock(mtx);
 309
 310         enc = periph->softc;
 311         enc->open_count--;
 312
 313         cam_periph_release_locked(periph);
 314
 315         /*
 316          * We reference the lock directly here, instead of using
 317          * cam_periph_unlock().  The reason is that the call to
 318          * cam_periph_release_locked() above could result in the periph
 319          * getting freed.  If that is the case, dereferencing the periph
 320          * with a cam_periph_unlock() call would cause a page fault.
 321          *
 322          * cam_periph_release() avoids this problem using the same method,
 323          * but we're manually acquiring and dropping the lock here to
 324          * protect the open count and avoid another lock acquisition and
 325          * release.
 326          */
 327         mtx_unlock(mtx);
 328
 329         return (0);
 330 }
 331
 332 int
 333 enc_error(union ccb *ccb, uint32_t cflags, uint32_t sflags)
 334 {
 335         struct enc_softc *softc;
 336         struct cam_periph *periph;
 337
 338         periph = xpt_path_periph(ccb->ccb_h.path);
 339         softc = (struct enc_softc *)periph->softc;
 340
 341         return (cam_periph_error(ccb, cflags, sflags, &softc->saved_ccb));
 342 }
 343
 344 static int
 345 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag,
 346          struct thread *td)
 347 {
 348         struct cam_periph *periph;
 349         encioc_enc_status_t tmp;
 350         encioc_string_t sstr;
 351         encioc_elm_status_t elms;
 352         encioc_elm_desc_t elmd;
 353         encioc_elm_devnames_t elmdn;
 354         encioc_element_t *uelm;
 355         enc_softc_t *enc;
 356         enc_cache_t *cache;
 357         void *addr;
 358         int error, i;
 359
 360
 361         if (arg_addr)
 362                 addr = *((caddr_t *) arg_addr);
 363         else
 364                 addr = NULL;
 365
 366         periph = (struct cam_periph *)dev->si_drv1;
 367         if (periph == NULL)
 368                 return (ENXIO);
 369
 370         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering encioctl\n"));
 371
 372         cam_periph_lock(periph);
 373         enc = (struct enc_softc *)periph->softc;
 374         cache = &enc->enc_cache;
 375
 376         /*
 377          * Now check to see whether we're initialized or not.
 378          * This actually should never fail as we're not supposed
 379          * to get past enc_open w/o successfully initializing
 380          * things.
 381          */
 382         if ((enc->enc_flags & ENC_FLAG_INITIALIZED) == 0) {
 383                 cam_periph_unlock(periph);
 384                 return (ENXIO);
 385         }
 386         cam_periph_unlock(periph);
 387
 388         error = 0;
 389
 390         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
 391             ("trying to do ioctl %#lx\n", cmd));
 392
 393         /*
 394          * If this command can change the device's state,
 395          * we must have the device open for writing.
 396          *
 397          * For commands that get information about the
 398          * device- we don't need to lock the peripheral
 399          * if we aren't running a command.  The periph
 400          * also can't go away while a user process has
 401          * it open.
 402          */
 403         switch (cmd) {
 404         case ENCIOC_GETNELM:
 405         case ENCIOC_GETELMMAP:
 406         case ENCIOC_GETENCSTAT:
 407         case ENCIOC_GETELMSTAT:
 408         case ENCIOC_GETELMDESC:
 409         case ENCIOC_GETELMDEVNAMES:
 410                 break;
 411         default:
 412                 if ((flag & FWRITE) == 0) {
 413                         return (EBADF);
 414                 }
 415         }
 416
 417         /*
 418          * XXX The values read here are only valid for the current
 419          *     configuration generation.  We need these ioctls
 420          *     to also pass in/out a generation number.
 421          */
 422         sx_slock(&enc->enc_cache_lock);
 423         switch (cmd) {
 424         case ENCIOC_GETNELM:
 425                 error = copyout(&cache->nelms, addr, sizeof (cache->nelms));
 426                 break;
 427
 428         case ENCIOC_GETELMMAP:
 429                 for (uelm = addr, i = 0; i != cache->nelms; i++) {
 430                         encioc_element_t kelm;
 431                         kelm.elm_idx = i;
 432                         kelm.elm_subenc_id = cache->elm_map[i].subenclosure;
 433                         kelm.elm_type = cache->elm_map[i].enctype;
 434                         error = copyout(&kelm, &uelm[i], sizeof(kelm));
 435                         if (error)
 436                                 break;
 437                 }
 438                 break;
 439
 440         case ENCIOC_GETENCSTAT:
 441                 cam_periph_lock(periph);
 442                 error = enc->enc_vec.get_enc_status(enc, 1);
 443                 if (error) {
 444                         cam_periph_unlock(periph);
 445                         break;
 446                 }
 447                 tmp = cache->enc_status;
 448                 cam_periph_unlock(periph);
 449                 error = copyout(&tmp, addr, sizeof(tmp));
 450                 cache->enc_status = tmp;
 451                 break;
 452
 453         case ENCIOC_SETENCSTAT:
 454                 error = copyin(addr, &tmp, sizeof(tmp));
 455                 if (error)
 456                         break;
 457                 cam_periph_lock(periph);
 458                 error = enc->enc_vec.set_enc_status(enc, tmp, 1);
 459                 cam_periph_unlock(periph);
 460                 break;
 461
 462         case ENCIOC_GETSTRING:
 463         case ENCIOC_SETSTRING:
 464                 if (enc->enc_vec.handle_string == NULL) {
 465                         error = EINVAL;
 466                         break;
 467                 }
 468                 error = copyin(addr, &sstr, sizeof(sstr));
 469                 if (error)
 470                         break;
 471                 cam_periph_lock(periph);
 472                 error = enc->enc_vec.handle_string(enc, &sstr, cmd);
 473                 cam_periph_unlock(periph);
 474                 break;
 475
 476         case ENCIOC_GETELMSTAT:
 477                 error = copyin(addr, &elms, sizeof(elms));
 478                 if (error)
 479                         break;
 480                 if (elms.elm_idx >= cache->nelms) {
 481                         error = EINVAL;
 482                         break;
 483                 }
 484                 cam_periph_lock(periph);
 485                 error = enc->enc_vec.get_elm_status(enc, &elms, 1);
 486                 cam_periph_unlock(periph);
 487                 if (error)
 488                         break;
 489                 error = copyout(&elms, addr, sizeof(elms));
 490                 break;
 491
 492         case ENCIOC_GETELMDESC:
 493                 error = copyin(addr, &elmd, sizeof(elmd));
 494                 if (error)
 495                         break;
 496                 if (elmd.elm_idx >= cache->nelms) {
 497                         error = EINVAL;
 498                         break;
 499                 }
 500                 if (enc->enc_vec.get_elm_desc != NULL) {
 501                         error = enc->enc_vec.get_elm_desc(enc, &elmd);
 502                         if (error)
 503                                 break;
 504                 } else
 505                         elmd.elm_desc_len = 0;
 506                 error = copyout(&elmd, addr, sizeof(elmd));
 507                 break;
 508
 509         case ENCIOC_GETELMDEVNAMES:
 510                 if (enc->enc_vec.get_elm_devnames == NULL) {
 511                         error = EINVAL;
 512                         break;
 513                 }
 514                 error = copyin(addr, &elmdn, sizeof(elmdn));
 515                 if (error)
 516                         break;
 517                 if (elmdn.elm_idx >= cache->nelms) {
 518                         error = EINVAL;
 519                         break;
 520                 }
 521                 cam_periph_lock(periph);
 522                 error = (*enc->enc_vec.get_elm_devnames)(enc, &elmdn);
 523                 cam_periph_unlock(periph);
 524                 if (error)
 525                         break;
 526                 error = copyout(&elmdn, addr, sizeof(elmdn));
 527                 break;
 528
 529         case ENCIOC_SETELMSTAT:
 530                 error = copyin(addr, &elms, sizeof(elms));
 531                 if (error)
 532                         break;
 533
 534                 if (elms.elm_idx >= cache->nelms) {
 535                         error = EINVAL;
 536                         break;
 537                 }
 538                 cam_periph_lock(periph);
 539                 error = enc->enc_vec.set_elm_status(enc, &elms, 1);
 540                 cam_periph_unlock(periph);
 541
 542                 break;
 543
 544         case ENCIOC_INIT:
 545
 546                 cam_periph_lock(periph);
 547                 error = enc->enc_vec.init_enc(enc);
 548                 cam_periph_unlock(periph);
 549                 break;
 550
 551         default:
 552                 cam_periph_lock(periph);
 553                 error = cam_periph_ioctl(periph, cmd, arg_addr, enc_error);
 554                 cam_periph_unlock(periph);
 555                 break;
 556         }
 557         sx_sunlock(&enc->enc_cache_lock);
 558         return (error);
 559 }
 560
 561 int
 562 enc_runcmd(struct enc_softc *enc, char *cdb, int cdbl, char *dptr, int *dlenp)
 563 {
 564         int error, dlen, tdlen;
 565         ccb_flags ddf;
 566         union ccb *ccb;
 567
 568         CAM_DEBUG(enc->periph->path, CAM_DEBUG_TRACE,
 569             ("entering enc_runcmd\n"));
 570         if (dptr) {
 571                 if ((dlen = *dlenp) < 0) {
 572                         dlen = -dlen;
 573                         ddf = CAM_DIR_OUT;
 574                 } else {
 575                         ddf = CAM_DIR_IN;
 576                 }
 577         } else {
 578                 dlen = 0;
 579                 ddf = CAM_DIR_NONE;
 580         }
 581
 582         if (cdbl > IOCDBLEN) {
 583                 cdbl = IOCDBLEN;
 584         }
 585
 586         ccb = cam_periph_getccb(enc->periph, CAM_PRIORITY_NORMAL);
 587         if (enc->enc_type == ENC_SEMB_SES || enc->enc_type == ENC_SEMB_SAFT) {
 588                 tdlen = min(dlen, 1020);
 589                 tdlen = (tdlen + 3) & ~3;
 590                 cam_fill_ataio(&ccb->ataio, 0, NULL, ddf, 0, dptr, tdlen,
 591                     30 * 1000);
 592                 if (cdb[0] == RECEIVE_DIAGNOSTIC)
 593                         ata_28bit_cmd(&ccb->ataio,
 594                             ATA_SEP_ATTN, cdb[2], 0x02, tdlen / 4);
 595                 else if (cdb[0] == SEND_DIAGNOSTIC)
 596                         ata_28bit_cmd(&ccb->ataio,
 597                             ATA_SEP_ATTN, dlen > 0 ? dptr[0] : 0,
 598                             0x82, tdlen / 4);
 599                 else if (cdb[0] == READ_BUFFER)
 600                         ata_28bit_cmd(&ccb->ataio,
 601                             ATA_SEP_ATTN, cdb[2], 0x00, tdlen / 4);
 602                 else
 603                         ata_28bit_cmd(&ccb->ataio,
 604                             ATA_SEP_ATTN, dlen > 0 ? dptr[0] : 0,
 605                             0x80, tdlen / 4);
 606         } else {
 607                 tdlen = dlen;
 608                 cam_fill_csio(&ccb->csio, 0, NULL, ddf, MSG_SIMPLE_Q_TAG,
 609                     dptr, dlen, sizeof (struct scsi_sense_data), cdbl,
 610                     60 * 1000);
 611                 bcopy(cdb, ccb->csio.cdb_io.cdb_bytes, cdbl);
 612         }
 613
 614         error = cam_periph_runccb(ccb, enc_error, ENC_CFLAGS, ENC_FLAGS, NULL);
 615         if (error) {
 616                 if (dptr) {
 617                         *dlenp = dlen;
 618                 }
 619         } else {
 620                 if (dptr) {
 621                         if (ccb->ccb_h.func_code == XPT_ATA_IO)
 622                                 *dlenp = ccb->ataio.resid;
 623                         else
 624                                 *dlenp = ccb->csio.resid;
 625                         *dlenp += tdlen - dlen;
 626                 }
 627         }
 628         xpt_release_ccb(ccb);
 629         CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE,
 630             ("exiting enc_runcmd: *dlenp = %d\n", *dlenp));
 631         return (error);
 632 }
 633
 634 void
 635 enc_log(struct enc_softc *enc, const char *fmt, ...)
 636 {
 637         va_list ap;
 638
 639         printf("%s%d: ", enc->periph->periph_name, enc->periph->unit_number);
 640         va_start(ap, fmt);
 641         vprintf(fmt, ap);
 642         va_end(ap);
 643 }
 644
 645 /*
 646  * The code after this point runs on many platforms,
 647  * so forgive the slightly awkward and nonconforming
 648  * appearance.
 649  */
 650
 651 /*
 652  * Is this a device that supports enclosure services?
 653  *
 654  * It's a pretty simple ruleset- if it is device type
 655  * 0x0D (13), it's an ENCLOSURE device.
 656  */
 657
 658 #define SAFTE_START     44
 659 #define SAFTE_END       50
 660 #define SAFTE_LEN       SAFTE_END-SAFTE_START
 661
 662 static enctyp
 663 enc_type(struct ccb_getdev *cgd)
 664 {
 665         int buflen;
 666         unsigned char *iqd;
 667
 668         if (cgd->protocol == PROTO_SEMB) {
 669                 iqd = (unsigned char *)&cgd->ident_data;
 670                 if (STRNCMP(iqd + 43, "S-E-S", 5) == 0)
 671                         return (ENC_SEMB_SES);
 672                 else if (STRNCMP(iqd + 43, "SAF-TE", 6) == 0)
 673                         return (ENC_SEMB_SAFT);
 674                 return (ENC_NONE);
 675
 676         } else if (cgd->protocol != PROTO_SCSI)
 677                 return (ENC_NONE);
 678
 679         iqd = (unsigned char *)&cgd->inq_data;
 680         buflen = min(sizeof(cgd->inq_data),
 681             SID_ADDITIONAL_LENGTH(&cgd->inq_data));
 682
 683         if ((iqd[0] & 0x1f) == T_ENCLOSURE) {
 684                 if ((iqd[2] & 0x7) > 2) {
 685                         return (ENC_SES);
 686                 } else {
 687                         return (ENC_SES_SCSI2);
 688                 }
 689                 return (ENC_NONE);
 690         }
 691
 692 #ifdef  SES_ENABLE_PASSTHROUGH
 693         if ((iqd[6] & 0x40) && (iqd[2] & 0x7) >= 2) {
 694                 /*
 695                  * PassThrough Device.
 696                  */
 697                 return (ENC_SES_PASSTHROUGH);
 698         }
 699 #endif
 700
 701         /*
 702          * The comparison is short for a reason-
 703          * some vendors were chopping it short.
 704          */
 705
 706         if (buflen < SAFTE_END - 2) {
 707                 return (ENC_NONE);
 708         }
 709
 710         if (STRNCMP((char *)&iqd[SAFTE_START], "SAF-TE", SAFTE_LEN - 2) == 0) {
 711                 return (ENC_SAFT);
 712         }
 713         return (ENC_NONE);
 714 }
 715
 716 /*================== Enclosure Monitoring/Processing Daemon ==================*/
 717 /**
 718  * \brief Queue an update request for a given action, if needed.
 719  *
 720  * \param enc           SES softc to queue the request for.
 721  * \param action        Action requested.
 722  */
 723 void
 724 enc_update_request(enc_softc_t *enc, uint32_t action)
 725 {
 726         if ((enc->pending_actions & (0x1 << action)) == 0) {
 727                 enc->pending_actions |= (0x1 << action);
 728                 ENC_DLOG(enc, "%s: queing requested action %d\n",
 729                     __func__, action);
 730                 if (enc->current_action == ENC_UPDATE_NONE)
 731                         wakeup(enc->enc_daemon);
 732         } else {
 733                 ENC_DLOG(enc, "%s: ignoring requested action %d - "
 734                     "Already queued\n", __func__, action);
 735         }
 736 }
 737
 738 /**
 739  * \brief Invoke the handler of the highest priority pending
 740  *        state in the SES state machine.
 741  *
 742  * \param enc  The SES instance invoking the state machine.
 743  */
 744 static void
 745 enc_fsm_step(enc_softc_t *enc)
 746 {
 747         union ccb            *ccb;
 748         uint8_t              *buf;
 749         struct enc_fsm_state *cur_state;
 750         int                   error;
 751         uint32_t              xfer_len;
 752
 753         ENC_DLOG(enc, "%s enter %p\n", __func__, enc);
 754
 755         enc->current_action   = ffs(enc->pending_actions) - 1;
 756         enc->pending_actions &= ~(0x1 << enc->current_action);
 757
 758         cur_state = &enc->enc_fsm_states[enc->current_action];
 759
 760         buf = NULL;
 761         if (cur_state->buf_size != 0) {
 762                 cam_periph_unlock(enc->periph);
 763                 buf = malloc(cur_state->buf_size, M_SCSIENC, M_WAITOK|M_ZERO);
 764                 cam_periph_lock(enc->periph);
 765         }
 766
 767         error = 0;
 768         ccb   = NULL;
 769         if (cur_state->fill != NULL) {
 770                 ccb = cam_periph_getccb(enc->periph, CAM_PRIORITY_NORMAL);
 771
 772                 error = cur_state->fill(enc, cur_state, ccb, buf);
 773                 if (error != 0)
 774                         goto done;
 775
 776                 error = cam_periph_runccb(ccb, cur_state->error,
 777                                           ENC_CFLAGS,
 778                                           ENC_FLAGS|SF_QUIET_IR, NULL);
 779         }
 780
 781         if (ccb != NULL) {
 782                 if (ccb->ccb_h.func_code == XPT_ATA_IO)
 783                         xfer_len = ccb->ataio.dxfer_len - ccb->ataio.resid;
 784                 else
 785                         xfer_len = ccb->csio.dxfer_len - ccb->csio.resid;
 786         } else
 787                 xfer_len = 0;
 788
 789         cam_periph_unlock(enc->periph);
 790         cur_state->done(enc, cur_state, ccb, &buf, error, xfer_len);
 791         cam_periph_lock(enc->periph);
 792
 793 done:
 794         ENC_DLOG(enc, "%s exit - result %d\n", __func__, error);
 795         ENC_FREE_AND_NULL(buf);
 796         if (ccb != NULL)
 797                 xpt_release_ccb(ccb);
 798 }
 799
 800 /**
 801  * \invariant Called with cam_periph mutex held.
 802  */
 803 static void
 804 enc_status_updater(void *arg)
 805 {
 806         enc_softc_t *enc;
 807
 808         enc = arg;
 809         if (enc->enc_vec.poll_status != NULL)
 810                 enc->enc_vec.poll_status(enc);
 811 }
 812
 813 static void
 814 enc_daemon(void *arg)
 815 {
 816         enc_softc_t *enc;
 817
 818         enc = arg;
 819
 820         cam_periph_lock(enc->periph);
 821         while ((enc->enc_flags & ENC_FLAG_SHUTDOWN) == 0) {
 822                 if (enc->pending_actions == 0) {
 823                         struct intr_config_hook *hook;
 824
 825                         /*
 826                          * Reset callout and msleep, or
 827                          * issue timed task completion
 828                          * status command.
 829                          */
 830                         enc->current_action = ENC_UPDATE_NONE;
 831
 832                         /*
 833                          * We've been through our state machine at least
 834                          * once.  Allow the transition to userland.
 835                          */
 836                         hook = &enc->enc_boot_hold_ch;
 837                         if (hook->ich_func != NULL) {
 838                                 config_intrhook_disestablish(hook);
 839                                 hook->ich_func = NULL;
 840                         }
 841
 842                         callout_reset(&enc->status_updater, 60*hz,
 843                                       enc_status_updater, enc);
 844
 845                         cam_periph_sleep(enc->periph, enc->enc_daemon,
 846                                          PUSER, "idle", 0);
 847                 } else {
 848                         enc_fsm_step(enc);
 849                 }
 850         }
 851         enc->enc_daemon = NULL;
 852         cam_periph_unlock(enc->periph);
 853         cam_periph_release(enc->periph);
 854         kproc_exit(0);
 855 }
 856
 857 static int
 858 enc_kproc_init(enc_softc_t *enc)
 859 {
 860         int result;
 861
 862         callout_init_mtx(&enc->status_updater, cam_periph_mtx(enc->periph), 0);
 863
 864         if (cam_periph_acquire(enc->periph) != CAM_REQ_CMP)
 865                 return (ENXIO);
 866
 867         result = kproc_create(enc_daemon, enc, &enc->enc_daemon, /*flags*/0,
 868                               /*stackpgs*/0, "enc_daemon%d",
 869                               enc->periph->unit_number);
 870         if (result == 0) {
 871                 /* Do an initial load of all page data. */
 872                 cam_periph_lock(enc->periph);
 873                 enc->enc_vec.poll_status(enc);
 874                 cam_periph_unlock(enc->periph);
 875         } else
 876                 cam_periph_release(enc->periph);
 877         return (result);
 878 }
 879
 880 /**
 881  * \brief Interrupt configuration hook callback associated with
 882  *        enc_boot_hold_ch.
 883  *
 884  * Since interrupts are always functional at the time of enclosure
 885  * configuration, there is nothing to be done when the callback occurs.
 886  * This hook is only registered to hold up boot processing while initial
 887  * eclosure processing occurs.
 888  *
 889  * \param arg  The enclosure softc, but currently unused in this callback.
 890  */
 891 static void
 892 enc_nop_confighook_cb(void *arg __unused)
 893 {
 894 }
 895
 896 static cam_status
 897 enc_ctor(struct cam_periph *periph, void *arg)
 898 {
 899         cam_status status = CAM_REQ_CMP_ERR;
 900         int err;
 901         enc_softc_t *enc;
 902         struct ccb_getdev *cgd;
 903         char *tname;
 904
 905         cgd = (struct ccb_getdev *)arg;
 906         if (cgd == NULL) {
 907                 printf("enc_ctor: no getdev CCB, can't register device\n");
 908                 goto out;
 909         }
 910
 911         enc = ENC_MALLOCZ(sizeof(*enc));
 912         if (enc == NULL) {
 913                 printf("enc_ctor: Unable to probe new device. "
 914                        "Unable to allocate enc\n");
 915                 goto out;
 916         }
 917         enc->periph = periph;
 918         enc->current_action = ENC_UPDATE_INVALID;
 919
 920         enc->enc_type = enc_type(cgd);
 921         sx_init(&enc->enc_cache_lock, "enccache");
 922
 923         switch (enc->enc_type) {
 924         case ENC_SES:
 925         case ENC_SES_SCSI2:
 926         case ENC_SES_PASSTHROUGH:
 927         case ENC_SEMB_SES:
 928                 err = ses_softc_init(enc);
 929                 break;
 930         case ENC_SAFT:
 931         case ENC_SEMB_SAFT:
 932                 err = safte_softc_init(enc);
 933                 break;
 934         case ENC_NONE:
 935         default:
 936                 ENC_FREE(enc);
 937                 return (CAM_REQ_CMP_ERR);
 938         }
 939
 940         if (err) {
 941                 xpt_print(periph->path, "error %d initializing\n", err);
 942                 goto out;
 943         }
 944
 945         /*
 946          * Hold off userland until we have made at least one pass
 947          * through our state machine so that physical path data is
 948          * present.
 949          */
 950         if (enc->enc_vec.poll_status != NULL) {
 951                 enc->enc_boot_hold_ch.ich_func = enc_nop_confighook_cb;
 952                 enc->enc_boot_hold_ch.ich_arg = enc;
 953                 config_intrhook_establish(&enc->enc_boot_hold_ch);
 954         }
 955
 956         /*
 957          * The softc field is set only once the enc is fully initialized
 958          * so that we can rely on this field to detect partially
 959          * initialized periph objects in the AC_FOUND_DEVICE handler.
 960          */
 961         periph->softc = enc;
 962
 963         cam_periph_unlock(periph);
 964         if (enc->enc_vec.poll_status != NULL) {
 965                 err = enc_kproc_init(enc);
 966                 if (err) {
 967                         xpt_print(periph->path,
 968                                   "error %d starting enc_daemon\n", err);
 969                         goto out;
 970                 }
 971         }
 972
 973         /*
 974          * Acquire a reference to the periph before we create the devfs
 975          * instance for it.  We'll release this reference once the devfs
 976          * instance has been freed.
 977          */
 978         if (cam_periph_acquire(periph) != CAM_REQ_CMP) {
 979                 xpt_print(periph->path, "%s: lost periph during "
 980                           "registration!\n", __func__);
 981                 cam_periph_lock(periph);
 982
 983                 return (CAM_REQ_CMP_ERR);
 984         }
 985
 986         enc->enc_dev = make_dev(&enc_cdevsw, periph->unit_number,
 987             UID_ROOT, GID_OPERATOR, 0600, "%s%d",
 988             periph->periph_name, periph->unit_number);
 989
 990         cam_periph_lock(periph);
 991         enc->enc_dev->si_drv1 = periph;
 992
 993         enc->enc_flags |= ENC_FLAG_INITIALIZED;
 994
 995         /*
 996          * Add an async callback so that we get notified if this
 997          * device goes away.
 998          */
 999         xpt_register_async(AC_LOST_DEVICE, enc_async, periph, periph->path);
1000
1001         switch (enc->enc_type) {
1002         default:
1003         case ENC_NONE:
1004                 tname = "No ENC device";
1005                 break;
1006         case ENC_SES_SCSI2:
1007                 tname = "SCSI-2 ENC Device";
1008                 break;
1009         case ENC_SES:
1010                 tname = "SCSI-3 ENC Device";
1011                 break;
1012         case ENC_SES_PASSTHROUGH:
1013                 tname = "ENC Passthrough Device";
1014                 break;
1015         case ENC_SAFT:
1016                 tname = "SAF-TE Compliant Device";
1017                 break;
1018         case ENC_SEMB_SES:
1019                 tname = "SEMB SES Device";
1020                 break;
1021         case ENC_SEMB_SAFT:
1022                 tname = "SEMB SAF-TE Device";
1023                 break;
1024         }
1025         xpt_announce_periph(periph, tname);
1026         status = CAM_REQ_CMP;
1027
1028 out:
1029         if (status != CAM_REQ_CMP)
1030                 enc_dtor(periph);
1031         return (status);
1032 }
1033