/* * Copyright (C) 1994 Poul-Henning Kamp * * All rights reserved. * * This file contains some material which are covered by the message after * this message. * * The rest of this file is covered by the following clause: * ---------------------------------------------------------------------------- * "THE BEER-WARE LICENSE" (Revision 42): * wrote this file. As long as you retain this notice you * can do whatever you want with this stuff. If we meet some day, and you think * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp * ---------------------------------------------------------------------------- * * $Id: pas.c,v 1.3 1994/09/13 06:44:39 phk Exp $ * * This is a driver for the one particular kind of the "ProAudioSpectrum" * card from MediaVision. To find out if your card is supported, you can * either try out the driver, or you can look for a chip a little less than * 1" square in one end of the card, with writing on it that say ...5380... * * Up to four of these cards can be in the same computer. If you have * multiple cards, you need to set the "card-id" jumpers correspondingly. * * The driver uses no interrupts, so don't expect record-breaking performance. * * Poul-Henning Kamp */ /* * Copyright (C) 1993 Allen K. Briggs, Chris P. Caputo, * Michael L. Finch, Bradley A. Grantham, and * Lawrence A. Kesteloot * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the Alice Group. * 4. The names of the Alice Group or any of its members may not be used * to endorse or promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE ALICE GROUP ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE ALICE GROUP BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Was: Id: pas.c,v 1.8.2.1 1994/07/11 00:02:32 cgd Exp * * Modified for use with the pc532 by Phil Nelson, Feb 94. */ #include "pas.h" #if NPAS > 0 #include "param.h" #include "systm.h" #include "types.h" #include "buf.h" #include "i386/isa/isa_device.h" #include #include #include "ic/ncr_5380.h" /* * Define this macro to disable the PSEUDO-DMA transfers. */ #undef NO_PAS16_PSEUDO_DMA /* * This parameter determines how many byte we "insb" between each check for * a change of phase. */ #ifndef PAS16_PSEUDO_DMA_SIZE # define PAS16_PSEUDO_DMA_SIZE 512 #endif /* * How many times we attempt to select a device. */ #ifndef ATTEMPT_SELECTION # define ATTEMPT_SELECTION 5 #endif /* ATTEMPT_SELECTION */ /* * How many microseconds between each attempt. */ #ifndef SELECTION_DELAY # define SELECTION_DELAY 10000 #endif /* SELECTION_DELAY */ #ifndef PAS16_TIMEOUT # define PAS16_TIMEOUT 1000000 #endif /* PAS16_TIMEOUT */ /* What we need to debug the driver */ #ifdef PAS_DEBUG # if PAS_DEBUG == 0 # undef PAS_DEBUG # else static int pas_show_scsi_cmd(struct scsi_xfer *xs); # ifndef PAS_DEBUG_REQUEST_SENSE # define PAS_DEBUG_REQUEST_SENSE # endif # endif #endif /* PAS_DEBUG */ #define SCSI_PHASE_DATA_OUT 0x0 #define SCSI_PHASE_DATA_IN 0x1 #define SCSI_PHASE_CMD 0x2 #define SCSI_PHASE_STATUS 0x3 #define SCSI_PHASE_UNSPEC1 0x4 #define SCSI_PHASE_UNSPEC2 0x5 #define SCSI_PHASE_MESSAGE_OUT 0x6 #define SCSI_PHASE_MESSAGE_IN 0x7 #define SCSI_CUR_PHASE(x) ((x>>2)&0x7) #define SCSI_RET_SUCCESS 0 #define SCSI_RET_RETRY 1 #define SCSI_RET_DEVICE_DOWN 2 #define SCSI_RET_COMMAND_FAIL 3 /* Our per device (card) structure */ static struct pas_softc { struct scsi_link sc_link; int mv_unit; u_short iobase; #define xor_0000 iobase u_short xor_0001; u_short xor_0002; u_short xor_0003; u_short xor_2000; u_short xor_2001; u_short xor_2002; u_short xor_2003; u_short xor_4000; u_short xor_4001; u_short xor_4003; } s_pas[NPAS]; /* * Register Access-macros use these */ #define r_csdr(ptr) (ptr->xor_0000) #define w_odr(ptr) (ptr->xor_0000) #define r_icr(ptr) (ptr->xor_0001) #define w_icr(ptr) (ptr->xor_0001) #define rw_mr(ptr) (ptr->xor_0002) #define r_tcr(ptr) (ptr->xor_0003) #define w_tcr(ptr) (ptr->xor_0003) #define r_cscr(ptr) (ptr->xor_2000) #define w_ser(ptr) (ptr->xor_2000) #define r_bsr(ptr) (ptr->xor_2001) #define w_sdsr(ptr) (ptr->xor_2001) #define r_idr(ptr) (ptr->xor_2002) #define w_sdtr(ptr) (ptr->xor_2002) #define r_rpir(ptr) (ptr->xor_2003) #define w_sdir(ptr) (ptr->xor_2003) #define pas_data(ptr) (ptr->xor_4000) #define pas_stat(ptr) (ptr->xor_4001) #define R_PAS_STAT_DREQ 0x80 #define pas_irq(ptr) (ptr->xor_4003) /* * The actual macros used to access the chip */ #define P_PAS struct pas_softc * #define R_PAS(ptr,foo) inb(foo(ptr)) #define W_PAS(ptr,foo,val) outb(foo(ptr),val) #define M_PAS(ptr,foo,opr,arg) outb(foo(ptr),R_PAS(ptr,foo) opr arg) #define WAIT_FOR_NOT_REQ(ptr) { \ int scsi_timeout = PAS16_TIMEOUT; \ while ( (R_PAS(ptr,r_cscr) & R_CSCR_REQ) && \ (R_PAS(ptr,r_cscr) & R_CSCR_REQ) && \ (R_PAS(ptr,r_cscr) & R_CSCR_REQ) && \ (--scsi_timeout) ); \ if (!scsi_timeout) { \ printf("scsi timeout--WAIT_FOR_NOT_REQ-- pas.c:%d.\n", __LINE__); \ goto scsi_timeout_error; \ } \ } #define WAIT_FOR_REQ(ptr) { \ int scsi_timeout = PAS16_TIMEOUT; \ while ( ((R_PAS(ptr,r_cscr) & R_CSCR_REQ) == 0) && \ ((R_PAS(ptr,r_cscr) & R_CSCR_REQ) == 0) && \ ((R_PAS(ptr,r_cscr) & R_CSCR_REQ) == 0) && \ (--scsi_timeout) ); \ if (!scsi_timeout) { \ printf("scsi timeout--WAIT_FOR_REQ-- pas.c:%d.\n", __LINE__); \ goto scsi_timeout_error; \ } \ } static u_int32 pas_adapter_info(int adapter_number); static void pas_minphys(struct buf *bp); static int32 pas_scsi_cmd(struct scsi_xfer *xs); static int pas_reset(int); static int pas_send_cmd(struct scsi_xfer *xs); static int scsi_req(P_PAS,int,int,u_char *,int, u_char *, int , int *, int *); static int sci_data_out(P_PAS, int, int, u_char *); static int sci_data_in(P_PAS, int, int, u_char *); static int select_target(P_PAS, int); extern int pasprobe(struct isa_device *dev); extern int pasattach(struct isa_device *dev); struct isa_driver pasdriver = { pasprobe, pasattach, "pas" }; static struct scsi_adapter pas_adapter = { pas_scsi_cmd, /* scsi_cmd() */ pas_minphys, /* scsi_minphys() */ 0, /* open_target_lu() */ 0, /* close_target_lu() */ pas_adapter_info, /* adapter_info() */ "pas", /* name */ { 0, 0 } /* spare[2] */ }; static struct scsi_device pas_dev = { NULL, /* Use default error handler. */ NULL, /* have a queue, served by this (?) */ NULL, /* have no async handler. */ NULL, /* Use default "done" routine. */ "pas", 0, { 0, 0 } }; static char *mv_type[] = { 0,0,0,0,0,0,"PAS+",0,0,0,0,0,"PAS16D",0,"CDPC","PAS16"}; int pasprobe(struct isa_device *dev) { int port = dev->id_iobase; int base = port - 0x1c00; int unit = dev->id_unit; int i, j; if(base & 3) { printf("pas%d cannot operate on address %x.", unit,port); printf(" Address must be a multiple of four.\n"); return 0; } /* Tell the PAS16 we want to talk to, where to listen */ outb(0x9a01,0xbc + unit); outb(0x9a01,base >> 2); #ifdef PAS_DEBUG printf("%x: 0x803=%x 0xec03=%x 0xff88=%x\n", base,inb(base^0x803),inb(base^0xec03),inb(base^0xfc00)); #endif /* Killer one */ i = inb(base ^ 0x803); if(i == 0xff) return 0; /* killer two */ if((0x03 & inb(base^0xec03)) != 0x03) return 0; /* killer three */ for(i=0;i<4;i++) { if(inb(port) != 0xff || inb(port^0x2000) != 0xff) goto ok; } return 0; ok: /* killer four */ i = inb(base ^ 0x803); outb(base^0x803,i ^ 0xe0); j = inb(base^0x803); outb(base^0x803,1); if(i != j) return 0; return 4; } static u_int32 pas_adapter_info(int adapter_number) { return 1; } int pasattach(struct isa_device *dev) { int i,base=dev->id_iobase-0x1c00; struct pas_softc *ppas; i = inb(base^0xEC03) & 0x0f; printf("pas%d: Type = %d <%s>\n",dev->id_unit,i,mv_type[i]); ppas = s_pas + dev->id_unit; ppas->sc_link.adapter_unit = dev->id_unit; ppas->sc_link.adapter_targ = 7; ppas->sc_link.adapter = &pas_adapter; ppas->sc_link.device = &pas_dev; ppas->iobase=dev->id_iobase; ppas->xor_0001 = ppas->iobase^0x0001; ppas->xor_0002 = ppas->iobase^0x0002; ppas->xor_0003 = ppas->iobase^0x0003; ppas->xor_2000 = ppas->iobase^0x2000; ppas->xor_2001 = ppas->iobase^0x2001; ppas->xor_2002 = ppas->iobase^0x2002; ppas->xor_2003 = ppas->iobase^0x2003; ppas->xor_4000 = ppas->iobase^0x4000; ppas->xor_4001 = ppas->iobase^0x4001; ppas->xor_4003 = ppas->iobase^0x4003; /* Various magic */ outb(base^0x4000,0x30); outb(base^0x4001,0x01); outb(base^0xbc00,0x01); outb(base^0x8003,0x4d); scsi_attachdevs(&(ppas->sc_link)); pas_reset(dev->id_unit); return 1; } static void pas_minphys(struct buf *bp) { #define MIN_PHYS 65536 /*BARF!!!!*/ if (bp->b_bcount > MIN_PHYS) { printf("Uh-oh... pas_minphys setting bp->b_bcount = %x.\n", MIN_PHYS); bp->b_bcount = MIN_PHYS; } #undef MIN_PHYS } static int32 pas_scsi_cmd(struct scsi_xfer *xs) { int flags, s, r; flags = xs->flags; if (xs->bp) flags |= (SCSI_NOSLEEP); if ( flags & ITSDONE ) { printf("Already done?"); xs->flags &= ~ITSDONE; } if ( ! ( flags & INUSE ) ) { printf("Not in use?"); xs->flags |= INUSE; } if ( flags & SCSI_RESET ) { printf("flags & SCSIRESET.\n"); if ( ! ( flags & SCSI_NOSLEEP ) ) { s = splbio(); pas_reset(xs->sc_link->adapter_unit); splx(s); return(SUCCESSFULLY_QUEUED); } else { pas_reset(xs->sc_link->adapter_unit); return (COMPLETE); } } r = pas_send_cmd(xs); xs->flags |= ITSDONE; scsi_done(xs); if (xs->flags&SCSI_NOMASK) { return (r); } return SUCCESSFULLY_QUEUED; } #ifdef PAS_DEBUG static int pas_show_scsi_cmd(struct scsi_xfer *xs) { u_char *b = (u_char *) xs->cmd; int i = 0; if ( ! ( xs->flags & SCSI_RESET ) ) { printf("pas(%d:%d:%d) ", xs->sc_link->adapter_unit, xs->sc_link->target, xs->sc_link->lun); printf("%d@%x, %d@%x <",xs->cmdlen,(u_long)xs->cmd, xs->datalen,(u_long)xs->data); while (i < xs->cmdlen) { if (i) printf(","); printf("%x",b[i++]); } printf(">\n"); } else { printf("pas(%d:%d:%d)-RESET-\n", xs->sc_link->adapter_unit, xs->sc_link->target, xs->sc_link->lun); } return 0; } #endif /* PAS_DEBUG */ static int pas_reset(int adapter) { struct pas_softc *ppas = s_pas + adapter; /* * Reset Hold Time is 25 uSec */ W_PAS(ppas,w_icr,W_ICR_ASSERT_RST); DELAY(25); W_PAS(ppas,w_icr,0); W_PAS(ppas,rw_mr,0); W_PAS(ppas,w_ser,0); return 0; } static int pas_send_cmd(struct scsi_xfer *xs) { P_PAS ptr = s_pas + xs->sc_link->adapter_unit; int s,sent,ret; int sense; u_char cmd[6]; #ifdef PAS_DEBUG pas_show_scsi_cmd(xs); #endif /* PAS_DEBUG */ s = splbio(); sense = scsi_req(ptr, xs->sc_link->target, xs->sc_link->lun, (u_char*)xs->cmd, xs->cmdlen, xs->data, xs->datalen, &sent, &ret); splx(s); switch (sense) { case 0x00: xs->error = XS_NOERROR; xs->resid = sent; return (COMPLETE); case 0x02: /* Check condition */ #ifdef PAS_DEBUG_REQUEST_SENSE printf("pas%d, target%d: sent=%d,ret=%d,sense=%x check. cond.\n", xs->sc_link->adapter_unit, xs->sc_link->target,sent,ret,sense); printf("Cmd:<%x",((u_char*)(xs->cmd))[0]); for(sent=1;sent < sizeof xs->cmdlen;sent++) { printf(",%x",((u_char*)(xs->cmd))[sent]); } printf(">\n"); #endif /* PAS_DEBUG_REQUEST_SENSE */ cmd[0] = 3; cmd[1] = xs->sc_link->lun<<5; cmd[2] = 0; cmd[3] = 0; cmd[4] = sizeof xs->sense; cmd[5] = 0; DELAY(10); s = splbio(); scsi_req(ptr, xs->sc_link->target, xs->sc_link->lun, cmd, sizeof cmd, (caddr_t) &(xs->sense), sizeof xs->sense, &sent, &ret); splx(s); #ifdef PAS_DEBUG_REQUEST_SENSE printf("Sense result: (sent=%d, ret=%d)\n",sent,ret); printf("<%x",((u_char*)(&xs->sense))[0]); for(sent=1;sent < sizeof xs->sense;sent++) { printf(",%x",((u_char*)(&xs->sense))[sent]); } printf(">\n"); #endif /* PAS_DEBUG_REQUEST_SENSE */ xs->error = XS_SENSE; return HAD_ERROR; case 0x08: /* Busy */ xs->error = XS_BUSY; return HAD_ERROR; default: xs->error = XS_DRIVER_STUFFUP; return HAD_ERROR; } } /* * Perform arbitration and selection. Figure 5-1, more or less. */ static int select_target(P_PAS ptr, int tid) { int myid = ptr->sc_link.adapter_targ; int ret = SCSI_RET_RETRY; int tries = ATTEMPT_SELECTION; int delay = SELECTION_DELAY; int i; /* * Convert the ID's to bit-maps. */ myid = 1 << myid; tid = 1 << tid; /* * Not documented, but clearly needed for now. * XXX is this missing somewhere else, and this is just a hack ? */ loop: W_PAS(ptr,w_tcr,0); /* * Write ID Bit to Output Register. */ W_PAS(ptr,w_odr,myid); /* * Set "ARBITRATE" Bit. */ W_PAS(ptr,rw_mr,RW_MR_ARBITRATE); /* * Check "Arbitration in progress" Bit. */ for (i = 0; i < 20; i++) /* 20usec circa */ if (R_PAS(ptr,r_icr) & R_ICR_ARBITRATION_IN_PROGRESS) goto aip; goto lost; aip: /* * Wait 2.2 usec Arbitration Delay. */ DELAY(2); /* * Check "Lost Arbitration" Bit. */ if (R_PAS(ptr,r_icr) & R_ICR_LOST_ARBITRATION) goto lost; /* * Higher priority ID present ? */ if ((R_PAS(ptr,r_csdr) & ~myid) > myid) goto lost; /* * Check "Lost Arbitration" Bit. */ if (R_PAS(ptr,r_icr) & R_ICR_LOST_ARBITRATION) goto lost; /* * Set "Assert SEL/". */ W_PAS(ptr,w_icr,W_ICR_ASSERT_SEL); /* * Check "Lost Arbitration" Bit. */ if (R_PAS(ptr,r_icr) & R_ICR_LOST_ARBITRATION) { goto nosel; } /* * Wait 1.2 usec minimum. (Bus Clear + Settle) */ DELAY(2); /* * Write Target and Initiator's ID bits to output Register. */ W_PAS(ptr,w_odr,myid|tid); /* * Set "Assert BSY/" + "Assert Data Bus". */ W_PAS(ptr,w_icr, W_ICR_ASSERT_SEL | W_ICR_ASSERT_BSY | W_ICR_ASSERT_DATA_BUS); /* * Reset "ARBITRATE" Bit. */ W_PAS(ptr,rw_mr,0); /* * Reset "Select Enable" Register. */ W_PAS(ptr,w_ser,0); /* * Reset "Assert BSY/". */ W_PAS(ptr,w_icr, W_ICR_ASSERT_SEL | W_ICR_ASSERT_DATA_BUS); /* * "BSY/" Asserted within 250 msec ? */ for(i=0;i<250000;i+=100) { if (R_PAS(ptr,r_cscr) & R_CSCR_BSY) goto resp; DELAY(100); } goto nodev; resp: /* * Reset "Assert SEL/" + "Assert Data Bus". */ W_PAS(ptr,w_icr,0); return SCSI_RET_SUCCESS; nodev: ret = SCSI_RET_DEVICE_DOWN; nosel: W_PAS(ptr,w_icr,0); lost: W_PAS(ptr,rw_mr,0); if(--tries) { DELAY(delay); goto loop; } return ret; } /* * Figure 5-2. */ int PHK; static int sci_data_out(P_PAS ptr, int phase, int count, u_char *data) { register unsigned char icmd; register int cnt=0,zonk; if (SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)) != phase) return cnt; icmd = R_PAS(ptr,r_icr) & RW_ICR_MASK; #ifndef NO_PAS16_PSEUDO_DMA /* * The PAS16 has special provisions for doing pseudo-dma. */ /* * Don't use pseudo-dma unless we need much data. This way we avoid all * the variable length stuff entirely. * * XXX something screws up for big transfers :-( */ if(count >= 128 && count <= 8192) { M_PAS(ptr,rw_mr,|,RW_MR_DMA_MODE); W_PAS(ptr,w_icr,icmd | W_ICR_ASSERT_DATA_BUS); W_PAS(ptr,w_sdsr,0); while(count >= PAS16_PSEUDO_DMA_SIZE) { zonk=0; while(!(R_PAS(ptr,pas_stat) & R_PAS_STAT_DREQ)) if (++zonk > 1000 || SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)) != phase) return cnt; outsb(pas_data(ptr),data,PAS16_PSEUDO_DMA_SIZE); data += PAS16_PSEUDO_DMA_SIZE; cnt += PAS16_PSEUDO_DMA_SIZE; count -= PAS16_PSEUDO_DMA_SIZE; } if(count) { while(!(R_PAS(ptr,pas_stat) & R_PAS_STAT_DREQ)) if (SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)) != phase) return cnt; outsb(pas_data(ptr),data,count); cnt += count; data += count; } M_PAS(ptr,rw_mr,&,~RW_MR_DMA_MODE); W_PAS(ptr,w_icr,icmd); return cnt; } #endif /* NO_PAS16_PSEUDO_DMA */ loop: if (SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)) != phase) return cnt; W_PAS(ptr,w_odr, *data); WAIT_FOR_REQ(ptr); icmd |= W_ICR_ASSERT_DATA_BUS; W_PAS(ptr,w_icr,icmd); icmd |= W_ICR_ASSERT_ACK; W_PAS(ptr,w_icr,icmd); icmd &= ~(W_ICR_ASSERT_DATA_BUS|W_ICR_ASSERT_ACK); WAIT_FOR_NOT_REQ(ptr); W_PAS(ptr,w_icr,icmd); ++cnt; data++; if (--count > 0) goto loop; scsi_timeout_error: return cnt; } static int sci_data_in(P_PAS ptr, int phase, int count, u_char *data) { unsigned char icmd; int cnt=0; if (SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)) != phase) return cnt; #ifndef NO_PAS16_PSEUDO_DMA /* * The PAS16 has special provisions for doing pseudo-dma. */ /* * Don't use pseudo-dma unless we need much data. This way we avoid all * the variable length stuff entirely. */ if(count >= 128) { M_PAS(ptr,rw_mr,|,RW_MR_DMA_MODE); W_PAS(ptr,w_sdir,0); while(count > PAS16_PSEUDO_DMA_SIZE) { while(!(R_PAS(ptr,pas_stat) & R_PAS_STAT_DREQ)) ; insb(pas_data(ptr),data,PAS16_PSEUDO_DMA_SIZE); data += PAS16_PSEUDO_DMA_SIZE; cnt += PAS16_PSEUDO_DMA_SIZE; count -= PAS16_PSEUDO_DMA_SIZE; if (SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)) != phase) return cnt; } while(!(R_PAS(ptr,pas_stat) & R_PAS_STAT_DREQ)) ; insb(pas_data(ptr),data,count-1); cnt += count-1; data += count-1; while(!(R_PAS(ptr,pas_stat) & R_PAS_STAT_DREQ)) ; while((R_PAS(ptr,r_cscr) & R_CSCR_REQ)); *data = R_PAS(ptr,r_idr); cnt++; M_PAS(ptr,rw_mr,&,~RW_MR_DMA_MODE); return cnt; } #endif /* NO_PAS16_PSEUDO_DMA */ icmd = R_PAS(ptr,r_icr) & RW_ICR_MASK; loop: if (SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)) != phase) return cnt; WAIT_FOR_REQ(ptr); *data++ = R_PAS(ptr,r_csdr); icmd |= W_ICR_ASSERT_ACK; W_PAS(ptr,w_icr,icmd); icmd &= ~W_ICR_ASSERT_ACK; WAIT_FOR_NOT_REQ(ptr); W_PAS(ptr,w_icr,icmd); ++cnt; if (--count > 0) goto loop; scsi_timeout_error: return cnt; } static int cmd_xfer(P_PAS ptr, int maxlen, u_char *data, u_char *status, u_char *msg) { int xfer=0, phase; W_PAS(ptr,w_icr,0); while (1) { WAIT_FOR_REQ(ptr); phase = SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)); switch (phase) { case SCSI_PHASE_CMD: W_PAS(ptr,w_tcr,SCSI_PHASE_CMD); xfer += sci_data_out(ptr, SCSI_PHASE_CMD, maxlen, data); return xfer; case SCSI_PHASE_DATA_IN: printf("Data in phase in cmd_xfer?\n"); return 0; case SCSI_PHASE_DATA_OUT: printf("Data out phase in cmd_xfer?\n"); return 0; case SCSI_PHASE_STATUS: W_PAS(ptr,w_tcr,SCSI_PHASE_STATUS); printf("status in cmd_xfer.\n"); sci_data_in(ptr, SCSI_PHASE_STATUS, 1, status); break; case SCSI_PHASE_MESSAGE_IN: W_PAS(ptr,w_tcr,SCSI_PHASE_MESSAGE_IN); printf("msgin in cmd_xfer.\n"); sci_data_in(ptr, SCSI_PHASE_MESSAGE_IN, 1, msg); break; case SCSI_PHASE_MESSAGE_OUT: W_PAS(ptr,w_tcr,SCSI_PHASE_MESSAGE_OUT); sci_data_out(ptr, SCSI_PHASE_MESSAGE_OUT, 1, msg); break; default: printf("Unexpected phase 0x%x in cmd_xfer()\n", phase); scsi_timeout_error: return xfer; break; } } } static int data_xfer(P_PAS ptr, int maxlen, u_char *data, u_char *status, u_char *msg) { int retlen = 0, xfer, phase; W_PAS(ptr,w_icr,0); *status = 0; while (1) { WAIT_FOR_REQ(ptr); phase = SCSI_CUR_PHASE(R_PAS(ptr,r_cscr)); switch (phase) { case SCSI_PHASE_CMD: printf("Command phase in data_xfer().\n"); return retlen; case SCSI_PHASE_DATA_IN: W_PAS(ptr,w_tcr,SCSI_PHASE_DATA_IN); xfer = sci_data_in (ptr, SCSI_PHASE_DATA_IN, maxlen, data); retlen += xfer; maxlen -= xfer; break; case SCSI_PHASE_DATA_OUT: W_PAS(ptr,w_tcr,SCSI_PHASE_DATA_OUT); xfer = sci_data_out (ptr, SCSI_PHASE_DATA_OUT, maxlen, data); retlen += xfer; maxlen -= xfer; break; case SCSI_PHASE_STATUS: W_PAS(ptr,w_tcr,SCSI_PHASE_STATUS); sci_data_in(ptr, SCSI_PHASE_STATUS, 1, status); break; case SCSI_PHASE_MESSAGE_IN: W_PAS(ptr,w_tcr,SCSI_PHASE_MESSAGE_IN); sci_data_in(ptr, SCSI_PHASE_MESSAGE_IN, 1, msg); if (*msg == 0) { return retlen; } else { printf( "message 0x%x in data_xfer.\n", *msg); } break; case SCSI_PHASE_MESSAGE_OUT: W_PAS(ptr,w_tcr,SCSI_PHASE_MESSAGE_OUT); sci_data_out(ptr, SCSI_PHASE_MESSAGE_OUT, 1, msg); break; default: printf( "Unexpected phase 0x%x in data_xfer().\n", phase); scsi_timeout_error: return retlen; break; } } } static int scsi_req(P_PAS ptr, int target, int lun, u_char *cmd, int cmdlen, u_char *databuf, int datalen, int *sent, int *ret) { /* Returns 0 on success, -1 on internal error, or the status byte */ int cmd_bytes_sent, r; u_char stat, msg, c; *sent = 0; if ( ( r = select_target(ptr, target) ) != SCSI_RET_SUCCESS) { *ret = r; switch (r) { case SCSI_RET_RETRY: return 0x08; default: printf("select_target(target %d, lun %d) failed(%d).\n", target, lun, r); case SCSI_RET_DEVICE_DOWN: return -1; } } c = 0x80 | lun; if ((cmd_bytes_sent = cmd_xfer(ptr, cmdlen, cmd, &stat, &c)) != cmdlen) { *ret = SCSI_RET_COMMAND_FAIL; printf("Data underrun sending CCB (%d bytes of %d, sent).\n", cmd_bytes_sent, cmdlen); return -1; } *sent=data_xfer(ptr, datalen, databuf, &stat, &msg); *ret = 0; return stat; } #endif /* NPAS */