![[BACK]](/icons/back.gif){kind=icon}
Return to seagate.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa|
Return to seagate.c CVS log | Up to [local] / sys / dev / isa |
1.1 nbrk 1: /* $OpenBSD: seagate.c,v 1.21 2007/06/29 15:17:02 jasper Exp $ */
2:
3: /*
4: * ST01/02, Future Domain TMC-885, TMC-950 SCSI driver
5: *
6: * Copyright 1994, Charles Hannum (mycroft@ai.mit.edu)
7: * Copyright 1994, Kent Palmkvist (kentp@isy.liu.se)
8: * Copyright 1994, Robert Knier (rknier@qgraph.com)
9: * Copyright 1992, 1994 Drew Eckhardt (drew@colorado.edu)
10: * Copyright 1994, Julian Elischer (julian@tfs.com)
11: *
12: * Others that has contributed by example code is
13: * Glen Overby (overby@cray.com)
14: * Tatu Yllnen
15: * Brian E Litzinger
16: *
17: * Redistribution and use in source and binary forms, with or without
18: * modification, are permitted provided that the following conditions
19: * are met:
20: * 1. Redistributions of source code must retain the above copyright
21: * notice, this list of conditions and the following disclaimer.
22: * 2. Redistributions in binary form must reproduce the above copyright
23: * notice, this list of conditions and the following disclaimer in the
24: * documentation and/or other materials provided with the distribution.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE DEVELOPERS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: */
38:
39: /*
40: * kentp 940307 alpha version based on newscsi-03 version of Julians SCSI-code
41: * kentp 940314 Added possibility to not use messages
42: * rknier 940331 Added fast transfer code
43: * rknier 940407 Added assembler coded data transfers
44: */
45:
46: /*
47: * What should really be done:
48: *
49: * Add missing tests for timeouts
50: * Restructure interrupt enable/disable code (runs to long with int disabled)
51: * Find bug? giving problem with tape status
52: * Add code to handle Future Domain 840, 841, 880 and 881
53: * adjust timeouts (startup is very slow)
54: * add code to use tagged commands in SCSI2
55: * Add code to handle slow devices better (sleep if device not disconnecting)
56: * Fix unnecessary interrupts
57: */
58:
59: /*
60: * Note to users trying to share a disk between DOS and unix:
61: * The ST01/02 is a translating host-adapter. It is not giving DOS
62: * the same number of heads/tracks/sectors as specified by the disk.
63: * It is therefore important to look at what numbers DOS thinks the
64: * disk has. Use these to disklabel your disk in an appropriate manner
65: */
66:
67: #include <sys/types.h>
68: #include <sys/param.h>
69: #include <sys/systm.h>
70: #include <sys/kernel.h>
71: #include <sys/errno.h>
72: #include <sys/ioctl.h>
73: #include <sys/device.h>
74: #include <sys/buf.h>
75: #include <sys/proc.h>
76: #include <sys/user.h>
77: #include <sys/queue.h>
78: #include <sys/malloc.h>
79:
80: #include <machine/intr.h>
81: #include <machine/pio.h>
82:
83: #include <scsi/scsi_all.h>
84: #include <scsi/scsi_message.h>
85: #include <scsi/scsiconf.h>
86:
87: #include <dev/isa/isareg.h>
88: #include <dev/isa/isavar.h>
89: #include <i386/isa/isa_machdep.h> /* XXX USES ISA HOLE DIRECTLY */
90:
91: #define SEA_SCB_MAX 32 /* allow maximally 8 scsi control blocks */
92: #define SCB_TABLE_SIZE 8 /* start with 8 scb entries in table */
93: #define BLOCK_SIZE 512 /* size of READ/WRITE areas on SCSI card */
94:
95: /*
96: * defining SEA_BLINDTRANSFER will make DATA IN and DATA OUT to be done with
97: * blind transfers, i.e. no check is done for scsi phase changes. This will
98: * result in data loss if the scsi device does not send its data using
99: * BLOCK_SIZE bytes at a time.
100: * If SEA_BLINDTRANSFER defined and SEA_ASSEMBLER also defined will result in
101: * the use of blind transfers coded in assembler. SEA_ASSEMBLER is no good
102: * without SEA_BLINDTRANSFER defined.
103: */
104: #define SEA_BLINDTRANSFER /* do blind transfers */
105: #define SEA_ASSEMBLER /* Use assembly code for fast transfers */
106:
107: /*
108: * defining SEA_NOMSGS causes messages not to be used (thereby disabling
109: * disconnects)
110: */
111: #undef SEA_NOMSGS
112:
113: /*
114: * defining SEA_NODATAOUT makes dataout phase being aborted
115: */
116: #undef SEA_NODATAOUT
117:
118: /* Debugging definitions. Should not be used unless you want a lot of
119: printouts even under normal conditions */
120:
121: #undef SEA_DEBUGQUEUE /* Display info about queue-lengths */
122:
123: /******************************* board definitions **************************/
124: /*
125: * CONTROL defines
126: */
127: #define CMD_RST 0x01 /* scsi reset */
128: #define CMD_SEL 0x02 /* scsi select */
129: #define CMD_BSY 0x04 /* scsi busy */
130: #define CMD_ATTN 0x08 /* scsi attention */
131: #define CMD_START_ARB 0x10 /* start arbitration bit */
132: #define CMD_EN_PARITY 0x20 /* enable scsi parity generation */
133: #define CMD_INTR 0x40 /* enable scsi interrupts */
134: #define CMD_DRVR_ENABLE 0x80 /* scsi enable */
135:
136: /*
137: * STATUS
138: */
139: #define STAT_BSY 0x01 /* scsi busy */
140: #define STAT_MSG 0x02 /* scsi msg */
141: #define STAT_IO 0x04 /* scsi I/O */
142: #define STAT_CD 0x08 /* scsi C/D */
143: #define STAT_REQ 0x10 /* scsi req */
144: #define STAT_SEL 0x20 /* scsi select */
145: #define STAT_PARITY 0x40 /* parity error bit */
146: #define STAT_ARB_CMPL 0x80 /* arbitration complete bit */
147:
148: /*
149: * REQUESTS
150: */
151: #define PH_DATAOUT (0)
152: #define PH_DATAIN (STAT_IO)
153: #define PH_CMD (STAT_CD)
154: #define PH_STAT (STAT_CD | STAT_IO)
155: #define PH_MSGOUT (STAT_MSG | STAT_CD)
156: #define PH_MSGIN (STAT_MSG | STAT_CD | STAT_IO)
157:
158: #define PH_MASK (STAT_MSG | STAT_CD | STAT_IO)
159:
160: #define PH_INVALID 0xff
161:
162: #define SEA_RAMOFFSET 0x00001800
163:
164: #define BASE_CMD (CMD_INTR | CMD_EN_PARITY)
165:
166: #define SEAGATE 1 /* Seagate ST0[12] */
167: #define FDOMAIN 2 /* Future Domain TMC-{885,950} */
168: #define FDOMAIN840 3 /* Future Domain TMC-{84[01],88[01]} */
169:
170: /******************************************************************************/
171:
172: /* scsi control block used to keep info about a scsi command */
173: struct sea_scb {
174: u_char *data; /* position in data buffer so far */
175: int datalen; /* bytes remaining to transfer */
176: TAILQ_ENTRY(sea_scb) chain;
177: struct scsi_xfer *xs; /* the scsi_xfer for this cmd */
178: int flags; /* status of the instruction */
179: #define SCB_FREE 0
180: #define SCB_ACTIVE 1
181: #define SCB_ABORTED 2
182: #define SCB_TIMEOUT 4
183: #define SCB_ERROR 8
184: };
185:
186: /*
187: * data structure describing current status of the scsi bus. One for each
188: * controller card.
189: */
190: struct sea_softc {
191: struct device sc_dev;
192: struct isadev sc_id;
193: void *sc_ih;
194:
195: int type; /* board type */
196: caddr_t maddr; /* Base address for card */
197: caddr_t maddr_cr_sr; /* Address of control and status reg */
198: caddr_t maddr_dr; /* Address of data register */
199:
200: struct scsi_link sc_link; /* prototype for subdevs */
201: TAILQ_HEAD(, sea_scb) free_list, ready_list, nexus_list;
202: struct sea_scb *nexus; /* currently connected command */
203: int numscbs; /* number of scsi control blocks */
204: struct sea_scb scb[SCB_TABLE_SIZE];
205:
206: int our_id; /* our scsi id */
207: u_char our_id_mask;
208: volatile u_char busy[8]; /* index=target, bit=lun, Keep track of
209: busy luns at device target */
210: };
211:
212: /* flag showing if main routine is running. */
213: static volatile int main_running = 0;
214:
215: #define STATUS (*(volatile u_char *)sea->maddr_cr_sr)
216: #define CONTROL STATUS
217: #define DATA (*(volatile u_char *)sea->maddr_dr)
218:
219: /*
220: * These are "special" values for the tag parameter passed to sea_select
221: * Not implemented right now.
222: */
223: #define TAG_NEXT -1 /* Use next free tag */
224: #define TAG_NONE -2 /*
225: * Establish I_T_L nexus instead of I_T_L_Q
226: * even on SCSI-II devices.
227: */
228:
229: typedef struct {
230: char *signature;
231: int offset, length;
232: int type;
233: } BiosSignature;
234:
235: /*
236: * Signatures for automatic recognition of board type
237: */
238: static const BiosSignature signatures[] = {
239: {"ST01 v1.7 (C) Copyright 1987 Seagate", 15, 37, SEAGATE},
240: {"SCSI BIOS 2.00 (C) Copyright 1987 Seagate", 15, 40, SEAGATE},
241:
242: /*
243: * The following two lines are NOT mistakes. One detects ROM revision
244: * 3.0.0, the other 3.2. Since seagate has only one type of SCSI adapter,
245: * and this is not going to change, the "SEAGATE" and "SCSI" together
246: * are probably "good enough"
247: */
248: {"SEAGATE SCSI BIOS ", 16, 17, SEAGATE},
249: {"SEAGATE SCSI BIOS ", 17, 17, SEAGATE},
250:
251: /*
252: * However, future domain makes several incompatible SCSI boards, so specific
253: * signatures must be used.
254: */
255: {"FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89", 5, 45, FDOMAIN},
256: {"FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89", 5, 46, FDOMAIN},
257: {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90",5, 47, FDOMAIN},
258: {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90",5, 47, FDOMAIN},
259: {"FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90", 5, 46, FDOMAIN},
260: {"FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92", 5, 44, FDOMAIN},
261: {"FUTURE DOMAIN TMC-950", 5, 21, FDOMAIN},
262: };
263:
264: #define nsignatures (sizeof(signatures) / sizeof(signatures[0]))
265:
266: #ifdef notdef
267: static const char *bases[] = {
268: (char *) 0xc8000, (char *) 0xca000, (char *) 0xcc000,
269: (char *) 0xce000, (char *) 0xdc000, (char *) 0xde000
270: };
271:
272: #define nbases (sizeof(bases) / sizeof(bases[0]))
273: #endif
274:
275: struct sea_scb *sea_get_scb(struct sea_softc *, int);
276: int seaintr(void *);
277: int sea_scsi_cmd(struct scsi_xfer *);
278: int sea_poll(struct sea_softc *, struct scsi_xfer *, int);
279: int sea_select(struct sea_softc *sea, struct sea_scb *scb);
280: int sea_transfer_pio(struct sea_softc *sea, u_char *phase,
281: int *count, u_char **data);
282: int sea_abort(struct sea_softc *, struct sea_scb *scb);
283: static void sea_main(void);
284: static void sea_information_transfer(struct sea_softc *);
285: void sea_timeout(void *);
286: void sea_done(struct sea_softc *, struct sea_scb *);
287: void sea_free_scb(struct sea_softc *, struct sea_scb *, int);
288: void sea_init(struct sea_softc *);
289: void sea_send_scb(struct sea_softc *sea, struct sea_scb *scb);
290: void sea_reselect(struct sea_softc *sea);
291:
292: struct scsi_adapter sea_switch = {
293: sea_scsi_cmd,
294: minphys, /* no special minphys(), since driver uses PIO */
295: 0,
296: 0,
297: };
298:
299: /* the below structure is so we have a default dev struct for our link struct */
300: struct scsi_device sea_dev = {
301: NULL, /* use default error handler */
302: NULL, /* have a queue, served by this */
303: NULL, /* have no async handler */
304: NULL, /* Use default 'done' routine */
305: };
306:
307: int seaprobe(struct device *, void *, void *);
308: void seaattach(struct device *, struct device *, void *);
309: int seaprint(void *, const char *);
310:
311: struct cfattach sea_ca = {
312: sizeof(struct sea_softc), seaprobe, seaattach
313: };
314:
315: struct cfdriver sea_cd = {
316: NULL, "sea", DV_DULL
317: };
318:
319: #ifdef SEA_DEBUGQUEUE
320: void
321: sea_queue_length(struct sea_softc *sea)
322: {
323: struct sea_scb *scb;
324: int connected, issued, disconnected;
325:
326: connected = sea->nexus ? 1 : 0;
327: issued = 0;
328: TAILQ_FOREACH(scb, &sea->ready_list, chain)
329: issued++;
330: disconnected = 0;
331: TAILQ_FOREACH(scb, &sea->nexus_list, chain)
332: disconnected++;
333: printf("%s: length: %d/%d/%d\n", sea->sc_dev.dv_xname, connected,
334: issued, disconnected);
335: }
336: #endif
337:
338: /*
339: * Check if the device can be found at the port given and if so, detect the
340: * type the type of board. Set it up ready for further work. Takes the isa_dev
341: * structure from autoconf as an argument.
342: * Returns 1 if card recognized, 0 if errors.
343: */
344: int
345: seaprobe(struct device *parent, void *match, void *aux)
346: {
347: struct sea_softc *sea = match;
348: struct isa_attach_args *ia = aux;
349: int i;
350:
351: /*
352: * Could try to find a board by looking through all possible addresses.
353: * This is not done the right way now, because I have not found a way
354: * to get a boards virtual memory address given its physical. There is
355: * a function that returns the physical address for a given virtual
356: * address, but not the other way around.
357: */
358:
359: if (ia->ia_maddr == MADDRUNK) {
360: /* XXX */
361: return 0;
362: } else
363: sea->maddr = ISA_HOLE_VADDR(ia->ia_maddr);
364:
365: /* check board type */ /* No way to define this through config */
366: for (i = 0; i < nsignatures; i++)
367: if (!bcmp(sea->maddr + signatures[i].offset,
368: signatures[i].signature, signatures[i].length)) {
369: sea->type = signatures[i].type;
370: break;
371: }
372:
373: /* Find controller and data memory addresses */
374: switch (sea->type) {
375: case SEAGATE:
376: case FDOMAIN840:
377: sea->maddr_cr_sr =
378: (void *) (((u_char *)sea->maddr) + 0x1a00);
379: sea->maddr_dr =
380: (void *) (((u_char *)sea->maddr) + 0x1c00);
381: break;
382: case FDOMAIN:
383: sea->maddr_cr_sr =
384: (void *) (((u_char *)sea->maddr) + 0x1c00);
385: sea->maddr_dr =
386: (void *) (((u_char *)sea->maddr) + 0x1e00);
387: break;
388: default:
389: #if 0
390: printf("%s: board type unknown at address %p\n",
391: sea->sc_dev.dv_xname, sea->maddr);
392: #endif
393: return 0;
394: }
395:
396: /* Test controller RAM (works the same way on future domain cards?) */
397: *((u_char *)sea->maddr + SEA_RAMOFFSET) = 0xa5;
398: *((u_char *)sea->maddr + SEA_RAMOFFSET + 1) = 0x5a;
399:
400: if ((*((u_char *)sea->maddr + SEA_RAMOFFSET) != 0xa5) ||
401: (*((u_char *)sea->maddr + SEA_RAMOFFSET + 1) != 0x5a)) {
402: printf("%s: board RAM failure\n", sea->sc_dev.dv_xname);
403: return 0;
404: }
405:
406: ia->ia_drq = DRQUNK;
407: ia->ia_msize = 0x2000;
408: ia->ia_iosize = 0;
409: return 1;
410: }
411:
412: int
413: seaprint(void *aux, const char *name)
414: {
415: if (name != NULL)
416: printf("%s: scsibus ", name);
417: return UNCONF;
418: }
419:
420: /*
421: * Attach all sub-devices we can find
422: */
423: void
424: seaattach(struct device *parent, struct device *self, void *aux)
425: {
426: struct isa_attach_args *ia = aux;
427: struct sea_softc *sea = (void *)self;
428: struct scsibus_attach_args saa;
429:
430: sea_init(sea);
431:
432: /*
433: * fill in the prototype scsi_link.
434: */
435: sea->sc_link.adapter_softc = sea;
436: sea->sc_link.adapter_target = sea->our_id;
437: sea->sc_link.adapter = &sea_switch;
438: sea->sc_link.device = &sea_dev;
439: sea->sc_link.openings = 1;
440:
441: printf("\n");
442:
443: sea->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE,
444: IPL_BIO, seaintr, sea, sea->sc_dev.dv_xname);
445:
446: bzero(&saa, sizeof(saa));
447: saa.saa_sc_link = &sea->sc_link;
448:
449: /*
450: * ask the adapter what subunits are present
451: */
452: config_found(self, &saa, seaprint);
453: }
454:
455: /*
456: * Catch an interrupt from the adaptor
457: */
458: int
459: seaintr(void *arg)
460: {
461: struct sea_softc *sea = arg;
462:
463: #ifdef DEBUG /* extra overhead, and only needed for intr debugging */
464: if ((STATUS & STAT_PARITY) == 0 &&
465: (STATUS & (STAT_SEL | STAT_IO)) != (STAT_SEL | STAT_IO))
466: return 0;
467: #endif
468:
469: loop:
470: /* dispatch to appropriate routine if found and done=0 */
471: /* should check to see that this card really caused the interrupt */
472:
473: if (STATUS & STAT_PARITY) {
474: /* Parity error interrupt */
475: printf("%s: parity error\n", sea->sc_dev.dv_xname);
476: return 1;
477: }
478:
479: if ((STATUS & (STAT_SEL | STAT_IO)) == (STAT_SEL | STAT_IO)) {
480: /* Reselect interrupt */
481: sea_reselect(sea);
482: if (!main_running)
483: sea_main();
484: goto loop;
485: }
486:
487: return 1;
488: }
489:
490: /*
491: * Setup data structures, and reset the board and the SCSI bus.
492: */
493: void
494: sea_init(struct sea_softc *sea)
495: {
496: int i;
497:
498: /* Reset the scsi bus (I don't know if this is needed */
499: CONTROL = BASE_CMD | CMD_DRVR_ENABLE | CMD_RST;
500: delay(25); /* hold reset for at least 25 microseconds */
501: CONTROL = BASE_CMD;
502: delay(10); /* wait a Bus Clear Delay (800 ns + bus free delay (800 ns) */
503:
504: /* Set our id (don't know anything about this) */
505: switch (sea->type) {
506: case SEAGATE:
507: sea->our_id = 7;
508: break;
509: case FDOMAIN:
510: case FDOMAIN840:
511: sea->our_id = 6;
512: break;
513: }
514: sea->our_id_mask = 1 << sea->our_id;
515:
516: /* init fields used by our routines */
517: sea->nexus = 0;
518: TAILQ_INIT(&sea->ready_list);
519: TAILQ_INIT(&sea->nexus_list);
520: TAILQ_INIT(&sea->free_list);
521: for (i = 0; i < 8; i++)
522: sea->busy[i] = 0x00;
523:
524: /* link up the free list of scbs */
525: sea->numscbs = SCB_TABLE_SIZE;
526: for (i = 0; i < SCB_TABLE_SIZE; i++) {
527: TAILQ_INSERT_TAIL(&sea->free_list, &sea->scb[i], chain);
528: }
529: }
530:
531: /*
532: * start a scsi operation given the command and the data address. Also needs
533: * the unit, target and lu.
534: */
535: int
536: sea_scsi_cmd(struct scsi_xfer *xs)
537: {
538: struct scsi_link *sc_link = xs->sc_link;
539: struct sea_softc *sea = sc_link->adapter_softc;
540: struct sea_scb *scb;
541: int flags;
542: int s;
543:
544: SC_DEBUG(sc_link, SDEV_DB2, ("sea_scsi_cmd\n"));
545:
546: flags = xs->flags;
547: if (flags & ITSDONE) {
548: printf("%s: done?\n", sea->sc_dev.dv_xname);
549: xs->flags &= ~ITSDONE;
550: }
551: if ((scb = sea_get_scb(sea, flags)) == NULL) {
552: return TRY_AGAIN_LATER;
553: }
554: scb->flags = SCB_ACTIVE;
555: scb->xs = xs;
556:
557: if (flags & SCSI_RESET) {
558: /*
559: * Try to send a reset command to the card.
560: * XXX Not implemented.
561: */
562: printf("%s: resetting\n", sea->sc_dev.dv_xname);
563: xs->error = XS_DRIVER_STUFFUP;
564: return COMPLETE;
565: }
566:
567: /*
568: * Put all the arguments for the xfer in the scb
569: */
570: scb->datalen = xs->datalen;
571: scb->data = xs->data;
572:
573: #ifdef SEA_DEBUGQUEUE
574: sea_queue_length(sea);
575: #endif
576:
577: s = splbio();
578:
579: sea_send_scb(sea, scb);
580:
581: /*
582: * Usually return SUCCESSFULLY QUEUED
583: */
584: if ((flags & SCSI_POLL) == 0) {
585: timeout_set(&scb->xs->stimeout, sea_timeout, scb);
586: timeout_add(&scb->xs->stimeout, (xs->timeout * hz) / 1000);
587: splx(s);
588: return SUCCESSFULLY_QUEUED;
589: }
590:
591: splx(s);
592:
593: /*
594: * If we can't use interrupts, poll on completion
595: */
596: if (sea_poll(sea, xs, xs->timeout)) {
597: sea_timeout(scb);
598: if (sea_poll(sea, xs, 2000))
599: sea_timeout(scb);
600: }
601: return COMPLETE;
602: }
603:
604: /*
605: * Get a free scb. If there are none, see if we can allocate a new one. If so,
606: * put it in the hash table too; otherwise return an error or sleep.
607: */
608: struct sea_scb *
609: sea_get_scb(struct sea_softc *sea, int flags)
610: {
611: int s;
612: struct sea_scb *scb;
613:
614: s = splbio();
615:
616: /*
617: * If we can and have to, sleep waiting for one to come free
618: * but only if we can't allocate a new one.
619: */
620: for (;;) {
621: scb = TAILQ_FIRST(&sea->free_list);
622: if (scb) {
623: TAILQ_REMOVE(&sea->free_list, scb, chain);
624: break;
625: }
626: if (sea->numscbs < SEA_SCB_MAX) {
627: scb = (struct sea_scb *) malloc(sizeof(struct sea_scb),
628: M_TEMP, M_NOWAIT);
629: if (scb) {
630: bzero(scb, sizeof(struct sea_scb));
631: sea->numscbs++;
632: } else
633: printf("%s: can't malloc scb\n",
634: sea->sc_dev.dv_xname);
635: break;
636: }
637: if ((flags & SCSI_NOSLEEP) != 0)
638: break;
639: tsleep(&sea->free_list, PRIBIO, "seascb", 0);
640: }
641:
642: splx(s);
643: return scb;
644: }
645:
646: /*
647: * Try to send this command to the board. Because this board does not use any
648: * mailboxes, this routine simply adds the command to the queue held by the
649: * sea_softc structure.
650: * A check is done to see if the command contains a REQUEST_SENSE command, and
651: * if so the command is put first in the queue, otherwise the command is added
652: * to the end of the queue. ?? Not correct ??
653: */
654: void
655: sea_send_scb(struct sea_softc *sea, struct sea_scb *scb)
656: {
657:
658: TAILQ_INSERT_TAIL(&sea->ready_list, scb, chain);
659: /* Try to do some work on the card. */
660: if (!main_running)
661: sea_main();
662: }
663:
664: /*
665: * Coroutine that runs as long as more work can be done on the seagate host
666: * adapter in a system. Both sea_scsi_cmd and sea_intr will try to start it in
667: * case it is not running.
668: */
669: void
670: sea_main(void)
671: {
672: struct sea_softc *sea;
673: struct sea_scb *scb;
674: int done;
675: int unit;
676: int s;
677:
678: main_running = 1;
679:
680: /*
681: * This should not be run with interrupts disabled, but use the splx
682: * code instead.
683: */
684: loop:
685: done = 1;
686: for (unit = 0; unit < sea_cd.cd_ndevs; unit++) {
687: sea = sea_cd.cd_devs[unit];
688: if (!sea)
689: continue;
690: s = splbio();
691: if (!sea->nexus) {
692: /*
693: * Search through the ready_list for a command
694: * destined for a target that's not busy.
695: */
696: TAILQ_FOREACH(scb, &sea->ready_list, chain) {
697: if (!(sea->busy[scb->xs->sc_link->target] &
698: (1 << scb->xs->sc_link->lun))) {
699: TAILQ_REMOVE(&sea->ready_list, scb,
700: chain);
701:
702: /* Re-enable interrupts. */
703: splx(s);
704:
705: /*
706: * Attempt to establish an I_T_L nexus.
707: * On success, sea->nexus is set.
708: * On failure, we must add the command
709: * back to the issue queue so we can
710: * keep trying.
711: */
712:
713: /*
714: * REQUEST_SENSE commands are issued
715: * without tagged queueing, even on
716: * SCSI-II devices because the
717: * contingent alligence condition
718: * exists for the entire unit.
719: */
720:
721: /*
722: * First check that if any device has
723: * tried a reconnect while we have done
724: * other things with interrupts
725: * disabled.
726: */
727:
728: if ((STATUS & (STAT_SEL | STAT_IO)) ==
729: (STAT_SEL | STAT_IO)) {
730: sea_reselect(sea);
731: break;
732: }
733: if (sea_select(sea, scb)) {
734: s = splbio();
735: TAILQ_INSERT_HEAD(&sea->ready_list,
736: scb, chain);
737: splx(s);
738: } else
739: break;
740: } /* if target/lun is not busy */
741: } /* for scb */
742: if (!sea->nexus) {
743: /* check for reselection phase */
744: if ((STATUS & (STAT_SEL | STAT_IO)) ==
745: (STAT_SEL | STAT_IO)) {
746: sea_reselect(sea);
747: }
748: }
749: } /* if (!sea->nexus) */
750:
751: splx(s);
752: if (sea->nexus) { /* we are connected. Do the task */
753: sea_information_transfer(sea);
754: done = 0;
755: } else
756: break;
757: } /* for instance */
758:
759: if (!done)
760: goto loop;
761:
762: main_running = 0;
763: }
764:
765: void
766: sea_free_scb(struct sea_softc *sea, struct sea_scb *scb, int flags)
767: {
768: int s;
769:
770: s = splbio();
771:
772: scb->flags = SCB_FREE;
773: TAILQ_INSERT_HEAD(&sea->free_list, scb, chain);
774:
775: /*
776: * If there were none, wake anybody waiting for one to come free,
777: * starting with queued entries.
778: */
779: if (TAILQ_NEXT(scb, chain) == NULL)
780: wakeup((caddr_t)&sea->free_list);
781:
782: splx(s);
783: }
784:
785: void
786: sea_timeout(void *arg)
787: {
788: struct sea_scb *scb = arg;
789: struct scsi_xfer *xs = scb->xs;
790: struct scsi_link *sc_link = xs->sc_link;
791: struct sea_softc *sea = sc_link->adapter_softc;
792: int s;
793:
794: sc_print_addr(sc_link);
795: printf("timed out");
796:
797: s = splbio();
798:
799: /*
800: * If it has been through before, then
801: * a previous abort has failed, don't
802: * try abort again
803: */
804: if (scb->flags & SCB_ABORTED) {
805: /* abort timed out */
806: printf(" AGAIN\n");
807: scb->xs->retries = 0;
808: scb->flags |= SCB_ABORTED;
809: sea_done(sea, scb);
810: } else {
811: /* abort the operation that has timed out */
812: printf("\n");
813: scb->flags |= SCB_ABORTED;
814: sea_abort(sea, scb);
815: /* 2 secs for the abort */
816: if ((xs->flags & SCSI_POLL) == 0) {
817: timeout_set(&scb->xs->stimeout, sea_timeout, scb);
818: timeout_add(&scb->xs->stimeout, 2 * hz);
819: }
820: }
821:
822: splx(s);
823: }
824:
825: void
826: sea_reselect(struct sea_softc *sea)
827: {
828: u_char target_mask;
829: int i;
830: u_char lun, phase;
831: u_char msg[3];
832: int len;
833: u_char *data;
834: struct sea_scb *scb;
835: int abort = 0;
836:
837: if (!((target_mask = STATUS) & STAT_SEL)) {
838: printf("%s: wrong state 0x%x\n", sea->sc_dev.dv_xname,
839: target_mask);
840: return;
841: }
842:
843: /* wait for a device to win the reselection phase */
844: /* signals this by asserting the I/O signal */
845: for (i = 10; i && (STATUS & (STAT_SEL | STAT_IO | STAT_BSY)) !=
846: (STAT_SEL | STAT_IO | 0); i--);
847: /* !! Check for timeout here */
848: /* the data bus contains original initiator id ORed with target id */
849: target_mask = DATA;
850: /* see that we really are the initiator */
851: if (!(target_mask & sea->our_id_mask)) {
852: printf("%s: polled reselection was not for me: 0x%x\n",
853: sea->sc_dev.dv_xname, target_mask);
854: return;
855: }
856: /* find target who won */
857: target_mask &= ~sea->our_id_mask;
858: /* host responds by asserting the BSY signal */
859: CONTROL = BASE_CMD | CMD_DRVR_ENABLE | CMD_BSY;
860: /* target should respond by deasserting the SEL signal */
861: for (i = 50000; i && (STATUS & STAT_SEL); i++);
862: /* remove the busy status */
863: CONTROL = BASE_CMD | CMD_DRVR_ENABLE;
864: /* we are connected. Now we wait for the MSGIN condition */
865: for (i = 50000; i && !(STATUS & STAT_REQ); i--);
866: /* !! Add timeout check here */
867: /* hope we get an IDENTIFY message */
868: len = 3;
869: data = msg;
870: phase = PH_MSGIN;
871: sea_transfer_pio(sea, &phase, &len, &data);
872:
873: if (MSG_ISIDENTIFY(msg[0])) {
874: printf("%s: expecting IDENTIFY message, got 0x%x\n",
875: sea->sc_dev.dv_xname, msg[0]);
876: abort = 1;
877: scb = NULL;
878: } else {
879: lun = msg[0] & 0x07;
880:
881: /*
882: * Find the command corresponding to the I_T_L or I_T_L_Q nexus
883: * we just reestablished, and remove it from the disconnected
884: * queue.
885: */
886: TAILQ_FOREACH(scb, &sea->nexus_list, chain)
887: if (target_mask == (1 << scb->xs->sc_link->target) &&
888: lun == scb->xs->sc_link->lun) {
889: TAILQ_REMOVE(&sea->nexus_list, scb,
890: chain);
891: break;
892: }
893: if (!scb) {
894: printf("%s: target %02x lun %d not disconnected\n",
895: sea->sc_dev.dv_xname, target_mask, lun);
896: /*
897: * Since we have an established nexus that we can't do
898: * anything with, we must abort it.
899: */
900: abort = 1;
901: }
902: }
903:
904: if (abort) {
905: msg[0] = MSG_ABORT;
906: len = 1;
907: data = msg;
908: phase = PH_MSGOUT;
909: CONTROL = BASE_CMD | CMD_ATTN;
910: sea_transfer_pio(sea, &phase, &len, &data);
911: } else
912: sea->nexus = scb;
913:
914: return;
915: }
916:
917: /*
918: * Transfer data in given phase using polled I/O.
919: */
920: int
921: sea_transfer_pio(struct sea_softc *sea, u_char *phase, int *count, u_char **data)
922: {
923: u_char p = *phase, tmp;
924: int c = *count;
925: u_char *d = *data;
926: int timeout;
927:
928: do {
929: /*
930: * Wait for assertion of REQ, after which the phase bits will
931: * be valid.
932: */
933: for (timeout = 0; timeout < 50000; timeout++)
934: if ((tmp = STATUS) & STAT_REQ)
935: break;
936: if (!(tmp & STAT_REQ)) {
937: printf("%s: timeout waiting for STAT_REQ\n",
938: sea->sc_dev.dv_xname);
939: break;
940: }
941:
942: /*
943: * Check for phase mismatch. Reached if the target decides
944: * that it has finished the transfer.
945: */
946: if (sea->type == FDOMAIN840)
947: tmp = ((tmp & 0x08) >> 2) |
948: ((tmp & 0x02) << 2) |
949: (tmp & 0xf5);
950: if ((tmp & PH_MASK) != p)
951: break;
952:
953: /* Do actual transfer from SCSI bus to/from memory. */
954: if (!(p & STAT_IO))
955: DATA = *d;
956: else
957: *d = DATA;
958: ++d;
959:
960: /*
961: * The SCSI standard suggests that in MSGOUT phase, the
962: * initiator should drop ATN on the last byte of the message
963: * phase after REQ has been asserted for the handshake but
964: * before the initiator raises ACK.
965: * Don't know how to accomplish this on the ST01/02.
966: */
967:
968: #if 0
969: /*
970: * XXX
971: * The st01 code doesn't wait for STAT_REQ to be deasserted.
972: * Is this ok?
973: */
974: for (timeout = 0; timeout < 200000L; timeout++)
975: if (!(STATUS & STAT_REQ))
976: break;
977: if (STATUS & STAT_REQ)
978: printf("%s: timeout on wait for !STAT_REQ",
979: sea->sc_dev.dv_xname);
980: #endif
981: } while (--c);
982:
983: *count = c;
984: *data = d;
985: tmp = STATUS;
986: if (tmp & STAT_REQ)
987: *phase = tmp & PH_MASK;
988: else
989: *phase = PH_INVALID;
990:
991: if (c && (*phase != p))
992: return -1;
993: return 0;
994: }
995:
996: /*
997: * Establish I_T_L or I_T_L_Q nexus for new or existing command including
998: * ARBITRATION, SELECTION, and initial message out for IDENTIFY and queue
999: * messages. Return -1 if selection could not execute for some reason, 0 if
1000: * selection succeded or failed because the target did not respond.
1001: */
1002: int
1003: sea_select(struct sea_softc *sea, struct sea_scb *scb)
1004: {
1005: u_char msg[3], phase;
1006: u_char *data;
1007: int len;
1008: int timeout;
1009:
1010: CONTROL = BASE_CMD;
1011: DATA = sea->our_id_mask;
1012: CONTROL = (BASE_CMD & ~CMD_INTR) | CMD_START_ARB;
1013:
1014: /* wait for arbitration to complete */
1015: for (timeout = 0; timeout < 3000000L; timeout++)
1016: if (STATUS & STAT_ARB_CMPL)
1017: break;
1018: if (!(STATUS & STAT_ARB_CMPL)) {
1019: if (STATUS & STAT_SEL) {
1020: printf("%s: arbitration lost\n", sea->sc_dev.dv_xname);
1021: scb->flags |= SCB_ERROR;
1022: } else {
1023: printf("%s: arbitration timeout\n",
1024: sea->sc_dev.dv_xname);
1025: scb->flags |= SCB_TIMEOUT;
1026: }
1027: CONTROL = BASE_CMD;
1028: return -1;
1029: }
1030:
1031: delay(2);
1032: DATA = (u_char)((1 << scb->xs->sc_link->target) | sea->our_id_mask);
1033: CONTROL =
1034: #ifdef SEA_NOMSGS
1035: (BASE_CMD & ~CMD_INTR) | CMD_DRVR_ENABLE | CMD_SEL;
1036: #else
1037: (BASE_CMD & ~CMD_INTR) | CMD_DRVR_ENABLE | CMD_SEL | CMD_ATTN;
1038: #endif
1039: delay(1);
1040:
1041: /* wait for a bsy from target */
1042: for (timeout = 0; timeout < 2000000L; timeout++)
1043: if (STATUS & STAT_BSY)
1044: break;
1045: if (!(STATUS & STAT_BSY)) {
1046: /* should return some error to the higher level driver */
1047: CONTROL = BASE_CMD;
1048: scb->flags |= SCB_TIMEOUT;
1049: return 0;
1050: }
1051:
1052: /* Try to make the target to take a message from us */
1053: #ifdef SEA_NOMSGS
1054: CONTROL = (BASE_CMD & ~CMD_INTR) | CMD_DRVR_ENABLE;
1055: #else
1056: CONTROL = (BASE_CMD & ~CMD_INTR) | CMD_DRVR_ENABLE | CMD_ATTN;
1057: #endif
1058: delay(1);
1059:
1060: /* should start a msg_out phase */
1061: for (timeout = 0; timeout < 2000000L; timeout++)
1062: if (STATUS & STAT_REQ)
1063: break;
1064: /* Remove ATN. */
1065: CONTROL = BASE_CMD | CMD_DRVR_ENABLE;
1066: if (!(STATUS & STAT_REQ)) {
1067: /*
1068: * This should not be taken as an error, but more like an
1069: * unsupported feature! Should set a flag indicating that the
1070: * target don't support messages, and continue without failure.
1071: * (THIS IS NOT AN ERROR!)
1072: */
1073: } else {
1074: msg[0] = MSG_IDENTIFY(scb->xs->sc_link->lun, 1);
1075: len = 1;
1076: data = msg;
1077: phase = PH_MSGOUT;
1078: /* Should do test on result of sea_transfer_pio(). */
1079: sea_transfer_pio(sea, &phase, &len, &data);
1080: }
1081: if (!(STATUS & STAT_BSY))
1082: printf("%s: after successful arbitrate: no STAT_BSY!\n",
1083: sea->sc_dev.dv_xname);
1084:
1085: sea->nexus = scb;
1086: sea->busy[scb->xs->sc_link->target] |= 1 << scb->xs->sc_link->lun;
1087: /* This assignment should depend on possibility to send a message to target. */
1088: CONTROL = BASE_CMD | CMD_DRVR_ENABLE;
1089: /* XXX Reset pointer in command? */
1090: return 0;
1091: }
1092:
1093: /*
1094: * Send an abort to the target. Return 1 success, 0 on failure.
1095: */
1096: int
1097: sea_abort(struct sea_softc *sea, struct sea_scb *scb)
1098: {
1099: struct sea_scb *tmp;
1100: u_char msg, phase, *msgptr;
1101: int len;
1102:
1103: /*
1104: * If the command hasn't been issued yet, we simply remove it from the
1105: * issue queue
1106: * XXX Could avoid this loop.
1107: */
1108: TAILQ_FOREACH(tmp, &sea->ready_list, chain)
1109: if (scb == tmp) {
1110: TAILQ_REMOVE(&sea->ready_list, scb, chain);
1111: /* XXX Set some type of error result for operation. */
1112: return 1;
1113: }
1114:
1115: /*
1116: * If any commands are connected, we're going to fail the abort and let
1117: * the high level SCSI driver retry at a later time or issue a reset.
1118: */
1119: if (sea->nexus)
1120: return 0;
1121:
1122: /*
1123: * If the command is currently disconnected from the bus, and there are
1124: * no connected commands, we reconnect the I_T_L or I_T_L_Q nexus
1125: * associated with it, go into message out, and send an abort message.
1126: */
1127: TAILQ_FOREACH(tmp, &sea->nexus_list, chain)
1128: if (scb == tmp) {
1129: if (sea_select(sea, scb))
1130: return 0;
1131:
1132: msg = MSG_ABORT;
1133: msgptr = &msg;
1134: len = 1;
1135: phase = PH_MSGOUT;
1136: CONTROL = BASE_CMD | CMD_ATTN;
1137: sea_transfer_pio(sea, &phase, &len, &msgptr);
1138:
1139: TAILQ_FOREACH(tmp, &sea->nexus_list, chain)
1140: if (scb == tmp) {
1141: TAILQ_REMOVE(&sea->nexus_list,
1142: scb, chain);
1143: /* XXX Set some type of error result
1144: for the operation. */
1145: return 1;
1146: }
1147: }
1148:
1149: /* Command not found in any queue; race condition? */
1150: return 1;
1151: }
1152:
1153: void
1154: sea_done(struct sea_softc *sea, struct sea_scb *scb)
1155: {
1156: struct scsi_xfer *xs = scb->xs;
1157:
1158: timeout_del(&scb->xs->stimeout);
1159:
1160: xs->resid = scb->datalen;
1161:
1162: /* XXXX need to get status */
1163: if (scb->flags == SCB_ACTIVE) {
1164: xs->resid = 0;
1165: } else {
1166: if (scb->flags & (SCB_TIMEOUT | SCB_ABORTED))
1167: xs->error = XS_TIMEOUT;
1168: if (scb->flags & SCB_ERROR)
1169: xs->error = XS_DRIVER_STUFFUP;
1170: }
1171: xs->flags |= ITSDONE;
1172: sea_free_scb(sea, scb, xs->flags);
1173: scsi_done(xs);
1174: }
1175:
1176: /*
1177: * Wait for completion of command in polled mode.
1178: */
1179: int
1180: sea_poll(struct sea_softc *sea, struct scsi_xfer *xs, int count)
1181: {
1182: int s;
1183:
1184: while (count) {
1185: /* try to do something */
1186: s = splbio();
1187: if (!main_running)
1188: sea_main();
1189: splx(s);
1190: if (xs->flags & ITSDONE)
1191: return 0;
1192: delay(1000);
1193: count--;
1194: }
1195: return 1;
1196: }
1197:
1198: /*
1199: * Do the transfer. We know we are connected. Update the flags, and call
1200: * sea_done() when task accomplished. Dialog controlled by the target.
1201: */
1202: void
1203: sea_information_transfer(struct sea_softc *sea)
1204: {
1205: int timeout;
1206: u_char msgout = MSG_NOOP;
1207: int len;
1208: int s;
1209: u_char *data;
1210: u_char phase, tmp, old_phase = PH_INVALID;
1211: struct sea_scb *scb = sea->nexus;
1212: int loop;
1213:
1214: for (timeout = 0; timeout < 10000000L; timeout++) {
1215: tmp = STATUS;
1216: if (tmp & STAT_PARITY)
1217: printf("%s: parity error detected\n",
1218: sea->sc_dev.dv_xname);
1219: if (!(tmp & STAT_BSY)) {
1220: for (loop = 0; loop < 20; loop++)
1221: if ((tmp = STATUS) & STAT_BSY)
1222: break;
1223: if (!(tmp & STAT_BSY)) {
1224: printf("%s: !STAT_BSY unit in data transfer!\n",
1225: sea->sc_dev.dv_xname);
1226: s = splbio();
1227: sea->nexus = NULL;
1228: scb->flags = SCB_ERROR;
1229: splx(s);
1230: sea_done(sea, scb);
1231: return;
1232: }
1233: }
1234:
1235: /* we only have a valid SCSI phase when REQ is asserted */
1236: if (!(tmp & STAT_REQ))
1237: continue;
1238:
1239: if (sea->type == FDOMAIN840)
1240: tmp = ((tmp & 0x08) >> 2) |
1241: ((tmp & 0x02) << 2) |
1242: (tmp & 0xf5);
1243: phase = tmp & PH_MASK;
1244: if (phase != old_phase)
1245: old_phase = phase;
1246:
1247: switch (phase) {
1248: case PH_DATAOUT:
1249: #ifdef SEA_NODATAOUT
1250: printf("%s: SEA_NODATAOUT set, attempted DATAOUT aborted\n",
1251: sea->sc_dev.dv_xname);
1252: msgout = MSG_ABORT;
1253: CONTROL = BASE_CMD | CMD_ATTN;
1254: break;
1255: #endif
1256: case PH_DATAIN:
1257: if (!scb->data)
1258: printf("no data address!\n");
1259: #ifdef SEA_BLINDTRANSFER
1260: if (scb->datalen && !(scb->datalen % BLOCK_SIZE)) {
1261: while (scb->datalen) {
1262: for (loop = 0; loop < 50000; loop++)
1263: if ((tmp = STATUS) & STAT_REQ)
1264: break;
1265: if (!(tmp & STAT_REQ)) {
1266: printf("%s: timeout waiting for STAT_REQ\n",
1267: sea->sc_dev.dv_xname);
1268: /* XXX Do something? */
1269: }
1270: if (sea->type == FDOMAIN840)
1271: tmp = ((tmp & 0x08) >> 2) |
1272: ((tmp & 0x02) << 2) |
1273: (tmp & 0xf5);
1274: if ((tmp & PH_MASK) != phase)
1275: break;
1276: if (!(phase & STAT_IO)) {
1277: int block = BLOCK_SIZE;
1278: void *a = sea->maddr_dr;
1279: #ifdef SEA_ASSEMBLER
1280: asm("shr $2, %%ecx\n\t\
1281: cld\n\t\
1282: rep\n\t\
1283: movsl" :
1284: "=S" (scb->data),
1285: "=c" (block) ,
1286: "=D" (a) :
1287: "0" (scb->data),
1288: "2" (a),
1289: "1" (block) );
1290: #else
1291: for (count = 0;
1292: count < BLOCK_SIZE;
1293: count++)
1294: DATA = *(scb->data++);
1295: #endif
1296: } else {
1297: int block = BLOCK_SIZE;
1298: void *a = sea->maddr_dr;
1299: #ifdef SEA_ASSEMBLER
1300: asm("shr $2, %%ecx\n\t\
1301: cld\n\t\
1302: rep\n\t\
1303: movsl" :
1304: "=D" (scb->data), "=c" (block) ,
1305: "=S" (a) :
1306: "0" (scb->data),
1307: "2" (a) ,
1308: "1" (block) );
1309: #else
1310: for (count = 0;
1311: count < BLOCK_SIZE;
1312: count++)
1313: *(scb->data++) = DATA;
1314: #endif
1315: }
1316: scb->datalen -= BLOCK_SIZE;
1317: }
1318: }
1319: #endif
1320: if (scb->datalen)
1321: sea_transfer_pio(sea, &phase, &scb->datalen,
1322: &scb->data);
1323: break;
1324: case PH_MSGIN:
1325: /* Multibyte messages should not be present here. */
1326: len = 1;
1327: data = &tmp;
1328: sea_transfer_pio(sea, &phase, &len, &data);
1329: /* scb->MessageIn = tmp; */
1330:
1331: switch (tmp) {
1332: case MSG_ABORT:
1333: scb->flags = SCB_ABORTED;
1334: printf("sea: command aborted by target\n");
1335: CONTROL = BASE_CMD;
1336: sea_done(sea, scb);
1337: return;
1338: case MSG_CMDCOMPLETE:
1339: s = splbio();
1340: sea->nexus = NULL;
1341: splx(s);
1342: sea->busy[scb->xs->sc_link->target] &=
1343: ~(1 << scb->xs->sc_link->lun);
1344: CONTROL = BASE_CMD;
1345: sea_done(sea, scb);
1346: return;
1347: case MSG_MESSAGE_REJECT:
1348: printf("%s: message_reject received\n",
1349: sea->sc_dev.dv_xname);
1350: break;
1351: case MSG_DISCONNECT:
1352: s = splbio();
1353: TAILQ_INSERT_TAIL(&sea->nexus_list,
1354: scb, chain);
1355: sea->nexus = NULL;
1356: CONTROL = BASE_CMD;
1357: splx(s);
1358: return;
1359: case MSG_SAVEDATAPOINTER:
1360: case MSG_RESTOREPOINTERS:
1361: /* save/restore of pointers are ignored */
1362: break;
1363: default:
1364: /*
1365: * This should be handled in the pio data
1366: * transfer phase, as the ATN should be raised
1367: * before ACK goes false when rejecting a
1368: * message.
1369: */
1370: printf("%s: unknown message in: %x\n",
1371: sea->sc_dev.dv_xname, tmp);
1372: break;
1373: } /* switch (tmp) */
1374: break;
1375: case PH_MSGOUT:
1376: len = 1;
1377: data = &msgout;
1378: /* sea->last_message = msgout; */
1379: sea_transfer_pio(sea, &phase, &len, &data);
1380: if (msgout == MSG_ABORT) {
1381: printf("%s: sent message abort to target\n",
1382: sea->sc_dev.dv_xname);
1383: s = splbio();
1384: sea->busy[scb->xs->sc_link->target] &=
1385: ~(1 << scb->xs->sc_link->lun);
1386: sea->nexus = NULL;
1387: scb->flags = SCB_ABORTED;
1388: splx(s);
1389: /* enable interrupt from scsi */
1390: sea_done(sea, scb);
1391: return;
1392: }
1393: msgout = MSG_NOOP;
1394: break;
1395: case PH_CMD:
1396: len = scb->xs->cmdlen;
1397: data = (char *) scb->xs->cmd;
1398: sea_transfer_pio(sea, &phase, &len, &data);
1399: break;
1400: case PH_STAT:
1401: len = 1;
1402: data = &tmp;
1403: sea_transfer_pio(sea, &phase, &len, &data);
1404: scb->xs->status = tmp;
1405: break;
1406: default:
1407: printf("sea: unknown phase\n");
1408: } /* switch (phase) */
1409: } /* for (...) */
1410:
1411: /* If we get here we have got a timeout! */
1412: printf("%s: timeout in data transfer\n", sea->sc_dev.dv_xname);
1413: scb->flags = SCB_TIMEOUT;
1414: /* XXX Should I clear scsi-bus state? */
1415: sea_done(sea, scb);
1416: }