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