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