![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to qlogicfas.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi|
Return to qlogicfas.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / scsi |
1.1 root 1: /*----------------------------------------------------------------*/
2: /*
3: Qlogic linux driver - work in progress. No Warranty express or implied.
4: Use at your own risk. Support Tort Reform so you won't have to read all
5: these silly disclaimers.
6:
7: Copyright 1994, Tom Zerucha.
8: [email protected]
9:
10: Additional Code, and much appreciated help by
11: Michael A. Griffith
12: [email protected]
13:
14: Thanks to Eric Youngdale and Dave Hinds for loadable module and PCMCIA
15: help respectively, and for suffering through my foolishness during the
16: debugging process.
17:
18: Reference Qlogic FAS408 Technical Manual, 53408-510-00A, May 10, 1994
19: (you can reference it, but it is incomplete and inaccurate in places)
20:
21: Version 0.45 6/9/96 - kernel 1.2.0+
22:
23: Functions as standalone, loadable, and PCMCIA driver, the latter from
24: Dave Hind's PCMCIA package.
25:
26: Redistributable under terms of the GNU Public License
27:
28: */
29: /*----------------------------------------------------------------*/
30: /* Configuration */
31:
32: /* Set the following to 2 to use normal interrupt (active high/totempole-
33: tristate), otherwise use 0 (REQUIRED FOR PCMCIA) for active low, open
34: drain */
35: #define QL_INT_ACTIVE_HIGH 2
36:
37: /* Set the following to 1 to enable the use of interrupts. Note that 0 tends
38: to be more stable, but slower (or ties up the system more) */
39: #define QL_USE_IRQ 1
40:
41: /* Set the following to max out the speed of the PIO PseudoDMA transfers,
42: again, 0 tends to be slower, but more stable. */
43: #define QL_TURBO_PDMA 1
44:
45: /* This should be 1 to enable parity detection */
46: #define QL_ENABLE_PARITY 1
47:
48: /* This will reset all devices when the driver is initialized (during bootup).
49: The other linux drivers don't do this, but the DOS drivers do, and after
50: using DOS or some kind of crash or lockup this will bring things back
51: without requiring a cold boot. It does take some time to recover from a
52: reset, so it is slower, and I have seen timeouts so that devices weren't
53: recognized when this was set. */
54: #define QL_RESET_AT_START 0
55:
56: /* crystal frequency in megahertz (for offset 5 and 9)
57: Please set this for your card. Most Qlogic cards are 40 Mhz. The
58: Control Concepts ISA (not VLB) is 24 Mhz */
59: #define XTALFREQ 40
60:
61: /**********/
62: /* DANGER! modify these at your own risk */
63: /* SLOWCABLE can usually be reset to zero if you have a clean setup and
64: proper termination. The rest are for synchronous transfers and other
65: advanced features if your device can transfer faster than 5Mb/sec.
66: If you are really curious, email me for a quick howto until I have
67: something official */
68: /**********/
69:
70: /*****/
71: /* config register 1 (offset 8) options */
72: /* This needs to be set to 1 if your cabling is long or noisy */
73: #define SLOWCABLE 1
74:
75: /*****/
76: /* offset 0xc */
77: /* This will set fast (10Mhz) synchronous timing when set to 1
78: For this to have an effect, FASTCLK must also be 1 */
79: #define FASTSCSI 0
80:
81: /* This when set to 1 will set a faster sync transfer rate */
82: #define FASTCLK 0
83: /*(XTALFREQ>25?1:0)*/
84:
85: /*****/
86: /* offset 6 */
87: /* This is the sync transfer divisor, XTALFREQ/X will be the maximum
88: achievable data rate (assuming the rest of the system is capable
89: and set properly) */
90: #define SYNCXFRPD 5
91: /*(XTALFREQ/5)*/
92:
93: /*****/
94: /* offset 7 */
95: /* This is the count of how many synchronous transfers can take place
96: i.e. how many reqs can occur before an ack is given.
97: The maximum value for this is 15, the upper bits can modify
98: REQ/ACK assertion and deassertion during synchronous transfers
99: If this is 0, the bus will only transfer asynchronously */
100: #define SYNCOFFST 0
101: /* for the curious, bits 7&6 control the deassertion delay in 1/2 cycles
102: of the 40Mhz clock. If FASTCLK is 1, specifying 01 (1/2) will
103: cause the deassertion to be early by 1/2 clock. Bits 5&4 control
104: the assertion delay, also in 1/2 clocks (FASTCLK is ignored here). */
105:
106: /*----------------------------------------------------------------*/
107: #ifdef PCMCIA
108: #undef QL_INT_ACTIVE_HIGH
109: #define QL_INT_ACTIVE_HIGH 0
110: #define MODULE
111: #endif
112:
113: #include <linux/module.h>
114:
115: #ifdef PCMCIA
116: #undef MODULE
117: #endif
118:
119: #include <linux/blk.h> /* to get disk capacity */
120: #include <linux/kernel.h>
121: #include <linux/string.h>
122: #include <linux/ioport.h>
123: #include <linux/sched.h>
124: #include <linux/proc_fs.h>
125: #include <linux/unistd.h>
126: #include <asm/io.h>
127: #include <asm/irq.h>
128: #include "sd.h"
129: #include "hosts.h"
130: #include "qlogicfas.h"
131: #include<linux/stat.h>
132:
133: struct proc_dir_entry proc_scsi_qlogicfas = {
134: PROC_SCSI_QLOGICFAS, 6, "qlogicfas",
135: S_IFDIR | S_IRUGO | S_IXUGO, 2
136: };
137:
138: /*----------------------------------------------------------------*/
139: /* driver state info, local to driver */
140: static int qbase = 0; /* Port */
141: static int qinitid; /* initiator ID */
142: static int qabort; /* Flag to cause an abort */
143: static int qlirq = -1; /* IRQ being used */
144: static char qinfo[80]; /* description */
145: static Scsi_Cmnd *qlcmd; /* current command being processed */
146:
147: static int qlcfg5 = ( XTALFREQ << 5 ); /* 15625/512 */
148: static int qlcfg6 = SYNCXFRPD;
149: static int qlcfg7 = SYNCOFFST;
150: static int qlcfg8 = ( SLOWCABLE << 7 ) | ( QL_ENABLE_PARITY << 4 );
151: static int qlcfg9 = ( ( XTALFREQ + 4 ) / 5 );
152: static int qlcfgc = ( FASTCLK << 3 ) | ( FASTSCSI << 4 );
153:
154: /*----------------------------------------------------------------*/
155: /* The qlogic card uses two register maps - These macros select which one */
156: #define REG0 ( outb( inb( qbase + 0xd ) & 0x7f , qbase + 0xd ), outb( 4 , qbase + 0xd ))
157: #define REG1 ( outb( inb( qbase + 0xd ) | 0x80 , qbase + 0xd ), outb( 0xb4 | QL_INT_ACTIVE_HIGH , qbase + 0xd ))
158:
159: /* following is watchdog timeout in microseconds */
160: #define WATCHDOG 5000000
161:
162: /*----------------------------------------------------------------*/
163: /* the following will set the monitor border color (useful to find
164: where something crashed or gets stuck at and as a simple profiler) */
165:
166: #if 0
167: #define rtrc(i) {inb(0x3da);outb(0x31,0x3c0);outb((i),0x3c0);}
168: #else
169: #define rtrc(i) {}
170: #endif
171:
172: /*----------------------------------------------------------------*/
173: /* local functions */
174: /*----------------------------------------------------------------*/
175: static void ql_zap(void);
176: /* error recovery - reset everything */
177: void ql_zap()
178: {
179: int x;
180: unsigned long flags;
181: save_flags( flags );
182: cli();
183: x = inb(qbase + 0xd);
184: REG0;
185: outb(3, qbase + 3); /* reset SCSI */
186: outb(2, qbase + 3); /* reset chip */
187: if (x & 0x80)
188: REG1;
189: restore_flags( flags );
190: }
191:
192: /*----------------------------------------------------------------*/
193: /* do pseudo-dma */
194: static int ql_pdma(int phase, char *request, int reqlen)
195: {
196: int j;
197: j = 0;
198: if (phase & 1) { /* in */
199: #if QL_TURBO_PDMA
200: rtrc(4)
201: /* empty fifo in large chunks */
202: if( reqlen >= 128 && (inb( qbase + 8 ) & 2) ) { /* full */
203: insl( qbase + 4, request, 32 );
204: reqlen -= 128;
205: request += 128;
206: }
207: while( reqlen >= 84 && !( j & 0xc0 ) ) /* 2/3 */
208: if( (j=inb( qbase + 8 )) & 4 ) {
209: insl( qbase + 4, request, 21 );
210: reqlen -= 84;
211: request += 84;
212: }
213: if( reqlen >= 44 && (inb( qbase + 8 ) & 8) ) { /* 1/3 */
214: insl( qbase + 4, request, 11 );
215: reqlen -= 44;
216: request += 44;
217: }
218: #endif
219: /* until both empty and int (or until reclen is 0) */
220: rtrc(7)
221: j = 0;
222: while( reqlen && !( (j & 0x10) && (j & 0xc0) ) ) {
223: /* while bytes to receive and not empty */
224: j &= 0xc0;
225: while ( reqlen && !( (j=inb(qbase + 8)) & 0x10 ) ) {
226: *request++ = inb(qbase + 4);
227: reqlen--;
228: }
229: if( j & 0x10 )
230: j = inb(qbase+8);
231:
232: }
233: }
234: else { /* out */
235: #if QL_TURBO_PDMA
236: rtrc(4)
237: if( reqlen >= 128 && inb( qbase + 8 ) & 0x10 ) { /* empty */
238: outsl(qbase + 4, request, 32 );
239: reqlen -= 128;
240: request += 128;
241: }
242: while( reqlen >= 84 && !( j & 0xc0 ) ) /* 1/3 */
243: if( !((j=inb( qbase + 8 )) & 8) ) {
244: outsl( qbase + 4, request, 21 );
245: reqlen -= 84;
246: request += 84;
247: }
248: if( reqlen >= 40 && !(inb( qbase + 8 ) & 4 ) ) { /* 2/3 */
249: outsl( qbase + 4, request, 10 );
250: reqlen -= 40;
251: request += 40;
252: }
253: #endif
254: /* until full and int (or until reclen is 0) */
255: rtrc(7)
256: j = 0;
257: while( reqlen && !( (j & 2) && (j & 0xc0) ) ) {
258: /* while bytes to send and not full */
259: while ( reqlen && !( (j=inb(qbase + 8)) & 2 ) ) {
260: outb(*request++, qbase + 4);
261: reqlen--;
262: }
263: if( j & 2 )
264: j = inb(qbase+8);
265: }
266: }
267: /* maybe return reqlen */
268: return inb( qbase + 8 ) & 0xc0;
269: }
270:
271: /*----------------------------------------------------------------*/
272: /* wait for interrupt flag (polled - not real hardware interrupt) */
273: static int ql_wai(void)
274: {
275: int i,k;
276: k = 0;
277: i = jiffies + WATCHDOG;
278: while ( i > jiffies && !qabort && !((k = inb(qbase + 4)) & 0xe0))
279: barrier();
280: if (i <= jiffies)
281: return (DID_TIME_OUT);
282: if (qabort)
283: return (qabort == 1 ? DID_ABORT : DID_RESET);
284: if (k & 0x60)
285: ql_zap();
286: if (k & 0x20)
287: return (DID_PARITY);
288: if (k & 0x40)
289: return (DID_ERROR);
290: return 0;
291: }
292:
293: /*----------------------------------------------------------------*/
294: /* initiate scsi command - queueing handler */
295: static void ql_icmd(Scsi_Cmnd * cmd)
296: {
297: unsigned int i;
298: unsigned long flags;
299:
300: qabort = 0;
301:
302: save_flags( flags );
303: cli();
304: REG0;
305: /* clearing of interrupts and the fifo is needed */
306: inb(qbase + 5); /* clear interrupts */
307: if (inb(qbase + 5)) /* if still interrupting */
308: outb(2, qbase + 3); /* reset chip */
309: else if (inb(qbase + 7) & 0x1f)
310: outb(1, qbase + 3); /* clear fifo */
311: while (inb(qbase + 5)); /* clear ints */
312: REG1;
313: outb(1, qbase + 8); /* set for PIO pseudo DMA */
314: outb(0, qbase + 0xb); /* disable ints */
315: inb(qbase + 8); /* clear int bits */
316: REG0;
317: outb(0x40, qbase + 0xb); /* enable features */
318:
319: /* configurables */
320: outb( qlcfgc , qbase + 0xc);
321: /* config: no reset interrupt, (initiator) bus id */
322: outb( 0x40 | qlcfg8 | qinitid, qbase + 8);
323: outb( qlcfg7 , qbase + 7 );
324: outb( qlcfg6 , qbase + 6 );
325: /**/
326: outb(qlcfg5, qbase + 5); /* select timer */
327: outb(qlcfg9 & 7, qbase + 9); /* prescaler */
328: /* outb(0x99, qbase + 5); */
329: outb(cmd->target, qbase + 4);
330:
331: for (i = 0; i < cmd->cmd_len; i++)
332: outb(cmd->cmnd[i], qbase + 2);
333: qlcmd = cmd;
334: outb(0x41, qbase + 3); /* select and send command */
335: restore_flags( flags );
336: }
337: /*----------------------------------------------------------------*/
338: /* process scsi command - usually after interrupt */
339: static unsigned int ql_pcmd(Scsi_Cmnd * cmd)
340: {
341: unsigned int i, j, k;
342: unsigned int result; /* ultimate return result */
343: unsigned int status; /* scsi returned status */
344: unsigned int message; /* scsi returned message */
345: unsigned int phase; /* recorded scsi phase */
346: unsigned int reqlen; /* total length of transfer */
347: struct scatterlist *sglist; /* scatter-gather list pointer */
348: unsigned int sgcount; /* sg counter */
349:
350: rtrc(1)
351: j = inb(qbase + 6);
352: i = inb(qbase + 5);
353: if (i == 0x20) {
354: return (DID_NO_CONNECT << 16);
355: }
356: i |= inb(qbase + 5); /* the 0x10 bit can be set after the 0x08 */
357: if (i != 0x18) {
358: printk("Ql:Bad Interrupt status:%02x\n", i);
359: ql_zap();
360: return (DID_BAD_INTR << 16);
361: }
362: j &= 7; /* j = inb( qbase + 7 ) >> 5; */
363: /* correct status is supposed to be step 4 */
364: /* it sometimes returns step 3 but with 0 bytes left to send */
365: /* We can try stuffing the FIFO with the max each time, but we will get a
366: sequence of 3 if any bytes are left (but we do flush the FIFO anyway */
367: if(j != 3 && j != 4) {
368: printk("Ql:Bad sequence for command %d, int %02X, cmdleft = %d\n", j, i, inb( qbase+7 ) & 0x1f );
369: ql_zap();
370: return (DID_ERROR << 16);
371: }
372: result = DID_OK;
373: if (inb(qbase + 7) & 0x1f) /* if some bytes in fifo */
374: outb(1, qbase + 3); /* clear fifo */
375: /* note that request_bufflen is the total xfer size when sg is used */
376: reqlen = cmd->request_bufflen;
377: /* note that it won't work if transfers > 16M are requested */
378: if (reqlen && !((phase = inb(qbase + 4)) & 6)) { /* data phase */
379: rtrc(2)
380: outb(reqlen, qbase); /* low-mid xfer cnt */
381: outb(reqlen >> 8, qbase+1); /* low-mid xfer cnt */
382: outb(reqlen >> 16, qbase + 0xe); /* high xfer cnt */
383: outb(0x90, qbase + 3); /* command do xfer */
384: /* PIO pseudo DMA to buffer or sglist */
385: REG1;
386: if (!cmd->use_sg)
387: ql_pdma(phase, cmd->request_buffer, cmd->request_bufflen);
388: else {
389: sgcount = cmd->use_sg;
390: sglist = cmd->request_buffer;
391: while (sgcount--) {
392: if (qabort) {
393: REG0;
394: return ((qabort == 1 ? DID_ABORT : DID_RESET) << 16);
395: }
396: if (ql_pdma(phase, sglist->address, sglist->length))
397: break;
398: sglist++;
399: }
400: }
401: REG0;
402: rtrc(2)
403: /* wait for irq (split into second state of irq handler if this can take time) */
404: if ((k = ql_wai()))
405: return (k << 16);
406: k = inb(qbase + 5); /* should be 0x10, bus service */
407: }
408: /*** Enter Status (and Message In) Phase ***/
409: k = jiffies + WATCHDOG;
410: while ( k > jiffies && !qabort && !(inb(qbase + 4) & 6)); /* wait for status phase */
411: if ( k <= jiffies ) {
412: ql_zap();
413: return (DID_TIME_OUT << 16);
414: }
415: while (inb(qbase + 5)); /* clear pending ints */
416: if (qabort)
417: return ((qabort == 1 ? DID_ABORT : DID_RESET) << 16);
418: outb(0x11, qbase + 3); /* get status and message */
419: if ((k = ql_wai()))
420: return (k << 16);
421: i = inb(qbase + 5); /* get chip irq stat */
422: j = inb(qbase + 7) & 0x1f; /* and bytes rec'd */
423: status = inb(qbase + 2);
424: message = inb(qbase + 2);
425: /* should get function complete int if Status and message, else bus serv if only status */
426: if (!((i == 8 && j == 2) || (i == 0x10 && j == 1))) {
427: printk("Ql:Error during status phase, int=%02X, %d bytes recd\n", i, j);
428: result = DID_ERROR;
429: }
430: outb(0x12, qbase + 3); /* done, disconnect */
431: rtrc(1)
432: if ((k = ql_wai()))
433: return (k << 16);
434: /* should get bus service interrupt and disconnect interrupt */
435: i = inb(qbase + 5); /* should be bus service */
436: while (!qabort && ((i & 0x20) != 0x20)) {
437: barrier();
438: i |= inb(qbase + 5);
439: }
440: rtrc(0)
441: if (qabort)
442: return ((qabort == 1 ? DID_ABORT : DID_RESET) << 16);
443: return (result << 16) | (message << 8) | (status & STATUS_MASK);
444: }
445:
446: #if QL_USE_IRQ
447: /*----------------------------------------------------------------*/
448: /* interrupt handler */
449: static void ql_ihandl(int irq, void *dev_id, struct pt_regs * regs)
450: {
451: Scsi_Cmnd *icmd;
452: REG0;
453: if (!(inb(qbase + 4) & 0x80)) /* false alarm? */
454: return;
455: if (qlcmd == NULL) { /* no command to process? */
456: int i;
457: i = 16;
458: while (i-- && inb(qbase + 5)); /* maybe also ql_zap() */
459: return;
460: }
461: icmd = qlcmd;
462: icmd->result = ql_pcmd(icmd);
463: qlcmd = NULL;
464: /* if result is CHECK CONDITION done calls qcommand to request sense */
465: (icmd->scsi_done) (icmd);
466: }
467: #endif
468:
469: /*----------------------------------------------------------------*/
470: /* global functions */
471: /*----------------------------------------------------------------*/
472: /* non queued command */
473: #if QL_USE_IRQ
474: static void qlidone(Scsi_Cmnd * cmd) {}; /* null function */
475: #endif
476:
477: /* command process */
478: int qlogicfas_command(Scsi_Cmnd * cmd)
479: {
480: int k;
481: #if QL_USE_IRQ
482: if (qlirq >= 0) {
483: qlogicfas_queuecommand(cmd, qlidone);
484: while (qlcmd != NULL);
485: return cmd->result;
486: }
487: #endif
488: /* non-irq version */
489: if (cmd->target == qinitid)
490: return (DID_BAD_TARGET << 16);
491: ql_icmd(cmd);
492: if ((k = ql_wai()))
493: return (k << 16);
494: return ql_pcmd(cmd);
495:
496: }
497:
498: #if QL_USE_IRQ
499: /*----------------------------------------------------------------*/
500: /* queued command */
501: int qlogicfas_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
502: {
503: if(cmd->target == qinitid) {
504: cmd->result = DID_BAD_TARGET << 16;
505: done(cmd);
506: return 0;
507: }
508:
509: cmd->scsi_done = done;
510: /* wait for the last command's interrupt to finish */
511: while (qlcmd != NULL)
512: barrier();
513: ql_icmd(cmd);
514: return 0;
515: }
516: #else
517: int qlogicfas_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
518: {
519: return 1;
520: }
521: #endif
522:
523: #ifdef PCMCIA
524: /*----------------------------------------------------------------*/
525: /* allow PCMCIA code to preset the port */
526: /* port should be 0 and irq to -1 respectively for autoprobing */
527: void qlogicfas_preset(int port, int irq)
528: {
529: qbase=port;
530: qlirq=irq;
531: }
532: #endif
533:
534: /*----------------------------------------------------------------*/
535: /* look for qlogic card and init if found */
536: int qlogicfas_detect(Scsi_Host_Template * host)
537: {
538: int i, j; /* these are only used by IRQ detect */
539: int qltyp; /* type of chip */
540: struct Scsi_Host *hreg; /* registered host structure */
541: unsigned long flags;
542:
543: host->proc_dir = &proc_scsi_qlogicfas;
544:
545: /* Qlogic Cards only exist at 0x230 or 0x330 (the chip itself decodes the
546: address - I check 230 first since MIDI cards are typically at 330
547:
548: Theoretically, two Qlogic cards can coexist in the same system. This
549: should work by simply using this as a loadable module for the second
550: card, but I haven't tested this.
551: */
552:
553: if( !qbase ) {
554: for (qbase = 0x230; qbase < 0x430; qbase += 0x100) {
555: if( check_region( qbase , 0x10 ) )
556: continue;
557: REG1;
558: if ( ( (inb(qbase + 0xe) ^ inb(qbase + 0xe)) == 7 )
559: && ( (inb(qbase + 0xe) ^ inb(qbase + 0xe)) == 7 ) )
560: break;
561: }
562: if (qbase == 0x430)
563: return 0;
564: }
565: else
566: printk( "Ql: Using preset base address of %03x\n", qbase );
567:
568: qltyp = inb(qbase + 0xe) & 0xf8;
569: qinitid = host->this_id;
570: if (qinitid < 0)
571: qinitid = 7; /* if no ID, use 7 */
572: outb(1, qbase + 8); /* set for PIO pseudo DMA */
573: REG0;
574: outb(0x40 | qlcfg8 | qinitid, qbase + 8); /* (ini) bus id, disable scsi rst */
575: outb(qlcfg5, qbase + 5); /* select timer */
576: outb(qlcfg9, qbase + 9); /* prescaler */
577: #if QL_RESET_AT_START
578: outb( 3 , qbase + 3 );
579: REG1;
580: while( inb( qbase + 0xf ) & 4 );
581: REG0;
582: #endif
583: #if QL_USE_IRQ
584: /* IRQ probe - toggle pin and check request pending */
585:
586: if( qlirq == -1 ) {
587: save_flags( flags );
588: cli();
589: i = 0xffff;
590: j = 3;
591: outb(0x90, qbase + 3); /* illegal command - cause interrupt */
592: REG1;
593: outb(10, 0x20); /* access pending interrupt map */
594: outb(10, 0xa0);
595: while (j--) {
596: outb(0xb0 | QL_INT_ACTIVE_HIGH , qbase + 0xd); /* int pin off */
597: i &= ~(inb(0x20) | (inb(0xa0) << 8)); /* find IRQ off */
598: outb(0xb4 | QL_INT_ACTIVE_HIGH , qbase + 0xd); /* int pin on */
599: i &= inb(0x20) | (inb(0xa0) << 8); /* find IRQ on */
600: }
601: REG0;
602: while (inb(qbase + 5)); /* purge int */
603: j = -1;
604: while (i) /* find on bit */
605: i >>= 1, j++; /* should check for exactly 1 on */
606: qlirq = j;
607: restore_flags( flags );
608: }
609: else
610: printk( "Ql: Using preset IRQ %d\n", qlirq );
611:
612: if (qlirq >= 0 && !request_irq(qlirq, ql_ihandl, 0, "qlogicfas", NULL))
613: host->can_queue = 1;
614: #endif
615: request_region( qbase , 0x10 ,"qlogicfas");
616: hreg = scsi_register( host , 0 ); /* no host data */
617: hreg->io_port = qbase;
618: hreg->n_io_port = 16;
619: hreg->dma_channel = -1;
620: if( qlirq != -1 )
621: hreg->irq = qlirq;
622:
623: sprintf(qinfo, "Qlogicfas Driver version 0.45, chip %02X at %03X, IRQ %d, TPdma:%d",
624: qltyp, qbase, qlirq, QL_TURBO_PDMA );
625: host->name = qinfo;
626:
627: return 1;
628: }
629:
630: /*----------------------------------------------------------------*/
631: /* return bios parameters */
632: int qlogicfas_biosparam(Disk * disk, kdev_t dev, int ip[])
633: {
634: /* This should mimic the DOS Qlogic driver's behavior exactly */
635: ip[0] = 0x40;
636: ip[1] = 0x20;
637: ip[2] = disk->capacity / (ip[0] * ip[1]);
638: if (ip[2] > 1024) {
639: ip[0] = 0xff;
640: ip[1] = 0x3f;
641: ip[2] = disk->capacity / (ip[0] * ip[1]);
642: if (ip[2] > 1023)
643: ip[2] = 1023;
644: }
645: return 0;
646: }
647:
648: /*----------------------------------------------------------------*/
649: /* abort command in progress */
650: int qlogicfas_abort(Scsi_Cmnd * cmd)
651: {
652: qabort = 1;
653: ql_zap();
654: return 0;
655: }
656:
657: /*----------------------------------------------------------------*/
658: /* reset SCSI bus */
659: int qlogicfas_reset(Scsi_Cmnd * cmd, unsigned int flags)
660: {
661: qabort = 2;
662: ql_zap();
663: return 1;
664: }
665:
666: /*----------------------------------------------------------------*/
667: /* return info string */
668: const char *qlogicfas_info(struct Scsi_Host * host)
669: {
670: return qinfo;
671: }
672:
673: #ifdef MODULE
674: /* Eventually this will go into an include file, but this will be later */
675: Scsi_Host_Template driver_template = QLOGICFAS;
676:
677: #include "scsi_module.c"
678: #endif
679:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.