![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aha1740.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi|
Return to aha1740.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / scsi |
1.1 root 1: /* $Id: aha1740.c,v 1.2 1997/03/24 21:51:17 thomas Exp $
2: * 1993/03/31
3: * linux/kernel/aha1740.c
4: *
5: * Based loosely on aha1542.c which is
6: * Copyright (C) 1992 Tommy Thorn and
7: * Modified by Eric Youngdale
8: *
9: * This file is aha1740.c, written and
10: * Copyright (C) 1992,1993 Brad McLean
11: *
12: * Modifications to makecode and queuecommand
13: * for proper handling of multiple devices courteously
14: * provided by Michael Weller, March, 1993
15: *
16: * aha1740_makecode may still need even more work
17: * if it doesn't work for your devices, take a look.
18: */
19:
20: #ifdef MODULE
21: #include <linux/module.h>
22: #endif
23:
24: #include <linux/kernel.h>
25: #include <linux/head.h>
26: #include <linux/types.h>
27: #include <linux/string.h>
28: #include <linux/ioport.h>
29: #include <linux/proc_fs.h>
30: #include <linux/sched.h>
31: #include <asm/dma.h>
32:
33: #include <asm/system.h>
34: #include <asm/io.h>
35: #include <linux/blk.h>
36: #include "scsi.h"
37: #include "hosts.h"
38: #include "sd.h"
39:
40: #include "aha1740.h"
41: #include<linux/stat.h>
42:
43: struct proc_dir_entry proc_scsi_aha1740 = {
44: PROC_SCSI_AHA1740, 7, "aha1740",
45: S_IFDIR | S_IRUGO | S_IXUGO, 2
46: };
47:
48: /* IF YOU ARE HAVING PROBLEMS WITH THIS DRIVER, AND WANT TO WATCH
49: IT WORK, THEN:
50: #define DEBUG
51: */
52: #ifdef DEBUG
53: #define DEB(x) x
54: #else
55: #define DEB(x)
56: #endif
57:
58: /*
59: static const char RCSid[] = "$Header: /gd4/gnu/cvsroot/gnumach/i386/i386at/gpl/linux/scsi/aha1740.c,v 1.2 1997/03/24 21:51:17 thomas Exp $";
60: */
61:
62: static unsigned int slot, base;
63: static unsigned char irq_level;
64:
65: static struct ecb ecb[AHA1740_ECBS]; /* One for each queued operation */
66:
67: static int aha1740_last_ecb_used = 0; /* optimization */
68:
69: int aha1740_makecode(unchar *sense, unchar *status)
70: {
71: struct statusword
72: {
73: ushort don:1, /* Command Done - No Error */
74: du:1, /* Data underrun */
75: :1, qf:1, /* Queue full */
76: sc:1, /* Specification Check */
77: dor:1, /* Data overrun */
78: ch:1, /* Chaining Halted */
79: intr:1, /* Interrupt issued */
80: asa:1, /* Additional Status Available */
81: sns:1, /* Sense information Stored */
82: :1, ini:1, /* Initialization Required */
83: me:1, /* Major error or exception */
84: :1, eca:1, /* Extended Contingent alliance */
85: :1;
86: } status_word;
87: int retval = DID_OK;
88:
89: status_word = * (struct statusword *) status;
90: #ifdef DEBUG
91: printk("makecode from %x,%x,%x,%x %x,%x,%x,%x",status[0],status[1],status[2],status[3],
92: sense[0],sense[1],sense[2],sense[3]);
93: #endif
94: if (!status_word.don) /* Anything abnormal was detected */
95: {
96: if ( (status[1]&0x18) || status_word.sc ) /*Additional info available*/
97: {
98: /* Use the supplied info for further diagnostics */
99: switch ( status[2] )
100: {
101: case 0x12:
102: if ( status_word.dor )
103: retval=DID_ERROR; /* It's an Overrun */
104: /* If not overrun, assume underrun and ignore it! */
105: case 0x00: /* No info, assume no error, should not occur */
106: break;
107: case 0x11:
108: case 0x21:
109: retval=DID_TIME_OUT;
110: break;
111: case 0x0a:
112: retval=DID_BAD_TARGET;
113: break;
114: case 0x04:
115: case 0x05:
116: retval=DID_ABORT; /* Either by this driver or the AHA1740
117: itself */
118: break;
119: default:
120: retval=DID_ERROR; /* No further diagnostics possible */
121: }
122: }
123: else
124: { /* Michael suggests, and Brad concurs: */
125: if ( status_word.qf )
126: {
127: retval = DID_TIME_OUT; /* forces a redo */
128: /* I think this specific one should not happen -Brad */
129: printk("aha1740.c: WARNING: AHA1740 queue overflow!\n");
130: }
131: else if ( status[0]&0x60 )
132: {
133: retval = DID_ERROR; /* Didn't find a better error */
134: }
135: /* In any other case return DID_OK so for example
136: CONDITION_CHECKS make it through to the appropriate
137: device driver */
138: }
139: }
140: /* Under all circumstances supply the target status -Michael */
141: return status[3] | retval << 16;
142: }
143:
144: int aha1740_test_port(void)
145: {
146: char name[4],tmp;
147:
148: /* Okay, look for the EISA ID's */
149: name[0]= 'A' -1 + ((tmp = inb(HID0)) >> 2); /* First character */
150: name[1]= 'A' -1 + ((tmp & 3) << 3);
151: name[1]+= ((tmp = inb(HID1)) >> 5)&0x7; /* Second Character */
152: name[2]= 'A' -1 + (tmp & 0x1f); /* Third Character */
153: name[3]=0;
154: tmp = inb(HID2);
155: if ( strcmp ( name, HID_MFG ) || inb(HID2) != HID_PRD )
156: return 0; /* Not an Adaptec 174x */
157:
158: /* if ( inb(HID3) != HID_REV )
159: printk("aha1740: Warning; board revision of %d; expected %d\n",
160: inb(HID3),HID_REV); */
161:
162: if ( inb(EBCNTRL) != EBCNTRL_VALUE )
163: {
164: printk("aha1740: Board detected, but EBCNTRL = %x, so disabled it.\n",
165: inb(EBCNTRL));
166: return 0;
167: }
168:
169: /* Try and turn on enhanced mode */
170: tmp = inb (PORTADR);
171: outb (PORTADR, tmp | PORTADDR_ENH);
172: if ( inb(PORTADR) & PORTADDR_ENH )
173: return 1; /* Okay, we're all set */
174:
175: printk("aha1740: Board detected, but not in enhanced mode, so disabled it.\n");
176: return 0;
177: }
178:
179: /* A "high" level interrupt handler */
180: void aha1740_intr_handle(int irq, struct pt_regs * regs)
181: {
182: void (*my_done)(Scsi_Cmnd *);
183: int errstatus, adapstat;
184: int number_serviced;
185: struct ecb *ecbptr;
186: Scsi_Cmnd *SCtmp;
187:
188: number_serviced = 0;
189:
190: while(inb(G2STAT) & G2STAT_INTPEND)
191: {
192: DEB(printk("aha1740_intr top of loop.\n"));
193: adapstat = inb(G2INTST);
194: ecbptr = (struct ecb *) bus_to_virt(inl(MBOXIN0));
195: outb(G2CNTRL_IRST,G2CNTRL); /* interrupt reset */
196:
197: switch ( adapstat & G2INTST_MASK )
198: {
199: case G2INTST_CCBRETRY:
200: case G2INTST_CCBERROR:
201: case G2INTST_CCBGOOD:
202: outb(G2CNTRL_HRDY,G2CNTRL); /* Host Ready -> Mailbox in complete */
203: if (!ecbptr)
204: {
205: printk("Aha1740 null ecbptr in interrupt (%x,%x,%x,%d)\n",
206: inb(G2STAT),adapstat,inb(G2INTST),number_serviced++);
207: continue;
208: }
209: SCtmp = ecbptr->SCpnt;
210: if (!SCtmp)
211: {
212: printk("Aha1740 null SCtmp in interrupt (%x,%x,%x,%d)\n",
213: inb(G2STAT),adapstat,inb(G2INTST),number_serviced++);
214: continue;
215: }
216: if (SCtmp->host_scribble)
217: scsi_free(SCtmp->host_scribble, 512);
218: /* Fetch the sense data, and tuck it away, in the required slot. The
219: Adaptec automatically fetches it, and there is no guarantee that
220: we will still have it in the cdb when we come back */
221: if ( (adapstat & G2INTST_MASK) == G2INTST_CCBERROR )
222: {
223: memcpy(SCtmp->sense_buffer, ecbptr->sense,
224: sizeof(SCtmp->sense_buffer));
225: errstatus = aha1740_makecode(ecbptr->sense,ecbptr->status);
226: }
227: else
228: errstatus = 0;
229: DEB(if (errstatus) printk("aha1740_intr_handle: returning %6x\n", errstatus));
230: SCtmp->result = errstatus;
231: my_done = ecbptr->done;
232: memset(ecbptr,0,sizeof(struct ecb));
233: if ( my_done )
234: my_done(SCtmp);
235: break;
236: case G2INTST_HARDFAIL:
237: printk("aha1740 hardware failure!\n");
238: panic("aha1740.c"); /* Goodbye */
239: case G2INTST_ASNEVENT:
240: printk("aha1740 asynchronous event: %02x %02x %02x %02x %02x\n",adapstat,
241: inb(MBOXIN0),inb(MBOXIN1),inb(MBOXIN2),inb(MBOXIN3)); /* Say What? */
242: outb(G2CNTRL_HRDY,G2CNTRL); /* Host Ready -> Mailbox in complete */
243: break;
244: case G2INTST_CMDGOOD:
245: /* set immediate command success flag here: */
246: break;
247: case G2INTST_CMDERROR:
248: /* Set immediate command failure flag here: */
249: break;
250: }
251: number_serviced++;
252: }
253: }
254:
255: int aha1740_queuecommand(Scsi_Cmnd * SCpnt, void (*done)(Scsi_Cmnd *))
256: {
257: unchar direction;
258: unchar *cmd = (unchar *) SCpnt->cmnd;
259: unchar target = SCpnt->target;
260: unsigned long flags;
261: void *buff = SCpnt->request_buffer;
262: int bufflen = SCpnt->request_bufflen;
263: int ecbno;
264: DEB(int i);
265:
266:
267: if(*cmd == REQUEST_SENSE)
268: {
269: if (bufflen != sizeof(SCpnt->sense_buffer))
270: {
271: printk("Wrong buffer length supplied for request sense (%d)\n",bufflen);
272: }
273: SCpnt->result = 0;
274: done(SCpnt);
275: return 0;
276: }
277:
278: #ifdef DEBUG
279: if (*cmd == READ_10 || *cmd == WRITE_10)
280: i = xscsi2int(cmd+2);
281: else if (*cmd == READ_6 || *cmd == WRITE_6)
282: i = scsi2int(cmd+2);
283: else
284: i = -1;
285: printk("aha1740_queuecommand: dev %d cmd %02x pos %d len %d ", target, *cmd, i, bufflen);
286: printk("scsi cmd:");
287: for (i = 0; i < SCpnt->cmd_len; i++) printk("%02x ", cmd[i]);
288: printk("\n");
289: #endif
290:
291: /* locate an available ecb */
292:
293: save_flags(flags);
294: cli();
295: ecbno = aha1740_last_ecb_used + 1; /* An optimization */
296: if (ecbno >= AHA1740_ECBS) ecbno = 0;
297:
298: do{
299: if( ! ecb[ecbno].cmdw )
300: break;
301: ecbno++;
302: if (ecbno >= AHA1740_ECBS ) ecbno = 0;
303: } while (ecbno != aha1740_last_ecb_used);
304:
305: if( ecb[ecbno].cmdw )
306: panic("Unable to find empty ecb for aha1740.\n");
307:
308: ecb[ecbno].cmdw = AHA1740CMD_INIT; /* SCSI Initiator Command doubles as reserved flag */
309:
310: aha1740_last_ecb_used = ecbno;
311: restore_flags(flags);
312:
313: #ifdef DEBUG
314: printk("Sending command (%d %x)...",ecbno, done);
315: #endif
316:
317: ecb[ecbno].cdblen = SCpnt->cmd_len; /* SCSI Command Descriptor Block Length */
318:
319: direction = 0;
320: if (*cmd == READ_10 || *cmd == READ_6)
321: direction = 1;
322: else if (*cmd == WRITE_10 || *cmd == WRITE_6)
323: direction = 0;
324:
325: memcpy(ecb[ecbno].cdb, cmd, ecb[ecbno].cdblen);
326:
327: if (SCpnt->use_sg)
328: {
329: struct scatterlist * sgpnt;
330: struct aha1740_chain * cptr;
331: int i;
332: #ifdef DEBUG
333: unsigned char * ptr;
334: #endif
335: ecb[ecbno].sg = 1; /* SCSI Initiator Command w/scatter-gather*/
336: SCpnt->host_scribble = (unsigned char *) scsi_malloc(512);
337: sgpnt = (struct scatterlist *) SCpnt->request_buffer;
338: cptr = (struct aha1740_chain *) SCpnt->host_scribble;
339: if (cptr == NULL) panic("aha1740.c: unable to allocate DMA memory\n");
340: for(i=0; i<SCpnt->use_sg; i++)
341: {
342: cptr[i].dataptr = (long) sgpnt[i].address;
343: cptr[i].datalen = sgpnt[i].length;
344: }
345: ecb[ecbno].datalen = SCpnt->use_sg * sizeof(struct aha1740_chain);
346: ecb[ecbno].dataptr = (long) cptr;
347: #ifdef DEBUG
348: printk("cptr %x: ",cptr);
349: ptr = (unsigned char *) cptr;
350: for(i=0;i<24;i++) printk("%02x ", ptr[i]);
351: #endif
352: }
353: else
354: {
355: SCpnt->host_scribble = NULL;
356: ecb[ecbno].datalen = bufflen;
357: ecb[ecbno].dataptr = (long) buff;
358: }
359: ecb[ecbno].lun = SCpnt->lun;
360: ecb[ecbno].ses = 1; /* Suppress underrun errors */
361: ecb[ecbno].dir= direction;
362: ecb[ecbno].ars=1; /* Yes, get the sense on an error */
363: ecb[ecbno].senselen = 12;
364: ecb[ecbno].senseptr = (long) ecb[ecbno].sense;
365: ecb[ecbno].statusptr = (long) ecb[ecbno].status;
366: ecb[ecbno].done = done;
367: ecb[ecbno].SCpnt = SCpnt;
368: #ifdef DEBUG
369: {
370: int i;
371: printk("aha1740_command: sending.. ");
372: for (i = 0; i < sizeof(ecb[ecbno])-10; i++)
373: printk("%02x ", ((unchar *)&ecb[ecbno])[i]);
374: }
375: printk("\n");
376: #endif
377: if (done)
378: { /* You may question the code below, which contains potentially
379: non-terminating while loops with interrupts disabled. So did
380: I when I wrote it, but the Adaptec Spec says the card is so fast,
381: that this problem virtually never occurs so I've kept it. We
382: do printk a warning first, so that you'll know if it happens.
383: In practice the only time we've seen this message is when some-
384: thing else is in the driver was broken, like _makecode(), or
385: when a scsi device hung the scsi bus. Even under these conditions,
386: The loop actually only cycled < 3 times (we instrumented it). */
387:
388: DEB(printk("aha1740[%d] critical section\n",ecbno));
389: save_flags(flags);
390: cli();
391: if ( ! (inb(G2STAT) & G2STAT_MBXOUT) )
392: {
393: printk("aha1740[%d]_mbxout wait!\n",ecbno);
394: cli(); /* printk may have done a sti()! */
395: }
396: mb();
397: while ( ! (inb(G2STAT) & G2STAT_MBXOUT) ); /* Oh Well. */
398: outl(virt_to_bus(ecb+ecbno), MBOXOUT0);
399: if ( inb(G2STAT) & G2STAT_BUSY )
400: {
401: printk("aha1740[%d]_attn wait!\n",ecbno);
402: cli();
403: }
404: while ( inb(G2STAT) & G2STAT_BUSY ); /* And Again! */
405: outb(ATTN_START | (target & 7), ATTN); /* Start it up */
406: restore_flags(flags);
407: DEB(printk("aha1740[%d] request queued.\n",ecbno));
408: }
409: else
410: printk("aha1740_queuecommand: done can't be NULL\n");
411:
412: return 0;
413: }
414:
415: static volatile int internal_done_flag = 0;
416: static volatile int internal_done_errcode = 0;
417:
418: static void internal_done(Scsi_Cmnd * SCpnt)
419: {
420: internal_done_errcode = SCpnt->result;
421: ++internal_done_flag;
422: }
423:
424: int aha1740_command(Scsi_Cmnd * SCpnt)
425: {
426: aha1740_queuecommand(SCpnt, internal_done);
427:
428: while (!internal_done_flag);
429: internal_done_flag = 0;
430: return internal_done_errcode;
431: }
432:
433: /* Query the board for its irq_level. Nothing else matters
434: in enhanced mode on an EISA bus. */
435:
436: void aha1740_getconfig(void)
437: {
438: static int intab[] = { 9,10,11,12,0,14,15,0 };
439:
440: irq_level = intab [ inb(INTDEF)&0x7 ];
441: outb(inb(INTDEF) | 0x10, INTDEF);
442: }
443:
444: int aha1740_detect(Scsi_Host_Template * tpnt)
445: {
446: tpnt->proc_dir = &proc_scsi_aha1740;
447:
448: memset(&ecb, 0, sizeof(struct ecb));
449: DEB(printk("aha1740_detect: \n"));
450:
451: for ( slot=MINEISA; slot <= MAXEISA; slot++ )
452: {
453: base = SLOTBASE(slot);
454: /*
455: * The ioports for eisa boards are generally beyond that used in the
456: * check/allocate region code, but this may change at some point,
457: * so we go through the motions.
458: */
459: if(check_region(base, 0x5c)) continue; /* See if in use */
460: if ( aha1740_test_port()) break;
461: }
462: if ( slot > MAXEISA )
463: return 0;
464:
465: aha1740_getconfig();
466:
467: if ( (inb(G2STAT) & (G2STAT_MBXOUT | G2STAT_BUSY) ) != G2STAT_MBXOUT )
468: { /* If the card isn't ready, hard reset it */
469: outb(G2CNTRL_HRST,G2CNTRL);
470: outb(0,G2CNTRL);
471: }
472:
473: printk("Configuring Adaptec at IO:%x, IRQ %d\n",base,
474: irq_level);
475:
476: DEB(printk("aha1740_detect: enable interrupt channel %d\n", irq_level));
477:
478: if (request_irq(irq_level,aha1740_intr_handle, 0, "aha1740"))
479: {
480: printk("Unable to allocate IRQ for adaptec controller.\n");
481: return 0;
482: }
483: request_region(base, 0x5c,"aha1740"); /* Reserve the space that we need to use */
484: return 1;
485: }
486:
487: /* Note: They following two functions do not apply very well to the Adaptec,
488: which basically manages its own affairs quite well without our interference,
489: so I haven't put anything into them. I can faintly imagine someone with a
490: *very* badly behaved SCSI target (perhaps an old tape?) wanting the abort(),
491: but it hasn't happened yet, and doing aborts brings the Adaptec to its
492: knees. I cannot (at this moment in time) think of any reason to reset the
493: card once it's running. So there. */
494:
495: int aha1740_abort(Scsi_Cmnd * SCpnt)
496: {
497: DEB(printk("aha1740_abort called\n"));
498: return SCSI_ABORT_SNOOZE;
499: }
500:
501: /* We do not implement a reset function here, but the upper level code assumes
502: that it will get some kind of response for the command in SCpnt. We must
503: oblige, or the command will hang the scsi system */
504:
505: int aha1740_reset(Scsi_Cmnd * SCpnt)
506: {
507: DEB(printk("aha1740_reset called\n"));
508: return SCSI_RESET_PUNT;
509: }
510:
511: int aha1740_biosparam(Disk * disk, kdev_t dev, int* ip)
512: {
513: int size = disk->capacity;
514: DEB(printk("aha1740_biosparam\n"));
515: ip[0] = 64;
516: ip[1] = 32;
517: ip[2] = size >> 11;
518: /* if (ip[2] >= 1024) ip[2] = 1024; */
519: return 0;
520: }
521:
522: #ifdef MODULE
523: /* Eventually this will go into an include file, but this will be later */
524: Scsi_Host_Template driver_template = AHA1740;
525:
526: #include "scsi_module.c"
527: #endif
528:
529: /* Okay, you made it all the way through. As of this writing, 3/31/93, I'm
530: [email protected] or [email protected]. I'll try to help as time
531: permits if you have any trouble with this driver. Happy Linuxing! */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.