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