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