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