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