scsi_pt.c revision 50073
139213Sgibbs/* 239213Sgibbs * Implementation of SCSI Processor Target Peripheral driver for CAM. 339213Sgibbs * 439213Sgibbs * Copyright (c) 1998 Justin T. Gibbs. 539213Sgibbs * All rights reserved. 639213Sgibbs * 739213Sgibbs * Redistribution and use in source and binary forms, with or without 839213Sgibbs * modification, are permitted provided that the following conditions 939213Sgibbs * are met: 1039213Sgibbs * 1. Redistributions of source code must retain the above copyright 1139213Sgibbs * notice, this list of conditions, and the following disclaimer, 1239213Sgibbs * without modification, immediately at the beginning of the file. 1339213Sgibbs * 2. The name of the author may not be used to endorse or promote products 1439213Sgibbs * derived from this software without specific prior written permission. 1539213Sgibbs * 1639213Sgibbs * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 1739213Sgibbs * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1839213Sgibbs * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1939213Sgibbs * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 2039213Sgibbs * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2139213Sgibbs * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 2239213Sgibbs * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 2339213Sgibbs * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 2439213Sgibbs * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 2539213Sgibbs * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 2639213Sgibbs * SUCH DAMAGE. 2739213Sgibbs * 2850073Sken * $Id: scsi_pt.c,v 1.11 1999/08/17 20:25:47 billf Exp $ 2939213Sgibbs */ 3039213Sgibbs 3139213Sgibbs#include <sys/param.h> 3239213Sgibbs#include <sys/queue.h> 3339213Sgibbs#include <sys/systm.h> 3439213Sgibbs#include <sys/kernel.h> 3539213Sgibbs#include <sys/types.h> 3639213Sgibbs#include <sys/buf.h> 3739213Sgibbs#include <sys/devicestat.h> 3839213Sgibbs#include <sys/malloc.h> 3939213Sgibbs#include <sys/conf.h> 4050073Sken#include <sys/ptio.h> 4139213Sgibbs 4239213Sgibbs#include <cam/cam.h> 4339213Sgibbs#include <cam/cam_ccb.h> 4439213Sgibbs#include <cam/cam_extend.h> 4539213Sgibbs#include <cam/cam_periph.h> 4639213Sgibbs#include <cam/cam_xpt_periph.h> 4739213Sgibbs#include <cam/cam_debug.h> 4839213Sgibbs 4939213Sgibbs#include <cam/scsi/scsi_all.h> 5039213Sgibbs#include <cam/scsi/scsi_message.h> 5139213Sgibbs#include <cam/scsi/scsi_pt.h> 5239213Sgibbs 5350073Sken#include "opt_pt.h" 5450073Sken 5539213Sgibbstypedef enum { 5639213Sgibbs PT_STATE_PROBE, 5739213Sgibbs PT_STATE_NORMAL 5839213Sgibbs} pt_state; 5939213Sgibbs 6039213Sgibbstypedef enum { 6139213Sgibbs PT_FLAG_NONE = 0x00, 6239213Sgibbs PT_FLAG_OPEN = 0x01, 6339213Sgibbs PT_FLAG_DEVICE_INVALID = 0x02, 6439213Sgibbs PT_FLAG_RETRY_UA = 0x04 6539213Sgibbs} pt_flags; 6639213Sgibbs 6739213Sgibbstypedef enum { 6839213Sgibbs PT_CCB_BUFFER_IO = 0x01, 6939213Sgibbs PT_CCB_WAITING = 0x02, 7039213Sgibbs PT_CCB_RETRY_UA = 0x04, 7139213Sgibbs PT_CCB_BUFFER_IO_UA = PT_CCB_BUFFER_IO|PT_CCB_RETRY_UA 7239213Sgibbs} pt_ccb_state; 7339213Sgibbs 7439213Sgibbs/* Offsets into our private area for storing information */ 7539213Sgibbs#define ccb_state ppriv_field0 7639213Sgibbs#define ccb_bp ppriv_ptr1 7739213Sgibbs 7839213Sgibbsstruct pt_softc { 7939213Sgibbs struct buf_queue_head buf_queue; 8039213Sgibbs struct devstat device_stats; 8139213Sgibbs LIST_HEAD(, ccb_hdr) pending_ccbs; 8239213Sgibbs pt_state state; 8339213Sgibbs pt_flags flags; 8439213Sgibbs union ccb saved_ccb; 8550073Sken int io_timeout; 8639213Sgibbs}; 8739213Sgibbs 8839213Sgibbsstatic d_open_t ptopen; 8939213Sgibbsstatic d_close_t ptclose; 9039213Sgibbsstatic d_strategy_t ptstrategy; 9139213Sgibbsstatic periph_init_t ptinit; 9239213Sgibbsstatic void ptasync(void *callback_arg, u_int32_t code, 9339213Sgibbs struct cam_path *path, void *arg); 9439213Sgibbsstatic periph_ctor_t ptctor; 9540603Skenstatic periph_oninv_t ptoninvalidate; 9639213Sgibbsstatic periph_dtor_t ptdtor; 9739213Sgibbsstatic periph_start_t ptstart; 9839213Sgibbsstatic void ptdone(struct cam_periph *periph, 9939213Sgibbs union ccb *done_ccb); 10050073Skenstatic d_ioctl_t ptioctl; 10139213Sgibbsstatic int pterror(union ccb *ccb, u_int32_t cam_flags, 10239213Sgibbs u_int32_t sense_flags); 10339213Sgibbs 10439213Sgibbsvoid scsi_send_receive(struct ccb_scsiio *csio, u_int32_t retries, 10539213Sgibbs void (*cbfcnp)(struct cam_periph *, union ccb *), 10639213Sgibbs u_int tag_action, int readop, u_int byte2, 10739213Sgibbs u_int32_t xfer_len, u_int8_t *data_ptr, 10839213Sgibbs u_int8_t sense_len, u_int32_t timeout); 10939213Sgibbs 11039213Sgibbsstatic struct periph_driver ptdriver = 11139213Sgibbs{ 11239213Sgibbs ptinit, "pt", 11339213Sgibbs TAILQ_HEAD_INITIALIZER(ptdriver.units), /* generation */ 0 11439213Sgibbs}; 11539213Sgibbs 11639213SgibbsDATA_SET(periphdriver_set, ptdriver); 11739213Sgibbs 11839213Sgibbs#define PT_CDEV_MAJOR 61 11939213Sgibbs 12047625Sphkstatic struct cdevsw pt_cdevsw = { 12147625Sphk /* open */ ptopen, 12247625Sphk /* close */ ptclose, 12347625Sphk /* read */ physread, 12447625Sphk /* write */ physwrite, 12550073Sken /* ioctl */ ptioctl, 12647625Sphk /* stop */ nostop, 12747625Sphk /* reset */ noreset, 12847625Sphk /* devtotty */ nodevtotty, 12947625Sphk /* poll */ nopoll, 13047625Sphk /* mmap */ nommap, 13147625Sphk /* strategy */ ptstrategy, 13247625Sphk /* name */ "pt", 13347625Sphk /* parms */ noparms, 13447625Sphk /* maj */ PT_CDEV_MAJOR, 13547625Sphk /* dump */ nodump, 13647625Sphk /* psize */ nopsize, 13747625Sphk /* flags */ 0, 13847625Sphk /* maxio */ 0, 13947625Sphk /* bmaj */ -1 14039213Sgibbs}; 14139213Sgibbs 14239213Sgibbsstatic struct extend_array *ptperiphs; 14339213Sgibbs 14450073Sken#ifndef SCSI_PT_DEFAULT_TIMEOUT 14550073Sken#define SCSI_PT_DEFAULT_TIMEOUT 60 14650073Sken#endif 14750073Sken 14839213Sgibbsstatic int 14939213Sgibbsptopen(dev_t dev, int flags, int fmt, struct proc *p) 15039213Sgibbs{ 15139213Sgibbs struct cam_periph *periph; 15239213Sgibbs struct pt_softc *softc; 15339213Sgibbs int unit; 15439213Sgibbs int error; 15540603Sken int s; 15639213Sgibbs 15739213Sgibbs unit = minor(dev); 15839213Sgibbs periph = cam_extend_get(ptperiphs, unit); 15939213Sgibbs if (periph == NULL) 16039213Sgibbs return (ENXIO); 16139213Sgibbs 16239213Sgibbs softc = (struct pt_softc *)periph->softc; 16339213Sgibbs 16440603Sken s = splsoftcam(); 16540603Sken if (softc->flags & PT_FLAG_DEVICE_INVALID) { 16640603Sken splx(s); 16740603Sken return(ENXIO); 16840603Sken } 16940603Sken 17039213Sgibbs CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, 17149982Sbillf ("ptopen: dev=%s (unit %d)\n", devtoname(dev), unit)); 17239213Sgibbs 17341297Sken if ((error = cam_periph_lock(periph, PRIBIO|PCATCH)) != 0) { 17441297Sken splx(s); 17539213Sgibbs return (error); /* error code from tsleep */ 17641297Sken } 17739213Sgibbs 17841297Sken splx(s); 17941297Sken 18039213Sgibbs if ((softc->flags & PT_FLAG_OPEN) == 0) { 18139213Sgibbs if (cam_periph_acquire(periph) != CAM_REQ_CMP) 18239213Sgibbs error = ENXIO; 18339213Sgibbs else 18439213Sgibbs softc->flags |= PT_FLAG_OPEN; 18539213Sgibbs } else 18639213Sgibbs error = EBUSY; 18739213Sgibbs 18839213Sgibbs cam_periph_unlock(periph); 18939213Sgibbs return (error); 19039213Sgibbs} 19139213Sgibbs 19239213Sgibbsstatic int 19339213Sgibbsptclose(dev_t dev, int flag, int fmt, struct proc *p) 19439213Sgibbs{ 19539213Sgibbs struct cam_periph *periph; 19639213Sgibbs struct pt_softc *softc; 19739213Sgibbs int unit; 19839213Sgibbs int error; 19939213Sgibbs 20039213Sgibbs unit = minor(dev); 20139213Sgibbs periph = cam_extend_get(ptperiphs, unit); 20239213Sgibbs if (periph == NULL) 20339213Sgibbs return (ENXIO); 20439213Sgibbs 20539213Sgibbs softc = (struct pt_softc *)periph->softc; 20639213Sgibbs 20739213Sgibbs if ((error = cam_periph_lock(periph, PRIBIO)) != 0) 20839213Sgibbs return (error); /* error code from tsleep */ 20939213Sgibbs 21039213Sgibbs softc->flags &= ~PT_FLAG_OPEN; 21139213Sgibbs cam_periph_unlock(periph); 21239213Sgibbs cam_periph_release(periph); 21339213Sgibbs return (0); 21439213Sgibbs} 21539213Sgibbs 21639213Sgibbs/* 21739213Sgibbs * Actually translate the requested transfer into one the physical driver 21839213Sgibbs * can understand. The transfer is described by a buf and will include 21939213Sgibbs * only one physical transfer. 22039213Sgibbs */ 22139213Sgibbsstatic void 22239213Sgibbsptstrategy(struct buf *bp) 22339213Sgibbs{ 22439213Sgibbs struct cam_periph *periph; 22539213Sgibbs struct pt_softc *softc; 22639213Sgibbs u_int unit; 22739213Sgibbs int s; 22839213Sgibbs 22939213Sgibbs unit = minor(bp->b_dev); 23039213Sgibbs periph = cam_extend_get(ptperiphs, unit); 23139213Sgibbs if (periph == NULL) { 23239213Sgibbs bp->b_error = ENXIO; 23339213Sgibbs goto bad; 23439213Sgibbs } 23539213Sgibbs softc = (struct pt_softc *)periph->softc; 23639213Sgibbs 23739213Sgibbs /* 23839213Sgibbs * Mask interrupts so that the pack cannot be invalidated until 23939213Sgibbs * after we are in the queue. Otherwise, we might not properly 24039213Sgibbs * clean up one of the buffers. 24139213Sgibbs */ 24239213Sgibbs s = splbio(); 24339213Sgibbs 24439213Sgibbs /* 24539213Sgibbs * If the device has been made invalid, error out 24639213Sgibbs */ 24739213Sgibbs if ((softc->flags & PT_FLAG_DEVICE_INVALID)) { 24839213Sgibbs splx(s); 24939213Sgibbs bp->b_error = ENXIO; 25039213Sgibbs goto bad; 25139213Sgibbs } 25239213Sgibbs 25339213Sgibbs /* 25439213Sgibbs * Place it in the queue of disk activities for this disk 25539213Sgibbs */ 25639213Sgibbs bufq_insert_tail(&softc->buf_queue, bp); 25739213Sgibbs 25839213Sgibbs splx(s); 25939213Sgibbs 26039213Sgibbs /* 26139213Sgibbs * Schedule ourselves for performing the work. 26239213Sgibbs */ 26339213Sgibbs xpt_schedule(periph, /* XXX priority */1); 26439213Sgibbs 26539213Sgibbs return; 26639213Sgibbsbad: 26739213Sgibbs bp->b_flags |= B_ERROR; 26839213Sgibbs 26939213Sgibbs /* 27039213Sgibbs * Correctly set the buf to indicate a completed xfer 27139213Sgibbs */ 27239213Sgibbs bp->b_resid = bp->b_bcount; 27339213Sgibbs biodone(bp); 27439213Sgibbs} 27539213Sgibbs 27639213Sgibbsstatic void 27739213Sgibbsptinit(void) 27839213Sgibbs{ 27939213Sgibbs cam_status status; 28039213Sgibbs struct cam_path *path; 28139213Sgibbs 28239213Sgibbs /* 28339213Sgibbs * Create our extend array for storing the devices we attach to. 28439213Sgibbs */ 28539213Sgibbs ptperiphs = cam_extend_new(); 28639213Sgibbs if (ptperiphs == NULL) { 28739213Sgibbs printf("pt: Failed to alloc extend array!\n"); 28839213Sgibbs return; 28939213Sgibbs } 29039213Sgibbs 29139213Sgibbs /* 29239213Sgibbs * Install a global async callback. This callback will 29339213Sgibbs * receive async callbacks like "new device found". 29439213Sgibbs */ 29539213Sgibbs status = xpt_create_path(&path, /*periph*/NULL, CAM_XPT_PATH_ID, 29639213Sgibbs CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD); 29739213Sgibbs 29839213Sgibbs if (status == CAM_REQ_CMP) { 29939213Sgibbs struct ccb_setasync csa; 30039213Sgibbs 30139213Sgibbs xpt_setup_ccb(&csa.ccb_h, path, /*priority*/5); 30239213Sgibbs csa.ccb_h.func_code = XPT_SASYNC_CB; 30339213Sgibbs csa.event_enable = AC_FOUND_DEVICE; 30439213Sgibbs csa.callback = ptasync; 30539213Sgibbs csa.callback_arg = NULL; 30639213Sgibbs xpt_action((union ccb *)&csa); 30739213Sgibbs status = csa.ccb_h.status; 30839213Sgibbs xpt_free_path(path); 30939213Sgibbs } 31039213Sgibbs 31139213Sgibbs if (status != CAM_REQ_CMP) { 31239213Sgibbs printf("pt: Failed to attach master async callback " 31339213Sgibbs "due to status 0x%x!\n", status); 31439213Sgibbs } else { 31539213Sgibbs /* If we were successfull, register our devsw */ 31647640Sphk cdevsw_add(&pt_cdevsw); 31739213Sgibbs } 31839213Sgibbs} 31939213Sgibbs 32039213Sgibbsstatic cam_status 32139213Sgibbsptctor(struct cam_periph *periph, void *arg) 32239213Sgibbs{ 32339213Sgibbs struct pt_softc *softc; 32439213Sgibbs struct ccb_setasync csa; 32539213Sgibbs struct ccb_getdev *cgd; 32639213Sgibbs 32739213Sgibbs cgd = (struct ccb_getdev *)arg; 32839213Sgibbs if (periph == NULL) { 32939213Sgibbs printf("ptregister: periph was NULL!!\n"); 33039213Sgibbs return(CAM_REQ_CMP_ERR); 33139213Sgibbs } 33239213Sgibbs 33339213Sgibbs if (cgd == NULL) { 33439213Sgibbs printf("ptregister: no getdev CCB, can't register device\n"); 33539213Sgibbs return(CAM_REQ_CMP_ERR); 33639213Sgibbs } 33739213Sgibbs 33839213Sgibbs softc = (struct pt_softc *)malloc(sizeof(*softc),M_DEVBUF,M_NOWAIT); 33939213Sgibbs 34039213Sgibbs if (softc == NULL) { 34139213Sgibbs printf("daregister: Unable to probe new device. " 34239213Sgibbs "Unable to allocate softc\n"); 34339213Sgibbs return(CAM_REQ_CMP_ERR); 34439213Sgibbs } 34539213Sgibbs 34639213Sgibbs bzero(softc, sizeof(*softc)); 34739213Sgibbs LIST_INIT(&softc->pending_ccbs); 34839213Sgibbs softc->state = PT_STATE_NORMAL; 34939213Sgibbs bufq_init(&softc->buf_queue); 35039213Sgibbs 35150073Sken softc->io_timeout = SCSI_PT_DEFAULT_TIMEOUT * 1000; 35250073Sken 35339213Sgibbs periph->softc = softc; 35439213Sgibbs 35539213Sgibbs cam_extend_set(ptperiphs, periph->unit_number, periph); 35639213Sgibbs 35739213Sgibbs /* 35839213Sgibbs * The DA driver supports a blocksize, but 35939213Sgibbs * we don't know the blocksize until we do 36039213Sgibbs * a read capacity. So, set a flag to 36139213Sgibbs * indicate that the blocksize is 36239213Sgibbs * unavailable right now. We'll clear the 36339213Sgibbs * flag as soon as we've done a read capacity. 36439213Sgibbs */ 36539213Sgibbs devstat_add_entry(&softc->device_stats, "pt", 36639213Sgibbs periph->unit_number, 0, 36739213Sgibbs DEVSTAT_NO_BLOCKSIZE, 36843819Sken cgd->pd_type | DEVSTAT_TYPE_IF_SCSI, 36943819Sken DEVSTAT_PRIORITY_OTHER); 37039213Sgibbs 37139213Sgibbs /* 37239213Sgibbs * Add async callbacks for bus reset and 37339213Sgibbs * bus device reset calls. I don't bother 37439213Sgibbs * checking if this fails as, in most cases, 37539213Sgibbs * the system will function just fine without 37639213Sgibbs * them and the only alternative would be to 37739213Sgibbs * not attach the device on failure. 37839213Sgibbs */ 37939213Sgibbs xpt_setup_ccb(&csa.ccb_h, periph->path, /*priority*/5); 38039213Sgibbs csa.ccb_h.func_code = XPT_SASYNC_CB; 38139213Sgibbs csa.event_enable = AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE; 38239213Sgibbs csa.callback = ptasync; 38339213Sgibbs csa.callback_arg = periph; 38439213Sgibbs xpt_action((union ccb *)&csa); 38539213Sgibbs 38639213Sgibbs /* Tell the user we've attached to the device */ 38739213Sgibbs xpt_announce_periph(periph, NULL); 38839213Sgibbs 38939213Sgibbs return(CAM_REQ_CMP); 39039213Sgibbs} 39139213Sgibbs 39239213Sgibbsstatic void 39340603Skenptoninvalidate(struct cam_periph *periph) 39440603Sken{ 39540603Sken int s; 39640603Sken struct pt_softc *softc; 39740603Sken struct buf *q_bp; 39840603Sken struct ccb_setasync csa; 39940603Sken 40040603Sken softc = (struct pt_softc *)periph->softc; 40140603Sken 40240603Sken /* 40340603Sken * De-register any async callbacks. 40440603Sken */ 40540603Sken xpt_setup_ccb(&csa.ccb_h, periph->path, 40640603Sken /* priority */ 5); 40740603Sken csa.ccb_h.func_code = XPT_SASYNC_CB; 40840603Sken csa.event_enable = 0; 40940603Sken csa.callback = ptasync; 41040603Sken csa.callback_arg = periph; 41140603Sken xpt_action((union ccb *)&csa); 41240603Sken 41340603Sken softc->flags |= PT_FLAG_DEVICE_INVALID; 41440603Sken 41540603Sken /* 41640603Sken * Although the oninvalidate() routines are always called at 41740603Sken * splsoftcam, we need to be at splbio() here to keep the buffer 41840603Sken * queue from being modified while we traverse it. 41940603Sken */ 42040603Sken s = splbio(); 42140603Sken 42240603Sken /* 42340603Sken * Return all queued I/O with ENXIO. 42440603Sken * XXX Handle any transactions queued to the card 42540603Sken * with XPT_ABORT_CCB. 42640603Sken */ 42740603Sken while ((q_bp = bufq_first(&softc->buf_queue)) != NULL){ 42840603Sken bufq_remove(&softc->buf_queue, q_bp); 42940603Sken q_bp->b_resid = q_bp->b_bcount; 43040603Sken q_bp->b_error = ENXIO; 43140603Sken q_bp->b_flags |= B_ERROR; 43240603Sken biodone(q_bp); 43340603Sken } 43440603Sken 43540603Sken splx(s); 43640603Sken 43740603Sken xpt_print_path(periph->path); 43840603Sken printf("lost device\n"); 43940603Sken} 44040603Sken 44140603Skenstatic void 44239213Sgibbsptdtor(struct cam_periph *periph) 44339213Sgibbs{ 44440603Sken struct pt_softc *softc; 44540603Sken 44640603Sken softc = (struct pt_softc *)periph->softc; 44740603Sken 44840603Sken devstat_remove_entry(&softc->device_stats); 44940603Sken 45039213Sgibbs cam_extend_release(ptperiphs, periph->unit_number); 45139213Sgibbs xpt_print_path(periph->path); 45239213Sgibbs printf("removing device entry\n"); 45340603Sken free(softc, M_DEVBUF); 45439213Sgibbs} 45539213Sgibbs 45639213Sgibbsstatic void 45739213Sgibbsptasync(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg) 45839213Sgibbs{ 45939213Sgibbs struct cam_periph *periph; 46039213Sgibbs 46139213Sgibbs periph = (struct cam_periph *)callback_arg; 46239213Sgibbs switch (code) { 46339213Sgibbs case AC_FOUND_DEVICE: 46439213Sgibbs { 46539213Sgibbs struct ccb_getdev *cgd; 46639213Sgibbs cam_status status; 46739213Sgibbs 46839213Sgibbs cgd = (struct ccb_getdev *)arg; 46939213Sgibbs 47039213Sgibbs if (cgd->pd_type != T_PROCESSOR) 47139213Sgibbs break; 47239213Sgibbs 47339213Sgibbs /* 47439213Sgibbs * Allocate a peripheral instance for 47539213Sgibbs * this device and start the probe 47639213Sgibbs * process. 47739213Sgibbs */ 47840603Sken status = cam_periph_alloc(ptctor, ptoninvalidate, ptdtor, 47940603Sken ptstart, "pt", CAM_PERIPH_BIO, 48040603Sken cgd->ccb_h.path, ptasync, 48140603Sken AC_FOUND_DEVICE, cgd); 48239213Sgibbs 48339213Sgibbs if (status != CAM_REQ_CMP 48439213Sgibbs && status != CAM_REQ_INPROG) 48539213Sgibbs printf("ptasync: Unable to attach to new device " 48639213Sgibbs "due to status 0x%x\n", status); 48739213Sgibbs break; 48839213Sgibbs } 48939213Sgibbs case AC_SENT_BDR: 49039213Sgibbs case AC_BUS_RESET: 49139213Sgibbs { 49239213Sgibbs struct pt_softc *softc; 49339213Sgibbs struct ccb_hdr *ccbh; 49439213Sgibbs int s; 49539213Sgibbs 49639213Sgibbs softc = (struct pt_softc *)periph->softc; 49739213Sgibbs s = splsoftcam(); 49839213Sgibbs /* 49939213Sgibbs * Don't fail on the expected unit attention 50039213Sgibbs * that will occur. 50139213Sgibbs */ 50239213Sgibbs softc->flags |= PT_FLAG_RETRY_UA; 50339213Sgibbs for (ccbh = LIST_FIRST(&softc->pending_ccbs); 50439213Sgibbs ccbh != NULL; ccbh = LIST_NEXT(ccbh, periph_links.le)) 50539213Sgibbs ccbh->ccb_state |= PT_CCB_RETRY_UA; 50639213Sgibbs splx(s); 50747413Sgibbs /* FALLTHROUGH */ 50839213Sgibbs } 50939213Sgibbs default: 51047413Sgibbs cam_periph_async(periph, code, path, arg); 51139213Sgibbs break; 51239213Sgibbs } 51339213Sgibbs} 51439213Sgibbs 51539213Sgibbsstatic void 51639213Sgibbsptstart(struct cam_periph *periph, union ccb *start_ccb) 51739213Sgibbs{ 51839213Sgibbs struct pt_softc *softc; 51939213Sgibbs struct buf *bp; 52039213Sgibbs int s; 52139213Sgibbs 52239213Sgibbs softc = (struct pt_softc *)periph->softc; 52339213Sgibbs 52439213Sgibbs /* 52539213Sgibbs * See if there is a buf with work for us to do.. 52639213Sgibbs */ 52739213Sgibbs s = splbio(); 52839213Sgibbs bp = bufq_first(&softc->buf_queue); 52939213Sgibbs if (periph->immediate_priority <= periph->pinfo.priority) { 53039213Sgibbs CAM_DEBUG_PRINT(CAM_DEBUG_SUBTRACE, 53139213Sgibbs ("queuing for immediate ccb\n")); 53239213Sgibbs start_ccb->ccb_h.ccb_state = PT_CCB_WAITING; 53339213Sgibbs SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h, 53439213Sgibbs periph_links.sle); 53539213Sgibbs periph->immediate_priority = CAM_PRIORITY_NONE; 53639213Sgibbs splx(s); 53739213Sgibbs wakeup(&periph->ccb_list); 53839213Sgibbs } else if (bp == NULL) { 53939213Sgibbs splx(s); 54039213Sgibbs xpt_release_ccb(start_ccb); 54139213Sgibbs } else { 54239213Sgibbs int oldspl; 54339213Sgibbs 54439213Sgibbs bufq_remove(&softc->buf_queue, bp); 54539213Sgibbs 54639213Sgibbs devstat_start_transaction(&softc->device_stats); 54739213Sgibbs 54839213Sgibbs scsi_send_receive(&start_ccb->csio, 54939213Sgibbs /*retries*/4, 55039213Sgibbs ptdone, 55139213Sgibbs MSG_SIMPLE_Q_TAG, 55239213Sgibbs bp->b_flags & B_READ, 55339213Sgibbs /*byte2*/0, 55439213Sgibbs bp->b_bcount, 55539213Sgibbs bp->b_data, 55639213Sgibbs /*sense_len*/SSD_FULL_SIZE, 55750073Sken /*timeout*/softc->io_timeout); 55839213Sgibbs 55939213Sgibbs start_ccb->ccb_h.ccb_state = PT_CCB_BUFFER_IO; 56039213Sgibbs 56139213Sgibbs /* 56239213Sgibbs * Block out any asyncronous callbacks 56339213Sgibbs * while we touch the pending ccb list. 56439213Sgibbs */ 56539213Sgibbs oldspl = splcam(); 56639213Sgibbs LIST_INSERT_HEAD(&softc->pending_ccbs, &start_ccb->ccb_h, 56739213Sgibbs periph_links.le); 56839213Sgibbs splx(oldspl); 56939213Sgibbs 57039213Sgibbs start_ccb->ccb_h.ccb_bp = bp; 57139213Sgibbs bp = bufq_first(&softc->buf_queue); 57239213Sgibbs splx(s); 57339213Sgibbs 57439213Sgibbs xpt_action(start_ccb); 57539213Sgibbs 57639213Sgibbs if (bp != NULL) { 57739213Sgibbs /* Have more work to do, so ensure we stay scheduled */ 57839213Sgibbs xpt_schedule(periph, /* XXX priority */1); 57939213Sgibbs } 58039213Sgibbs } 58139213Sgibbs} 58239213Sgibbs 58339213Sgibbsstatic void 58439213Sgibbsptdone(struct cam_periph *periph, union ccb *done_ccb) 58539213Sgibbs{ 58639213Sgibbs struct pt_softc *softc; 58739213Sgibbs struct ccb_scsiio *csio; 58839213Sgibbs 58939213Sgibbs softc = (struct pt_softc *)periph->softc; 59039213Sgibbs csio = &done_ccb->csio; 59139213Sgibbs switch (csio->ccb_h.ccb_state) { 59239213Sgibbs case PT_CCB_BUFFER_IO: 59339213Sgibbs case PT_CCB_BUFFER_IO_UA: 59439213Sgibbs { 59539213Sgibbs struct buf *bp; 59639213Sgibbs int oldspl; 59739213Sgibbs 59839213Sgibbs bp = (struct buf *)done_ccb->ccb_h.ccb_bp; 59939213Sgibbs if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 60039213Sgibbs int error; 60139213Sgibbs int s; 60239213Sgibbs int sf; 60339213Sgibbs 60439213Sgibbs if ((csio->ccb_h.ccb_state & PT_CCB_RETRY_UA) != 0) 60539213Sgibbs sf = SF_RETRY_UA; 60639213Sgibbs else 60739213Sgibbs sf = 0; 60839213Sgibbs 60946747Sken sf |= SF_RETRY_SELTO; 61046747Sken 61139213Sgibbs if ((error = pterror(done_ccb, 0, sf)) == ERESTART) { 61239213Sgibbs /* 61339213Sgibbs * A retry was scheuled, so 61439213Sgibbs * just return. 61539213Sgibbs */ 61639213Sgibbs return; 61739213Sgibbs } 61839213Sgibbs if (error != 0) { 61939213Sgibbs struct buf *q_bp; 62039213Sgibbs 62139213Sgibbs s = splbio(); 62239213Sgibbs 62339213Sgibbs if (error == ENXIO) { 62439213Sgibbs /* 62539213Sgibbs * Catastrophic error. Mark our device 62639213Sgibbs * as invalid. 62739213Sgibbs */ 62839213Sgibbs xpt_print_path(periph->path); 62939213Sgibbs printf("Invalidating device\n"); 63039213Sgibbs softc->flags |= PT_FLAG_DEVICE_INVALID; 63139213Sgibbs } 63239213Sgibbs 63339213Sgibbs /* 63439213Sgibbs * return all queued I/O with EIO, so that 63539213Sgibbs * the client can retry these I/Os in the 63639213Sgibbs * proper order should it attempt to recover. 63739213Sgibbs */ 63839213Sgibbs while ((q_bp = bufq_first(&softc->buf_queue)) 63939213Sgibbs != NULL) { 64039213Sgibbs bufq_remove(&softc->buf_queue, q_bp); 64139213Sgibbs q_bp->b_resid = q_bp->b_bcount; 64239213Sgibbs q_bp->b_error = EIO; 64339213Sgibbs q_bp->b_flags |= B_ERROR; 64439213Sgibbs biodone(q_bp); 64539213Sgibbs } 64639213Sgibbs splx(s); 64739213Sgibbs bp->b_error = error; 64839213Sgibbs bp->b_resid = bp->b_bcount; 64939213Sgibbs bp->b_flags |= B_ERROR; 65039213Sgibbs } else { 65139213Sgibbs bp->b_resid = csio->resid; 65239213Sgibbs bp->b_error = 0; 65339213Sgibbs if (bp->b_resid != 0) { 65439213Sgibbs /* Short transfer ??? */ 65539213Sgibbs bp->b_flags |= B_ERROR; 65639213Sgibbs } 65739213Sgibbs } 65839213Sgibbs if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) 65939213Sgibbs cam_release_devq(done_ccb->ccb_h.path, 66039213Sgibbs /*relsim_flags*/0, 66139213Sgibbs /*reduction*/0, 66239213Sgibbs /*timeout*/0, 66339213Sgibbs /*getcount_only*/0); 66439213Sgibbs } else { 66539213Sgibbs bp->b_resid = csio->resid; 66639213Sgibbs if (bp->b_resid != 0) 66739213Sgibbs bp->b_flags |= B_ERROR; 66839213Sgibbs } 66939213Sgibbs 67039213Sgibbs /* 67139213Sgibbs * Block out any asyncronous callbacks 67239213Sgibbs * while we touch the pending ccb list. 67339213Sgibbs */ 67439213Sgibbs oldspl = splcam(); 67539213Sgibbs LIST_REMOVE(&done_ccb->ccb_h, periph_links.le); 67639213Sgibbs splx(oldspl); 67739213Sgibbs 67839213Sgibbs devstat_end_transaction(&softc->device_stats, 67939213Sgibbs bp->b_bcount - bp->b_resid, 68039213Sgibbs done_ccb->csio.tag_action & 0xf, 68139213Sgibbs (bp->b_flags & B_READ) ? DEVSTAT_READ 68239213Sgibbs : DEVSTAT_WRITE); 68339213Sgibbs 68439213Sgibbs biodone(bp); 68539213Sgibbs break; 68639213Sgibbs } 68739213Sgibbs case PT_CCB_WAITING: 68839213Sgibbs /* Caller will release the CCB */ 68939213Sgibbs wakeup(&done_ccb->ccb_h.cbfcnp); 69039213Sgibbs return; 69139213Sgibbs } 69239213Sgibbs xpt_release_ccb(done_ccb); 69339213Sgibbs} 69439213Sgibbs 69539213Sgibbsstatic int 69639213Sgibbspterror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags) 69739213Sgibbs{ 69839213Sgibbs struct pt_softc *softc; 69939213Sgibbs struct cam_periph *periph; 70039213Sgibbs 70139213Sgibbs periph = xpt_path_periph(ccb->ccb_h.path); 70239213Sgibbs softc = (struct pt_softc *)periph->softc; 70339213Sgibbs 70439213Sgibbs return(cam_periph_error(ccb, cam_flags, sense_flags, 70539213Sgibbs &softc->saved_ccb)); 70639213Sgibbs} 70739213Sgibbs 70850073Skenstatic int 70950073Skenptioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) 71050073Sken{ 71150073Sken struct cam_periph *periph; 71250073Sken struct pt_softc *softc; 71350073Sken int unit; 71450073Sken int error; 71550073Sken 71650073Sken unit = minor(dev); 71750073Sken periph = cam_extend_get(ptperiphs, unit); 71850073Sken 71950073Sken if (periph == NULL) 72050073Sken return(ENXIO); 72150073Sken 72250073Sken softc = (struct pt_softc *)periph->softc; 72350073Sken 72450073Sken if ((error = cam_periph_lock(periph, PRIBIO|PCATCH)) != 0) { 72550073Sken return (error); /* error code from tsleep */ 72650073Sken } 72750073Sken 72850073Sken switch(cmd) { 72950073Sken case PTIOCGETTIMEOUT: 73050073Sken if (softc->io_timeout >= 1000) 73150073Sken *(int *)addr = softc->io_timeout / 1000; 73250073Sken else 73350073Sken *(int *)addr = 0; 73450073Sken break; 73550073Sken case PTIOCSETTIMEOUT: 73650073Sken { 73750073Sken int s; 73850073Sken 73950073Sken if (*(int *)addr < 1) { 74050073Sken error = EINVAL; 74150073Sken break; 74250073Sken } 74350073Sken 74450073Sken s = splsoftcam(); 74550073Sken softc->io_timeout = *(int *)addr * 1000; 74650073Sken splx(s); 74750073Sken 74850073Sken break; 74950073Sken } 75050073Sken default: 75150073Sken error = cam_periph_ioctl(periph, cmd, addr, pterror); 75250073Sken break; 75350073Sken } 75450073Sken 75550073Sken cam_periph_unlock(periph); 75650073Sken 75750073Sken return(error); 75850073Sken} 75950073Sken 76039213Sgibbsvoid 76139213Sgibbsscsi_send_receive(struct ccb_scsiio *csio, u_int32_t retries, 76239213Sgibbs void (*cbfcnp)(struct cam_periph *, union ccb *), 76339213Sgibbs u_int tag_action, int readop, u_int byte2, 76439213Sgibbs u_int32_t xfer_len, u_int8_t *data_ptr, u_int8_t sense_len, 76539213Sgibbs u_int32_t timeout) 76639213Sgibbs{ 76739213Sgibbs struct scsi_send_receive *scsi_cmd; 76839213Sgibbs 76939213Sgibbs scsi_cmd = (struct scsi_send_receive *)&csio->cdb_io.cdb_bytes; 77039213Sgibbs scsi_cmd->opcode = readop ? RECEIVE : SEND; 77139213Sgibbs scsi_cmd->byte2 = byte2; 77239213Sgibbs scsi_ulto3b(xfer_len, scsi_cmd->xfer_len); 77339213Sgibbs scsi_cmd->control = 0; 77439213Sgibbs 77539213Sgibbs cam_fill_csio(csio, 77639213Sgibbs retries, 77739213Sgibbs cbfcnp, 77839213Sgibbs /*flags*/readop ? CAM_DIR_IN : CAM_DIR_OUT, 77939213Sgibbs tag_action, 78039213Sgibbs data_ptr, 78139213Sgibbs xfer_len, 78239213Sgibbs sense_len, 78339213Sgibbs sizeof(*scsi_cmd), 78439213Sgibbs timeout); 78539213Sgibbs} 786