This source file includes following definitions.
- aha1542_stat
- aha1542_out
- aha1542_in
- aha1542_in1
- makecode
- aha1542_test_port
- aha1542_intr_handle
- aha1542_queuecommand
- internal_done
- aha1542_command
- setup_mailboxes
- aha1542_getconfig
- aha1542_mbenable
- aha1542_query
- aha1542_setup
- aha1542_detect
- aha1542_restart
- aha1542_abort
- aha1542_reset
- aha1542_biosparam
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 #ifdef MODULE
18 #include <linux/autoconf.h>
19 #include <linux/module.h>
20 #endif
21
22 #include <linux/kernel.h>
23 #include <linux/head.h>
24 #include <linux/types.h>
25 #include <linux/string.h>
26 #include <linux/ioport.h>
27 #include <linux/delay.h>
28 #include <linux/sched.h>
29 #include <linux/proc_fs.h>
30 #include <asm/dma.h>
31 #include <asm/system.h>
32 #include <asm/io.h>
33 #include "../block/blk.h"
34 #include "scsi.h"
35 #include "hosts.h"
36
37
38 #include "aha1542.h"
39
40 #ifdef DEBUG
41 #define DEB(x) x
42 #else
43 #define DEB(x)
44 #endif
45
46
47
48
49
50
51
52
53
54 #define MAXBOARDS 2
55
56
57 static unsigned int bases[MAXBOARDS]={0x330, 0x334};
58
59
60 static int setup_called[MAXBOARDS] = {0,0};
61 static int setup_buson[MAXBOARDS] = {0,0};
62 static int setup_busoff[MAXBOARDS] = {0,0};
63 static int setup_dmaspeed[MAXBOARDS] = {-1,-1};
64
65 static char *setup_str[MAXBOARDS] = {(char *)NULL,(char *)NULL};
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87 #define DMA_MODE_REG 0xd6
88 #define DMA_MASK_REG 0xd4
89 #define CASCADE 0xc0
90
91 #define BIOS_TRANSLATION_1632 0
92 #define BIOS_TRANSLATION_6432 1
93 #define BIOS_TRANSLATION_25563 2
94
95 struct aha1542_hostdata{
96
97 int bios_translation;
98 int aha1542_last_mbi_used;
99 int aha1542_last_mbo_used;
100 Scsi_Cmnd * SCint[AHA1542_MAILBOXES];
101 struct mailbox mb[2*AHA1542_MAILBOXES];
102 struct ccb ccb[AHA1542_MAILBOXES];
103 };
104
105 #define HOSTDATA(host) ((struct aha1542_hostdata *) &host->hostdata)
106
107 static struct Scsi_Host * aha_host[7] = {NULL,};
108
109
110
111
112 #define WAITnexttimeout 3000000
113
114 static void setup_mailboxes(int base_io, struct Scsi_Host * shpnt);
115 static int aha1542_restart(struct Scsi_Host * shost);
116
117 #define aha1542_intr_reset(base) outb(IRST, CONTROL(base))
118
119 #define WAIT(port, mask, allof, noneof) \
120 { register WAITbits; \
121 register WAITtimeout = WAITnexttimeout; \
122 while (1) { \
123 WAITbits = inb(port) & (mask); \
124 if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
125 break; \
126 if (--WAITtimeout == 0) goto fail; \
127 } \
128 }
129
130
131
132 #define WAITd(port, mask, allof, noneof, timeout) \
133 { register WAITbits; \
134 register WAITtimeout = timeout; \
135 while (1) { \
136 WAITbits = inb(port) & (mask); \
137 if ((WAITbits & (allof)) == (allof) && ((WAITbits & (noneof)) == 0)) \
138 break; \
139 udelay(1000); \
140 if (--WAITtimeout == 0) goto fail; \
141 } \
142 }
143
144 static void aha1542_stat(void)
145 {
146
147
148 }
149
150
151
152
153
154 static int aha1542_out(unsigned int base, unchar *cmdp, int len)
155 {
156 unsigned long flags = 0;
157
158 if(len == 1) {
159 while(1==1){
160 WAIT(STATUS(base), CDF, 0, CDF);
161 save_flags(flags);
162 cli();
163 if(inb(STATUS(base)) & CDF) {restore_flags(flags); continue;}
164 outb(*cmdp, DATA(base));
165 restore_flags(flags);
166 return 0;
167 }
168 } else {
169 save_flags(flags);
170 cli();
171 while (len--)
172 {
173 WAIT(STATUS(base), CDF, 0, CDF);
174 outb(*cmdp++, DATA(base));
175 }
176 restore_flags(flags);
177 }
178 return 0;
179 fail:
180 restore_flags(flags);
181 printk("aha1542_out failed(%d): ", len+1); aha1542_stat();
182 return 1;
183 }
184
185
186
187 static int aha1542_in(unsigned int base, unchar *cmdp, int len)
188 {
189 unsigned long flags;
190
191 save_flags(flags);
192 cli();
193 while (len--)
194 {
195 WAIT(STATUS(base), DF, DF, 0);
196 *cmdp++ = inb(DATA(base));
197 }
198 restore_flags(flags);
199 return 0;
200 fail:
201 restore_flags(flags);
202 printk("aha1542_in failed(%d): ", len+1); aha1542_stat();
203 return 1;
204 }
205
206
207
208
209 static int aha1542_in1(unsigned int base, unchar *cmdp, int len)
210 {
211 unsigned long flags;
212
213 save_flags(flags);
214 cli();
215 while (len--)
216 {
217 WAITd(STATUS(base), DF, DF, 0, 100);
218 *cmdp++ = inb(DATA(base));
219 }
220 restore_flags(flags);
221 return 0;
222 fail:
223 restore_flags(flags);
224 return 1;
225 }
226
227 static int makecode(unsigned hosterr, unsigned scsierr)
228 {
229 switch (hosterr) {
230 case 0x0:
231 case 0xa:
232 case 0xb:
233 hosterr = 0;
234 break;
235
236 case 0x11:
237
238 hosterr = DID_TIME_OUT;
239 break;
240
241 case 0x12:
242
243
244
245 case 0x13:
246
247 case 0x15:
248
249
250 case 0x16:
251
252
253 case 0x17:
254
255
256 case 0x18:
257
258
259 case 0x19:
260
261
262
263 case 0x1a:
264
265
266 DEB(printk("Aha1542: %x %x\n", hosterr, scsierr));
267 hosterr = DID_ERROR;
268 break;
269
270 case 0x14:
271
272
273
274 hosterr = DID_RESET;
275 break;
276 default:
277 printk("makecode: unknown hoststatus %x\n", hosterr);
278 break;
279 }
280 return scsierr|(hosterr << 16);
281 }
282
283 static int aha1542_test_port(int bse, struct Scsi_Host * shpnt)
284 {
285 int i;
286 unchar inquiry_cmd[] = {CMD_INQUIRY };
287 unchar inquiry_result[4];
288 unchar *cmdp;
289 int len;
290 volatile int debug = 0;
291
292
293 if(inb(STATUS(bse)) == 0xff) return 0;
294
295
296
297
298
299
300 aha1542_intr_reset(bse);
301
302 outb(SRST|IRST, CONTROL(bse));
303
304 i = jiffies + 2;
305 while (i>jiffies);
306
307 debug = 1;
308
309 WAIT(STATUS(bse), STATMASK, INIT|IDLE, STST|DIAGF|INVDCMD|DF|CDF);
310
311 debug = 2;
312
313 if (inb(INTRFLAGS(bse))&INTRMASK) goto fail;
314
315
316
317
318
319 aha1542_out(bse, inquiry_cmd, 1);
320
321 debug = 3;
322 len = 4;
323 cmdp = &inquiry_result[0];
324
325 while (len--)
326 {
327 WAIT(STATUS(bse), DF, DF, 0);
328 *cmdp++ = inb(DATA(bse));
329 }
330
331 debug = 8;
332
333 if (inb(STATUS(bse)) & DF) goto fail;
334
335 debug = 9;
336
337 WAIT(INTRFLAGS(bse), HACC, HACC, 0);
338
339
340 debug = 10;
341
342 outb(IRST, CONTROL(bse));
343
344 debug = 11;
345
346 return debug;
347 fail:
348 return 0;
349 }
350
351
352 static void aha1542_intr_handle(int irq, struct pt_regs *regs)
353 {
354 void (*my_done)(Scsi_Cmnd *) = NULL;
355 int errstatus, mbi, mbo, mbistatus;
356 int number_serviced;
357 unsigned int flags;
358 struct Scsi_Host * shost;
359 Scsi_Cmnd * SCtmp;
360 int flag;
361 int needs_restart;
362 struct mailbox * mb;
363 struct ccb *ccb;
364
365 shost = aha_host[irq - 9];
366 if(!shost) panic("Splunge!");
367
368 mb = HOSTDATA(shost)->mb;
369 ccb = HOSTDATA(shost)->ccb;
370
371 #ifdef DEBUG
372 {
373 flag = inb(INTRFLAGS(shost->io_port));
374 printk("aha1542_intr_handle: ");
375 if (!(flag&ANYINTR)) printk("no interrupt?");
376 if (flag&MBIF) printk("MBIF ");
377 if (flag&MBOA) printk("MBOF ");
378 if (flag&HACC) printk("HACC ");
379 if (flag&SCRD) printk("SCRD ");
380 printk("status %02x\n", inb(STATUS(shost->io_port)));
381 };
382 #endif
383 number_serviced = 0;
384 needs_restart = 0;
385
386 while(1==1){
387 flag = inb(INTRFLAGS(shost->io_port));
388
389
390
391
392
393 if (flag & ~MBIF) {
394 if (flag&MBOA) printk("MBOF ");
395 if (flag&HACC) printk("HACC ");
396 if (flag&SCRD) {
397 needs_restart = 1;
398 printk("SCRD ");
399 }
400 }
401
402 aha1542_intr_reset(shost->io_port);
403
404 save_flags(flags);
405 cli();
406 mbi = HOSTDATA(shost)->aha1542_last_mbi_used + 1;
407 if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
408
409 do{
410 if(mb[mbi].status != 0) break;
411 mbi++;
412 if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
413 } while (mbi != HOSTDATA(shost)->aha1542_last_mbi_used);
414
415 if(mb[mbi].status == 0){
416 restore_flags(flags);
417
418 if (!number_serviced && !needs_restart)
419 printk("aha1542.c: interrupt received, but no mail.\n");
420
421
422 if(needs_restart) aha1542_restart(shost);
423 return;
424 };
425
426 mbo = (scsi2int(mb[mbi].ccbptr) - ((unsigned int) &ccb[0])) / sizeof(struct ccb);
427 mbistatus = mb[mbi].status;
428 mb[mbi].status = 0;
429 HOSTDATA(shost)->aha1542_last_mbi_used = mbi;
430 restore_flags(flags);
431
432 #ifdef DEBUG
433 {
434 if (ccb[mbo].tarstat|ccb[mbo].hastat)
435 printk("aha1542_command: returning %x (status %d)\n",
436 ccb[mbo].tarstat + ((int) ccb[mbo].hastat << 16), mb[mbi].status);
437 };
438 #endif
439
440 if(mbistatus == 3) continue;
441
442 #ifdef DEBUG
443 printk("...done %d %d\n",mbo, mbi);
444 #endif
445
446 SCtmp = HOSTDATA(shost)->SCint[mbo];
447
448 if (!SCtmp || !SCtmp->scsi_done) {
449 printk("aha1542_intr_handle: Unexpected interrupt\n");
450 printk("tarstat=%x, hastat=%x idlun=%x ccb#=%d \n", ccb[mbo].tarstat,
451 ccb[mbo].hastat, ccb[mbo].idlun, mbo);
452 return;
453 }
454
455 my_done = SCtmp->scsi_done;
456 if (SCtmp->host_scribble) scsi_free(SCtmp->host_scribble, 512);
457
458
459
460
461 if (ccb[mbo].tarstat == 2)
462 memcpy(SCtmp->sense_buffer, &ccb[mbo].cdb[ccb[mbo].cdblen],
463 sizeof(SCtmp->sense_buffer));
464
465
466
467
468
469 if (mbistatus != 1)
470
471 errstatus = makecode(ccb[mbo].hastat, ccb[mbo].tarstat);
472 else
473 errstatus = 0;
474
475 #ifdef DEBUG
476 if(errstatus) printk("(aha1542 error:%x %x %x) ",errstatus,
477 ccb[mbo].hastat, ccb[mbo].tarstat);
478 #endif
479
480 if (ccb[mbo].tarstat == 2) {
481 #ifdef DEBUG
482 int i;
483 #endif
484 DEB(printk("aha1542_intr_handle: sense:"));
485 #ifdef DEBUG
486 for (i = 0; i < 12; i++)
487 printk("%02x ", ccb[mbo].cdb[ccb[mbo].cdblen+i]);
488 printk("\n");
489 #endif
490
491
492
493
494
495
496 }
497 DEB(if (errstatus) printk("aha1542_intr_handle: returning %6x\n", errstatus));
498 SCtmp->result = errstatus;
499 HOSTDATA(shost)->SCint[mbo] = NULL;
500
501 my_done(SCtmp);
502 number_serviced++;
503 };
504 }
505
506 int aha1542_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
507 {
508 unchar ahacmd = CMD_START_SCSI;
509 unchar direction;
510 unchar *cmd = (unchar *) SCpnt->cmnd;
511 unchar target = SCpnt->target;
512 unchar lun = SCpnt->lun;
513 unsigned long flags;
514 void *buff = SCpnt->request_buffer;
515 int bufflen = SCpnt->request_bufflen;
516 int mbo;
517 struct mailbox * mb;
518 struct ccb *ccb;
519
520 DEB(int i);
521
522 mb = HOSTDATA(SCpnt->host)->mb;
523 ccb = HOSTDATA(SCpnt->host)->ccb;
524
525 DEB(if (target > 1) {
526 SCpnt->result = DID_TIME_OUT << 16;
527 done(SCpnt); return 0;});
528
529 if(*cmd == REQUEST_SENSE){
530 #ifndef DEBUG
531 if (bufflen != sizeof(SCpnt->sense_buffer)) {
532 printk("Wrong buffer length supplied for request sense (%d)\n",bufflen);
533 };
534 #endif
535 SCpnt->result = 0;
536 done(SCpnt);
537 return 0;
538 };
539
540 #ifdef DEBUG
541 if (*cmd == READ_10 || *cmd == WRITE_10)
542 i = xscsi2int(cmd+2);
543 else if (*cmd == READ_6 || *cmd == WRITE_6)
544 i = scsi2int(cmd+2);
545 else
546 i = -1;
547 if (done)
548 printk("aha1542_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
549 else
550 printk("aha1542_command: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
551 aha1542_stat();
552 printk("aha1542_queuecommand: dumping scsi cmd:");
553 for (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
554 printk("\n");
555 if (*cmd == WRITE_10 || *cmd == WRITE_6)
556 return 0;
557 #endif
558
559
560
561 save_flags(flags);
562 cli();
563 mbo = HOSTDATA(SCpnt->host)->aha1542_last_mbo_used + 1;
564 if (mbo >= AHA1542_MAILBOXES) mbo = 0;
565
566 do{
567 if(mb[mbo].status == 0 && HOSTDATA(SCpnt->host)->SCint[mbo] == NULL)
568 break;
569 mbo++;
570 if (mbo >= AHA1542_MAILBOXES) mbo = 0;
571 } while (mbo != HOSTDATA(SCpnt->host)->aha1542_last_mbo_used);
572
573 if(mb[mbo].status || HOSTDATA(SCpnt->host)->SCint[mbo])
574 panic("Unable to find empty mailbox for aha1542.\n");
575
576 HOSTDATA(SCpnt->host)->SCint[mbo] = SCpnt;
577
578
579 HOSTDATA(SCpnt->host)->aha1542_last_mbo_used = mbo;
580 restore_flags(flags);
581
582 #ifdef DEBUG
583 printk("Sending command (%d %x)...",mbo, done);
584 #endif
585
586 any2scsi(mb[mbo].ccbptr, &ccb[mbo]);
587
588 memset(&ccb[mbo], 0, sizeof(struct ccb));
589
590 ccb[mbo].cdblen = SCpnt->cmd_len;
591
592 direction = 0;
593 if (*cmd == READ_10 || *cmd == READ_6)
594 direction = 8;
595 else if (*cmd == WRITE_10 || *cmd == WRITE_6)
596 direction = 16;
597
598 memcpy(ccb[mbo].cdb, cmd, ccb[mbo].cdblen);
599
600 if (SCpnt->use_sg) {
601 struct scatterlist * sgpnt;
602 struct chain * cptr;
603 #ifdef DEBUG
604 unsigned char * ptr;
605 #endif
606 int i;
607 ccb[mbo].op = 2;
608 SCpnt->host_scribble = (unsigned char *) scsi_malloc(512);
609 sgpnt = (struct scatterlist *) SCpnt->request_buffer;
610 cptr = (struct chain *) SCpnt->host_scribble;
611 if (cptr == NULL) panic("aha1542.c: unable to allocate DMA memory\n");
612 for(i=0; i<SCpnt->use_sg; i++) {
613 if(sgpnt[i].length == 0 || SCpnt->use_sg > 16 ||
614 (((int)sgpnt[i].address) & 1) || (sgpnt[i].length & 1)){
615 unsigned char * ptr;
616 printk("Bad segment list supplied to aha1542.c (%d, %d)\n",SCpnt->use_sg,i);
617 for(i=0;i<SCpnt->use_sg;i++){
618 printk("%d: %x %x %d\n",i,(unsigned int) sgpnt[i].address, (unsigned int) sgpnt[i].alt_address,
619 sgpnt[i].length);
620 };
621 printk("cptr %x: ",(unsigned int) cptr);
622 ptr = (unsigned char *) &cptr[i];
623 for(i=0;i<18;i++) printk("%02x ", ptr[i]);
624 panic("Foooooooood fight!");
625 };
626 any2scsi(cptr[i].dataptr, sgpnt[i].address);
627 if(((unsigned int) sgpnt[i].address) & 0xff000000) goto baddma;
628 any2scsi(cptr[i].datalen, sgpnt[i].length);
629 };
630 any2scsi(ccb[mbo].datalen, SCpnt->use_sg * sizeof(struct chain));
631 any2scsi(ccb[mbo].dataptr, cptr);
632 #ifdef DEBUG
633 printk("cptr %x: ",cptr);
634 ptr = (unsigned char *) cptr;
635 for(i=0;i<18;i++) printk("%02x ", ptr[i]);
636 #endif
637 } else {
638 ccb[mbo].op = 0;
639 SCpnt->host_scribble = NULL;
640 any2scsi(ccb[mbo].datalen, bufflen);
641 if(((unsigned int) buff & 0xff000000)) goto baddma;
642 any2scsi(ccb[mbo].dataptr, buff);
643 };
644 ccb[mbo].idlun = (target&7)<<5 | direction | (lun & 7);
645 ccb[mbo].rsalen = 12;
646 ccb[mbo].linkptr[0] = ccb[mbo].linkptr[1] = ccb[mbo].linkptr[2] = 0;
647 ccb[mbo].commlinkid = 0;
648
649 #ifdef DEBUG
650 { int i;
651 printk("aha1542_command: sending.. ");
652 for (i = 0; i < sizeof(ccb[mbo])-10; i++)
653 printk("%02x ", ((unchar *)&ccb[mbo])[i]);
654 };
655 #endif
656
657 if (done) {
658 DEB(printk("aha1542_queuecommand: now waiting for interrupt "); aha1542_stat());
659 SCpnt->scsi_done = done;
660 mb[mbo].status = 1;
661 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
662 DEB(aha1542_stat());
663 }
664 else
665 printk("aha1542_queuecommand: done can't be NULL\n");
666
667 return 0;
668 baddma:
669 panic("Buffer at address > 16Mb used for 1542B");
670 }
671
672 static void internal_done(Scsi_Cmnd * SCpnt)
673 {
674 SCpnt->SCp.Status++;
675 }
676
677 int aha1542_command(Scsi_Cmnd * SCpnt)
678 {
679 DEB(printk("aha1542_command: ..calling aha1542_queuecommand\n"));
680
681 aha1542_queuecommand(SCpnt, internal_done);
682
683 SCpnt->SCp.Status = 0;
684 while (!SCpnt->SCp.Status)
685 barrier();
686 return SCpnt->result;
687 }
688
689
690 static void setup_mailboxes(int bse, struct Scsi_Host * shpnt)
691 {
692 int i;
693 struct mailbox * mb;
694 struct ccb *ccb;
695
696 unchar cmd[5] = {CMD_MBINIT, AHA1542_MAILBOXES, 0, 0, 0};
697
698 mb = HOSTDATA(shpnt)->mb;
699 ccb = HOSTDATA(shpnt)->ccb;
700
701 for(i=0; i<AHA1542_MAILBOXES; i++){
702 mb[i].status = mb[AHA1542_MAILBOXES+i].status = 0;
703 any2scsi(mb[i].ccbptr, &ccb[i]);
704 };
705 aha1542_intr_reset(bse);
706 any2scsi((cmd+2), mb);
707 aha1542_out(bse, cmd, 5);
708 WAIT(INTRFLAGS(bse), INTRMASK, HACC, 0);
709 while (0) {
710 fail:
711 printk("aha1542_detect: failed setting up mailboxes\n");
712 }
713 aha1542_intr_reset(bse);
714 }
715
716 static int aha1542_getconfig(int base_io, unsigned char * irq_level, unsigned char * dma_chan)
717 {
718 unchar inquiry_cmd[] = {CMD_RETCONF };
719 unchar inquiry_result[3];
720 int i;
721 i = inb(STATUS(base_io));
722 if (i & DF) {
723 i = inb(DATA(base_io));
724 };
725 aha1542_out(base_io, inquiry_cmd, 1);
726 aha1542_in(base_io, inquiry_result, 3);
727 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
728 while (0) {
729 fail:
730 printk("aha1542_detect: query board settings\n");
731 }
732 aha1542_intr_reset(base_io);
733 switch(inquiry_result[0]){
734 case 0x80:
735 *dma_chan = 7;
736 break;
737 case 0x40:
738 *dma_chan = 6;
739 break;
740 case 0x20:
741 *dma_chan = 5;
742 break;
743 case 0x01:
744 printk("DMA priority 0 not available for Adaptec driver\n");
745 return -1;
746 case 0:
747
748
749 *dma_chan = 0xFF;
750 break;
751 default:
752 printk("Unable to determine Adaptec DMA priority. Disabling board\n");
753 return -1;
754 };
755 switch(inquiry_result[1]){
756 case 0x40:
757 *irq_level = 15;
758 break;
759 case 0x20:
760 *irq_level = 14;
761 break;
762 case 0x8:
763 *irq_level = 12;
764 break;
765 case 0x4:
766 *irq_level = 11;
767 break;
768 case 0x2:
769 *irq_level = 10;
770 break;
771 case 0x1:
772 *irq_level = 9;
773 break;
774 default:
775 printk("Unable to determine Adaptec IRQ level. Disabling board\n");
776 return -1;
777 };
778 return 0;
779 }
780
781
782
783
784 static int aha1542_mbenable(int base)
785 {
786 static unchar mbenable_cmd[3];
787 static unchar mbenable_result[2];
788 int retval;
789
790 retval = BIOS_TRANSLATION_6432;
791
792 mbenable_cmd[0]=CMD_EXTBIOS;
793 aha1542_out(base,mbenable_cmd,1);
794 if(aha1542_in1(base,mbenable_result,2))
795 return retval;
796 WAITd(INTRFLAGS(base),INTRMASK,HACC,0,100);
797 aha1542_intr_reset(base);
798
799 if ((mbenable_result[0] & 0x08) || mbenable_result[1]) {
800 mbenable_cmd[0]=CMD_MBENABLE;
801 mbenable_cmd[1]=0;
802 mbenable_cmd[2]=mbenable_result[1];
803 if(mbenable_result[1] & 1) retval = BIOS_TRANSLATION_25563;
804 aha1542_out(base,mbenable_cmd,3);
805 WAIT(INTRFLAGS(base),INTRMASK,HACC,0);
806 };
807 while(0) {
808 fail:
809 printk("aha1542_mbenable: Mailbox init failed\n");
810 }
811 aha1542_intr_reset(base);
812 return retval;
813 }
814
815
816 static int aha1542_query(int base_io, int * transl)
817 {
818 unchar inquiry_cmd[] = {CMD_INQUIRY };
819 unchar inquiry_result[4];
820 int i;
821 i = inb(STATUS(base_io));
822 if (i & DF) {
823 i = inb(DATA(base_io));
824 };
825 aha1542_out(base_io, inquiry_cmd, 1);
826 aha1542_in(base_io, inquiry_result, 4);
827 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
828 while (0) {
829 fail:
830 printk("aha1542_detect: query card type\n");
831 }
832 aha1542_intr_reset(base_io);
833
834 *transl = BIOS_TRANSLATION_6432;
835
836
837
838
839
840
841
842 if (inquiry_result[0] == 0x43) {
843 printk("aha1542.c: Emulation mode not supported for AHA 174N hardware.\n");
844 return 1;
845 };
846
847
848
849
850 *transl = aha1542_mbenable(base_io);
851
852 return 0;
853 }
854
855
856 void aha1542_setup( char *str, int *ints)
857 {
858 char *ahausage = "aha1542: usage: aha1542=<PORTBASE>[,<BUSON>,<BUSOFF>[,<DMASPEED>]]\n";
859 static int setup_idx = 0;
860 int setup_portbase;
861
862 if(setup_idx >= MAXBOARDS)
863 {
864 printk("aha1542: aha1542_setup called too many times! Bad LILO params ?\n");
865 printk(" Entryline 1: %s\n",setup_str[0]);
866 printk(" Entryline 2: %s\n",setup_str[1]);
867 printk(" This line: %s\n",str);
868 return;
869 }
870 if (ints[0] < 1 || ints[0] > 4)
871 {
872 printk("aha1542: %s\n", str );
873 printk(ahausage);
874 printk("aha1542: Wrong parameters may cause system malfunction.. We try anyway..\n");
875 }
876
877 setup_called[setup_idx]=ints[0];
878 setup_str[setup_idx]=str;
879
880 setup_portbase = ints[0] >= 1 ? ints[1] : 0;
881 setup_buson [setup_idx] = ints[0] >= 2 ? ints[2] : 7;
882 setup_busoff [setup_idx] = ints[0] >= 3 ? ints[3] : 5;
883 if (ints[0] >= 4) {
884 int atbt = -1;
885 switch (ints[4]) {
886 case 5:
887 atbt = 0x00;
888 break;
889 case 6:
890 atbt = 0x04;
891 break;
892 case 7:
893 atbt = 0x01;
894 break;
895 case 8:
896 atbt = 0x02;
897 break;
898 case 10:
899 atbt = 0x03;
900 break;
901 default:
902 printk("aha1542: %s\n", str );
903 printk(ahausage);
904 printk("aha1542: Valid values for DMASPEED are 5-8, 10 MB/s. Using jumper defaults.\n");
905 break;
906 }
907 setup_dmaspeed[setup_idx] = atbt;
908 }
909
910 if (setup_portbase != 0)
911 bases[setup_idx] = setup_portbase;
912
913 ++setup_idx;
914 }
915
916
917 int aha1542_detect(Scsi_Host_Template * tpnt)
918 {
919 unsigned char dma_chan;
920 unsigned char irq_level;
921 unsigned long flags;
922 unsigned int base_io;
923 int trans;
924 struct Scsi_Host * shpnt = NULL;
925 int count = 0;
926 int indx;
927
928 DEB(printk("aha1542_detect: \n"));
929
930 for(indx = 0; indx < sizeof(bases)/sizeof(bases[0]); indx++)
931 if(bases[indx] != 0 && !check_region(bases[indx], 4)) {
932 shpnt = scsi_register(tpnt,
933 sizeof(struct aha1542_hostdata));
934
935
936
937 if ((unsigned int) shpnt > 0xffffff) {
938 printk("Invalid address for shpnt with 1542.\n");
939 goto unregister;
940 }
941
942 if(!aha1542_test_port(bases[indx], shpnt)) goto unregister;
943
944
945 base_io = bases[indx];
946
947
948 {
949 unchar oncmd[] = {CMD_BUSON_TIME, 7};
950 unchar offcmd[] = {CMD_BUSOFF_TIME, 5};
951
952 if(setup_called[indx])
953 {
954 oncmd[1] = setup_buson[indx];
955 offcmd[1] = setup_busoff[indx];
956 }
957
958 aha1542_intr_reset(base_io);
959 aha1542_out(base_io, oncmd, 2);
960 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
961 aha1542_intr_reset(base_io);
962 aha1542_out(base_io, offcmd, 2);
963 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
964 if (setup_dmaspeed[indx] >= 0)
965 {
966 unchar dmacmd[] = {CMD_DMASPEED, 0};
967 dmacmd[1] = setup_dmaspeed[indx];
968 aha1542_intr_reset(base_io);
969 aha1542_out(base_io, dmacmd, 2);
970 WAIT(INTRFLAGS(base_io), INTRMASK, HACC, 0);
971 }
972 while (0) {
973 fail:
974 printk("aha1542_detect: setting bus on/off-time failed\n");
975 }
976 aha1542_intr_reset(base_io);
977 }
978 if(aha1542_query(base_io, &trans)) goto unregister;
979
980 if (aha1542_getconfig(base_io, &irq_level, &dma_chan) == -1) goto unregister;
981
982 printk("Configuring Adaptec at IO:%x, IRQ %d",base_io, irq_level);
983 if (dma_chan != 0xFF)
984 printk(", DMA priority %d", dma_chan);
985 printk("\n");
986
987 DEB(aha1542_stat());
988 setup_mailboxes(base_io, shpnt);
989
990 DEB(aha1542_stat());
991
992 DEB(printk("aha1542_detect: enable interrupt channel %d\n", irq_level));
993 save_flags(flags);
994 cli();
995 if (request_irq(irq_level,aha1542_intr_handle, 0, "aha1542")) {
996 printk("Unable to allocate IRQ for adaptec controller.\n");
997 goto unregister;
998 }
999
1000 if (dma_chan != 0xFF) {
1001 if (request_dma(dma_chan,"aha1542")) {
1002 printk("Unable to allocate DMA channel for Adaptec.\n");
1003 free_irq(irq_level);
1004 goto unregister;
1005 }
1006
1007 if (dma_chan >= 5) {
1008 outb((dma_chan - 4) | CASCADE, DMA_MODE_REG);
1009 outb(dma_chan - 4, DMA_MASK_REG);
1010 }
1011 }
1012 aha_host[irq_level - 9] = shpnt;
1013 shpnt->io_port = base_io;
1014 shpnt->n_io_port = 4;
1015 shpnt->dma_channel = dma_chan;
1016 shpnt->irq = irq_level;
1017 HOSTDATA(shpnt)->bios_translation = trans;
1018 if(trans == 2)
1019 printk("aha1542.c: Using extended bios translation\n");
1020 HOSTDATA(shpnt)->aha1542_last_mbi_used = (2*AHA1542_MAILBOXES - 1);
1021 HOSTDATA(shpnt)->aha1542_last_mbo_used = (AHA1542_MAILBOXES - 1);
1022 memset(HOSTDATA(shpnt)->SCint, 0, sizeof(HOSTDATA(shpnt)->SCint));
1023 restore_flags(flags);
1024 #if 0
1025 DEB(printk(" *** READ CAPACITY ***\n"));
1026
1027 {
1028 unchar buf[8];
1029 static unchar cmd[] = { READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0};
1030 int i;
1031
1032 for (i = 0; i < sizeof(buf); ++i) buf[i] = 0x87;
1033 for (i = 0; i < 2; ++i)
1034 if (!aha1542_command(i, cmd, buf, sizeof(buf))) {
1035 printk("aha_detect: LU %d sector_size %d device_size %d\n",
1036 i, xscsi2int(buf+4), xscsi2int(buf));
1037 }
1038 }
1039
1040 DEB(printk(" *** NOW RUNNING MY OWN TEST *** \n"));
1041
1042 for (i = 0; i < 4; ++i)
1043 {
1044 unsigned char cmd[10];
1045 static buffer[512];
1046
1047 cmd[0] = READ_10;
1048 cmd[1] = 0;
1049 xany2scsi(cmd+2, i);
1050 cmd[6] = 0;
1051 cmd[7] = 0;
1052 cmd[8] = 1;
1053 cmd[9] = 0;
1054 aha1542_command(0, cmd, buffer, 512);
1055 }
1056 #endif
1057 request_region(bases[indx], 4,"aha1542");
1058 count++;
1059 continue;
1060 unregister:
1061 scsi_unregister(shpnt);
1062 continue;
1063
1064 };
1065 return count;
1066 }
1067
1068 static int aha1542_restart(struct Scsi_Host * shost)
1069 {
1070 int i;
1071 int count = 0;
1072 #if 0
1073 unchar ahacmd = CMD_START_SCSI;
1074 #endif
1075
1076 for(i=0; i< AHA1542_MAILBOXES; i++)
1077 if(HOSTDATA(shost)->SCint[i] &&
1078 !(HOSTDATA(shost)->SCint[i]->device->soft_reset))
1079 {
1080 #if 0
1081 HOSTDATA(shost)->mb[i].status = 1;
1082 #endif
1083 count++;
1084 }
1085
1086 printk("Potential to restart %d stalled commands...\n", count);
1087 #if 0
1088
1089 if (count) aha1542_out(shost->io_port, &ahacmd, 1);
1090 #endif
1091 return 0;
1092 }
1093
1094
1095
1096
1097
1098 int aha1542_abort(Scsi_Cmnd * SCpnt)
1099 {
1100 #if 0
1101 unchar ahacmd = CMD_START_SCSI;
1102 unsigned long flags;
1103 struct mailbox * mb;
1104 int mbi, mbo, i;
1105
1106 printk("In aha1542_abort: %x %x\n",
1107 inb(STATUS(SCpnt->host->io_port)),
1108 inb(INTRFLAGS(SCpnt->host->io_port)));
1109
1110 save_flags(flags);
1111 cli();
1112 mb = HOSTDATA(SCpnt->host)->mb;
1113 mbi = HOSTDATA(SCpnt->host)->aha1542_last_mbi_used + 1;
1114 if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
1115
1116 do{
1117 if(mb[mbi].status != 0) break;
1118 mbi++;
1119 if (mbi >= 2*AHA1542_MAILBOXES) mbi = AHA1542_MAILBOXES;
1120 } while (mbi != HOSTDATA(SCpnt->host)->aha1542_last_mbi_used);
1121 restore_flags(flags);
1122
1123 if(mb[mbi].status) {
1124 printk("Lost interrupt discovered on irq %d - attempting to recover\n",
1125 SCpnt->host->irq);
1126 aha1542_intr_handle(SCpnt->host->irq, NULL);
1127 return 0;
1128 }
1129
1130
1131
1132
1133 for(i=0; i< AHA1542_MAILBOXES; i++)
1134 if(HOSTDATA(SCpnt->host)->SCint[i])
1135 {
1136 if(HOSTDATA(SCpnt->host)->SCint[i] == SCpnt) {
1137 printk("Timed out command pending for %4.4x\n", SCpnt->request.dev);
1138 if (HOSTDATA(SCpnt->host)->mb[i].status) {
1139 printk("OGMB still full - restarting\n");
1140 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1141 };
1142 } else
1143 printk("Other pending command %4.4x\n", SCpnt->request.dev);
1144 }
1145
1146 #endif
1147
1148 DEB(printk("aha1542_abort\n"));
1149 #if 0
1150 save_flags(flags);
1151 cli();
1152 for(mbo = 0; mbo < AHA1542_MAILBOXES; mbo++)
1153 if (SCpnt == HOSTDATA(SCpnt->host)->SCint[mbo]){
1154 mb[mbo].status = 2;
1155 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1156 restore_flags(flags);
1157 break;
1158 };
1159 #endif
1160 return SCSI_ABORT_SNOOZE;
1161 }
1162
1163
1164
1165
1166
1167
1168
1169 int aha1542_reset(Scsi_Cmnd * SCpnt)
1170 {
1171 unchar ahacmd = CMD_START_SCSI;
1172 int i;
1173
1174 DEB(printk("aha1542_reset called\n"));
1175 #if 0
1176
1177 outb(SCRST, CONTROL(SCpnt->host->io_port));
1178 #else
1179
1180
1181 for(i=0; i< AHA1542_MAILBOXES; i++)
1182 if(HOSTDATA(SCpnt->host)->SCint[i] == SCpnt)
1183 {
1184 HOSTDATA(SCpnt->host)->ccb[i].op = 0x81;
1185
1186 aha1542_out(SCpnt->host->io_port, &ahacmd, 1);
1187
1188
1189
1190
1191
1192 printk("Sent BUS DEVICE RESET to target %d\n", SCpnt->target);
1193
1194
1195
1196
1197 #if 1
1198 for(i=0; i< AHA1542_MAILBOXES; i++)
1199 if(HOSTDATA(SCpnt->host)->SCint[i] &&
1200 HOSTDATA(SCpnt->host)->SCint[i]->target == SCpnt->target)
1201 {
1202 Scsi_Cmnd * SCtmp;
1203 SCtmp = HOSTDATA(SCpnt->host)->SCint[i];
1204 SCtmp->result = DID_RESET << 16;
1205 if (SCtmp->host_scribble) scsi_free(SCtmp->host_scribble, 512);
1206 printk("Sending DID_RESET for target %d\n", SCpnt->target);
1207 SCtmp->scsi_done(SCpnt);
1208
1209 HOSTDATA(SCpnt->host)->SCint[i] = NULL;
1210 HOSTDATA(SCpnt->host)->mb[i].status = 0;
1211 }
1212 return SCSI_RESET_SUCCESS;
1213 #else
1214 return SCSI_RESET_PENDING;
1215 #endif
1216 }
1217
1218 #endif
1219
1220
1221
1222 return SCSI_RESET_PUNT;
1223 }
1224
1225 #include "sd.h"
1226
1227 int aha1542_biosparam(Scsi_Disk * disk, int dev, int * ip)
1228 {
1229 int translation_algorithm;
1230 int size = disk->capacity;
1231
1232 translation_algorithm = HOSTDATA(disk->device->host)->bios_translation;
1233
1234 if((size>>11) > 1024 && translation_algorithm == 2) {
1235
1236 ip[0] = 255;
1237 ip[1] = 63;
1238 ip[2] = size /255/63;
1239 } else {
1240 ip[0] = 64;
1241 ip[1] = 32;
1242 ip[2] = size >> 11;
1243 };
1244
1245 return 0;
1246 }
1247
1248
1249 #ifdef MODULE
1250
1251 Scsi_Host_Template driver_template = AHA1542;
1252
1253 #include "scsi_module.c"
1254 #endif
1255