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