![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aha1542.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to aha1542.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /* $Id: aha1542.c,v 1.1.1.1 1997/02/25 21:27:46 thomas Exp $
2: * linux/kernel/aha1542.c
3: *
4: * Copyright (C) 1992 Tommy Thorn
5: * Copyright (C) 1993, 1994, 1995 Eric Youngdale
6: *
7: * Modified by Eric Youngdale
8: * Use request_irq and request_dma to help prevent unexpected conflicts
9: * Set up on-board DMA controller, such that we do not have to
10: * have the bios enabled to use the aha1542.
11: * Modified by David Gentzel
12: * Don't call request_dma if dma mask is 0 (for BusLogic BT-445S VL-Bus
13: * controller).
14: * Modified by Matti Aarnio
15: * Accept parameters from LILO cmd-line. -- 1-Oct-94
16: */
17:
18: #include <linux/module.h>
19:
20: #include <linux/kernel.h>
21: #include <linux/head.h>
22: #include <linux/types.h>
23: #include <linux/string.h>
24: #include <linux/ioport.h>
25: #include <linux/delay.h>
26: #include <linux/sched.h>
27: #include <linux/proc_fs.h>
28: #include <asm/dma.h>
29: #include <asm/system.h>
30: #include <asm/io.h>
31: #include <linux/blk.h>
32: #include "scsi.h"
33: #include "hosts.h"
34:
35:
36: #include "aha1542.h"
37:
38: #include<linux/stat.h>
39:
40: struct proc_dir_entry proc_scsi_aha1542 = {
41: PROC_SCSI_AHA1542, 7, "aha1542",
42: S_IFDIR | S_IRUGO | S_IXUGO, 2
43: };
44:
45: #ifdef DEBUG
46: #define DEB(x) x
47: #else
48: #define DEB(x)
49: #endif
50: /*
51: static const char RCSid[] = "$Header: /gd4/gnu/cvsroot/gnumach/i386/i386at/gpl/linux/scsi/aha1542.c,v 1.1.1.1 1997/02/25 21:27:46 thomas Exp $";
52: */
53:
54: /* The adaptec can be configured for quite a number of addresses, but
55: I generally do not want the card poking around at random. We allow
56: two addresses - this allows people to use the Adaptec with a Midi
57: card, which also used 0x330 -- can be overridden with LILO! */
58:
59: #define MAXBOARDS 2 /* Increase this and the sizes of the
60: arrays below, if you need more.. */
61:
62: static unsigned int bases[MAXBOARDS]={0x330, 0x334};
63:
64: /* set by aha1542_setup according to the command line */
65: static int setup_called[MAXBOARDS] = {0,0};
66: static int setup_buson[MAXBOARDS] = {0,0};
67: static int setup_busoff[MAXBOARDS] = {0,0};
68: static int setup_dmaspeed[MAXBOARDS] = {-1,-1};
69:
70: static char *setup_str[MAXBOARDS] = {(char *)NULL,(char *)NULL};
71:
72: /*
73: * LILO params: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]
74: *
75: * Where: <PORTBASE> is any of the valid AHA addresses:
76: * 0x130, 0x134, 0x230, 0x234, 0x330, 0x334
77: * <BUSON> is the time (in microsecs) that AHA spends on the AT-bus
78: * when transferring data. 1542A power-on default is 11us,
79: * valid values are in range: 2..15 (decimal)
80: * <BUSOFF> is the time that AHA spends OFF THE BUS after while
81: * it is transferring data (not to monopolize the bus).
82: * Power-on default is 4us, valid range: 1..64 microseconds.
83: * <DMASPEED> Default is jumper selected (1542A: on the J1),
84: * but experimenter can alter it with this.
85: * Valid values: 5, 6, 7, 8, 10 (MB/s)
86: * Factory default is 5 MB/s.
87: */
88:
89:
90: /* The DMA-Controller. We need to fool with this because we want to
91: be able to use the aha1542 without having to have the bios enabled */
92: #define DMA_MODE_REG 0xd6
93: #define DMA_MASK_REG 0xd4
94: #define CASCADE 0xc0
95:
96: #define BIOS_TRANSLATION_1632 0 /* Used by some old 1542A boards */
97: #define BIOS_TRANSLATION_6432 1 /* Default case these days */
98: #define BIOS_TRANSLATION_25563 2 /* Big disk case */
99:
100: struct aha1542_hostdata{
101: /* This will effectively start both of them at the first mailbox */
102: int bios_translation; /* Mapping bios uses - for compatibility */
103: int aha1542_last_mbi_used;
104: int aha1542_last_mbo_used;
105: Scsi_Cmnd * SCint[AHA1542_MAILBOXES];
106: struct mailbox mb[2*AHA1542_MAILBOXES];
107: struct ccb ccb[AHA1542_MAILBOXES];
108: };
109:
110: #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
111:
112: static struct Scsi_Host * aha_host[7] = {NULL,}; /* One for each IRQ level (9-15) */
113:
114:
115:
116:
117: #define WAITnexttimeout 3000000
118:
119: static void setup_mailboxes(int base_io, struct Scsi_Host * shpnt);
120: static int aha1542_restart(struct Scsi_Host * shost);
121:
122: #define aha1542_intr_reset(base) outb(IRST, CONTROL(base))
123:
124: #define WAIT(port, mask, allof, noneof) \
125: { register WAITbits; \
126: register WAITtimeout = WAITnexttimeout; \
127: while (1) { \
128: WAITbits = inb(port) & (mask); \
129: if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
130: break; \
131: if (--WAITtimeout == 0) goto fail; \
132: } \
133: }
134:
135: /* Similar to WAIT, except we use the udelay call to regulate the
136: amount of time we wait. */
137: #define WAITd(port, mask, allof, noneof, timeout) \
138: { register WAITbits; \
139: register WAITtimeout = timeout; \
140: while (1) { \
141: WAITbits = inb(port) & (mask); \
142: if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
143: break; \
144: udelay(1000); \
145: if (--WAITtimeout == 0) goto fail; \
146: } \
147: }
148:
149: static void aha1542_stat(void)
150: {
151: /* int s = inb(STATUS), i = inb(INTRFLAGS);
152: printk("status=%x intrflags=%x\n", s, i, WAITnexttimeout-WAITtimeout); */
153: }
154:
155: /* This is a bit complicated, but we need to make sure that an interrupt
156: routine does not send something out while we are in the middle of this.
157: Fortunately, it is only at boot time that multi-byte messages
158: are ever sent. */
159: static int aha1542_out(unsigned int base, unchar *cmdp, int len)
160: {
161: unsigned long flags = 0;
162:
163: save_flags(flags);
164: if(len == 1) {
165: while(1==1){
166: WAIT(STATUS(base), CDF, 0, CDF);
167: cli();
168: if(inb(STATUS(base)) & CDF) {restore_flags(flags); continue;}
169: outb(*cmdp, DATA(base));
170: restore_flags(flags);
171: return 0;
172: }
173: } else {
174: cli();
175: while (len--)
176: {
177: WAIT(STATUS(base), CDF, 0, CDF);
178: outb(*cmdp++, DATA(base));
179: }
180: restore_flags(flags);
181: }
182: return 0;
183: fail:
184: restore_flags(flags);
185: printk("aha1542_out failed(%d): ", len+1); aha1542_stat();
186: return 1;
187: }
188:
189: /* Only used at boot time, so we do not need to worry about latency as much
190: here */
191: static int aha1542_in(unsigned int base, unchar *cmdp, int len)
192: {
193: unsigned long flags;
194:
195: save_flags(flags);
196: cli();
197: while (len--)
198: {
199: WAIT(STATUS(base), DF, DF, 0);
200: *cmdp++ = inb(DATA(base));
201: }
202: restore_flags(flags);
203: return 0;
204: fail:
205: restore_flags(flags);
206: printk("aha1542_in failed(%d): ", len+1); aha1542_stat();
207: return 1;
208: }
209:
210: /* Similar to aha1542_in, except that we wait a very short period of time.
211: We use this if we know the board is alive and awake, but we are not sure
212: if the board will respond the the command we are about to send or not */
213: static int aha1542_in1(unsigned int base, unchar *cmdp, int len)
214: {
215: unsigned long flags;
216:
217: save_flags(flags);
218: cli();
219: while (len--)
220: {
221: WAITd(STATUS(base), DF, DF, 0, 100);
222: *cmdp++ = inb(DATA(base));
223: }
224: restore_flags(flags);
225: return 0;
226: fail:
227: restore_flags(flags);
228: return 1;
229: }
230:
231: static int makecode(unsigned hosterr, unsigned scsierr)
232: {
233: switch (hosterr) {
234: case 0x0:
235: case 0xa: /* Linked command complete without error and linked normally */
236: case 0xb: /* Linked command complete without error, interrupt generated */
237: hosterr = 0;
238: break;
239:
240: case 0x11: /* Selection time out-The initiator selection or target
241: reselection was not complete within the SCSI Time out period */
242: hosterr = DID_TIME_OUT;
243: break;
244:
245: case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
246: than was allocated by the Data Length field or the sum of the
247: Scatter / Gather Data Length fields. */
248:
249: case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
250:
251: case 0x15: /* MBO command was not 00, 01 or 02-The first byte of the CB was
252: invalid. This usually indicates a software failure. */
253:
254: case 0x16: /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
255: This usually indicates a software failure. */
256:
257: case 0x17: /* Linked CCB does not have the same LUN-A subsequent CCB of a set
258: of linked CCB's does not specify the same logical unit number as
259: the first. */
260: case 0x18: /* Invalid Target Direction received from Host-The direction of a
261: Target Mode CCB was invalid. */
262:
263: case 0x19: /* Duplicate CCB Received in Target Mode-More than once CCB was
264: received to service data transfer between the same target LUN
265: and initiator SCSI ID in the same direction. */
266:
267: case 0x1a: /* Invalid CCB or Segment List Parameter-A segment list with a zero
268: length segment or invalid segment list boundaries was received.
269: A CCB parameter was invalid. */
270: DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
271: hosterr = DID_ERROR; /* Couldn't find any better */
272: break;
273:
274: case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
275: phase sequence was requested by the target. The host adapter
276: will generate a SCSI Reset Condition, notifying the host with
277: a SCRD interrupt */
278: hosterr = DID_RESET;
279: break;
280: default:
281: printk("makecode: unknown hoststatus %x\n", hosterr);
282: break;
283: }
284: return scsierr|(hosterr << 16);
285: }
286:
287: static int aha1542_test_port(int bse, struct Scsi_Host * shpnt)
288: {
289: int i;
290: unchar inquiry_cmd[] = {CMD_INQUIRY };
291: unchar inquiry_result[4];
292: unchar *cmdp;
293: int len;
294: volatile int debug = 0;
295:
296: /* Quick and dirty test for presence of the card. */
297: if(inb(STATUS(bse)) == 0xff) return 0;
298:
299: /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
300:
301: /* DEB(printk("aha1542_test_port called \n")); */
302:
303: /* In case some other card was probing here, reset interrupts */
304: aha1542_intr_reset(bse); /* reset interrupts, so they don't block */
305:
306: outb(SRST|IRST/*|SCRST*/, CONTROL(bse));
307:
308: i = jiffies + 2;
309: while (i>jiffies); /* Wait a little bit for things to settle down. */
310:
311: debug = 1;
312: /* Expect INIT and IDLE, any of the others are bad */
313: WAIT(STATUS(bse), STATMASK, INIT|IDLE, STST|DIAGF|INVDCMD|DF|CDF);
314:
315: debug = 2;
316: /* Shouldn't have generated any interrupts during reset */
317: if (inb(INTRFLAGS(bse))&INTRMASK) goto fail;
318:
319:
320: /* Perform a host adapter inquiry instead so we do not need to set
321: up the mailboxes ahead of time */
322:
323: aha1542_out(bse, inquiry_cmd, 1);
324:
325: debug = 3;
326: len = 4;
327: cmdp = &inquiry_result[0];
328:
329: while (len--)
330: {
331: WAIT(STATUS(bse), DF, DF, 0);
332: *cmdp++ = inb(DATA(bse));
333: }
334:
335: debug = 8;
336: /* Reading port should reset DF */
337: if (inb(STATUS(bse)) & DF) goto fail;
338:
339: debug = 9;
340: /* When HACC, command is completed, and we're though testing */
341: WAIT(INTRFLAGS(bse), HACC, HACC, 0);
342: /* now initialize adapter */
343:
344: debug = 10;
345: /* Clear interrupts */
346: outb(IRST, CONTROL(bse));
347:
348: debug = 11;
349:
350: return debug; /* 1 = ok */
351: fail:
352: return 0; /* 0 = not ok */
353: }
354:
355: /* A "high" level interrupt handler */
356: static void aha1542_intr_handle(int irq, struct pt_regs *regs)
357: {
358: void (*my_done)(Scsi_Cmnd *) = NULL;
359: int errstatus, mbi, mbo, mbistatus;
360: int number_serviced;
361: unsigned int flags;
362: struct Scsi_Host * shost;
363: Scsi_Cmnd * SCtmp;
364: int flag;
365: int needs_restart;
366: struct mailbox * mb;
367: struct ccb *ccb;
368:
369: shost = aha_host[irq - 9];
370: if(!shost) panic("Splunge!");
371:
372: mb = HOSTDATA(shost)->mb;
373: ccb = HOSTDATA(shost)->ccb;
374:
375: #ifdef DEBUG
376: {
377: flag = inb(INTRFLAGS(shost->io_port));
378: printk("aha1542_intr_handle: ");
379: if (!(flag&ANYINTR)) printk("no interrupt?");
380: if (flag&MBIF) printk("MBIF ");
381: if (flag&MBOA) printk("MBOF ");
382: if (flag&HACC) printk("HACC ");
383: if (flag&SCRD) printk("SCRD ");
384: printk("status %02x\n", inb(STATUS(shost->io_port)));
385: };
386: #endif
387: number_serviced = 0;
388: needs_restart = 0;
389:
390: while(1==1){
391: flag = inb(INTRFLAGS(shost->io_port));
392:
393: /* Check for unusual interrupts. If any of these happen, we should
394: probably do something special, but for now just printing a message
395: is sufficient. A SCSI reset detected is something that we really
396: need to deal with in some way. */
397: if (flag & ~MBIF) {
398: if (flag&MBOA) printk("MBOF ");
399: if (flag&HACC) printk("HACC ");
400: if (flag&SCRD) {
401: needs_restart = 1;
402: printk("SCRD ");
403: }
404: }
405:
406: aha1542_intr_reset(shost->io_port);
407:
408: save_flags(flags);
409: cli();
410: mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1;
411: if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
412:
413: do{
414: if(mb[mbi].status != 0) break;
415: mbi++;
416: if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
417: } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used);
418:
419: if(mb[mbi].status == 0){
420: restore_flags(flags);
421: /* Hmm, no mail. Must have read it the last time around */
422: if (!number_serviced && !needs_restart)
423: printk("aha1542.c: interrupt received, but no mail.\n");
424: /* We detected a reset. Restart all pending commands for
425: devices that use the hard reset option */
426: if(needs_restart) aha1542_restart(shost);
427: return;
428: };
429:
430: mbo = (scsi2int(mb[mbi].ccbptr) - ((unsigned int) &ccb[0])) / sizeof(struct ccb);
431: mbistatus = mb[mbi].status;
432: mb[mbi].status = 0;
433: HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
434: restore_flags(flags);
435:
436: #ifdef DEBUG
437: {
438: if (ccb[mbo].tarstat|ccb[mbo].hastat)
439: printk("aha1542_command: returning %x (status %d)\n",
440: ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
441: };
442: #endif
443:
444: if(mbistatus == 3) continue; /* Aborted command not found */
445:
446: #ifdef DEBUG
447: printk("...done %d %d\n",mbo, mbi);
448: #endif
449:
450: SCtmp = HOSTDATA(shost)->SCint[mbo];
451:
452: if (!SCtmp || !SCtmp->scsi_done) {
453: printk("aha1542_intr_handle: Unexpected interrupt\n");
454: printk("tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat,
455: ccb[mbo].hastat, ccb[mbo].idlun, mbo);
456: return;
457: }
458:
459: my_done = SCtmp->scsi_done;
460: if (SCtmp->host_scribble) scsi_free(SCtmp->host_scribble, 512);
461:
462: /* Fetch the sense data, and tuck it away, in the required slot. The
463: Adaptec automatically fetches it, and there is no guarantee that
464: we will still have it in the cdb when we come back */
465: if (ccb[mbo].tarstat == 2)
466: memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
467: sizeof(SCtmp->sense_buffer));
468:
469:
470: /* is there mail :-) */
471:
472: /* more error checking left out here */
473: if (mbistatus != 1)
474: /* This is surely wrong, but I don't know what's right */
475: errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
476: else
477: errstatus = 0;
478:
479: #ifdef DEBUG
480: if(errstatus) printk("(aha1542 error:%x %x %x) ",errstatus,
481: ccb[mbo].hastat, ccb[mbo].tarstat);
482: #endif
483:
484: if (ccb[mbo].tarstat == 2) {
485: #ifdef DEBUG
486: int i;
487: #endif
488: DEB(printk("aha1542_intr_handle: sense:"));
489: #ifdef DEBUG
490: for (i = 0; i < 12; i++)
491: printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen+i]);
492: printk("\n");
493: #endif
494: /*
495: DEB(printk("aha1542_intr_handle: buf:"));
496: for (i = 0; i < bufflen; i++)
497: printk("%02x ", ((unchar *)buff)[i]);
498: printk("\n");
499: */
500: }
501: DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
502: SCtmp->result = errstatus;
503: HOSTDATA(shost)->SCint[mbo] = NULL; /* This effectively frees up the mailbox slot, as
504: far as queuecommand is concerned */
505: my_done(SCtmp);
506: number_serviced++;
507: };
508: }
509:
510: int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
511: {
512: unchar ahacmd = CMD_START_SCSI;
513: unchar direction;
514: unchar *cmd = (unchar *) SCpnt->cmnd;
515: unchar target = SCpnt->target;
516: unchar lun = SCpnt->lun;
517: unsigned long flags;
518: void *buff = SCpnt->request_buffer;
519: int bufflen = SCpnt->request_bufflen;
520: int mbo;
521: struct mailbox * mb;
522: struct ccb *ccb;
523:
524: DEB(int i);
525:
526: mb = HOSTDATA(SCpnt->host)->mb;
527: ccb = HOSTDATA(SCpnt->host)->ccb;
528:
529: DEB(if (target > 1) {
530: SCpnt->result = DID_TIME_OUT << 16;
531: done(SCpnt); return 0;});
532:
533: if(*cmd == REQUEST_SENSE){
534: #ifndef DEBUG
535: if (bufflen != sizeof(SCpnt->sense_buffer)) {
536: printk("Wrong buffer length supplied for request sense (%d)\n",bufflen);
537: };
538: #endif
539: SCpnt->result = 0;
540: done(SCpnt);
541: return 0;
542: };
543:
544: #ifdef DEBUG
545: if (*cmd == READ_10 || *cmd == WRITE_10)
546: i = xscsi2int(cmd+2);
547: else if (*cmd == READ_6 || *cmd == WRITE_6)
548: i = scsi2int(cmd+2);
549: else
550: i = -1;
551: if (done)
552: printk("aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
553: else
554: printk("aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
555: aha1542_stat();
556: printk("aha1542_queuecommand: dumping scsi cmd:");
557: for (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
558: printk("\n");
559: if (*cmd == WRITE_10 || *cmd == WRITE_6)
560: return 0; /* we are still testing, so *don't* write */
561: #endif
562: /* Use the outgoing mailboxes in a round-robin fashion, because this
563: is how the host adapter will scan for them */
564:
565: save_flags(flags);
566: cli();
567: mbo = HOSTDATA(SCpnt->host)->aha1542_last_mbo_used + 1;
568: if (mbo >= AHA1542_MAILBOXES) mbo = 0;
569:
570: do{
571: if(mb[mbo].status == 0 && HOSTDATA(SCpnt->host)->SCint[mbo] == NULL)
572: break;
573: mbo++;
574: if (mbo >= AHA1542_MAILBOXES) mbo = 0;
575: } while (mbo != HOSTDATA(SCpnt->host)->aha1542_last_mbo_used);
576:
577: if(mb[mbo].status || HOSTDATA(SCpnt->host)->SCint[mbo])
578: panic("Unable to find empty mailbox for aha1542.\n");
579:
580: HOSTDATA(SCpnt->host)->SCint[mbo] = SCpnt; /* This will effectively prevent someone else from
581: screwing with this cdb. */
582:
583: HOSTDATA(SCpnt->host)->aha1542_last_mbo_used = mbo;
584: restore_flags(flags);
585:
586: #ifdef DEBUG
587: printk("Sending command (%d %x)...",mbo, done);
588: #endif
589:
590: any2scsi(mb[mbo].ccbptr, &ccb[mbo]); /* This gets trashed for some reason*/
591:
592: memset(&ccb[mbo], 0, sizeof(struct ccb));
593:
594: ccb[mbo].cdblen = SCpnt->cmd_len;
595:
596: direction = 0;
597: if (*cmd == READ_10 || *cmd == READ_6)
598: direction = 8;
599: else if (*cmd == WRITE_10 || *cmd == WRITE_6)
600: direction = 16;
601:
602: memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
603:
604: if (SCpnt->use_sg) {
605: struct scatterlist * sgpnt;
606: struct chain * cptr;
607: #ifdef DEBUG
608: unsigned char * ptr;
609: #endif
610: int i;
611: ccb[mbo].op = 2; /* SCSI Initiator Command w/scatter-gather*/
612: SCpnt->host_scribble = (unsigned char *) scsi_malloc(512);
613: sgpnt = (struct scatterlist *) SCpnt->request_buffer;
614: cptr = (struct chain *) SCpnt->host_scribble;
615: if (cptr == NULL) panic("aha1542.c: unable to allocate DMA memory\n");
616: for(i=0; i<SCpnt->use_sg; i++) {
617: if(sgpnt[i].length == 0 || SCpnt->use_sg > 16 ||
618: (((int)sgpnt[i].address) & 1) || (sgpnt[i].length & 1)){
619: unsigned char * ptr;
620: printk("Bad segment list supplied to aha1542.c (%d, %d)\n",SCpnt->use_sg,i);
621: for(i=0;i<SCpnt->use_sg;i++){
622: printk("%d: %x %x %d\n",i,(unsigned int) sgpnt[i].address, (unsigned int) sgpnt[i].alt_address,
623: sgpnt[i].length);
624: };
625: printk("cptr %x: ",(unsigned int) cptr);
626: ptr = (unsigned char *) &cptr[i];
627: for(i=0;i<18;i++) printk("%02x ", ptr[i]);
628: panic("Foooooooood fight!");
629: };
630: any2scsi(cptr[i].dataptr, sgpnt[i].address);
631: if(((unsigned int) sgpnt[i].address) & 0xff000000) goto baddma;
632: any2scsi(cptr[i].datalen, sgpnt[i].length);
633: };
634: any2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
635: any2scsi(ccb[mbo].dataptr, cptr);
636: #ifdef DEBUG
637: printk("cptr %x: ",cptr);
638: ptr = (unsigned char *) cptr;
639: for(i=0;i<18;i++) printk("%02x ", ptr[i]);
640: #endif
641: } else {
642: ccb[mbo].op = 0; /* SCSI Initiator Command */
643: SCpnt->host_scribble = NULL;
644: any2scsi(ccb[mbo].datalen, bufflen);
645: if(((unsigned int) buff & 0xff000000)) goto baddma;
646: any2scsi(ccb[mbo].dataptr, buff);
647: };
648: ccb[mbo].idlun = (target&7)<<5 | direction | (lun & 7); /*SCSI Target Id*/
649: ccb[mbo].rsalen = 12;
650: ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
651: ccb[mbo].commlinkid = 0;
652:
653: #ifdef DEBUG
654: { int i;
655: printk("aha1542_command: sending.. ");
656: for (i = 0; i < sizeof(ccb[mbo])-10; i++)
657: printk("%02x ", ((unchar *)&ccb[mbo])[i]);
658: };
659: #endif
660:
661: if (done) {
662: DEB(printk("aha1542_queuecommand: now waiting for interrupt "); aha1542_stat());
663: SCpnt->scsi_done = done;
664: mb[mbo].status = 1;
665: aha1542_out(SCpnt->host->io_port, &ahacmd, 1); /* start scsi command */
666: DEB(aha1542_stat());
667: }
668: else
669: printk("aha1542_queuecommand: done can't be NULL\n");
670:
671: return 0;
672: baddma:
673: panic("Buffer at address > 16Mb used for 1542B");
674: }
675:
676: static void internal_done(Scsi_Cmnd * SCpnt)
677: {
678: SCpnt->SCp.Status++;
679: }
680:
681: int aha1542_command(Scsi_Cmnd * SCpnt)
682: {
683: DEB(printk("aha1542_command: ..calling aha1542_queuecommand\n"));
684:
685: aha1542_queuecommand(SCpnt, internal_done);
686:
687: SCpnt->SCp.Status = 0;
688: while (!SCpnt->SCp.Status)
689: barrier();
690: return SCpnt->result;
691: }
692:
693: /* Initialize mailboxes */
694: static void setup_mailboxes(int bse, struct Scsi_Host * shpnt)
695: {
696: int i;
697: struct mailbox * mb;
698: struct ccb *ccb;
699:
700: unchar cmd[5] = {CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
701:
702: mb = HOSTDATA(shpnt)->mb;
703: ccb = HOSTDATA(shpnt)->ccb;
704:
705: for(i=0; i<AHA1542_MAILBOXES; i++){
706: mb[i].status = mb[AHA1542_MAILBOXES+i].status = 0;
707: any2scsi(mb[i].ccbptr, &ccb[i]);
708: };
709: aha1542_intr_reset(bse); /* reset interrupts, so they don't block */
710: any2scsi((cmd+2), mb);
711: aha1542_out(bse, cmd, 5);
712: WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
713: while (0) {
714: fail:
715: printk("aha1542_detect: failed setting up mailboxes\n");
716: }
717: aha1542_intr_reset(bse);
718: }
719:
720: static int aha1542_getconfig(int base_io, unsigned char * irq_level, unsigned char * dma_chan, unsigned char * scsi_id)
721: {
722: unchar inquiry_cmd[] = {CMD_RETCONF };
723: unchar inquiry_result[3];
724: int i;
725: i = inb(STATUS(base_io));
726: if (i & DF) {
727: i = inb(DATA(base_io));
728: };
729: aha1542_out(base_io, inquiry_cmd, 1);
730: aha1542_in(base_io, inquiry_result, 3);
731: WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
732: while (0) {
733: fail:
734: printk("aha1542_detect: query board settings\n");
735: }
736: aha1542_intr_reset(base_io);
737: switch(inquiry_result[0]){
738: case 0x80:
739: *dma_chan = 7;
740: break;
741: case 0x40:
742: *dma_chan = 6;
743: break;
744: case 0x20:
745: *dma_chan = 5;
746: break;
747: case 0x01:
748: printk("DMA priority 0 not available for Adaptec driver\n");
749: return -1;
750: case 0:
751: /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
752: Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
753: *dma_chan = 0xFF;
754: break;
755: default:
756: printk("Unable to determine Adaptec DMA priority. Disabling board\n");
757: return -1;
758: };
759: switch(inquiry_result[1]){
760: case 0x40:
761: *irq_level = 15;
762: break;
763: case 0x20:
764: *irq_level = 14;
765: break;
766: case 0x8:
767: *irq_level = 12;
768: break;
769: case 0x4:
770: *irq_level = 11;
771: break;
772: case 0x2:
773: *irq_level = 10;
774: break;
775: case 0x1:
776: *irq_level = 9;
777: break;
778: default:
779: printk("Unable to determine Adaptec IRQ level. Disabling board\n");
780: return -1;
781: };
782: *scsi_id=inquiry_result[2] & 7;
783: return 0;
784: }
785:
786: /* This function should only be called for 1542C boards - we can detect
787: the special firmware settings and unlock the board */
788:
789: static int aha1542_mbenable(int base)
790: {
791: static unchar mbenable_cmd[3];
792: static unchar mbenable_result[2];
793: int retval;
794:
795: retval = BIOS_TRANSLATION_6432;
796:
797: mbenable_cmd[0]=CMD_EXTBIOS;
798: aha1542_out(base,mbenable_cmd,1);
799: if(aha1542_in1(base,mbenable_result,2))
800: return retval;
801: WAITd(INTRFLAGS(base),INTRMASK,HACC,0,100);
802: aha1542_intr_reset(base);
803:
804: if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
805: mbenable_cmd[0]=CMD_MBENABLE;
806: mbenable_cmd[1]=0;
807: mbenable_cmd[2]=mbenable_result[1];
808: if(mbenable_result[1] & 1) retval = BIOS_TRANSLATION_25563;
809: aha1542_out(base,mbenable_cmd,3);
810: WAIT(INTRFLAGS(base),INTRMASK,HACC,0);
811: };
812: while(0) {
813: fail:
814: printk("aha1542_mbenable: Mailbox init failed\n");
815: }
816: aha1542_intr_reset(base);
817: return retval;
818: }
819:
820: /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
821: static int aha1542_query(int base_io, int * transl)
822: {
823: unchar inquiry_cmd[] = {CMD_INQUIRY };
824: unchar inquiry_result[4];
825: int i;
826: i = inb(STATUS(base_io));
827: if (i & DF) {
828: i = inb(DATA(base_io));
829: };
830: aha1542_out(base_io, inquiry_cmd, 1);
831: aha1542_in(base_io, inquiry_result, 4);
832: WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
833: while (0) {
834: fail:
835: printk("aha1542_detect: query card type\n");
836: }
837: aha1542_intr_reset(base_io);
838:
839: *transl = BIOS_TRANSLATION_6432; /* Default case */
840:
841: /* For an AHA1740 series board, we ignore the board since there is a
842: hardware bug which can lead to wrong blocks being returned if the board
843: is operating in the 1542 emulation mode. Since there is an extended mode
844: driver, we simply ignore the board and let the 1740 driver pick it up.
845: */
846:
847: if (inquiry_result[0] == 0x43) {
848: printk("aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
849: return 1;
850: };
851:
852: /* Always call this - boards that do not support extended bios translation
853: will ignore the command, and we will set the proper default */
854:
855: *transl = aha1542_mbenable(base_io);
856:
857: return 0;
858: }
859:
860: /* called from init/main.c */
861: void aha1542_setup( char *str, int *ints)
862: {
863: const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
864: static int setup_idx = 0;
865: int setup_portbase;
866:
867: if(setup_idx >= MAXBOARDS)
868: {
869: printk("aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
870: printk(" Entryline 1: %s\n",setup_str[0]);
871: printk(" Entryline 2: %s\n",setup_str[1]);
872: printk(" This line: %s\n",str);
873: return;
874: }
875: if (ints[0] < 1 || ints[0] > 4)
876: {
877: printk("aha1542: %s\n", str );
878: printk(ahausage);
879: printk("aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
880: }
881:
882: setup_called[setup_idx]=ints[0];
883: setup_str[setup_idx]=str;
884:
885: setup_portbase = ints[0] >= 1 ? ints[1] : 0; /* Preserve the default value.. */
886: setup_buson [setup_idx] = ints[0] >= 2 ? ints[2] : 7;
887: setup_busoff [setup_idx] = ints[0] >= 3 ? ints[3] : 5;
888: if (ints[0] >= 4) {
889: int atbt = -1;
890: switch (ints[4]) {
891: case 5:
892: atbt = 0x00;
893: break;
894: case 6:
895: atbt = 0x04;
896: break;
897: case 7:
898: atbt = 0x01;
899: break;
900: case 8:
901: atbt = 0x02;
902: break;
903: case 10:
904: atbt = 0x03;
905: break;
906: default:
907: printk("aha1542: %s\n", str );
908: printk(ahausage);
909: printk("aha1542: Valid values for DMASPEED are 5-8, 10 MB/s. Using jumper defaults.\n");
910: break;
911: }
912: setup_dmaspeed[setup_idx] = atbt;
913: }
914:
915: if (setup_portbase != 0)
916: bases[setup_idx] = setup_portbase;
917:
918: ++setup_idx;
919: }
920:
921: /* return non-zero on detection */
922: int aha1542_detect(Scsi_Host_Template * tpnt)
923: {
924: unsigned char dma_chan;
925: unsigned char irq_level;
926: unsigned char scsi_id;
927: unsigned long flags;
928: unsigned int base_io;
929: int trans;
930: struct Scsi_Host * shpnt = NULL;
931: int count = 0;
932: int indx;
933:
934: DEB(printk("aha1542_detect: \n"));
935:
936: tpnt->proc_dir = &proc_scsi_aha1542;
937:
938: for(indx = 0; indx < sizeof(bases)/sizeof(bases[0]); indx++)
939: if(bases[indx] != 0 && !check_region(bases[indx], 4)) {
940: shpnt = scsi_register(tpnt,
941: sizeof(struct aha1542_hostdata));
942:
943: /* For now we do this - until kmalloc is more intelligent
944: we are resigned to stupid hacks like this */
945: if ((unsigned int) shpnt > 0xffffff) {
946: printk("Invalid address for shpnt with 1542.\n");
947: goto unregister;
948: }
949:
950: if(!aha1542_test_port(bases[indx], shpnt)) goto unregister;
951:
952:
953: base_io = bases[indx];
954:
955: /* Set the Bus on/off-times as not to ruin floppy performance */
956: {
957: unchar oncmd[] = {CMD_BUSON_TIME, 7};
958: unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
959:
960: if(setup_called[indx])
961: {
962: oncmd[1] = setup_buson[indx];
963: offcmd[1] = setup_busoff[indx];
964: }
965:
966: aha1542_intr_reset(base_io);
967: aha1542_out(base_io, oncmd, 2);
968: WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
969: aha1542_intr_reset(base_io);
970: aha1542_out(base_io, offcmd, 2);
971: WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
972: if (setup_dmaspeed[indx] >= 0)
973: {
974: unchar dmacmd[] = {CMD_DMASPEED, 0};
975: dmacmd[1] = setup_dmaspeed[indx];
976: aha1542_intr_reset(base_io);
977: aha1542_out(base_io, dmacmd, 2);
978: WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
979: }
980: while (0) {
981: fail:
982: printk("aha1542_detect: setting bus on/off-time failed\n");
983: }
984: aha1542_intr_reset(base_io);
985: }
986: if(aha1542_query(base_io, &trans)) goto unregister;
987:
988: if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1) goto unregister;
989:
990: printk("Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
991: if (dma_chan != 0xFF)
992: printk(", DMA priority %d", dma_chan);
993: printk("\n");
994:
995: DEB(aha1542_stat());
996: setup_mailboxes(base_io, shpnt);
997:
998: DEB(aha1542_stat());
999:
1000: DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
1001: save_flags(flags);
1002: cli();
1003: if (request_irq(irq_level,aha1542_intr_handle, 0, "aha1542")) {
1004: printk("Unable to allocate IRQ for adaptec controller.\n");
1005: goto unregister;
1006: }
1007:
1008: if (dma_chan != 0xFF) {
1009: if (request_dma(dma_chan,"aha1542")) {
1010: printk("Unable to allocate DMA channel for Adaptec.\n");
1011: free_irq(irq_level);
1012: goto unregister;
1013: }
1014:
1015: if (dma_chan >= 5) {
1016: outb((dma_chan - 4) | CASCADE, DMA_MODE_REG);
1017: outb(dma_chan - 4, DMA_MASK_REG);
1018: }
1019: }
1020: aha_host[irq_level - 9] = shpnt;
1021: shpnt->this_id = scsi_id;
1022: shpnt->unique_id = base_io;
1023: shpnt->io_port = base_io;
1024: shpnt->n_io_port = 4; /* Number of bytes of I/O space used */
1025: shpnt->dma_channel = dma_chan;
1026: shpnt->irq = irq_level;
1027: HOSTDATA(shpnt)->bios_translation = trans;
1028: if(trans == 2)
1029: printk("aha1542.c: Using extended bios translation\n");
1030: HOSTDATA(shpnt)->aha1542_last_mbi_used = (2*AHA1542_MAILBOXES - 1);
1031: HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1032: memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1033: restore_flags(flags);
1034: #if 0
1035: DEB(printk(" *** READ CAPACITY ***\n"));
1036:
1037: {
1038: unchar buf[8];
1039: static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1040: int i;
1041:
1042: for (i = 0; i < sizeof(buf); ++i) buf[i] = 0x87;
1043: for (i = 0; i < 2; ++i)
1044: if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1045: printk("aha_detect: LU %d sector_size %d device_size %d\n",
1046: i, xscsi2int(buf+4), xscsi2int(buf));
1047: }
1048: }
1049:
1050: DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1051:
1052: for (i = 0; i < 4; ++i)
1053: {
1054: unsigned char cmd[10];
1055: static buffer[512];
1056:
1057: cmd[0] = READ_10;
1058: cmd[1] = 0;
1059: xany2scsi(cmd+2, i);
1060: cmd[6] = 0;
1061: cmd[7] = 0;
1062: cmd[8] = 1;
1063: cmd[9] = 0;
1064: aha1542_command(0, cmd, buffer, 512);
1065: }
1066: #endif
1067: request_region(bases[indx], 4,"aha1542"); /* Register the IO ports that we use */
1068: count++;
1069: continue;
1070: unregister:
1071: scsi_unregister(shpnt);
1072: continue;
1073:
1074: };
1075:
1076: return count;
1077: }
1078:
1079: static int aha1542_restart(struct Scsi_Host * shost)
1080: {
1081: int i;
1082: int count = 0;
1083: #if 0
1084: unchar ahacmd = CMD_START_SCSI;
1085: #endif
1086:
1087: for(i=0; i< AHA1542_MAILBOXES; i++)
1088: if(HOSTDATA(shost)->SCint[i] &&
1089: !(HOSTDATA(shost)->SCint[i]->device->soft_reset))
1090: {
1091: #if 0
1092: HOSTDATA(shost)->mb[i].status = 1; /* Indicate ready to restart... */
1093: #endif
1094: count++;
1095: }
1096:
1097: printk("Potential to restart %d stalled commands...\n", count);
1098: #if 0
1099: /* start scsi command */
1100: if (count) aha1542_out(shost->io_port, &ahacmd, 1);
1101: #endif
1102: return 0;
1103: }
1104:
1105: /* The abort command does not leave the device in a clean state where
1106: it is available to be used again. Until this gets worked out, we will
1107: leave it commented out. */
1108:
1109: int aha1542_abort(Scsi_Cmnd * SCpnt)
1110: {
1111: #if 0
1112: unchar ahacmd = CMD_START_SCSI;
1113: unsigned long flags;
1114: struct mailbox * mb;
1115: int mbi, mbo, i;
1116:
1117: printk("In aha1542_abort: %x %x\n",
1118: inb(STATUS(SCpnt->host->io_port)),
1119: inb(INTRFLAGS(SCpnt->host->io_port)));
1120:
1121: save_flags(flags);
1122: cli();
1123: mb = HOSTDATA(SCpnt->host)->mb;
1124: mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1125: if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
1126:
1127: do{
1128: if(mb[mbi].status != 0) break;
1129: mbi++;
1130: if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
1131: } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1132: restore_flags(flags);
1133:
1134: if(mb[mbi].status) {
1135: printk("Lost interrupt discovered on irq %d - attempting to recover\n",
1136: SCpnt->host->irq);
1137: aha1542_intr_handle(SCpnt->host->irq, NULL);
1138: return 0;
1139: }
1140:
1141: /* OK, no lost interrupt. Try looking to see how many pending commands
1142: we think we have. */
1143:
1144: for(i=0; i< AHA1542_MAILBOXES; i++)
1145: if(HOSTDATA(SCpnt->host)->SCint[i])
1146: {
1147: if(HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1148: printk("Timed out command pending for %s\n",
1149: kdevname(SCpnt->request.rq_dev));
1150: if (HOSTDATA(SCpnt->host)->mb[i].status) {
1151: printk("OGMB still full - restarting\n");
1152: aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1153: };
1154: } else
1155: printk("Other pending command %s\n",
1156: kdevname(SCpnt->request.rq_dev));
1157: }
1158:
1159: #endif
1160:
1161: DEB(printk("aha1542_abort\n"));
1162: #if 0
1163: save_flags(flags);
1164: cli();
1165: for(mbo = 0; mbo < AHA1542_MAILBOXES; mbo++)
1166: if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]){
1167: mb[mbo].status = 2; /* Abort command */
1168: aha1542_out(SCpnt->host->io_port, &ahacmd, 1); /* start scsi command */
1169: restore_flags(flags);
1170: break;
1171: };
1172: #endif
1173: return SCSI_ABORT_SNOOZE;
1174: }
1175:
1176: /* We do not implement a reset function here, but the upper level code
1177: assumes that it will get some kind of response for the command in
1178: SCpnt. We must oblige, or the command will hang the scsi system.
1179: For a first go, we assume that the 1542 notifies us with all of the
1180: pending commands (it does implement soft reset, after all). */
1181:
1182: int aha1542_reset(Scsi_Cmnd * SCpnt)
1183: {
1184: unchar ahacmd = CMD_START_SCSI;
1185: int i;
1186:
1187: /*
1188: * See if a bus reset was suggested.
1189: */
1190: if( SCpnt->host->suggest_bus_reset )
1191: {
1192: /*
1193: * This does a scsi reset for all devices on the bus.
1194: * In principle, we could also reset the 1542 - should
1195: * we do this? Try this first, and we can add that later
1196: * if it turns out to be useful.
1197: */
1198: outb(HRST | SCRST, CONTROL(SCpnt->host->io_port));
1199:
1200: /*
1201: * Wait for the thing to settle down a bit. Unfortunately
1202: * this is going to basically lock up the machine while we
1203: * wait for this to complete. To be 100% correct, we need to
1204: * check for timeout, and if we are doing something like this
1205: * we are pretty desperate anyways.
1206: */
1207: WAIT(STATUS(SCpnt->host->io_port),
1208: STATMASK, INIT|IDLE, STST|DIAGF|INVDCMD|DF|CDF);
1209:
1210: /*
1211: * We need to do this too before the 1542 can interact with
1212: * us again.
1213: */
1214: setup_mailboxes(SCpnt->host->io_port, SCpnt->host);
1215:
1216: /*
1217: * Now try and pick up the pieces. Restart all commands
1218: * that are currently active on the bus, and reset all of
1219: * the datastructures. We have some time to kill while
1220: * things settle down, so print a nice message.
1221: */
1222: printk("Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no);
1223:
1224: for(i=0; i< AHA1542_MAILBOXES; i++)
1225: if(HOSTDATA(SCpnt->host)->SCint[i] != NULL)
1226: {
1227: Scsi_Cmnd * SCtmp;
1228: SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1229: SCtmp->result = DID_RESET << 16;
1230: if (SCtmp->host_scribble) scsi_free(SCtmp->host_scribble, 512);
1231: printk("Sending DID_RESET for target %d\n", SCpnt->target);
1232: SCtmp->scsi_done(SCpnt);
1233:
1234: HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1235: HOSTDATA(SCpnt->host)->mb[i].status = 0;
1236: }
1237: /*
1238: * Now tell the mid-level code what we did here. Since
1239: * we have restarted all of the outstanding commands,
1240: * then report SUCCESS.
1241: */
1242: return (SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET);
1243: fail:
1244: printk("aha1542.c: Unable to perform hard reset.\n");
1245: printk("Power cycle machine to reset\n");
1246: return (SCSI_RESET_ERROR | SCSI_RESET_BUS_RESET);
1247:
1248:
1249: }
1250: else
1251: {
1252: /* This does a selective reset of just the one device */
1253: /* First locate the ccb for this command */
1254: for(i=0; i< AHA1542_MAILBOXES; i++)
1255: if(HOSTDATA(SCpnt->host)->SCint[i] == SCpnt)
1256: {
1257: HOSTDATA(SCpnt->host)->ccb[i].op = 0x81; /* BUS DEVICE RESET */
1258: /* Now tell the 1542 to flush all pending commands for this target */
1259: aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1260:
1261: /* Here is the tricky part. What to do next. Do we get an interrupt
1262: for the commands that we aborted with the specified target, or
1263: do we generate this on our own? Try it without first and see
1264: what happens */
1265: printk("Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1266:
1267: /* If the first does not work, then try the second. I think the
1268: first option is more likely to be correct. Free the command
1269: block for all commands running on this target... */
1270: for(i=0; i< AHA1542_MAILBOXES; i++)
1271: if(HOSTDATA(SCpnt->host)->SCint[i] &&
1272: HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target)
1273: {
1274: Scsi_Cmnd * SCtmp;
1275: SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1276: SCtmp->result = DID_RESET << 16;
1277: if (SCtmp->host_scribble) scsi_free(SCtmp->host_scribble, 512);
1278: printk("Sending DID_RESET for target %d\n", SCpnt->target);
1279: SCtmp->scsi_done(SCpnt);
1280:
1281: HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1282: HOSTDATA(SCpnt->host)->mb[i].status = 0;
1283: }
1284: return SCSI_RESET_SUCCESS;
1285: }
1286: }
1287: /* No active command at this time, so this means that each time we got
1288: some kind of response the last time through. Tell the mid-level code
1289: to request sense information in order to decide what to do next. */
1290: return SCSI_RESET_PUNT;
1291: }
1292:
1293: #include "sd.h"
1294:
1295: int aha1542_biosparam(Scsi_Disk * disk, kdev_t dev, int * ip)
1296: {
1297: int translation_algorithm;
1298: int size = disk->capacity;
1299:
1300: translation_algorithm = HOSTDATA(disk->device->host)->bios_translation;
1301: /* Should this be > 1024, or >= 1024? Enquiring minds want to know. */
1302: if((size>>11) > 1024 && translation_algorithm == 2) {
1303: /* Please verify that this is the same as what DOS returns */
1304: ip[0] = 255;
1305: ip[1] = 63;
1306: ip[2] = size /255/63;
1307: } else {
1308: ip[0] = 64;
1309: ip[1] = 32;
1310: ip[2] = size >> 11;
1311: };
1312: /* if (ip[2] >= 1024) ip[2] = 1024; */
1313: return 0;
1314: }
1315:
1316:
1317: #ifdef MODULE
1318: /* Eventually this will go into an include file, but this will be later */
1319: Scsi_Host_Template driver_template = AHA1542;
1320:
1321: #include "scsi_module.c"
1322: #endif
1323:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.