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