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