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