MAINTAINERS: remove Adam Fritzler, remove his email address in other sources
[linux-2.6.git] / drivers / scsi / aha1542.c
1 /* $Id: aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $
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 <mike.mclagan@linux.org>
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  *  Modified by Chris Faulhaber <jedgar@fxp.org>
22  *        Added module command-line options
23  *        19-Jul-99
24  *  Modified by Adam Fritzler
25  *        Added proper detection of the AHA-1640 (MCA version of AHA-1540)
26  */
27
28 #include <linux/module.h>
29 #include <linux/interrupt.h>
30 #include <linux/kernel.h>
31 #include <linux/types.h>
32 #include <linux/string.h>
33 #include <linux/ioport.h>
34 #include <linux/delay.h>
35 #include <linux/proc_fs.h>
36 #include <linux/init.h>
37 #include <linux/spinlock.h>
38 #include <linux/isapnp.h>
39 #include <linux/blkdev.h>
40 #include <linux/mca.h>
41 #include <linux/mca-legacy.h>
42
43 #include <asm/dma.h>
44 #include <asm/system.h>
45 #include <asm/io.h>
46
47 #include "scsi.h"
48 #include <scsi/scsi_host.h>
49 #include "aha1542.h"
50
51 #define SCSI_BUF_PA(address)    isa_virt_to_bus(address)
52 #define SCSI_SG_PA(sgent)       (isa_page_to_bus(sg_page((sgent))) + (sgent)->offset)
53
54 static void BAD_SG_DMA(Scsi_Cmnd * SCpnt,
55                        struct scatterlist *sgp,
56                        int nseg,
57                        int badseg)
58 {
59         printk(KERN_CRIT "sgpnt[%d:%d] page %p/0x%llx length %u\n",
60                badseg, nseg, sg_virt(sgp),
61                (unsigned long long)SCSI_SG_PA(sgp),
62                sgp->length);
63
64         /*
65          * Not safe to continue.
66          */
67         panic("Buffer at physical address > 16Mb used for aha1542");
68 }
69
70 #include<linux/stat.h>
71
72 #ifdef DEBUG
73 #define DEB(x) x
74 #else
75 #define DEB(x)
76 #endif
77
78 /*
79    static const char RCSid[] = "$Header: /usr/src/linux/kernel/blk_drv/scsi/RCS/aha1542.c,v 1.1 1992/07/24 06:27:38 root Exp root $";
80  */
81
82 /* The adaptec can be configured for quite a number of addresses, but
83    I generally do not want the card poking around at random.  We allow
84    two addresses - this allows people to use the Adaptec with a Midi
85    card, which also used 0x330 -- can be overridden with LILO! */
86
87 #define MAXBOARDS 4             /* Increase this and the sizes of the
88                                    arrays below, if you need more.. */
89
90 /* Boards 3,4 slots are reserved for ISAPnP/MCA scans */
91
92 static unsigned int bases[MAXBOARDS] __initdata = {0x330, 0x334, 0, 0};
93
94 /* set by aha1542_setup according to the command line; they also may
95    be marked __initdata, but require zero initializers then */
96
97 static int setup_called[MAXBOARDS];
98 static int setup_buson[MAXBOARDS];
99 static int setup_busoff[MAXBOARDS];
100 static int setup_dmaspeed[MAXBOARDS] __initdata = { -1, -1, -1, -1 };
101
102 /*
103  * LILO/Module params:  aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]
104  *
105  * Where:  <PORTBASE> is any of the valid AHA addresses:
106  *                      0x130, 0x134, 0x230, 0x234, 0x330, 0x334
107  *         <BUSON>  is the time (in microsecs) that AHA spends on the AT-bus
108  *                  when transferring data.  1542A power-on default is 11us,
109  *                  valid values are in range: 2..15 (decimal)
110  *         <BUSOFF> is the time that AHA spends OFF THE BUS after while
111  *                  it is transferring data (not to monopolize the bus).
112  *                  Power-on default is 4us, valid range: 1..64 microseconds.
113  *         <DMASPEED> Default is jumper selected (1542A: on the J1),
114  *                  but experimenter can alter it with this.
115  *                  Valid values: 5, 6, 7, 8, 10 (MB/s)
116  *                  Factory default is 5 MB/s.
117  */
118
119 #if defined(MODULE)
120 static int isapnp = 0;
121 static int aha1542[] = {0x330, 11, 4, -1};
122 module_param_array(aha1542, int, NULL, 0);
123 module_param(isapnp, bool, 0);
124
125 static struct isapnp_device_id id_table[] __initdata = {
126         {
127                 ISAPNP_ANY_ID, ISAPNP_ANY_ID,
128                 ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1542),
129                 0
130         },
131         {0}
132 };
133
134 MODULE_DEVICE_TABLE(isapnp, id_table);
135
136 #else
137 static int isapnp = 1;
138 #endif
139
140 #define BIOS_TRANSLATION_1632 0 /* Used by some old 1542A boards */
141 #define BIOS_TRANSLATION_6432 1 /* Default case these days */
142 #define BIOS_TRANSLATION_25563 2        /* Big disk case */
143
144 struct aha1542_hostdata {
145         /* This will effectively start both of them at the first mailbox */
146         int bios_translation;   /* Mapping bios uses - for compatibility */
147         int aha1542_last_mbi_used;
148         int aha1542_last_mbo_used;
149         Scsi_Cmnd *SCint[AHA1542_MAILBOXES];
150         struct mailbox mb[2 * AHA1542_MAILBOXES];
151         struct ccb ccb[AHA1542_MAILBOXES];
152 };
153
154 #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
155
156 static struct Scsi_Host *aha_host[7];   /* One for each IRQ level (9-15) */
157
158 static DEFINE_SPINLOCK(aha1542_lock);
159
160
161
162 #define WAITnexttimeout 3000000
163
164 static void setup_mailboxes(int base_io, struct Scsi_Host *shpnt);
165 static int aha1542_restart(struct Scsi_Host *shost);
166 static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id);
167 static irqreturn_t do_aha1542_intr_handle(int irq, void *dev_id);
168
169 #define aha1542_intr_reset(base)  outb(IRST, CONTROL(base))
170
171 #define WAIT(port, mask, allof, noneof)                                 \
172  { register int WAITbits;                                               \
173    register int WAITtimeout = WAITnexttimeout;                          \
174    while (1) {                                                          \
175      WAITbits = inb(port) & (mask);                                     \
176      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
177        break;                                                           \
178      if (--WAITtimeout == 0) goto fail;                                 \
179    }                                                                    \
180  }
181
182 /* Similar to WAIT, except we use the udelay call to regulate the
183    amount of time we wait.  */
184 #define WAITd(port, mask, allof, noneof, timeout)                       \
185  { register int WAITbits;                                               \
186    register int WAITtimeout = timeout;                                  \
187    while (1) {                                                          \
188      WAITbits = inb(port) & (mask);                                     \
189      if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
190        break;                                                           \
191      mdelay(1);                                                 \
192      if (--WAITtimeout == 0) goto fail;                                 \
193    }                                                                    \
194  }
195
196 static void aha1542_stat(void)
197 {
198 /*      int s = inb(STATUS), i = inb(INTRFLAGS);
199         printk("status=%x intrflags=%x\n", s, i, WAITnexttimeout-WAITtimeout); */
200 }
201
202 /* This is a bit complicated, but we need to make sure that an interrupt
203    routine does not send something out while we are in the middle of this.
204    Fortunately, it is only at boot time that multi-byte messages
205    are ever sent. */
206 static int aha1542_out(unsigned int base, unchar * cmdp, int len)
207 {
208         unsigned long flags = 0;
209         int got_lock;
210
211         if (len == 1) {
212                 got_lock = 0;
213                 while (1 == 1) {
214                         WAIT(STATUS(base), CDF, 0, CDF);
215                         spin_lock_irqsave(&aha1542_lock, flags);
216                         if (inb(STATUS(base)) & CDF) {
217                                 spin_unlock_irqrestore(&aha1542_lock, flags);
218                                 continue;
219                         }
220                         outb(*cmdp, DATA(base));
221                         spin_unlock_irqrestore(&aha1542_lock, flags);
222                         return 0;
223                 }
224         } else {
225                 spin_lock_irqsave(&aha1542_lock, flags);
226                 got_lock = 1;
227                 while (len--) {
228                         WAIT(STATUS(base), CDF, 0, CDF);
229                         outb(*cmdp++, DATA(base));
230                 }
231                 spin_unlock_irqrestore(&aha1542_lock, flags);
232         }
233         return 0;
234 fail:
235         if (got_lock)
236                 spin_unlock_irqrestore(&aha1542_lock, flags);
237         printk(KERN_ERR "aha1542_out failed(%d): ", len + 1);
238         aha1542_stat();
239         return 1;
240 }
241
242 /* Only used at boot time, so we do not need to worry about latency as much
243    here */
244
245 static int __init aha1542_in(unsigned int base, unchar * cmdp, int len)
246 {
247         unsigned long flags;
248
249         spin_lock_irqsave(&aha1542_lock, flags);
250         while (len--) {
251                 WAIT(STATUS(base), DF, DF, 0);
252                 *cmdp++ = inb(DATA(base));
253         }
254         spin_unlock_irqrestore(&aha1542_lock, flags);
255         return 0;
256 fail:
257         spin_unlock_irqrestore(&aha1542_lock, flags);
258         printk(KERN_ERR "aha1542_in failed(%d): ", len + 1);
259         aha1542_stat();
260         return 1;
261 }
262
263 /* Similar to aha1542_in, except that we wait a very short period of time.
264    We use this if we know the board is alive and awake, but we are not sure
265    if the board will respond to the command we are about to send or not */
266 static int __init aha1542_in1(unsigned int base, unchar * cmdp, int len)
267 {
268         unsigned long flags;
269
270         spin_lock_irqsave(&aha1542_lock, flags);
271         while (len--) {
272                 WAITd(STATUS(base), DF, DF, 0, 100);
273                 *cmdp++ = inb(DATA(base));
274         }
275         spin_unlock_irqrestore(&aha1542_lock, flags);
276         return 0;
277 fail:
278         spin_unlock_irqrestore(&aha1542_lock, flags);
279         return 1;
280 }
281
282 static int makecode(unsigned hosterr, unsigned scsierr)
283 {
284         switch (hosterr) {
285         case 0x0:
286         case 0xa:               /* Linked command complete without error and linked normally */
287         case 0xb:               /* Linked command complete without error, interrupt generated */
288                 hosterr = 0;
289                 break;
290
291         case 0x11:              /* Selection time out-The initiator selection or target
292                                    reselection was not complete within the SCSI Time out period */
293                 hosterr = DID_TIME_OUT;
294                 break;
295
296         case 0x12:              /* Data overrun/underrun-The target attempted to transfer more data
297                                    than was allocated by the Data Length field or the sum of the
298                                    Scatter / Gather Data Length fields. */
299
300         case 0x13:              /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
301
302         case 0x15:              /* MBO command was not 00, 01 or 02-The first byte of the CB was
303                                    invalid. This usually indicates a software failure. */
304
305         case 0x16:              /* Invalid CCB Operation Code-The first byte of the CCB was invalid.
306                                    This usually indicates a software failure. */
307
308         case 0x17:              /* Linked CCB does not have the same LUN-A subsequent CCB of a set
309                                    of linked CCB's does not specify the same logical unit number as
310                                    the first. */
311         case 0x18:              /* Invalid Target Direction received from Host-The direction of a
312                                    Target Mode CCB was invalid. */
313
314         case 0x19:              /* Duplicate CCB Received in Target Mode-More than once CCB was
315                                    received to service data transfer between the same target LUN
316                                    and initiator SCSI ID in the same direction. */
317
318         case 0x1a:              /* Invalid CCB or Segment List Parameter-A segment list with a zero
319                                    length segment or invalid segment list boundaries was received.
320                                    A CCB parameter was invalid. */
321                 DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
322                 hosterr = DID_ERROR;    /* Couldn't find any better */
323                 break;
324
325         case 0x14:              /* Target bus phase sequence failure-An invalid bus phase or bus
326                                    phase sequence was requested by the target. The host adapter
327                                    will generate a SCSI Reset Condition, notifying the host with
328                                    a SCRD interrupt */
329                 hosterr = DID_RESET;
330                 break;
331         default:
332                 printk(KERN_ERR "aha1542: makecode: unknown hoststatus %x\n", hosterr);
333                 break;
334         }
335         return scsierr | (hosterr << 16);
336 }
337
338 static int __init aha1542_test_port(int bse, struct Scsi_Host *shpnt)
339 {
340         unchar inquiry_cmd[] = {CMD_INQUIRY};
341         unchar inquiry_result[4];
342         unchar *cmdp;
343         int len;
344         volatile int debug = 0;
345
346         /* Quick and dirty test for presence of the card. */
347         if (inb(STATUS(bse)) == 0xff)
348                 return 0;
349
350         /* Reset the adapter. I ought to make a hard reset, but it's not really necessary */
351
352         /*  DEB(printk("aha1542_test_port called \n")); */
353
354         /* In case some other card was probing here, reset interrupts */
355         aha1542_intr_reset(bse);        /* reset interrupts, so they don't block */
356
357         outb(SRST | IRST /*|SCRST */ , CONTROL(bse));
358
359         mdelay(20);             /* Wait a little bit for things to settle down. */
360
361         debug = 1;
362         /* Expect INIT and IDLE, any of the others are bad */
363         WAIT(STATUS(bse), STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
364
365         debug = 2;
366         /* Shouldn't have generated any interrupts during reset */
367         if (inb(INTRFLAGS(bse)) & INTRMASK)
368                 goto fail;
369
370
371         /* Perform a host adapter inquiry instead so we do not need to set
372            up the mailboxes ahead of time */
373
374         aha1542_out(bse, inquiry_cmd, 1);
375
376         debug = 3;
377         len = 4;
378         cmdp = &inquiry_result[0];
379
380         while (len--) {
381                 WAIT(STATUS(bse), DF, DF, 0);
382                 *cmdp++ = inb(DATA(bse));
383         }
384
385         debug = 8;
386         /* Reading port should reset DF */
387         if (inb(STATUS(bse)) & DF)
388                 goto fail;
389
390         debug = 9;
391         /* When HACC, command is completed, and we're though testing */
392         WAIT(INTRFLAGS(bse), HACC, HACC, 0);
393         /* now initialize adapter */
394
395         debug = 10;
396         /* Clear interrupts */
397         outb(IRST, CONTROL(bse));
398
399         debug = 11;
400
401         return debug;           /* 1 = ok */
402 fail:
403         return 0;               /* 0 = not ok */
404 }
405
406 /* A quick wrapper for do_aha1542_intr_handle to grab the spin lock */
407 static irqreturn_t do_aha1542_intr_handle(int irq, void *dev_id)
408 {
409         unsigned long flags;
410         struct Scsi_Host *shost;
411
412         shost = aha_host[irq - 9];
413         if (!shost)
414                 panic("Splunge!");
415
416         spin_lock_irqsave(shost->host_lock, flags);
417         aha1542_intr_handle(shost, dev_id);
418         spin_unlock_irqrestore(shost->host_lock, flags);
419         return IRQ_HANDLED;
420 }
421
422 /* A "high" level interrupt handler */
423 static void aha1542_intr_handle(struct Scsi_Host *shost, void *dev_id)
424 {
425         void (*my_done) (Scsi_Cmnd *) = NULL;
426         int errstatus, mbi, mbo, mbistatus;
427         int number_serviced;
428         unsigned long flags;
429         Scsi_Cmnd *SCtmp;
430         int flag;
431         int needs_restart;
432         struct mailbox *mb;
433         struct ccb *ccb;
434
435         mb = HOSTDATA(shost)->mb;
436         ccb = HOSTDATA(shost)->ccb;
437
438 #ifdef DEBUG
439         {
440                 flag = inb(INTRFLAGS(shost->io_port));
441                 printk(KERN_DEBUG "aha1542_intr_handle: ");
442                 if (!(flag & ANYINTR))
443                         printk("no interrupt?");
444                 if (flag & MBIF)
445                         printk("MBIF ");
446                 if (flag & MBOA)
447                         printk("MBOF ");
448                 if (flag & HACC)
449                         printk("HACC ");
450                 if (flag & SCRD)
451                         printk("SCRD ");
452                 printk("status %02x\n", inb(STATUS(shost->io_port)));
453         };
454 #endif
455         number_serviced = 0;
456         needs_restart = 0;
457
458         while (1 == 1) {
459                 flag = inb(INTRFLAGS(shost->io_port));
460
461                 /* Check for unusual interrupts.  If any of these happen, we should
462                    probably do something special, but for now just printing a message
463                    is sufficient.  A SCSI reset detected is something that we really
464                    need to deal with in some way. */
465                 if (flag & ~MBIF) {
466                         if (flag & MBOA)
467                                 printk("MBOF ");
468                         if (flag & HACC)
469                                 printk("HACC ");
470                         if (flag & SCRD) {
471                                 needs_restart = 1;
472                                 printk("SCRD ");
473                         }
474                 }
475                 aha1542_intr_reset(shost->io_port);
476
477                 spin_lock_irqsave(&aha1542_lock, flags);
478                 mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1;
479                 if (mbi >= 2 * AHA1542_MAILBOXES)
480                         mbi = AHA1542_MAILBOXES;
481
482                 do {
483                         if (mb[mbi].status != 0)
484                                 break;
485                         mbi++;
486                         if (mbi >= 2 * AHA1542_MAILBOXES)
487                                 mbi = AHA1542_MAILBOXES;
488                 } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used);
489
490                 if (mb[mbi].status == 0) {
491                         spin_unlock_irqrestore(&aha1542_lock, flags);
492                         /* Hmm, no mail.  Must have read it the last time around */
493                         if (!number_serviced && !needs_restart)
494                                 printk(KERN_WARNING "aha1542.c: interrupt received, but no mail.\n");
495                         /* We detected a reset.  Restart all pending commands for
496                            devices that use the hard reset option */
497                         if (needs_restart)
498                                 aha1542_restart(shost);
499                         return;
500                 };
501
502                 mbo = (scsi2int(mb[mbi].ccbptr) - (SCSI_BUF_PA(&ccb[0]))) / sizeof(struct ccb);
503                 mbistatus = mb[mbi].status;
504                 mb[mbi].status = 0;
505                 HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
506                 spin_unlock_irqrestore(&aha1542_lock, flags);
507
508 #ifdef DEBUG
509                 {
510                         if (ccb[mbo].tarstat | ccb[mbo].hastat)
511                                 printk(KERN_DEBUG "aha1542_command: returning %x (status %d)\n",
512                                        ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
513                 };
514 #endif
515
516                 if (mbistatus == 3)
517                         continue;       /* Aborted command not found */
518
519 #ifdef DEBUG
520                 printk(KERN_DEBUG "...done %d %d\n", mbo, mbi);
521 #endif
522
523                 SCtmp = HOSTDATA(shost)->SCint[mbo];
524
525                 if (!SCtmp || !SCtmp->scsi_done) {
526                         printk(KERN_WARNING "aha1542_intr_handle: Unexpected interrupt\n");
527                         printk(KERN_WARNING "tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat,
528                                ccb[mbo].hastat, ccb[mbo].idlun, mbo);
529                         return;
530                 }
531                 my_done = SCtmp->scsi_done;
532                 kfree(SCtmp->host_scribble);
533                 SCtmp->host_scribble = NULL;
534                 /* Fetch the sense data, and tuck it away, in the required slot.  The
535                    Adaptec automatically fetches it, and there is no guarantee that
536                    we will still have it in the cdb when we come back */
537                 if (ccb[mbo].tarstat == 2)
538                         memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
539                                SCSI_SENSE_BUFFERSIZE);
540
541
542                 /* is there mail :-) */
543
544                 /* more error checking left out here */
545                 if (mbistatus != 1)
546                         /* This is surely wrong, but I don't know what's right */
547                         errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
548                 else
549                         errstatus = 0;
550
551 #ifdef DEBUG
552                 if (errstatus)
553                         printk(KERN_DEBUG "(aha1542 error:%x %x %x) ", errstatus,
554                                ccb[mbo].hastat, ccb[mbo].tarstat);
555 #endif
556
557                 if (ccb[mbo].tarstat == 2) {
558 #ifdef DEBUG
559                         int i;
560 #endif
561                         DEB(printk("aha1542_intr_handle: sense:"));
562 #ifdef DEBUG
563                         for (i = 0; i < 12; i++)
564                                 printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen + i]);
565                         printk("\n");
566 #endif
567                         /*
568                            DEB(printk("aha1542_intr_handle: buf:"));
569                            for (i = 0; i < bufflen; i++)
570                            printk("%02x ", ((unchar *)buff)[i]);
571                            printk("\n");
572                          */
573                 }
574                 DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
575                 SCtmp->result = errstatus;
576                 HOSTDATA(shost)->SCint[mbo] = NULL;     /* This effectively frees up the mailbox slot, as
577                                                            far as queuecommand is concerned */
578                 my_done(SCtmp);
579                 number_serviced++;
580         };
581 }
582
583 static int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
584 {
585         unchar ahacmd = CMD_START_SCSI;
586         unchar direction;
587         unchar *cmd = (unchar *) SCpnt->cmnd;
588         unchar target = SCpnt->device->id;
589         unchar lun = SCpnt->device->lun;
590         unsigned long flags;
591         int bufflen = scsi_bufflen(SCpnt);
592         int mbo;
593         struct mailbox *mb;
594         struct ccb *ccb;
595
596         DEB(int i);
597
598         mb = HOSTDATA(SCpnt->device->host)->mb;
599         ccb = HOSTDATA(SCpnt->device->host)->ccb;
600
601         DEB(if (target > 1) {
602             SCpnt->result = DID_TIME_OUT << 16;
603             done(SCpnt); return 0;
604             }
605         );
606
607         if (*cmd == REQUEST_SENSE) {
608                 /* Don't do the command - we have the sense data already */
609 #if 0
610                 /* scsi_request_sense() provides a buffer of size 256,
611                    so there is no reason to expect equality */
612                 if (bufflen != SCSI_SENSE_BUFFERSIZE)
613                         printk(KERN_CRIT "aha1542: Wrong buffer length supplied "
614                                "for request sense (%d)\n", bufflen);
615 #endif
616                 SCpnt->result = 0;
617                 done(SCpnt);
618                 return 0;
619         }
620 #ifdef DEBUG
621         if (*cmd == READ_10 || *cmd == WRITE_10)
622                 i = xscsi2int(cmd + 2);
623         else if (*cmd == READ_6 || *cmd == WRITE_6)
624                 i = scsi2int(cmd + 2);
625         else
626                 i = -1;
627         if (done)
628                 printk(KERN_DEBUG "aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
629         else
630                 printk(KERN_DEBUG "aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
631         aha1542_stat();
632         printk(KERN_DEBUG "aha1542_queuecommand: dumping scsi cmd:");
633         for (i = 0; i < SCpnt->cmd_len; i++)
634                 printk("%02x ", cmd[i]);
635         printk("\n");
636         if (*cmd == WRITE_10 || *cmd == WRITE_6)
637                 return 0;       /* we are still testing, so *don't* write */
638 #endif
639         /* Use the outgoing mailboxes in a round-robin fashion, because this
640            is how the host adapter will scan for them */
641
642         spin_lock_irqsave(&aha1542_lock, flags);
643         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
644         if (mbo >= AHA1542_MAILBOXES)
645                 mbo = 0;
646
647         do {
648                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
649                         break;
650                 mbo++;
651                 if (mbo >= AHA1542_MAILBOXES)
652                         mbo = 0;
653         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
654
655         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
656                 panic("Unable to find empty mailbox for aha1542.\n");
657
658         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively prevent someone else from
659                                                            screwing with this cdb. */
660
661         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
662         spin_unlock_irqrestore(&aha1542_lock, flags);
663
664 #ifdef DEBUG
665         printk(KERN_DEBUG "Sending command (%d %x)...", mbo, done);
666 #endif
667
668         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
669
670         memset(&ccb[mbo], 0, sizeof(struct ccb));
671
672         ccb[mbo].cdblen = SCpnt->cmd_len;
673
674         direction = 0;
675         if (*cmd == READ_10 || *cmd == READ_6)
676                 direction = 8;
677         else if (*cmd == WRITE_10 || *cmd == WRITE_6)
678                 direction = 16;
679
680         memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
681
682         if (bufflen) {
683                 struct scatterlist *sg;
684                 struct chain *cptr;
685 #ifdef DEBUG
686                 unsigned char *ptr;
687 #endif
688                 int i, sg_count = scsi_sg_count(SCpnt);
689                 ccb[mbo].op = 2;        /* SCSI Initiator Command  w/scatter-gather */
690                 SCpnt->host_scribble = kmalloc(sizeof(*cptr)*sg_count,
691                                                          GFP_KERNEL | GFP_DMA);
692                 cptr = (struct chain *) SCpnt->host_scribble;
693                 if (cptr == NULL) {
694                         /* free the claimed mailbox slot */
695                         HOSTDATA(SCpnt->device->host)->SCint[mbo] = NULL;
696                         return SCSI_MLQUEUE_HOST_BUSY;
697                 }
698                 scsi_for_each_sg(SCpnt, sg, sg_count, i) {
699                         any2scsi(cptr[i].dataptr, SCSI_SG_PA(sg));
700                         if (SCSI_SG_PA(sg) + sg->length - 1 > ISA_DMA_THRESHOLD)
701                                 BAD_SG_DMA(SCpnt, scsi_sglist(SCpnt), sg_count, i);
702                         any2scsi(cptr[i].datalen, sg->length);
703                 };
704                 any2scsi(ccb[mbo].datalen, sg_count * sizeof(struct chain));
705                 any2scsi(ccb[mbo].dataptr, SCSI_BUF_PA(cptr));
706 #ifdef DEBUG
707                 printk("cptr %x: ", cptr);
708                 ptr = (unsigned char *) cptr;
709                 for (i = 0; i < 18; i++)
710                         printk("%02x ", ptr[i]);
711 #endif
712         } else {
713                 ccb[mbo].op = 0;        /* SCSI Initiator Command */
714                 SCpnt->host_scribble = NULL;
715                 any2scsi(ccb[mbo].datalen, 0);
716                 any2scsi(ccb[mbo].dataptr, 0);
717         };
718         ccb[mbo].idlun = (target & 7) << 5 | direction | (lun & 7);     /*SCSI Target Id */
719         ccb[mbo].rsalen = 16;
720         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
721         ccb[mbo].commlinkid = 0;
722
723 #ifdef DEBUG
724         {
725                 int i;
726                 printk(KERN_DEBUG "aha1542_command: sending.. ");
727                 for (i = 0; i < sizeof(ccb[mbo]) - 10; i++)
728                         printk("%02x ", ((unchar *) & ccb[mbo])[i]);
729         };
730 #endif
731
732         if (done) {
733                 DEB(printk("aha1542_queuecommand: now waiting for interrupt ");
734                     aha1542_stat());
735                 SCpnt->scsi_done = done;
736                 mb[mbo].status = 1;
737                 aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);  /* start scsi command */
738                 DEB(aha1542_stat());
739         } else
740                 printk("aha1542_queuecommand: done can't be NULL\n");
741
742         return 0;
743 }
744
745 /* Initialize mailboxes */
746 static void setup_mailboxes(int bse, struct Scsi_Host *shpnt)
747 {
748         int i;
749         struct mailbox *mb;
750         struct ccb *ccb;
751
752         unchar cmd[5] = { CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
753
754         mb = HOSTDATA(shpnt)->mb;
755         ccb = HOSTDATA(shpnt)->ccb;
756
757         for (i = 0; i < AHA1542_MAILBOXES; i++) {
758                 mb[i].status = mb[AHA1542_MAILBOXES + i].status = 0;
759                 any2scsi(mb[i].ccbptr, SCSI_BUF_PA(&ccb[i]));
760         };
761         aha1542_intr_reset(bse);        /* reset interrupts, so they don't block */
762         any2scsi((cmd + 2), SCSI_BUF_PA(mb));
763         aha1542_out(bse, cmd, 5);
764         WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
765         while (0) {
766 fail:
767                 printk(KERN_ERR "aha1542_detect: failed setting up mailboxes\n");
768         }
769         aha1542_intr_reset(bse);
770 }
771
772 static int __init aha1542_getconfig(int base_io, unsigned char *irq_level, unsigned char *dma_chan, unsigned char *scsi_id)
773 {
774         unchar inquiry_cmd[] = {CMD_RETCONF};
775         unchar inquiry_result[3];
776         int i;
777         i = inb(STATUS(base_io));
778         if (i & DF) {
779                 i = inb(DATA(base_io));
780         };
781         aha1542_out(base_io, inquiry_cmd, 1);
782         aha1542_in(base_io, inquiry_result, 3);
783         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
784         while (0) {
785 fail:
786                 printk(KERN_ERR "aha1542_detect: query board settings\n");
787         }
788         aha1542_intr_reset(base_io);
789         switch (inquiry_result[0]) {
790         case 0x80:
791                 *dma_chan = 7;
792                 break;
793         case 0x40:
794                 *dma_chan = 6;
795                 break;
796         case 0x20:
797                 *dma_chan = 5;
798                 break;
799         case 0x01:
800                 *dma_chan = 0;
801                 break;
802         case 0:
803                 /* This means that the adapter, although Adaptec 1542 compatible, doesn't use a DMA channel.
804                    Currently only aware of the BusLogic BT-445S VL-Bus adapter which needs this. */
805                 *dma_chan = 0xFF;
806                 break;
807         default:
808                 printk(KERN_ERR "Unable to determine Adaptec DMA priority.  Disabling board\n");
809                 return -1;
810         };
811         switch (inquiry_result[1]) {
812         case 0x40:
813                 *irq_level = 15;
814                 break;
815         case 0x20:
816                 *irq_level = 14;
817                 break;
818         case 0x8:
819                 *irq_level = 12;
820                 break;
821         case 0x4:
822                 *irq_level = 11;
823                 break;
824         case 0x2:
825                 *irq_level = 10;
826                 break;
827         case 0x1:
828                 *irq_level = 9;
829                 break;
830         default:
831                 printk(KERN_ERR "Unable to determine Adaptec IRQ level.  Disabling board\n");
832                 return -1;
833         };
834         *scsi_id = inquiry_result[2] & 7;
835         return 0;
836 }
837
838 /* This function should only be called for 1542C boards - we can detect
839    the special firmware settings and unlock the board */
840
841 static int __init aha1542_mbenable(int base)
842 {
843         static unchar mbenable_cmd[3];
844         static unchar mbenable_result[2];
845         int retval;
846
847         retval = BIOS_TRANSLATION_6432;
848
849         mbenable_cmd[0] = CMD_EXTBIOS;
850         aha1542_out(base, mbenable_cmd, 1);
851         if (aha1542_in1(base, mbenable_result, 2))
852                 return retval;
853         WAITd(INTRFLAGS(base), INTRMASK, HACC, 0, 100);
854         aha1542_intr_reset(base);
855
856         if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
857                 mbenable_cmd[0] = CMD_MBENABLE;
858                 mbenable_cmd[1] = 0;
859                 mbenable_cmd[2] = mbenable_result[1];
860
861                 if ((mbenable_result[0] & 0x08) && (mbenable_result[1] & 0x03))
862                         retval = BIOS_TRANSLATION_25563;
863
864                 aha1542_out(base, mbenable_cmd, 3);
865                 WAIT(INTRFLAGS(base), INTRMASK, HACC, 0);
866         };
867         while (0) {
868 fail:
869                 printk(KERN_ERR "aha1542_mbenable: Mailbox init failed\n");
870         }
871         aha1542_intr_reset(base);
872         return retval;
873 }
874
875 /* Query the board to find out if it is a 1542 or a 1740, or whatever. */
876 static int __init aha1542_query(int base_io, int *transl)
877 {
878         unchar inquiry_cmd[] = {CMD_INQUIRY};
879         unchar inquiry_result[4];
880         int i;
881         i = inb(STATUS(base_io));
882         if (i & DF) {
883                 i = inb(DATA(base_io));
884         };
885         aha1542_out(base_io, inquiry_cmd, 1);
886         aha1542_in(base_io, inquiry_result, 4);
887         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
888         while (0) {
889 fail:
890                 printk(KERN_ERR "aha1542_detect: query card type\n");
891         }
892         aha1542_intr_reset(base_io);
893
894         *transl = BIOS_TRANSLATION_6432;        /* Default case */
895
896         /* For an AHA1740 series board, we ignore the board since there is a
897            hardware bug which can lead to wrong blocks being returned if the board
898            is operating in the 1542 emulation mode.  Since there is an extended mode
899            driver, we simply ignore the board and let the 1740 driver pick it up.
900          */
901
902         if (inquiry_result[0] == 0x43) {
903                 printk(KERN_INFO "aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
904                 return 1;
905         };
906
907         /* Always call this - boards that do not support extended bios translation
908            will ignore the command, and we will set the proper default */
909
910         *transl = aha1542_mbenable(base_io);
911
912         return 0;
913 }
914
915 #ifndef MODULE
916 static char *setup_str[MAXBOARDS] __initdata;
917 static int setup_idx = 0;
918
919 static void __init aha1542_setup(char *str, int *ints)
920 {
921         const char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
922         int setup_portbase;
923
924         if (setup_idx >= MAXBOARDS) {
925                 printk(KERN_ERR "aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
926                 printk(KERN_ERR "   Entryline 1: %s\n", setup_str[0]);
927                 printk(KERN_ERR "   Entryline 2: %s\n", setup_str[1]);
928                 printk(KERN_ERR "   This line:   %s\n", str);
929                 return;
930         }
931         if (ints[0] < 1 || ints[0] > 4) {
932                 printk(KERN_ERR "aha1542: %s\n", str);
933                 printk(ahausage);
934                 printk(KERN_ERR "aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
935         }
936         setup_called[setup_idx] = ints[0];
937         setup_str[setup_idx] = str;
938
939         setup_portbase = ints[0] >= 1 ? ints[1] : 0;    /* Preserve the default value.. */
940         setup_buson[setup_idx] = ints[0] >= 2 ? ints[2] : 7;
941         setup_busoff[setup_idx] = ints[0] >= 3 ? ints[3] : 5;
942         if (ints[0] >= 4) 
943         {
944                 int atbt = -1;
945                 switch (ints[4]) {
946                 case 5:
947                         atbt = 0x00;
948                         break;
949                 case 6:
950                         atbt = 0x04;
951                         break;
952                 case 7:
953                         atbt = 0x01;
954                         break;
955                 case 8:
956                         atbt = 0x02;
957                         break;
958                 case 10:
959                         atbt = 0x03;
960                         break;
961                 default:
962                         printk(KERN_ERR "aha1542: %s\n", str);
963                         printk(ahausage);
964                         printk(KERN_ERR "aha1542: Valid values for DMASPEED are 5-8, 10 MB/s.  Using jumper defaults.\n");
965                         break;
966                 }
967                 setup_dmaspeed[setup_idx] = atbt;
968         }
969         if (setup_portbase != 0)
970                 bases[setup_idx] = setup_portbase;
971
972         ++setup_idx;
973 }
974
975 static int __init do_setup(char *str)
976 {
977         int ints[5];
978
979         int count=setup_idx;
980
981         get_options(str, ARRAY_SIZE(ints), ints);
982         aha1542_setup(str,ints);
983
984         return count<setup_idx;
985 }
986
987 __setup("aha1542=",do_setup);
988 #endif
989
990 /* return non-zero on detection */
991 static int __init aha1542_detect(struct scsi_host_template * tpnt)
992 {
993         unsigned char dma_chan;
994         unsigned char irq_level;
995         unsigned char scsi_id;
996         unsigned long flags;
997         unsigned int base_io;
998         int trans;
999         struct Scsi_Host *shpnt = NULL;
1000         int count = 0;
1001         int indx;
1002
1003         DEB(printk("aha1542_detect: \n"));
1004
1005         tpnt->proc_name = "aha1542";
1006
1007 #ifdef MODULE
1008         bases[0] = aha1542[0];
1009         setup_buson[0] = aha1542[1];
1010         setup_busoff[0] = aha1542[2];
1011         {
1012                 int atbt = -1;
1013                 switch (aha1542[3]) {
1014                 case 5:
1015                         atbt = 0x00;
1016                         break;
1017                 case 6:
1018                         atbt = 0x04;
1019                         break;
1020                 case 7:
1021                         atbt = 0x01;
1022                         break;
1023                 case 8:
1024                         atbt = 0x02;
1025                         break;
1026                 case 10:
1027                         atbt = 0x03;
1028                         break;
1029                 };
1030                 setup_dmaspeed[0] = atbt;
1031         }
1032 #endif
1033
1034         /*
1035          *      Find MicroChannel cards (AHA1640)
1036          */
1037 #ifdef CONFIG_MCA_LEGACY
1038         if(MCA_bus) {
1039                 int slot = 0;
1040                 int pos = 0;
1041
1042                 for (indx = 0; (slot != MCA_NOTFOUND) && (indx < ARRAY_SIZE(bases)); indx++) {
1043
1044                         if (bases[indx])
1045                                 continue;
1046
1047                         /* Detect only AHA-1640 cards -- MCA ID 0F1F */
1048                         slot = mca_find_unused_adapter(0x0f1f, slot);
1049                         if (slot == MCA_NOTFOUND)
1050                                 break;
1051
1052                         /* Found one */
1053                         pos = mca_read_stored_pos(slot, 3);
1054
1055                         /* Decode address */
1056                         if (pos & 0x80) {
1057                                 if (pos & 0x02) {
1058                                         if (pos & 0x01)
1059                                                 bases[indx] = 0x334;
1060                                         else
1061                                                 bases[indx] = 0x234;
1062                                 } else {
1063                                         if (pos & 0x01)
1064                                                 bases[indx] = 0x134;
1065                                 }
1066                         } else {
1067                                 if (pos & 0x02) {
1068                                         if (pos & 0x01)
1069                                                 bases[indx] = 0x330;
1070                                         else
1071                                                 bases[indx] = 0x230;
1072                                 } else {
1073                                         if (pos & 0x01)
1074                                                 bases[indx] = 0x130;
1075                                 }
1076                         }
1077
1078                         /* No need to decode IRQ and Arb level -- those are
1079                          * read off the card later.
1080                          */
1081                         printk(KERN_INFO "Found an AHA-1640 in MCA slot %d, I/O 0x%04x\n", slot, bases[indx]);
1082
1083                         mca_set_adapter_name(slot, "Adapter AHA-1640");
1084                         mca_set_adapter_procfn(slot, NULL, NULL);
1085                         mca_mark_as_used(slot);
1086
1087                         /* Go on */
1088                         slot++;
1089                 }
1090
1091         }
1092 #endif
1093
1094         /*
1095          *      Hunt for ISA Plug'n'Pray Adaptecs (AHA1535)
1096          */
1097
1098         if(isapnp)
1099         {
1100                 struct pnp_dev *pdev = NULL;
1101                 for(indx = 0; indx < ARRAY_SIZE(bases); indx++) {
1102                         if(bases[indx])
1103                                 continue;
1104                         pdev = pnp_find_dev(NULL, ISAPNP_VENDOR('A', 'D', 'P'), 
1105                                 ISAPNP_FUNCTION(0x1542), pdev);
1106                         if(pdev==NULL)
1107                                 break;
1108                         /*
1109                          *      Activate the PnP card
1110                          */
1111
1112                         if(pnp_device_attach(pdev)<0)
1113                                 continue;
1114
1115                         if(pnp_activate_dev(pdev)<0) {
1116                                 pnp_device_detach(pdev);
1117                                 continue;
1118                         }
1119
1120                         if(!pnp_port_valid(pdev, 0)) {
1121                                 pnp_device_detach(pdev);
1122                                 continue;
1123                         }
1124
1125                         bases[indx] = pnp_port_start(pdev, 0);
1126
1127                         /* The card can be queried for its DMA, we have 
1128                            the DMA set up that is enough */
1129
1130                         printk(KERN_INFO "ISAPnP found an AHA1535 at I/O 0x%03X\n", bases[indx]);
1131                 }
1132         }
1133         for (indx = 0; indx < ARRAY_SIZE(bases); indx++)
1134                 if (bases[indx] != 0 && request_region(bases[indx], 4, "aha1542")) {
1135                         shpnt = scsi_register(tpnt,
1136                                         sizeof(struct aha1542_hostdata));
1137
1138                         if(shpnt==NULL) {
1139                                 release_region(bases[indx], 4);
1140                                 continue;
1141                         }
1142                         /* For now we do this - until kmalloc is more intelligent
1143                            we are resigned to stupid hacks like this */
1144                         if (SCSI_BUF_PA(shpnt) >= ISA_DMA_THRESHOLD) {
1145                                 printk(KERN_ERR "Invalid address for shpnt with 1542.\n");
1146                                 goto unregister;
1147                         }
1148                         if (!aha1542_test_port(bases[indx], shpnt))
1149                                 goto unregister;
1150
1151
1152                         base_io = bases[indx];
1153
1154                         /* Set the Bus on/off-times as not to ruin floppy performance */
1155                         {
1156                                 unchar oncmd[] = {CMD_BUSON_TIME, 7};
1157                                 unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
1158
1159                                 if (setup_called[indx]) {
1160                                         oncmd[1] = setup_buson[indx];
1161                                         offcmd[1] = setup_busoff[indx];
1162                                 }
1163                                 aha1542_intr_reset(base_io);
1164                                 aha1542_out(base_io, oncmd, 2);
1165                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1166                                 aha1542_intr_reset(base_io);
1167                                 aha1542_out(base_io, offcmd, 2);
1168                                 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1169                                 if (setup_dmaspeed[indx] >= 0) {
1170                                         unchar dmacmd[] = {CMD_DMASPEED, 0};
1171                                         dmacmd[1] = setup_dmaspeed[indx];
1172                                         aha1542_intr_reset(base_io);
1173                                         aha1542_out(base_io, dmacmd, 2);
1174                                         WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
1175                                 }
1176                                 while (0) {
1177 fail:
1178                                         printk(KERN_ERR "aha1542_detect: setting bus on/off-time failed\n");
1179                                 }
1180                                 aha1542_intr_reset(base_io);
1181                         }
1182                         if (aha1542_query(base_io, &trans))
1183                                 goto unregister;
1184
1185                         if (aha1542_getconfig(base_io, &irq_level, &dma_chan, &scsi_id) == -1)
1186                                 goto unregister;
1187
1188                         printk(KERN_INFO "Configuring Adaptec (SCSI-ID %d) at IO:%x, IRQ %d", scsi_id, base_io, irq_level);
1189                         if (dma_chan != 0xFF)
1190                                 printk(", DMA priority %d", dma_chan);
1191                         printk("\n");
1192
1193                         DEB(aha1542_stat());
1194                         setup_mailboxes(base_io, shpnt);
1195
1196                         DEB(aha1542_stat());
1197
1198                         DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
1199                         spin_lock_irqsave(&aha1542_lock, flags);
1200                         if (request_irq(irq_level, do_aha1542_intr_handle, 0, "aha1542", NULL)) {
1201                                 printk(KERN_ERR "Unable to allocate IRQ for adaptec controller.\n");
1202                                 spin_unlock_irqrestore(&aha1542_lock, flags);
1203                                 goto unregister;
1204                         }
1205                         if (dma_chan != 0xFF) {
1206                                 if (request_dma(dma_chan, "aha1542")) {
1207                                         printk(KERN_ERR "Unable to allocate DMA channel for Adaptec.\n");
1208                                         free_irq(irq_level, NULL);
1209                                         spin_unlock_irqrestore(&aha1542_lock, flags);
1210                                         goto unregister;
1211                                 }
1212                                 if (dma_chan == 0 || dma_chan >= 5) {
1213                                         set_dma_mode(dma_chan, DMA_MODE_CASCADE);
1214                                         enable_dma(dma_chan);
1215                                 }
1216                         }
1217                         aha_host[irq_level - 9] = shpnt;
1218                         shpnt->this_id = scsi_id;
1219                         shpnt->unique_id = base_io;
1220                         shpnt->io_port = base_io;
1221                         shpnt->n_io_port = 4;   /* Number of bytes of I/O space used */
1222                         shpnt->dma_channel = dma_chan;
1223                         shpnt->irq = irq_level;
1224                         HOSTDATA(shpnt)->bios_translation = trans;
1225                         if (trans == BIOS_TRANSLATION_25563)
1226                                 printk(KERN_INFO "aha1542.c: Using extended bios translation\n");
1227                         HOSTDATA(shpnt)->aha1542_last_mbi_used = (2 * AHA1542_MAILBOXES - 1);
1228                         HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1229                         memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1230                         spin_unlock_irqrestore(&aha1542_lock, flags);
1231 #if 0
1232                         DEB(printk(" *** READ CAPACITY ***\n"));
1233
1234                         {
1235                                 unchar buf[8];
1236                                 static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1237                                 int i;
1238
1239                                 for (i = 0; i < sizeof(buf); ++i)
1240                                         buf[i] = 0x87;
1241                                 for (i = 0; i < 2; ++i)
1242                                         if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1243                                                 printk(KERN_DEBUG "aha_detect: LU %d sector_size %d device_size %d\n",
1244                                                        i, xscsi2int(buf + 4), xscsi2int(buf));
1245                                         }
1246                         }
1247
1248                         DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1249
1250                         for (i = 0; i < 4; ++i) {
1251                                 unsigned char cmd[10];
1252                                 static buffer[512];
1253
1254                                 cmd[0] = READ_10;
1255                                 cmd[1] = 0;
1256                                 xany2scsi(cmd + 2, i);
1257                                 cmd[6] = 0;
1258                                 cmd[7] = 0;
1259                                 cmd[8] = 1;
1260                                 cmd[9] = 0;
1261                                 aha1542_command(0, cmd, buffer, 512);
1262                         }
1263 #endif
1264                         count++;
1265                         continue;
1266 unregister:
1267                         release_region(bases[indx], 4);
1268                         scsi_unregister(shpnt);
1269                         continue;
1270
1271                 };
1272
1273         return count;
1274 }
1275
1276 static int aha1542_release(struct Scsi_Host *shost)
1277 {
1278         if (shost->irq)
1279                 free_irq(shost->irq, NULL);
1280         if (shost->dma_channel != 0xff)
1281                 free_dma(shost->dma_channel);
1282         if (shost->io_port && shost->n_io_port)
1283                 release_region(shost->io_port, shost->n_io_port);
1284         scsi_unregister(shost);
1285         return 0;
1286 }
1287
1288 static int aha1542_restart(struct Scsi_Host *shost)
1289 {
1290         int i;
1291         int count = 0;
1292 #if 0
1293         unchar ahacmd = CMD_START_SCSI;
1294 #endif
1295
1296         for (i = 0; i < AHA1542_MAILBOXES; i++)
1297                 if (HOSTDATA(shost)->SCint[i] &&
1298                     !(HOSTDATA(shost)->SCint[i]->device->soft_reset)) {
1299 #if 0
1300                         HOSTDATA(shost)->mb[i].status = 1;      /* Indicate ready to restart... */
1301 #endif
1302                         count++;
1303                 }
1304         printk(KERN_DEBUG "Potential to restart %d stalled commands...\n", count);
1305 #if 0
1306         /* start scsi command */
1307         if (count)
1308                 aha1542_out(shost->io_port, &ahacmd, 1);
1309 #endif
1310         return 0;
1311 }
1312
1313 /*
1314  * This is a device reset.  This is handled by sending a special command
1315  * to the device.
1316  */
1317 static int aha1542_dev_reset(Scsi_Cmnd * SCpnt)
1318 {
1319         unsigned long flags;
1320         struct mailbox *mb;
1321         unchar target = SCpnt->device->id;
1322         unchar lun = SCpnt->device->lun;
1323         int mbo;
1324         struct ccb *ccb;
1325         unchar ahacmd = CMD_START_SCSI;
1326
1327         ccb = HOSTDATA(SCpnt->device->host)->ccb;
1328         mb = HOSTDATA(SCpnt->device->host)->mb;
1329
1330         spin_lock_irqsave(&aha1542_lock, flags);
1331         mbo = HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used + 1;
1332         if (mbo >= AHA1542_MAILBOXES)
1333                 mbo = 0;
1334
1335         do {
1336                 if (mb[mbo].status == 0 && HOSTDATA(SCpnt->device->host)->SCint[mbo] == NULL)
1337                         break;
1338                 mbo++;
1339                 if (mbo >= AHA1542_MAILBOXES)
1340                         mbo = 0;
1341         } while (mbo != HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used);
1342
1343         if (mb[mbo].status || HOSTDATA(SCpnt->device->host)->SCint[mbo])
1344                 panic("Unable to find empty mailbox for aha1542.\n");
1345
1346         HOSTDATA(SCpnt->device->host)->SCint[mbo] = SCpnt;      /* This will effectively
1347                                                            prevent someone else from
1348                                                            screwing with this cdb. */
1349
1350         HOSTDATA(SCpnt->device->host)->aha1542_last_mbo_used = mbo;
1351         spin_unlock_irqrestore(&aha1542_lock, flags);
1352
1353         any2scsi(mb[mbo].ccbptr, SCSI_BUF_PA(&ccb[mbo]));       /* This gets trashed for some reason */
1354
1355         memset(&ccb[mbo], 0, sizeof(struct ccb));
1356
1357         ccb[mbo].op = 0x81;     /* BUS DEVICE RESET */
1358
1359         ccb[mbo].idlun = (target & 7) << 5 | (lun & 7);         /*SCSI Target Id */
1360
1361         ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
1362         ccb[mbo].commlinkid = 0;
1363
1364         /* 
1365          * Now tell the 1542 to flush all pending commands for this 
1366          * target 
1367          */
1368         aha1542_out(SCpnt->device->host->io_port, &ahacmd, 1);
1369
1370         scmd_printk(KERN_WARNING, SCpnt,
1371                 "Trying device reset for target\n");
1372
1373         return SUCCESS;
1374
1375
1376 #ifdef ERIC_neverdef
1377         /* 
1378          * With the 1542 we apparently never get an interrupt to
1379          * acknowledge a device reset being sent.  Then again, Leonard
1380          * says we are doing this wrong in the first place...
1381          *
1382          * Take a wait and see attitude.  If we get spurious interrupts,
1383          * then the device reset is doing something sane and useful, and
1384          * we will wait for the interrupt to post completion.
1385          */
1386         printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1387
1388         /*
1389          * Free the command block for all commands running on this 
1390          * target... 
1391          */
1392         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1393                 if (HOSTDATA(SCpnt->host)->SCint[i] &&
1394                     HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1395                         Scsi_Cmnd *SCtmp;
1396                         SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1397                         kfree(SCtmp->host_scribble);
1398                         SCtmp->host_scribble = NULL;
1399                         HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1400                         HOSTDATA(SCpnt->host)->mb[i].status = 0;
1401                 }
1402         }
1403         return SUCCESS;
1404
1405         return FAILED;
1406 #endif                          /* ERIC_neverdef */
1407 }
1408
1409 static int aha1542_bus_reset(Scsi_Cmnd * SCpnt)
1410 {
1411         int i;
1412
1413         /* 
1414          * This does a scsi reset for all devices on the bus.
1415          * In principle, we could also reset the 1542 - should
1416          * we do this?  Try this first, and we can add that later
1417          * if it turns out to be useful.
1418          */
1419         outb(SCRST, CONTROL(SCpnt->device->host->io_port));
1420
1421         /*
1422          * Wait for the thing to settle down a bit.  Unfortunately
1423          * this is going to basically lock up the machine while we
1424          * wait for this to complete.  To be 100% correct, we need to
1425          * check for timeout, and if we are doing something like this
1426          * we are pretty desperate anyways.
1427          */
1428         ssleep(4);
1429
1430         spin_lock_irq(SCpnt->device->host->host_lock);
1431
1432         WAIT(STATUS(SCpnt->device->host->io_port),
1433              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1434
1435         /*
1436          * Now try to pick up the pieces.  For all pending commands,
1437          * free any internal data structures, and basically clear things
1438          * out.  We do not try and restart any commands or anything - 
1439          * the strategy handler takes care of that crap.
1440          */
1441         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1442
1443         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1444                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1445                         Scsi_Cmnd *SCtmp;
1446                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1447
1448
1449                         if (SCtmp->device->soft_reset) {
1450                                 /*
1451                                  * If this device implements the soft reset option,
1452                                  * then it is still holding onto the command, and
1453                                  * may yet complete it.  In this case, we don't
1454                                  * flush the data.
1455                                  */
1456                                 continue;
1457                         }
1458                         kfree(SCtmp->host_scribble);
1459                         SCtmp->host_scribble = NULL;
1460                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1461                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1462                 }
1463         }
1464
1465         spin_unlock_irq(SCpnt->device->host->host_lock);
1466         return SUCCESS;
1467
1468 fail:
1469         spin_unlock_irq(SCpnt->device->host->host_lock);
1470         return FAILED;
1471 }
1472
1473 static int aha1542_host_reset(Scsi_Cmnd * SCpnt)
1474 {
1475         int i;
1476
1477         /* 
1478          * This does a scsi reset for all devices on the bus.
1479          * In principle, we could also reset the 1542 - should
1480          * we do this?  Try this first, and we can add that later
1481          * if it turns out to be useful.
1482          */
1483         outb(HRST | SCRST, CONTROL(SCpnt->device->host->io_port));
1484
1485         /*
1486          * Wait for the thing to settle down a bit.  Unfortunately
1487          * this is going to basically lock up the machine while we
1488          * wait for this to complete.  To be 100% correct, we need to
1489          * check for timeout, and if we are doing something like this
1490          * we are pretty desperate anyways.
1491          */
1492         ssleep(4);
1493         spin_lock_irq(SCpnt->device->host->host_lock);
1494
1495         WAIT(STATUS(SCpnt->device->host->io_port),
1496              STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1497
1498         /*
1499          * We need to do this too before the 1542 can interact with
1500          * us again.
1501          */
1502         setup_mailboxes(SCpnt->device->host->io_port, SCpnt->device->host);
1503
1504         /*
1505          * Now try to pick up the pieces.  For all pending commands,
1506          * free any internal data structures, and basically clear things
1507          * out.  We do not try and restart any commands or anything - 
1508          * the strategy handler takes care of that crap.
1509          */
1510         printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->device->host->host_no);
1511
1512         for (i = 0; i < AHA1542_MAILBOXES; i++) {
1513                 if (HOSTDATA(SCpnt->device->host)->SCint[i] != NULL) {
1514                         Scsi_Cmnd *SCtmp;
1515                         SCtmp = HOSTDATA(SCpnt->device->host)->SCint[i];
1516
1517                         if (SCtmp->device->soft_reset) {
1518                                 /*
1519                                  * If this device implements the soft reset option,
1520                                  * then it is still holding onto the command, and
1521                                  * may yet complete it.  In this case, we don't
1522                                  * flush the data.
1523                                  */
1524                                 continue;
1525                         }
1526                         kfree(SCtmp->host_scribble);
1527                         SCtmp->host_scribble = NULL;
1528                         HOSTDATA(SCpnt->device->host)->SCint[i] = NULL;
1529                         HOSTDATA(SCpnt->device->host)->mb[i].status = 0;
1530                 }
1531         }
1532
1533         spin_unlock_irq(SCpnt->device->host->host_lock);
1534         return SUCCESS;
1535
1536 fail:
1537         spin_unlock_irq(SCpnt->device->host->host_lock);
1538         return FAILED;
1539 }
1540
1541 #if 0
1542 /*
1543  * These are the old error handling routines.  They are only temporarily
1544  * here while we play with the new error handling code.
1545  */
1546 static int aha1542_old_abort(Scsi_Cmnd * SCpnt)
1547 {
1548 #if 0
1549         unchar ahacmd = CMD_START_SCSI;
1550         unsigned long flags;
1551         struct mailbox *mb;
1552         int mbi, mbo, i;
1553
1554         printk(KERN_DEBUG "In aha1542_abort: %x %x\n",
1555                inb(STATUS(SCpnt->host->io_port)),
1556                inb(INTRFLAGS(SCpnt->host->io_port)));
1557
1558         spin_lock_irqsave(&aha1542_lock, flags);
1559         mb = HOSTDATA(SCpnt->host)->mb;
1560         mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1561         if (mbi >= 2 * AHA1542_MAILBOXES)
1562                 mbi = AHA1542_MAILBOXES;
1563
1564         do {
1565                 if (mb[mbi].status != 0)
1566                         break;
1567                 mbi++;
1568                 if (mbi >= 2 * AHA1542_MAILBOXES)
1569                         mbi = AHA1542_MAILBOXES;
1570         } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1571         spin_unlock_irqrestore(&aha1542_lock, flags);
1572
1573         if (mb[mbi].status) {
1574                 printk(KERN_ERR "Lost interrupt discovered on irq %d - attempting to recover\n",
1575                        SCpnt->host->irq);
1576                 aha1542_intr_handle(SCpnt->host, NULL);
1577                 return 0;
1578         }
1579         /* OK, no lost interrupt.  Try looking to see how many pending commands
1580            we think we have. */
1581
1582         for (i = 0; i < AHA1542_MAILBOXES; i++)
1583                 if (HOSTDATA(SCpnt->host)->SCint[i]) {
1584                         if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1585                                 printk(KERN_ERR "Timed out command pending for %s\n",
1586                                        SCpnt->request->rq_disk ?
1587                                        SCpnt->request->rq_disk->disk_name : "?"
1588                                        );
1589                                 if (HOSTDATA(SCpnt->host)->mb[i].status) {
1590                                         printk(KERN_ERR "OGMB still full - restarting\n");
1591                                         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1592                                 };
1593                         } else
1594                                 printk(KERN_ERR "Other pending command %s\n",
1595                                        SCpnt->request->rq_disk ?
1596                                        SCpnt->request->rq_disk->disk_name : "?"
1597                                        );
1598                 }
1599 #endif
1600
1601         DEB(printk("aha1542_abort\n"));
1602 #if 0
1603         spin_lock_irqsave(&aha1542_lock, flags);
1604         for (mbo = 0; mbo < AHA1542_MAILBOXES; mbo++) {
1605                 if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]) {
1606                         mb[mbo].status = 2;     /* Abort command */
1607                         aha1542_out(SCpnt->host->io_port, &ahacmd, 1);  /* start scsi command */
1608                         spin_unlock_irqrestore(&aha1542_lock, flags);
1609                         break;
1610                 }
1611         }
1612         if (AHA1542_MAILBOXES == mbo)
1613                 spin_unlock_irqrestore(&aha1542_lock, flags);
1614 #endif
1615         return SCSI_ABORT_SNOOZE;
1616 }
1617
1618 /* We do not implement a reset function here, but the upper level code
1619    assumes that it will get some kind of response for the command in
1620    SCpnt.  We must oblige, or the command will hang the scsi system.
1621    For a first go, we assume that the 1542 notifies us with all of the
1622    pending commands (it does implement soft reset, after all). */
1623
1624 static int aha1542_old_reset(Scsi_Cmnd * SCpnt, unsigned int reset_flags)
1625 {
1626         unchar ahacmd = CMD_START_SCSI;
1627         int i;
1628
1629         /*
1630          * See if a bus reset was suggested.
1631          */
1632         if (reset_flags & SCSI_RESET_SUGGEST_BUS_RESET) {
1633                 /* 
1634                  * This does a scsi reset for all devices on the bus.
1635                  * In principle, we could also reset the 1542 - should
1636                  * we do this?  Try this first, and we can add that later
1637                  * if it turns out to be useful.
1638                  */
1639                 outb(HRST | SCRST, CONTROL(SCpnt->host->io_port));
1640
1641                 /*
1642                  * Wait for the thing to settle down a bit.  Unfortunately
1643                  * this is going to basically lock up the machine while we
1644                  * wait for this to complete.  To be 100% correct, we need to
1645                  * check for timeout, and if we are doing something like this
1646                  * we are pretty desperate anyways.
1647                  */
1648                 WAIT(STATUS(SCpnt->host->io_port),
1649                 STATMASK, INIT | IDLE, STST | DIAGF | INVDCMD | DF | CDF);
1650
1651                 /*
1652                  * We need to do this too before the 1542 can interact with
1653                  * us again.
1654                  */
1655                 setup_mailboxes(SCpnt->host->io_port, SCpnt->host);
1656
1657                 /*
1658                  * Now try to pick up the pieces.  Restart all commands
1659                  * that are currently active on the bus, and reset all of
1660                  * the datastructures.  We have some time to kill while
1661                  * things settle down, so print a nice message.
1662                  */
1663                 printk(KERN_WARNING "Sent BUS RESET to scsi host %d\n", SCpnt->host->host_no);
1664
1665                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1666                         if (HOSTDATA(SCpnt->host)->SCint[i] != NULL) {
1667                                 Scsi_Cmnd *SCtmp;
1668                                 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1669                                 SCtmp->result = DID_RESET << 16;
1670                                 kfree(SCtmp->host_scribble);
1671                                 SCtmp->host_scribble = NULL;
1672                                 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1673                                 SCtmp->scsi_done(SCpnt);
1674
1675                                 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1676                                 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1677                         }
1678                 /*
1679                  * Now tell the mid-level code what we did here.  Since
1680                  * we have restarted all of the outstanding commands,
1681                  * then report SUCCESS.
1682                  */
1683                 return (SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET);
1684 fail:
1685                 printk(KERN_CRIT "aha1542.c: Unable to perform hard reset.\n");
1686                 printk(KERN_CRIT "Power cycle machine to reset\n");
1687                 return (SCSI_RESET_ERROR | SCSI_RESET_BUS_RESET);
1688
1689
1690         } else {
1691                 /* This does a selective reset of just the one device */
1692                 /* First locate the ccb for this command */
1693                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1694                         if (HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1695                                 HOSTDATA(SCpnt->host)->ccb[i].op = 0x81;        /* BUS DEVICE RESET */
1696                                 /* Now tell the 1542 to flush all pending commands for this target */
1697                                 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1698
1699                                 /* Here is the tricky part.  What to do next.  Do we get an interrupt
1700                                    for the commands that we aborted with the specified target, or
1701                                    do we generate this on our own?  Try it without first and see
1702                                    what happens */
1703                                 printk(KERN_WARNING "Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1704
1705                                 /* If the first does not work, then try the second.  I think the
1706                                    first option is more likely to be correct. Free the command
1707                                    block for all commands running on this target... */
1708                                 for (i = 0; i < AHA1542_MAILBOXES; i++)
1709                                         if (HOSTDATA(SCpnt->host)->SCint[i] &&
1710                                             HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target) {
1711                                                 Scsi_Cmnd *SCtmp;
1712                                                 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1713                                                 SCtmp->result = DID_RESET << 16;
1714                                                 kfree(SCtmp->host_scribble);
1715                                                 SCtmp->host_scribble = NULL;
1716                                                 printk(KERN_WARNING "Sending DID_RESET for target %d\n", SCpnt->target);
1717                                                 SCtmp->scsi_done(SCpnt);
1718
1719                                                 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1720                                                 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1721                                         }
1722                                 return SCSI_RESET_SUCCESS;
1723                         }
1724         }
1725         /* No active command at this time, so this means that each time we got
1726            some kind of response the last time through.  Tell the mid-level code
1727            to request sense information in order to decide what to do next. */
1728         return SCSI_RESET_PUNT;
1729 }
1730 #endif    /* end of big comment block around old_abort + old_reset */
1731
1732 static int aha1542_biosparam(struct scsi_device *sdev,
1733                 struct block_device *bdev, sector_t capacity, int *ip)
1734 {
1735         int translation_algorithm;
1736         int size = capacity;
1737
1738         translation_algorithm = HOSTDATA(sdev->host)->bios_translation;
1739
1740         if ((size >> 11) > 1024 && translation_algorithm == BIOS_TRANSLATION_25563) {
1741                 /* Please verify that this is the same as what DOS returns */
1742                 ip[0] = 255;
1743                 ip[1] = 63;
1744                 ip[2] = size / 255 / 63;
1745         } else {
1746                 ip[0] = 64;
1747                 ip[1] = 32;
1748                 ip[2] = size >> 11;
1749         }
1750
1751         return 0;
1752 }
1753 MODULE_LICENSE("GPL");
1754
1755
1756 static struct scsi_host_template driver_template = {
1757         .proc_name              = "aha1542",
1758         .name                   = "Adaptec 1542",
1759         .detect                 = aha1542_detect,
1760         .release                = aha1542_release,
1761         .queuecommand           = aha1542_queuecommand,
1762         .eh_device_reset_handler= aha1542_dev_reset,
1763         .eh_bus_reset_handler   = aha1542_bus_reset,
1764         .eh_host_reset_handler  = aha1542_host_reset,
1765         .bios_param             = aha1542_biosparam,
1766         .can_queue              = AHA1542_MAILBOXES, 
1767         .this_id                = 7,
1768         .sg_tablesize           = AHA1542_SCATTER,
1769         .cmd_per_lun            = AHA1542_CMDLUN,
1770         .unchecked_isa_dma      = 1, 
1771         .use_clustering         = ENABLE_CLUSTERING,
1772 };
1773 #include "scsi_module.c"