scsi_pt.c revision 115562
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 * 2850477Speter * $FreeBSD: head/sys/cam/scsi/scsi_pt.c 115562 2003-05-31 20:46:21Z phk $ 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> 3660041Sphk#include <sys/bio.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_periph.h> 4539213Sgibbs#include <cam/cam_xpt_periph.h> 4639213Sgibbs#include <cam/cam_debug.h> 4739213Sgibbs 4839213Sgibbs#include <cam/scsi/scsi_all.h> 4939213Sgibbs#include <cam/scsi/scsi_message.h> 5039213Sgibbs#include <cam/scsi/scsi_pt.h> 5139213Sgibbs 5250073Sken#include "opt_pt.h" 5350073Sken 5439213Sgibbstypedef enum { 5539213Sgibbs PT_STATE_PROBE, 5639213Sgibbs PT_STATE_NORMAL 5739213Sgibbs} pt_state; 5839213Sgibbs 5939213Sgibbstypedef enum { 6039213Sgibbs PT_FLAG_NONE = 0x00, 6139213Sgibbs PT_FLAG_OPEN = 0x01, 6239213Sgibbs PT_FLAG_DEVICE_INVALID = 0x02, 6339213Sgibbs PT_FLAG_RETRY_UA = 0x04 6439213Sgibbs} pt_flags; 6539213Sgibbs 6639213Sgibbstypedef enum { 6739213Sgibbs PT_CCB_BUFFER_IO = 0x01, 6839213Sgibbs PT_CCB_WAITING = 0x02, 6939213Sgibbs PT_CCB_RETRY_UA = 0x04, 7039213Sgibbs PT_CCB_BUFFER_IO_UA = PT_CCB_BUFFER_IO|PT_CCB_RETRY_UA 7139213Sgibbs} pt_ccb_state; 7239213Sgibbs 7339213Sgibbs/* Offsets into our private area for storing information */ 7439213Sgibbs#define ccb_state ppriv_field0 7539213Sgibbs#define ccb_bp ppriv_ptr1 7639213Sgibbs 7739213Sgibbsstruct pt_softc { 7859249Sphk struct bio_queue_head bio_queue; 79112006Sphk struct devstat *device_stats; 8060938Sjake LIST_HEAD(, ccb_hdr) pending_ccbs; 8139213Sgibbs pt_state state; 8239213Sgibbs pt_flags flags; 8339213Sgibbs union ccb saved_ccb; 8450073Sken int io_timeout; 8553257Sken dev_t dev; 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 11672119SpeterPERIPHDRIVER_DECLARE(pt, ptdriver); 11739213Sgibbs 11839213Sgibbs#define PT_CDEV_MAJOR 61 11939213Sgibbs 12047625Sphkstatic struct cdevsw pt_cdevsw = { 121111815Sphk .d_open = ptopen, 122111815Sphk .d_close = ptclose, 123111815Sphk .d_read = physread, 124111815Sphk .d_write = physwrite, 125111815Sphk .d_ioctl = ptioctl, 126111815Sphk .d_strategy = ptstrategy, 127111815Sphk .d_name = "pt", 128111815Sphk .d_maj = PT_CDEV_MAJOR, 12939213Sgibbs}; 13039213Sgibbs 13150073Sken#ifndef SCSI_PT_DEFAULT_TIMEOUT 13250073Sken#define SCSI_PT_DEFAULT_TIMEOUT 60 13350073Sken#endif 13450073Sken 13539213Sgibbsstatic int 13683366Sjulianptopen(dev_t dev, int flags, int fmt, struct thread *td) 13739213Sgibbs{ 13839213Sgibbs struct cam_periph *periph; 13939213Sgibbs struct pt_softc *softc; 14039213Sgibbs int unit; 14139213Sgibbs int error; 14240603Sken int s; 14339213Sgibbs 14439213Sgibbs unit = minor(dev); 145101940Snjl periph = (struct cam_periph *)dev->si_drv1; 14639213Sgibbs if (periph == NULL) 14739213Sgibbs return (ENXIO); 14839213Sgibbs 14939213Sgibbs softc = (struct pt_softc *)periph->softc; 15039213Sgibbs 15140603Sken s = splsoftcam(); 15240603Sken if (softc->flags & PT_FLAG_DEVICE_INVALID) { 15340603Sken splx(s); 15440603Sken return(ENXIO); 15540603Sken } 15640603Sken 15739213Sgibbs CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, 15849982Sbillf ("ptopen: dev=%s (unit %d)\n", devtoname(dev), unit)); 15939213Sgibbs 16041297Sken if ((error = cam_periph_lock(periph, PRIBIO|PCATCH)) != 0) { 16141297Sken splx(s); 16239213Sgibbs return (error); /* error code from tsleep */ 16341297Sken } 16439213Sgibbs 16541297Sken splx(s); 16641297Sken 16739213Sgibbs if ((softc->flags & PT_FLAG_OPEN) == 0) { 16839213Sgibbs if (cam_periph_acquire(periph) != CAM_REQ_CMP) 16939213Sgibbs error = ENXIO; 17039213Sgibbs else 17139213Sgibbs softc->flags |= PT_FLAG_OPEN; 17239213Sgibbs } else 17339213Sgibbs error = EBUSY; 17439213Sgibbs 17539213Sgibbs cam_periph_unlock(periph); 17639213Sgibbs return (error); 17739213Sgibbs} 17839213Sgibbs 17939213Sgibbsstatic int 18083366Sjulianptclose(dev_t dev, int flag, int fmt, struct thread *td) 18139213Sgibbs{ 18239213Sgibbs struct cam_periph *periph; 18339213Sgibbs struct pt_softc *softc; 18439213Sgibbs int error; 18539213Sgibbs 186101940Snjl periph = (struct cam_periph *)dev->si_drv1; 18739213Sgibbs if (periph == NULL) 18839213Sgibbs return (ENXIO); 18939213Sgibbs 19039213Sgibbs softc = (struct pt_softc *)periph->softc; 19139213Sgibbs 19239213Sgibbs if ((error = cam_periph_lock(periph, PRIBIO)) != 0) 19339213Sgibbs return (error); /* error code from tsleep */ 19439213Sgibbs 19539213Sgibbs softc->flags &= ~PT_FLAG_OPEN; 19639213Sgibbs cam_periph_unlock(periph); 19739213Sgibbs cam_periph_release(periph); 19839213Sgibbs return (0); 19939213Sgibbs} 20039213Sgibbs 20139213Sgibbs/* 20239213Sgibbs * Actually translate the requested transfer into one the physical driver 20339213Sgibbs * can understand. The transfer is described by a buf and will include 20439213Sgibbs * only one physical transfer. 20539213Sgibbs */ 20639213Sgibbsstatic void 20759249Sphkptstrategy(struct bio *bp) 20839213Sgibbs{ 20939213Sgibbs struct cam_periph *periph; 21039213Sgibbs struct pt_softc *softc; 21139213Sgibbs int s; 21239213Sgibbs 213101940Snjl periph = (struct cam_periph *)bp->bio_dev->si_drv1; 21476362Sphk bp->bio_resid = bp->bio_bcount; 21539213Sgibbs if (periph == NULL) { 21676362Sphk biofinish(bp, NULL, ENXIO); 21776362Sphk return; 21839213Sgibbs } 21939213Sgibbs softc = (struct pt_softc *)periph->softc; 22039213Sgibbs 22139213Sgibbs /* 22239213Sgibbs * Mask interrupts so that the pack cannot be invalidated until 22339213Sgibbs * after we are in the queue. Otherwise, we might not properly 22439213Sgibbs * clean up one of the buffers. 22539213Sgibbs */ 22639213Sgibbs s = splbio(); 22739213Sgibbs 22839213Sgibbs /* 22939213Sgibbs * If the device has been made invalid, error out 23039213Sgibbs */ 23139213Sgibbs if ((softc->flags & PT_FLAG_DEVICE_INVALID)) { 23239213Sgibbs splx(s); 23376362Sphk biofinish(bp, NULL, ENXIO); 23476362Sphk return; 23539213Sgibbs } 23639213Sgibbs 23739213Sgibbs /* 23839213Sgibbs * Place it in the queue of disk activities for this disk 23939213Sgibbs */ 24059249Sphk bioq_insert_tail(&softc->bio_queue, bp); 24139213Sgibbs 24239213Sgibbs splx(s); 24339213Sgibbs 24439213Sgibbs /* 24539213Sgibbs * Schedule ourselves for performing the work. 24639213Sgibbs */ 24739213Sgibbs xpt_schedule(periph, /* XXX priority */1); 24839213Sgibbs 24939213Sgibbs return; 25039213Sgibbs} 25139213Sgibbs 25239213Sgibbsstatic void 25339213Sgibbsptinit(void) 25439213Sgibbs{ 25539213Sgibbs cam_status status; 25639213Sgibbs struct cam_path *path; 25739213Sgibbs 25839213Sgibbs /* 25939213Sgibbs * Install a global async callback. This callback will 26039213Sgibbs * receive async callbacks like "new device found". 26139213Sgibbs */ 26239213Sgibbs status = xpt_create_path(&path, /*periph*/NULL, CAM_XPT_PATH_ID, 26339213Sgibbs CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD); 26439213Sgibbs 26539213Sgibbs if (status == CAM_REQ_CMP) { 26639213Sgibbs struct ccb_setasync csa; 26739213Sgibbs 26839213Sgibbs xpt_setup_ccb(&csa.ccb_h, path, /*priority*/5); 26939213Sgibbs csa.ccb_h.func_code = XPT_SASYNC_CB; 27039213Sgibbs csa.event_enable = AC_FOUND_DEVICE; 27139213Sgibbs csa.callback = ptasync; 27239213Sgibbs csa.callback_arg = NULL; 27339213Sgibbs xpt_action((union ccb *)&csa); 27439213Sgibbs status = csa.ccb_h.status; 27539213Sgibbs xpt_free_path(path); 27639213Sgibbs } 27739213Sgibbs 27839213Sgibbs if (status != CAM_REQ_CMP) { 27939213Sgibbs printf("pt: Failed to attach master async callback " 28039213Sgibbs "due to status 0x%x!\n", status); 28139213Sgibbs } 28239213Sgibbs} 28339213Sgibbs 28439213Sgibbsstatic cam_status 28539213Sgibbsptctor(struct cam_periph *periph, void *arg) 28639213Sgibbs{ 28739213Sgibbs struct pt_softc *softc; 28839213Sgibbs struct ccb_setasync csa; 28939213Sgibbs struct ccb_getdev *cgd; 29039213Sgibbs 29139213Sgibbs cgd = (struct ccb_getdev *)arg; 29239213Sgibbs if (periph == NULL) { 29339213Sgibbs printf("ptregister: periph was NULL!!\n"); 29439213Sgibbs return(CAM_REQ_CMP_ERR); 29539213Sgibbs } 29639213Sgibbs 29739213Sgibbs if (cgd == NULL) { 29839213Sgibbs printf("ptregister: no getdev CCB, can't register device\n"); 29939213Sgibbs return(CAM_REQ_CMP_ERR); 30039213Sgibbs } 30139213Sgibbs 30239213Sgibbs softc = (struct pt_softc *)malloc(sizeof(*softc),M_DEVBUF,M_NOWAIT); 30339213Sgibbs 30439213Sgibbs if (softc == NULL) { 30539213Sgibbs printf("daregister: Unable to probe new device. " 30639213Sgibbs "Unable to allocate softc\n"); 30739213Sgibbs return(CAM_REQ_CMP_ERR); 30839213Sgibbs } 30939213Sgibbs 31039213Sgibbs bzero(softc, sizeof(*softc)); 31139213Sgibbs LIST_INIT(&softc->pending_ccbs); 31239213Sgibbs softc->state = PT_STATE_NORMAL; 31359249Sphk bioq_init(&softc->bio_queue); 31439213Sgibbs 31550073Sken softc->io_timeout = SCSI_PT_DEFAULT_TIMEOUT * 1000; 31650073Sken 31739213Sgibbs periph->softc = softc; 31839213Sgibbs 319112006Sphk softc->device_stats = devstat_new_entry("pt", 32039213Sgibbs periph->unit_number, 0, 32139213Sgibbs DEVSTAT_NO_BLOCKSIZE, 32256148Smjacob SID_TYPE(&cgd->inq_data) | DEVSTAT_TYPE_IF_SCSI, 32343819Sken DEVSTAT_PRIORITY_OTHER); 32439213Sgibbs 32553257Sken softc->dev = make_dev(&pt_cdevsw, periph->unit_number, UID_ROOT, 32653257Sken GID_OPERATOR, 0600, "%s%d", periph->periph_name, 32753257Sken periph->unit_number); 328101940Snjl softc->dev->si_drv1 = periph; 329101940Snjl 33039213Sgibbs /* 33139213Sgibbs * Add async callbacks for bus reset and 33239213Sgibbs * bus device reset calls. I don't bother 33339213Sgibbs * checking if this fails as, in most cases, 33439213Sgibbs * the system will function just fine without 33539213Sgibbs * them and the only alternative would be to 33639213Sgibbs * not attach the device on failure. 33739213Sgibbs */ 33839213Sgibbs xpt_setup_ccb(&csa.ccb_h, periph->path, /*priority*/5); 33939213Sgibbs csa.ccb_h.func_code = XPT_SASYNC_CB; 34039213Sgibbs csa.event_enable = AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE; 34139213Sgibbs csa.callback = ptasync; 34239213Sgibbs csa.callback_arg = periph; 34339213Sgibbs xpt_action((union ccb *)&csa); 34439213Sgibbs 34539213Sgibbs /* Tell the user we've attached to the device */ 34639213Sgibbs xpt_announce_periph(periph, NULL); 34739213Sgibbs 34839213Sgibbs return(CAM_REQ_CMP); 34939213Sgibbs} 35039213Sgibbs 35139213Sgibbsstatic void 35240603Skenptoninvalidate(struct cam_periph *periph) 35340603Sken{ 35440603Sken int s; 35540603Sken struct pt_softc *softc; 35640603Sken struct ccb_setasync csa; 35740603Sken 35840603Sken softc = (struct pt_softc *)periph->softc; 35940603Sken 36040603Sken /* 36140603Sken * De-register any async callbacks. 36240603Sken */ 36340603Sken xpt_setup_ccb(&csa.ccb_h, periph->path, 36440603Sken /* priority */ 5); 36540603Sken csa.ccb_h.func_code = XPT_SASYNC_CB; 36640603Sken csa.event_enable = 0; 36740603Sken csa.callback = ptasync; 36840603Sken csa.callback_arg = periph; 36940603Sken xpt_action((union ccb *)&csa); 37040603Sken 37140603Sken softc->flags |= PT_FLAG_DEVICE_INVALID; 37240603Sken 37340603Sken /* 37440603Sken * Although the oninvalidate() routines are always called at 37540603Sken * splsoftcam, we need to be at splbio() here to keep the buffer 37640603Sken * queue from being modified while we traverse it. 37740603Sken */ 37840603Sken s = splbio(); 37940603Sken 38040603Sken /* 38140603Sken * Return all queued I/O with ENXIO. 38240603Sken * XXX Handle any transactions queued to the card 38340603Sken * with XPT_ABORT_CCB. 38440603Sken */ 385112946Sphk bioq_flush(&softc->bio_queue, NULL, ENXIO); 38640603Sken 38740603Sken splx(s); 38840603Sken 38940603Sken xpt_print_path(periph->path); 39040603Sken printf("lost device\n"); 39140603Sken} 39240603Sken 39340603Skenstatic void 39439213Sgibbsptdtor(struct cam_periph *periph) 39539213Sgibbs{ 39640603Sken struct pt_softc *softc; 39740603Sken 39840603Sken softc = (struct pt_softc *)periph->softc; 39940603Sken 400112006Sphk devstat_remove_entry(softc->device_stats); 40140603Sken 40253257Sken destroy_dev(softc->dev); 40353257Sken 40439213Sgibbs xpt_print_path(periph->path); 40539213Sgibbs printf("removing device entry\n"); 40640603Sken free(softc, M_DEVBUF); 40739213Sgibbs} 40839213Sgibbs 40939213Sgibbsstatic void 41039213Sgibbsptasync(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg) 41139213Sgibbs{ 41239213Sgibbs struct cam_periph *periph; 41339213Sgibbs 41439213Sgibbs periph = (struct cam_periph *)callback_arg; 41539213Sgibbs switch (code) { 41639213Sgibbs case AC_FOUND_DEVICE: 41739213Sgibbs { 41839213Sgibbs struct ccb_getdev *cgd; 41939213Sgibbs cam_status status; 42039213Sgibbs 42139213Sgibbs cgd = (struct ccb_getdev *)arg; 42279177Smjacob if (cgd == NULL) 42379177Smjacob break; 42439213Sgibbs 42556148Smjacob if (SID_TYPE(&cgd->inq_data) != T_PROCESSOR) 42639213Sgibbs break; 42739213Sgibbs 42839213Sgibbs /* 42939213Sgibbs * Allocate a peripheral instance for 43039213Sgibbs * this device and start the probe 43139213Sgibbs * process. 43239213Sgibbs */ 43340603Sken status = cam_periph_alloc(ptctor, ptoninvalidate, ptdtor, 43440603Sken ptstart, "pt", CAM_PERIPH_BIO, 43540603Sken cgd->ccb_h.path, ptasync, 43640603Sken AC_FOUND_DEVICE, cgd); 43739213Sgibbs 43839213Sgibbs if (status != CAM_REQ_CMP 43939213Sgibbs && status != CAM_REQ_INPROG) 44039213Sgibbs printf("ptasync: Unable to attach to new device " 44139213Sgibbs "due to status 0x%x\n", status); 44239213Sgibbs break; 44339213Sgibbs } 44439213Sgibbs case AC_SENT_BDR: 44539213Sgibbs case AC_BUS_RESET: 44639213Sgibbs { 44739213Sgibbs struct pt_softc *softc; 44839213Sgibbs struct ccb_hdr *ccbh; 44939213Sgibbs int s; 45039213Sgibbs 45139213Sgibbs softc = (struct pt_softc *)periph->softc; 45239213Sgibbs s = splsoftcam(); 45339213Sgibbs /* 45439213Sgibbs * Don't fail on the expected unit attention 45539213Sgibbs * that will occur. 45639213Sgibbs */ 45739213Sgibbs softc->flags |= PT_FLAG_RETRY_UA; 45871999Sphk LIST_FOREACH(ccbh, &softc->pending_ccbs, periph_links.le) 45939213Sgibbs ccbh->ccb_state |= PT_CCB_RETRY_UA; 46039213Sgibbs splx(s); 46139213Sgibbs } 462115562Sphk /* FALLTHROUGH */ 46339213Sgibbs default: 46447413Sgibbs cam_periph_async(periph, code, path, arg); 46539213Sgibbs break; 46639213Sgibbs } 46739213Sgibbs} 46839213Sgibbs 46939213Sgibbsstatic void 47039213Sgibbsptstart(struct cam_periph *periph, union ccb *start_ccb) 47139213Sgibbs{ 47239213Sgibbs struct pt_softc *softc; 47359249Sphk struct bio *bp; 47439213Sgibbs int s; 47539213Sgibbs 47639213Sgibbs softc = (struct pt_softc *)periph->softc; 47739213Sgibbs 47839213Sgibbs /* 47939213Sgibbs * See if there is a buf with work for us to do.. 48039213Sgibbs */ 48139213Sgibbs s = splbio(); 48259249Sphk bp = bioq_first(&softc->bio_queue); 48339213Sgibbs if (periph->immediate_priority <= periph->pinfo.priority) { 48439213Sgibbs CAM_DEBUG_PRINT(CAM_DEBUG_SUBTRACE, 48539213Sgibbs ("queuing for immediate ccb\n")); 48639213Sgibbs start_ccb->ccb_h.ccb_state = PT_CCB_WAITING; 48739213Sgibbs SLIST_INSERT_HEAD(&periph->ccb_list, &start_ccb->ccb_h, 48839213Sgibbs periph_links.sle); 48939213Sgibbs periph->immediate_priority = CAM_PRIORITY_NONE; 49039213Sgibbs splx(s); 49139213Sgibbs wakeup(&periph->ccb_list); 49239213Sgibbs } else if (bp == NULL) { 49339213Sgibbs splx(s); 49439213Sgibbs xpt_release_ccb(start_ccb); 49539213Sgibbs } else { 49639213Sgibbs int oldspl; 49739213Sgibbs 49859249Sphk bioq_remove(&softc->bio_queue, bp); 49939213Sgibbs 500112260Sphk devstat_start_transaction_bio(softc->device_stats, bp); 50139213Sgibbs 50239213Sgibbs scsi_send_receive(&start_ccb->csio, 50339213Sgibbs /*retries*/4, 50439213Sgibbs ptdone, 50539213Sgibbs MSG_SIMPLE_Q_TAG, 50659249Sphk bp->bio_cmd == BIO_READ, 50739213Sgibbs /*byte2*/0, 50859249Sphk bp->bio_bcount, 50959249Sphk bp->bio_data, 51039213Sgibbs /*sense_len*/SSD_FULL_SIZE, 51150073Sken /*timeout*/softc->io_timeout); 51239213Sgibbs 51376192Sken start_ccb->ccb_h.ccb_state = PT_CCB_BUFFER_IO_UA; 51439213Sgibbs 51539213Sgibbs /* 51639213Sgibbs * Block out any asyncronous callbacks 51739213Sgibbs * while we touch the pending ccb list. 51839213Sgibbs */ 51939213Sgibbs oldspl = splcam(); 52039213Sgibbs LIST_INSERT_HEAD(&softc->pending_ccbs, &start_ccb->ccb_h, 52139213Sgibbs periph_links.le); 52239213Sgibbs splx(oldspl); 52339213Sgibbs 52439213Sgibbs start_ccb->ccb_h.ccb_bp = bp; 52559249Sphk bp = bioq_first(&softc->bio_queue); 52639213Sgibbs splx(s); 52739213Sgibbs 52839213Sgibbs xpt_action(start_ccb); 52939213Sgibbs 53039213Sgibbs if (bp != NULL) { 53139213Sgibbs /* Have more work to do, so ensure we stay scheduled */ 53239213Sgibbs xpt_schedule(periph, /* XXX priority */1); 53339213Sgibbs } 53439213Sgibbs } 53539213Sgibbs} 53639213Sgibbs 53739213Sgibbsstatic void 53839213Sgibbsptdone(struct cam_periph *periph, union ccb *done_ccb) 53939213Sgibbs{ 54039213Sgibbs struct pt_softc *softc; 54139213Sgibbs struct ccb_scsiio *csio; 54239213Sgibbs 54339213Sgibbs softc = (struct pt_softc *)periph->softc; 54439213Sgibbs csio = &done_ccb->csio; 54539213Sgibbs switch (csio->ccb_h.ccb_state) { 54639213Sgibbs case PT_CCB_BUFFER_IO: 54739213Sgibbs case PT_CCB_BUFFER_IO_UA: 54839213Sgibbs { 54959249Sphk struct bio *bp; 55039213Sgibbs int oldspl; 55139213Sgibbs 55259249Sphk bp = (struct bio *)done_ccb->ccb_h.ccb_bp; 55339213Sgibbs if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 55439213Sgibbs int error; 55539213Sgibbs int s; 55639213Sgibbs int sf; 55739213Sgibbs 55839213Sgibbs if ((csio->ccb_h.ccb_state & PT_CCB_RETRY_UA) != 0) 55939213Sgibbs sf = SF_RETRY_UA; 56039213Sgibbs else 56139213Sgibbs sf = 0; 56239213Sgibbs 56374840Sken error = pterror(done_ccb, CAM_RETRY_SELTO, sf); 56474840Sken if (error == ERESTART) { 56539213Sgibbs /* 56639213Sgibbs * A retry was scheuled, so 56739213Sgibbs * just return. 56839213Sgibbs */ 56939213Sgibbs return; 57039213Sgibbs } 57139213Sgibbs if (error != 0) { 57239213Sgibbs s = splbio(); 57339213Sgibbs 57439213Sgibbs if (error == ENXIO) { 57539213Sgibbs /* 57639213Sgibbs * Catastrophic error. Mark our device 57739213Sgibbs * as invalid. 57839213Sgibbs */ 57939213Sgibbs xpt_print_path(periph->path); 58039213Sgibbs printf("Invalidating device\n"); 58139213Sgibbs softc->flags |= PT_FLAG_DEVICE_INVALID; 58239213Sgibbs } 58339213Sgibbs 58439213Sgibbs /* 58539213Sgibbs * return all queued I/O with EIO, so that 58639213Sgibbs * the client can retry these I/Os in the 58739213Sgibbs * proper order should it attempt to recover. 58839213Sgibbs */ 589112946Sphk bioq_flush(&softc->bio_queue, NULL, EIO); 59039213Sgibbs splx(s); 59159249Sphk bp->bio_error = error; 59259249Sphk bp->bio_resid = bp->bio_bcount; 59359249Sphk bp->bio_flags |= BIO_ERROR; 59439213Sgibbs } else { 59559249Sphk bp->bio_resid = csio->resid; 59659249Sphk bp->bio_error = 0; 59759249Sphk if (bp->bio_resid != 0) { 59839213Sgibbs /* Short transfer ??? */ 59959249Sphk bp->bio_flags |= BIO_ERROR; 60039213Sgibbs } 60139213Sgibbs } 60239213Sgibbs if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) 60339213Sgibbs cam_release_devq(done_ccb->ccb_h.path, 60439213Sgibbs /*relsim_flags*/0, 60539213Sgibbs /*reduction*/0, 60639213Sgibbs /*timeout*/0, 60739213Sgibbs /*getcount_only*/0); 60839213Sgibbs } else { 60959249Sphk bp->bio_resid = csio->resid; 61059249Sphk if (bp->bio_resid != 0) 61159249Sphk bp->bio_flags |= BIO_ERROR; 61239213Sgibbs } 61339213Sgibbs 61439213Sgibbs /* 61539213Sgibbs * Block out any asyncronous callbacks 61639213Sgibbs * while we touch the pending ccb list. 61739213Sgibbs */ 61839213Sgibbs oldspl = splcam(); 61939213Sgibbs LIST_REMOVE(&done_ccb->ccb_h, periph_links.le); 62039213Sgibbs splx(oldspl); 62139213Sgibbs 622112006Sphk biofinish(bp, softc->device_stats, 0); 62339213Sgibbs break; 62439213Sgibbs } 62539213Sgibbs case PT_CCB_WAITING: 62639213Sgibbs /* Caller will release the CCB */ 62739213Sgibbs wakeup(&done_ccb->ccb_h.cbfcnp); 62839213Sgibbs return; 62939213Sgibbs } 63039213Sgibbs xpt_release_ccb(done_ccb); 63139213Sgibbs} 63239213Sgibbs 63339213Sgibbsstatic int 63439213Sgibbspterror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags) 63539213Sgibbs{ 63639213Sgibbs struct pt_softc *softc; 63739213Sgibbs struct cam_periph *periph; 63839213Sgibbs 63939213Sgibbs periph = xpt_path_periph(ccb->ccb_h.path); 64039213Sgibbs softc = (struct pt_softc *)periph->softc; 64139213Sgibbs 64239213Sgibbs return(cam_periph_error(ccb, cam_flags, sense_flags, 64339213Sgibbs &softc->saved_ccb)); 64439213Sgibbs} 64539213Sgibbs 64650073Skenstatic int 64783366Sjulianptioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct thread *td) 64850073Sken{ 64950073Sken struct cam_periph *periph; 65050073Sken struct pt_softc *softc; 65150073Sken int error; 65250073Sken 653101940Snjl periph = (struct cam_periph *)dev->si_drv1; 65450073Sken if (periph == NULL) 65550073Sken return(ENXIO); 65650073Sken 65750073Sken softc = (struct pt_softc *)periph->softc; 65850073Sken 65950073Sken if ((error = cam_periph_lock(periph, PRIBIO|PCATCH)) != 0) { 66050073Sken return (error); /* error code from tsleep */ 66150073Sken } 66250073Sken 66350073Sken switch(cmd) { 66450073Sken case PTIOCGETTIMEOUT: 66550073Sken if (softc->io_timeout >= 1000) 66650073Sken *(int *)addr = softc->io_timeout / 1000; 66750073Sken else 66850073Sken *(int *)addr = 0; 66950073Sken break; 67050073Sken case PTIOCSETTIMEOUT: 67150073Sken { 67250073Sken int s; 67350073Sken 67450073Sken if (*(int *)addr < 1) { 67550073Sken error = EINVAL; 67650073Sken break; 67750073Sken } 67850073Sken 67950073Sken s = splsoftcam(); 68050073Sken softc->io_timeout = *(int *)addr * 1000; 68150073Sken splx(s); 68250073Sken 68350073Sken break; 68450073Sken } 68550073Sken default: 68650073Sken error = cam_periph_ioctl(periph, cmd, addr, pterror); 68750073Sken break; 68850073Sken } 68950073Sken 69050073Sken cam_periph_unlock(periph); 69150073Sken 69250073Sken return(error); 69350073Sken} 69450073Sken 69539213Sgibbsvoid 69639213Sgibbsscsi_send_receive(struct ccb_scsiio *csio, u_int32_t retries, 69739213Sgibbs void (*cbfcnp)(struct cam_periph *, union ccb *), 69839213Sgibbs u_int tag_action, int readop, u_int byte2, 69939213Sgibbs u_int32_t xfer_len, u_int8_t *data_ptr, u_int8_t sense_len, 70039213Sgibbs u_int32_t timeout) 70139213Sgibbs{ 70239213Sgibbs struct scsi_send_receive *scsi_cmd; 70339213Sgibbs 70439213Sgibbs scsi_cmd = (struct scsi_send_receive *)&csio->cdb_io.cdb_bytes; 70539213Sgibbs scsi_cmd->opcode = readop ? RECEIVE : SEND; 70639213Sgibbs scsi_cmd->byte2 = byte2; 70739213Sgibbs scsi_ulto3b(xfer_len, scsi_cmd->xfer_len); 70839213Sgibbs scsi_cmd->control = 0; 70939213Sgibbs 71039213Sgibbs cam_fill_csio(csio, 71139213Sgibbs retries, 71239213Sgibbs cbfcnp, 71339213Sgibbs /*flags*/readop ? CAM_DIR_IN : CAM_DIR_OUT, 71439213Sgibbs tag_action, 71539213Sgibbs data_ptr, 71639213Sgibbs xfer_len, 71739213Sgibbs sense_len, 71839213Sgibbs sizeof(*scsi_cmd), 71939213Sgibbs timeout); 72039213Sgibbs} 721