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