2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2000 Matthew Jacob
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions, and the following disclaimer,
12 * without modification, immediately at the beginning of the file.
13 * 2. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
35 #include <sys/errno.h>
36 #include <sys/fcntl.h>
37 #include <sys/kernel.h>
38 #include <sys/kthread.h>
40 #include <sys/malloc.h>
41 #include <sys/mutex.h>
43 #include <sys/queue.h>
46 #include <sys/sysent.h>
47 #include <sys/systm.h>
48 #include <sys/sysctl.h>
49 #include <sys/types.h>
51 #include <machine/stdarg.h>
54 #include <cam/cam_ccb.h>
55 #include <cam/cam_debug.h>
56 #include <cam/cam_periph.h>
57 #include <cam/cam_xpt_periph.h>
59 #include <cam/scsi/scsi_all.h>
60 #include <cam/scsi/scsi_message.h>
61 #include <cam/scsi/scsi_enc.h>
62 #include <cam/scsi/scsi_enc_internal.h>
66 MALLOC_DEFINE(M_SCSIENC, "SCSI ENC", "SCSI ENC buffers");
68 /* Enclosure type independent driver */
70 static d_open_t enc_open;
71 static d_close_t enc_close;
72 static d_ioctl_t enc_ioctl;
73 static periph_init_t enc_init;
74 static periph_ctor_t enc_ctor;
75 static periph_oninv_t enc_oninvalidate;
76 static periph_dtor_t enc_dtor;
78 static void enc_async(void *, uint32_t, struct cam_path *, void *);
79 static enctyp enc_type(struct ccb_getdev *);
81 SYSCTL_NODE(_kern_cam, OID_AUTO, enc, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
82 "CAM Enclosure Services driver");
84 #if defined(DEBUG) || defined(ENC_DEBUG)
89 SYSCTL_INT(_kern_cam_enc, OID_AUTO, verbose, CTLFLAG_RWTUN,
90 &enc_verbose, 0, "Enable verbose logging");
92 const char *elm_type_names[] = ELM_TYPE_NAMES;
93 CTASSERT(nitems(elm_type_names) - 1 == ELMTYP_LAST);
95 static struct periph_driver encdriver = {
97 TAILQ_HEAD_INITIALIZER(encdriver.units), /* generation */ 0
100 PERIPHDRIVER_DECLARE(enc, encdriver);
102 static struct cdevsw enc_cdevsw = {
103 .d_version = D_VERSION,
105 .d_close = enc_close,
106 .d_ioctl = enc_ioctl,
108 .d_flags = D_TRACKCLOSE,
117 * Install a global async callback. This callback will
118 * receive async callbacks like "new device found".
120 status = xpt_register_async(AC_FOUND_DEVICE, enc_async, NULL, NULL);
122 if (status != CAM_REQ_CMP) {
123 printf("enc: Failed to attach master async callback "
124 "due to status 0x%x!\n", status);
129 enc_devgonecb(void *arg)
131 struct cam_periph *periph;
132 struct enc_softc *enc;
136 periph = (struct cam_periph *)arg;
137 mtx = cam_periph_mtx(periph);
139 enc = (struct enc_softc *)periph->softc;
142 * When we get this callback, we will get no more close calls from
143 * devfs. So if we have any dangling opens, we need to release the
144 * reference held for that particular context.
146 for (i = 0; i < enc->open_count; i++)
147 cam_periph_release_locked(periph);
152 * Release the reference held for the device node, it is gone now.
154 cam_periph_release_locked(periph);
157 * We reference the lock directly here, instead of using
158 * cam_periph_unlock(). The reason is that the final call to
159 * cam_periph_release_locked() above could result in the periph
160 * getting freed. If that is the case, dereferencing the periph
161 * with a cam_periph_unlock() call would cause a page fault.
167 enc_oninvalidate(struct cam_periph *periph)
169 struct enc_softc *enc;
173 enc->enc_flags |= ENC_FLAG_INVALID;
175 /* If the sub-driver has an invalidate routine, call it */
176 if (enc->enc_vec.softc_invalidate != NULL)
177 enc->enc_vec.softc_invalidate(enc);
180 * Unregister any async callbacks.
182 xpt_register_async(0, enc_async, periph, periph->path);
185 * Shutdown our daemon.
187 enc->enc_flags |= ENC_FLAG_SHUTDOWN;
188 if (enc->enc_daemon != NULL) {
189 /* Signal the ses daemon to terminate. */
190 wakeup(enc->enc_daemon);
192 callout_drain(&enc->status_updater);
194 destroy_dev_sched_cb(enc->enc_dev, enc_devgonecb, periph);
198 enc_dtor(struct cam_periph *periph)
200 struct enc_softc *enc;
204 /* If the sub-driver has a cleanup routine, call it */
205 if (enc->enc_vec.softc_cleanup != NULL)
206 enc->enc_vec.softc_cleanup(enc);
208 root_mount_rel(&enc->enc_rootmount);
214 enc_async(void *callback_arg, uint32_t code, struct cam_path *path, void *arg)
216 struct cam_periph *periph;
218 periph = (struct cam_periph *)callback_arg;
221 case AC_FOUND_DEVICE:
223 struct ccb_getdev *cgd;
227 cgd = (struct ccb_getdev *)arg;
232 if (enc_type(cgd) == ENC_NONE) {
234 * Schedule announcement of the ENC bindings for
235 * this device if it is managed by a SEP.
237 path_id = xpt_path_path_id(path);
239 TAILQ_FOREACH(periph, &encdriver.units, unit_links) {
240 struct enc_softc *softc;
242 softc = (struct enc_softc *)periph->softc;
244 /* Check this SEP is ready. */
245 if (softc == NULL || (softc->enc_flags &
246 ENC_FLAG_INITIALIZED) == 0 ||
247 softc->enc_vec.device_found == NULL)
250 /* Check this SEP may manage this device. */
251 if (xpt_path_path_id(periph->path) != path_id &&
252 (softc->enc_type != ENC_SEMB_SES ||
253 cgd->protocol != PROTO_ATA))
256 softc->enc_vec.device_found(softc);
262 status = cam_periph_alloc(enc_ctor, enc_oninvalidate,
263 enc_dtor, NULL, "ses", CAM_PERIPH_BIO,
264 path, enc_async, AC_FOUND_DEVICE, cgd);
266 if (status != CAM_REQ_CMP && status != CAM_REQ_INPROG) {
267 printf("enc_async: Unable to probe new device due to "
268 "status 0x%x\n", status);
273 cam_periph_async(periph, code, path, arg);
279 enc_open(struct cdev *dev, int flags, int fmt, struct thread *td)
281 struct cam_periph *periph;
282 struct enc_softc *softc;
285 periph = (struct cam_periph *)dev->si_drv1;
286 if (cam_periph_acquire(periph) != 0)
289 cam_periph_lock(periph);
291 softc = (struct enc_softc *)periph->softc;
293 if ((softc->enc_flags & ENC_FLAG_INITIALIZED) == 0) {
297 if (softc->enc_flags & ENC_FLAG_INVALID) {
303 cam_periph_release_locked(periph);
307 cam_periph_unlock(periph);
313 enc_close(struct cdev *dev, int flag, int fmt, struct thread *td)
315 struct cam_periph *periph;
316 struct enc_softc *enc;
319 periph = (struct cam_periph *)dev->si_drv1;
320 mtx = cam_periph_mtx(periph);
326 cam_periph_release_locked(periph);
329 * We reference the lock directly here, instead of using
330 * cam_periph_unlock(). The reason is that the call to
331 * cam_periph_release_locked() above could result in the periph
332 * getting freed. If that is the case, dereferencing the periph
333 * with a cam_periph_unlock() call would cause a page fault.
335 * cam_periph_release() avoids this problem using the same method,
336 * but we're manually acquiring and dropping the lock here to
337 * protect the open count and avoid another lock acquisition and
346 enc_error(union ccb *ccb, uint32_t cflags, uint32_t sflags)
348 struct enc_softc *softc;
349 struct cam_periph *periph;
351 periph = xpt_path_periph(ccb->ccb_h.path);
352 softc = (struct enc_softc *)periph->softc;
354 return (cam_periph_error(ccb, cflags, sflags));
358 enc_ioctl(struct cdev *dev, u_long cmd, caddr_t arg_addr, int flag,
361 struct cam_periph *periph;
362 encioc_enc_status_t tmp;
363 encioc_string_t sstr;
364 encioc_elm_status_t elms;
365 encioc_elm_desc_t elmd;
366 encioc_elm_devnames_t elmdn;
367 encioc_element_t *uelm;
373 #ifdef COMPAT_FREEBSD32
374 if (SV_PROC_FLAG(td->td_proc, SV_ILP32))
379 addr = *((caddr_t *) arg_addr);
383 periph = (struct cam_periph *)dev->si_drv1;
384 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("entering encioctl\n"));
386 cam_periph_lock(periph);
387 enc = (struct enc_softc *)periph->softc;
388 cache = &enc->enc_cache;
391 * Now check to see whether we're initialized or not.
392 * This actually should never fail as we're not supposed
393 * to get past enc_open w/o successfully initializing
396 if ((enc->enc_flags & ENC_FLAG_INITIALIZED) == 0) {
397 cam_periph_unlock(periph);
400 cam_periph_unlock(periph);
404 CAM_DEBUG(periph->path, CAM_DEBUG_TRACE,
405 ("trying to do ioctl %#lx\n", cmd));
408 * If this command can change the device's state,
409 * we must have the device open for writing.
411 * For commands that get information about the
412 * device- we don't need to lock the peripheral
413 * if we aren't running a command. The periph
414 * also can't go away while a user process has
419 case ENCIOC_GETELMMAP:
420 case ENCIOC_GETENCSTAT:
421 case ENCIOC_GETELMSTAT:
422 case ENCIOC_GETELMDESC:
423 case ENCIOC_GETELMDEVNAMES:
424 case ENCIOC_GETENCNAME:
425 case ENCIOC_GETENCID:
428 if ((flag & FWRITE) == 0) {
434 * XXX The values read here are only valid for the current
435 * configuration generation. We need these ioctls
436 * to also pass in/out a generation number.
438 sx_slock(&enc->enc_cache_lock);
441 error = copyout(&cache->nelms, addr, sizeof (cache->nelms));
444 case ENCIOC_GETELMMAP:
445 for (uelm = addr, i = 0; i != cache->nelms; i++) {
446 encioc_element_t kelm;
448 kelm.elm_subenc_id = cache->elm_map[i].subenclosure;
449 kelm.elm_type = cache->elm_map[i].elm_type;
450 error = copyout(&kelm, &uelm[i], sizeof(kelm));
456 case ENCIOC_GETENCSTAT:
457 cam_periph_lock(periph);
458 error = enc->enc_vec.get_enc_status(enc, 1);
460 cam_periph_unlock(periph);
463 tmp = cache->enc_status;
464 cam_periph_unlock(periph);
465 error = copyout(&tmp, addr, sizeof(tmp));
466 cache->enc_status = tmp;
469 case ENCIOC_SETENCSTAT:
470 error = copyin(addr, &tmp, sizeof(tmp));
473 cam_periph_lock(periph);
474 error = enc->enc_vec.set_enc_status(enc, tmp, 1);
475 cam_periph_unlock(periph);
478 case ENCIOC_GETSTRING:
479 case ENCIOC_SETSTRING:
480 case ENCIOC_GETENCNAME:
481 case ENCIOC_GETENCID:
482 if (enc->enc_vec.handle_string == NULL) {
486 error = copyin(addr, &sstr, sizeof(sstr));
489 cam_periph_lock(periph);
490 error = enc->enc_vec.handle_string(enc, &sstr, cmd);
491 cam_periph_unlock(periph);
492 if (error == 0 || error == ENOMEM)
493 (void)copyout(&sstr.bufsiz,
494 &((encioc_string_t *)addr)->bufsiz,
495 sizeof(sstr.bufsiz));
498 case ENCIOC_GETELMSTAT:
499 error = copyin(addr, &elms, sizeof(elms));
502 if (elms.elm_idx >= cache->nelms) {
506 cam_periph_lock(periph);
507 error = enc->enc_vec.get_elm_status(enc, &elms, 1);
508 cam_periph_unlock(periph);
511 error = copyout(&elms, addr, sizeof(elms));
514 case ENCIOC_GETELMDESC:
515 error = copyin(addr, &elmd, sizeof(elmd));
518 if (elmd.elm_idx >= cache->nelms) {
522 if (enc->enc_vec.get_elm_desc != NULL) {
523 error = enc->enc_vec.get_elm_desc(enc, &elmd);
527 elmd.elm_desc_len = 0;
528 error = copyout(&elmd, addr, sizeof(elmd));
531 case ENCIOC_GETELMDEVNAMES:
532 if (enc->enc_vec.get_elm_devnames == NULL) {
536 error = copyin(addr, &elmdn, sizeof(elmdn));
539 if (elmdn.elm_idx >= cache->nelms) {
543 cam_periph_lock(periph);
544 error = (*enc->enc_vec.get_elm_devnames)(enc, &elmdn);
545 cam_periph_unlock(periph);
548 error = copyout(&elmdn, addr, sizeof(elmdn));
551 case ENCIOC_SETELMSTAT:
552 error = copyin(addr, &elms, sizeof(elms));
556 if (elms.elm_idx >= cache->nelms) {
560 cam_periph_lock(periph);
561 error = enc->enc_vec.set_elm_status(enc, &elms, 1);
562 cam_periph_unlock(periph);
568 cam_periph_lock(periph);
569 error = enc->enc_vec.init_enc(enc);
570 cam_periph_unlock(periph);
574 cam_periph_lock(periph);
575 error = cam_periph_ioctl(periph, cmd, arg_addr, enc_error);
576 cam_periph_unlock(periph);
579 sx_sunlock(&enc->enc_cache_lock);
584 enc_runcmd(struct enc_softc *enc, char *cdb, int cdbl, char *dptr, int *dlenp)
586 int error, dlen, tdlen;
590 CAM_DEBUG(enc->periph->path, CAM_DEBUG_TRACE,
591 ("entering enc_runcmd\n"));
593 if ((dlen = *dlenp) < 0) {
604 if (cdbl > IOCDBLEN) {
608 ccb = cam_periph_getccb(enc->periph, CAM_PRIORITY_NORMAL);
609 if (enc->enc_type == ENC_SEMB_SES || enc->enc_type == ENC_SEMB_SAFT) {
610 tdlen = min(dlen, 1020);
611 tdlen = (tdlen + 3) & ~3;
612 cam_fill_ataio(&ccb->ataio, 0, NULL, ddf, 0, dptr, tdlen,
614 if (cdb[0] == RECEIVE_DIAGNOSTIC)
615 ata_28bit_cmd(&ccb->ataio,
616 ATA_SEP_ATTN, cdb[2], 0x02, tdlen / 4);
617 else if (cdb[0] == SEND_DIAGNOSTIC)
618 ata_28bit_cmd(&ccb->ataio,
619 ATA_SEP_ATTN, dlen > 0 ? dptr[0] : 0,
621 else if (cdb[0] == READ_BUFFER)
622 ata_28bit_cmd(&ccb->ataio,
623 ATA_SEP_ATTN, cdb[2], 0x00, tdlen / 4);
625 ata_28bit_cmd(&ccb->ataio,
626 ATA_SEP_ATTN, dlen > 0 ? dptr[0] : 0,
630 cam_fill_csio(&ccb->csio, 0, NULL, ddf, MSG_SIMPLE_Q_TAG,
631 dptr, dlen, sizeof (struct scsi_sense_data), cdbl,
633 bcopy(cdb, ccb->csio.cdb_io.cdb_bytes, cdbl);
636 error = cam_periph_runccb(ccb, enc_error, ENC_CFLAGS, ENC_FLAGS, NULL);
643 if (ccb->ccb_h.func_code == XPT_ATA_IO)
644 *dlenp = ccb->ataio.resid;
646 *dlenp = ccb->csio.resid;
647 *dlenp += tdlen - dlen;
650 xpt_release_ccb(ccb);
651 CAM_DEBUG(enc->periph->path, CAM_DEBUG_SUBTRACE,
652 ("exiting enc_runcmd: *dlenp = %d\n", *dlenp));
657 enc_log(struct enc_softc *enc, const char *fmt, ...)
661 printf("%s%d: ", enc->periph->periph_name, enc->periph->unit_number);
668 * The code after this point runs on many platforms,
669 * so forgive the slightly awkward and nonconforming
674 * Is this a device that supports enclosure services?
676 * It's a pretty simple ruleset- if it is device type
677 * 0x0D (13), it's an ENCLOSURE device.
680 #define SAFTE_START 44
682 #define SAFTE_LEN SAFTE_END-SAFTE_START
685 enc_type(struct ccb_getdev *cgd)
690 if (cgd->protocol == PROTO_SEMB) {
691 iqd = (unsigned char *)&cgd->ident_data;
692 if (STRNCMP(iqd + 43, "S-E-S", 5) == 0)
693 return (ENC_SEMB_SES);
694 else if (STRNCMP(iqd + 43, "SAF-TE", 6) == 0)
695 return (ENC_SEMB_SAFT);
698 } else if (cgd->protocol != PROTO_SCSI)
701 iqd = (unsigned char *)&cgd->inq_data;
702 buflen = min(sizeof(cgd->inq_data),
703 SID_ADDITIONAL_LENGTH(&cgd->inq_data));
705 if ((iqd[0] & 0x1f) == T_ENCLOSURE)
708 #ifdef SES_ENABLE_PASSTHROUGH
709 if ((iqd[6] & 0x40) && (iqd[2] & 0x7) >= 2) {
711 * PassThrough Device.
713 return (ENC_SES_PASSTHROUGH);
718 * The comparison is short for a reason-
719 * some vendors were chopping it short.
722 if (buflen < SAFTE_END - 2) {
726 if (STRNCMP((char *)&iqd[SAFTE_START], "SAF-TE", SAFTE_LEN - 2) == 0) {
732 /*================== Enclosure Monitoring/Processing Daemon ==================*/
734 * \brief Queue an update request for a given action, if needed.
736 * \param enc SES softc to queue the request for.
737 * \param action Action requested.
740 enc_update_request(enc_softc_t *enc, uint32_t action)
742 if ((enc->pending_actions & (0x1 << action)) == 0) {
743 enc->pending_actions |= (0x1 << action);
744 ENC_DLOG(enc, "%s: queing requested action %d\n",
746 if (enc->current_action == ENC_UPDATE_NONE)
747 wakeup(enc->enc_daemon);
749 ENC_DLOG(enc, "%s: ignoring requested action %d - "
750 "Already queued\n", __func__, action);
755 * \brief Invoke the handler of the highest priority pending
756 * state in the SES state machine.
758 * \param enc The SES instance invoking the state machine.
761 enc_fsm_step(enc_softc_t *enc)
765 struct enc_fsm_state *cur_state;
769 ENC_DLOG(enc, "%s enter %p\n", __func__, enc);
771 enc->current_action = ffs(enc->pending_actions) - 1;
772 enc->pending_actions &= ~(0x1 << enc->current_action);
774 cur_state = &enc->enc_fsm_states[enc->current_action];
777 if (cur_state->buf_size != 0) {
778 cam_periph_unlock(enc->periph);
779 buf = malloc(cur_state->buf_size, M_SCSIENC, M_WAITOK|M_ZERO);
780 cam_periph_lock(enc->periph);
785 if (cur_state->fill != NULL) {
786 ccb = cam_periph_getccb(enc->periph, CAM_PRIORITY_NORMAL);
788 error = cur_state->fill(enc, cur_state, ccb, buf);
792 error = cam_periph_runccb(ccb, cur_state->error,
794 ENC_FLAGS|SF_QUIET_IR, NULL);
798 if (ccb->ccb_h.func_code == XPT_ATA_IO)
799 xfer_len = ccb->ataio.dxfer_len - ccb->ataio.resid;
801 xfer_len = ccb->csio.dxfer_len - ccb->csio.resid;
805 cam_periph_unlock(enc->periph);
806 cur_state->done(enc, cur_state, ccb, &buf, error, xfer_len);
807 cam_periph_lock(enc->periph);
810 ENC_DLOG(enc, "%s exit - result %d\n", __func__, error);
811 ENC_FREE_AND_NULL(buf);
813 xpt_release_ccb(ccb);
817 * \invariant Called with cam_periph mutex held.
820 enc_status_updater(void *arg)
825 if (enc->enc_vec.poll_status != NULL)
826 enc->enc_vec.poll_status(enc);
830 enc_daemon(void *arg)
836 cam_periph_lock(enc->periph);
837 while ((enc->enc_flags & ENC_FLAG_SHUTDOWN) == 0) {
838 if (enc->pending_actions == 0) {
840 * Reset callout and msleep, or
841 * issue timed task completion
844 enc->current_action = ENC_UPDATE_NONE;
847 * We've been through our state machine at least
848 * once. Allow the transition to userland.
850 root_mount_rel(&enc->enc_rootmount);
852 callout_reset(&enc->status_updater, 60*hz,
853 enc_status_updater, enc);
855 cam_periph_sleep(enc->periph, enc->enc_daemon,
861 enc->enc_daemon = NULL;
862 cam_periph_unlock(enc->periph);
863 cam_periph_release(enc->periph);
868 enc_kproc_init(enc_softc_t *enc)
872 callout_init_mtx(&enc->status_updater, cam_periph_mtx(enc->periph), 0);
874 if (cam_periph_acquire(enc->periph) != 0)
877 result = kproc_create(enc_daemon, enc, &enc->enc_daemon, /*flags*/0,
878 /*stackpgs*/0, "enc_daemon%d",
879 enc->periph->unit_number);
881 /* Do an initial load of all page data. */
882 cam_periph_lock(enc->periph);
883 enc->enc_vec.poll_status(enc);
884 cam_periph_unlock(enc->periph);
886 cam_periph_release(enc->periph);
891 enc_ctor(struct cam_periph *periph, void *arg)
893 cam_status status = CAM_REQ_CMP_ERR;
896 struct ccb_getdev *cgd;
898 struct make_dev_args args;
901 cgd = (struct ccb_getdev *)arg;
903 printf("enc_ctor: no getdev CCB, can't register device\n");
907 enc = ENC_MALLOCZ(sizeof(*enc));
909 printf("enc_ctor: Unable to probe new device. "
910 "Unable to allocate enc\n");
913 enc->periph = periph;
914 enc->current_action = ENC_UPDATE_INVALID;
916 enc->enc_type = enc_type(cgd);
917 sx_init(&enc->enc_cache_lock, "enccache");
919 switch (enc->enc_type) {
921 case ENC_SES_PASSTHROUGH:
923 err = ses_softc_init(enc);
927 err = safte_softc_init(enc);
932 return (CAM_REQ_CMP_ERR);
936 xpt_print(periph->path, "error %d initializing\n", err);
941 * Hold off userland until we have made at least one pass
942 * through our state machine so that physical path data is
945 if (enc->enc_vec.poll_status != NULL) {
946 root_mount_hold_token(periph->periph_name, &enc->enc_rootmount);
950 * The softc field is set only once the enc is fully initialized
951 * so that we can rely on this field to detect partially
952 * initialized periph objects in the AC_FOUND_DEVICE handler.
956 cam_periph_unlock(periph);
957 if (enc->enc_vec.poll_status != NULL) {
958 err = enc_kproc_init(enc);
960 xpt_print(periph->path,
961 "error %d starting enc_daemon\n", err);
967 * Acquire a reference to the periph before we create the devfs
968 * instance for it. We'll release this reference once the devfs
969 * instance has been freed.
971 if (cam_periph_acquire(periph) != 0) {
972 xpt_print(periph->path, "%s: lost periph during "
973 "registration!\n", __func__);
974 cam_periph_lock(periph);
976 return (CAM_REQ_CMP_ERR);
979 make_dev_args_init(&args);
980 args.mda_devsw = &enc_cdevsw;
981 args.mda_unit = periph->unit_number;
982 args.mda_uid = UID_ROOT;
983 args.mda_gid = GID_OPERATOR;
984 args.mda_mode = 0600;
985 args.mda_si_drv1 = periph;
986 err = make_dev_s(&args, &enc->enc_dev, "%s%d", periph->periph_name,
987 periph->unit_number);
988 cam_periph_lock(periph);
990 cam_periph_release_locked(periph);
991 return (CAM_REQ_CMP_ERR);
994 enc->enc_flags |= ENC_FLAG_INITIALIZED;
997 * Add an async callback so that we get notified if this
1000 xpt_register_async(AC_LOST_DEVICE, enc_async, periph, periph->path);
1002 switch (enc->enc_type) {
1005 tname = "No ENC device";
1008 tname = "SES Device";
1010 case ENC_SES_PASSTHROUGH:
1011 tname = "SES Passthrough Device";
1014 tname = "SAF-TE Device";
1017 tname = "SEMB SES Device";
1020 tname = "SEMB SAF-TE Device";
1024 sbuf_new(&sb, enc->announce_buf, ENC_ANNOUNCE_SZ, SBUF_FIXEDLEN);
1025 xpt_announce_periph_sbuf(periph, &sb, tname);
1029 status = CAM_REQ_CMP;
1032 if (status != CAM_REQ_CMP)