Loading...
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 tz@execpc.com
9
10 Additional Code, and much appreciated help by
11 Michael A. Griffith
12 grif@cs.ucr.edu
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.46 1/30/97 - kernel 1.2.0+
22
23 Functions as standalone, loadable, and PCMCIA driver, the latter from
24 Dave Hinds' PCMCIA package.
25
26 Cleaned up 26/10/2002 by Alan Cox <alan@lxorguk.ukuu.org.uk> as part of the 2.5
27 SCSI driver cleanup and audit. This driver still needs work on the
28 following
29 - Non terminating hardware waits
30 - Some layering violations with its pcmcia stub
31
32 Redistributable under terms of the GNU General Public License
33
34 For the avoidance of doubt the "preferred form" of this code is one which
35 is in an open non patent encumbered format. Where cryptographic key signing
36 forms part of the process of creating an executable the information
37 including keys needed to generate an equivalently functional executable
38 are deemed to be part of the source code.
39
40*/
41
42#include <linux/module.h>
43#include <linux/blkdev.h> /* to get disk capacity */
44#include <linux/kernel.h>
45#include <linux/string.h>
46#include <linux/init.h>
47#include <linux/interrupt.h>
48#include <linux/ioport.h>
49#include <linux/proc_fs.h>
50#include <linux/unistd.h>
51#include <linux/spinlock.h>
52#include <linux/stat.h>
53
54#include <asm/io.h>
55#include <asm/irq.h>
56#include <asm/dma.h>
57
58#include "scsi.h"
59#include <scsi/scsi_host.h>
60#include "qlogicfas408.h"
61
62/*----------------------------------------------------------------*/
63static int qlcfg5 = (XTALFREQ << 5); /* 15625/512 */
64static int qlcfg6 = SYNCXFRPD;
65static int qlcfg7 = SYNCOFFST;
66static int qlcfg8 = (SLOWCABLE << 7) | (QL_ENABLE_PARITY << 4);
67static int qlcfg9 = ((XTALFREQ + 4) / 5);
68static int qlcfgc = (FASTCLK << 3) | (FASTSCSI << 4);
69
70/*----------------------------------------------------------------*/
71
72/*----------------------------------------------------------------*/
73/* local functions */
74/*----------------------------------------------------------------*/
75
76/* error recovery - reset everything */
77
78static void ql_zap(struct qlogicfas408_priv *priv)
79{
80 int x;
81 int qbase = priv->qbase;
82 int int_type = priv->int_type;
83
84 x = inb(qbase + 0xd);
85 REG0;
86 outb(3, qbase + 3); /* reset SCSI */
87 outb(2, qbase + 3); /* reset chip */
88 if (x & 0x80)
89 REG1;
90}
91
92/*
93 * Do a pseudo-dma tranfer
94 */
95
96static int ql_pdma(struct qlogicfas408_priv *priv, int phase, char *request, int reqlen)
97{
98 int j;
99 int qbase = priv->qbase;
100 j = 0;
101 if (phase & 1) { /* in */
102#if QL_TURBO_PDMA
103 rtrc(4)
104 /* empty fifo in large chunks */
105 if (reqlen >= 128 && (inb(qbase + 8) & 2)) { /* full */
106 insl(qbase + 4, request, 32);
107 reqlen -= 128;
108 request += 128;
109 }
110 while (reqlen >= 84 && !(j & 0xc0)) /* 2/3 */
111 if ((j = inb(qbase + 8)) & 4)
112 {
113 insl(qbase + 4, request, 21);
114 reqlen -= 84;
115 request += 84;
116 }
117 if (reqlen >= 44 && (inb(qbase + 8) & 8)) { /* 1/3 */
118 insl(qbase + 4, request, 11);
119 reqlen -= 44;
120 request += 44;
121 }
122#endif
123 /* until both empty and int (or until reclen is 0) */
124 rtrc(7)
125 j = 0;
126 while (reqlen && !((j & 0x10) && (j & 0xc0)))
127 {
128 /* while bytes to receive and not empty */
129 j &= 0xc0;
130 while (reqlen && !((j = inb(qbase + 8)) & 0x10))
131 {
132 *request++ = inb(qbase + 4);
133 reqlen--;
134 }
135 if (j & 0x10)
136 j = inb(qbase + 8);
137
138 }
139 } else { /* out */
140#if QL_TURBO_PDMA
141 rtrc(4)
142 if (reqlen >= 128 && inb(qbase + 8) & 0x10) { /* empty */
143 outsl(qbase + 4, request, 32);
144 reqlen -= 128;
145 request += 128;
146 }
147 while (reqlen >= 84 && !(j & 0xc0)) /* 1/3 */
148 if (!((j = inb(qbase + 8)) & 8)) {
149 outsl(qbase + 4, request, 21);
150 reqlen -= 84;
151 request += 84;
152 }
153 if (reqlen >= 40 && !(inb(qbase + 8) & 4)) { /* 2/3 */
154 outsl(qbase + 4, request, 10);
155 reqlen -= 40;
156 request += 40;
157 }
158#endif
159 /* until full and int (or until reclen is 0) */
160 rtrc(7)
161 j = 0;
162 while (reqlen && !((j & 2) && (j & 0xc0))) {
163 /* while bytes to send and not full */
164 while (reqlen && !((j = inb(qbase + 8)) & 2))
165 {
166 outb(*request++, qbase + 4);
167 reqlen--;
168 }
169 if (j & 2)
170 j = inb(qbase + 8);
171 }
172 }
173 /* maybe return reqlen */
174 return inb(qbase + 8) & 0xc0;
175}
176
177/*
178 * Wait for interrupt flag (polled - not real hardware interrupt)
179 */
180
181static int ql_wai(struct qlogicfas408_priv *priv)
182{
183 int k;
184 int qbase = priv->qbase;
185 unsigned long i;
186
187 k = 0;
188 i = jiffies + WATCHDOG;
189 while (time_before(jiffies, i) && !priv->qabort &&
190 !((k = inb(qbase + 4)) & 0xe0)) {
191 barrier();
192 cpu_relax();
193 }
194 if (time_after_eq(jiffies, i))
195 return (DID_TIME_OUT);
196 if (priv->qabort)
197 return (priv->qabort == 1 ? DID_ABORT : DID_RESET);
198 if (k & 0x60)
199 ql_zap(priv);
200 if (k & 0x20)
201 return (DID_PARITY);
202 if (k & 0x40)
203 return (DID_ERROR);
204 return 0;
205}
206
207/*
208 * Initiate scsi command - queueing handler
209 * caller must hold host lock
210 */
211
212static void ql_icmd(struct scsi_cmnd *cmd)
213{
214 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
215 int qbase = priv->qbase;
216 int int_type = priv->int_type;
217 unsigned int i;
218
219 priv->qabort = 0;
220
221 REG0;
222 /* clearing of interrupts and the fifo is needed */
223
224 inb(qbase + 5); /* clear interrupts */
225 if (inb(qbase + 5)) /* if still interrupting */
226 outb(2, qbase + 3); /* reset chip */
227 else if (inb(qbase + 7) & 0x1f)
228 outb(1, qbase + 3); /* clear fifo */
229 while (inb(qbase + 5)); /* clear ints */
230 REG1;
231 outb(1, qbase + 8); /* set for PIO pseudo DMA */
232 outb(0, qbase + 0xb); /* disable ints */
233 inb(qbase + 8); /* clear int bits */
234 REG0;
235 outb(0x40, qbase + 0xb); /* enable features */
236
237 /* configurables */
238 outb(qlcfgc, qbase + 0xc);
239 /* config: no reset interrupt, (initiator) bus id */
240 outb(0x40 | qlcfg8 | priv->qinitid, qbase + 8);
241 outb(qlcfg7, qbase + 7);
242 outb(qlcfg6, qbase + 6);
243 /**/ outb(qlcfg5, qbase + 5); /* select timer */
244 outb(qlcfg9 & 7, qbase + 9); /* prescaler */
245/* outb(0x99, qbase + 5); */
246 outb(scmd_id(cmd), qbase + 4);
247
248 for (i = 0; i < cmd->cmd_len; i++)
249 outb(cmd->cmnd[i], qbase + 2);
250
251 priv->qlcmd = cmd;
252 outb(0x41, qbase + 3); /* select and send command */
253}
254
255/*
256 * Process scsi command - usually after interrupt
257 */
258
259static unsigned int ql_pcmd(struct scsi_cmnd *cmd)
260{
261 unsigned int i, j;
262 unsigned long k;
263 unsigned int result; /* ultimate return result */
264 unsigned int status; /* scsi returned status */
265 unsigned int message; /* scsi returned message */
266 unsigned int phase; /* recorded scsi phase */
267 unsigned int reqlen; /* total length of transfer */
268 char *buf;
269 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
270 int qbase = priv->qbase;
271 int int_type = priv->int_type;
272
273 rtrc(1)
274 j = inb(qbase + 6);
275 i = inb(qbase + 5);
276 if (i == 0x20) {
277 return (DID_NO_CONNECT << 16);
278 }
279 i |= inb(qbase + 5); /* the 0x10 bit can be set after the 0x08 */
280 if (i != 0x18) {
281 printk(KERN_ERR "Ql:Bad Interrupt status:%02x\n", i);
282 ql_zap(priv);
283 return (DID_BAD_INTR << 16);
284 }
285 j &= 7; /* j = inb( qbase + 7 ) >> 5; */
286
287 /* correct status is supposed to be step 4 */
288 /* it sometimes returns step 3 but with 0 bytes left to send */
289 /* We can try stuffing the FIFO with the max each time, but we will get a
290 sequence of 3 if any bytes are left (but we do flush the FIFO anyway */
291
292 if (j != 3 && j != 4) {
293 printk(KERN_ERR "Ql:Bad sequence for command %d, int %02X, cmdleft = %d\n",
294 j, i, inb(qbase + 7) & 0x1f);
295 ql_zap(priv);
296 return (DID_ERROR << 16);
297 }
298 result = DID_OK;
299 if (inb(qbase + 7) & 0x1f) /* if some bytes in fifo */
300 outb(1, qbase + 3); /* clear fifo */
301 /* note that request_bufflen is the total xfer size when sg is used */
302 reqlen = scsi_bufflen(cmd);
303 /* note that it won't work if transfers > 16M are requested */
304 if (reqlen && !((phase = inb(qbase + 4)) & 6)) { /* data phase */
305 struct scatterlist *sg;
306 rtrc(2)
307 outb(reqlen, qbase); /* low-mid xfer cnt */
308 outb(reqlen >> 8, qbase + 1); /* low-mid xfer cnt */
309 outb(reqlen >> 16, qbase + 0xe); /* high xfer cnt */
310 outb(0x90, qbase + 3); /* command do xfer */
311 /* PIO pseudo DMA to buffer or sglist */
312 REG1;
313
314 scsi_for_each_sg(cmd, sg, scsi_sg_count(cmd), i) {
315 if (priv->qabort) {
316 REG0;
317 return ((priv->qabort == 1 ?
318 DID_ABORT : DID_RESET) << 16);
319 }
320 buf = sg_virt(sg);
321 if (ql_pdma(priv, phase, buf, sg->length))
322 break;
323 }
324 REG0;
325 rtrc(2)
326 /*
327 * Wait for irq (split into second state of irq handler
328 * if this can take time)
329 */
330 if ((k = ql_wai(priv)))
331 return (k << 16);
332 k = inb(qbase + 5); /* should be 0x10, bus service */
333 }
334
335 /*
336 * Enter Status (and Message In) Phase
337 */
338
339 k = jiffies + WATCHDOG;
340
341 while (time_before(jiffies, k) && !priv->qabort &&
342 !(inb(qbase + 4) & 6))
343 cpu_relax(); /* wait for status phase */
344
345 if (time_after_eq(jiffies, k)) {
346 ql_zap(priv);
347 return (DID_TIME_OUT << 16);
348 }
349
350 /* FIXME: timeout ?? */
351 while (inb(qbase + 5))
352 cpu_relax(); /* clear pending ints */
353
354 if (priv->qabort)
355 return ((priv->qabort == 1 ? DID_ABORT : DID_RESET) << 16);
356
357 outb(0x11, qbase + 3); /* get status and message */
358 if ((k = ql_wai(priv)))
359 return (k << 16);
360 i = inb(qbase + 5); /* get chip irq stat */
361 j = inb(qbase + 7) & 0x1f; /* and bytes rec'd */
362 status = inb(qbase + 2);
363 message = inb(qbase + 2);
364
365 /*
366 * Should get function complete int if Status and message, else
367 * bus serv if only status
368 */
369 if (!((i == 8 && j == 2) || (i == 0x10 && j == 1))) {
370 printk(KERN_ERR "Ql:Error during status phase, int=%02X, %d bytes recd\n", i, j);
371 result = DID_ERROR;
372 }
373 outb(0x12, qbase + 3); /* done, disconnect */
374 rtrc(1)
375 if ((k = ql_wai(priv)))
376 return (k << 16);
377
378 /*
379 * Should get bus service interrupt and disconnect interrupt
380 */
381
382 i = inb(qbase + 5); /* should be bus service */
383 while (!priv->qabort && ((i & 0x20) != 0x20)) {
384 barrier();
385 cpu_relax();
386 i |= inb(qbase + 5);
387 }
388 rtrc(0)
389
390 if (priv->qabort)
391 return ((priv->qabort == 1 ? DID_ABORT : DID_RESET) << 16);
392
393 return (result << 16) | (message << 8) | (status & STATUS_MASK);
394}
395
396/*
397 * Interrupt handler
398 */
399
400static void ql_ihandl(void *dev_id)
401{
402 struct scsi_cmnd *icmd;
403 struct Scsi_Host *host = dev_id;
404 struct qlogicfas408_priv *priv = get_priv_by_host(host);
405 int qbase = priv->qbase;
406 REG0;
407
408 if (!(inb(qbase + 4) & 0x80)) /* false alarm? */
409 return;
410
411 if (priv->qlcmd == NULL) { /* no command to process? */
412 int i;
413 i = 16;
414 while (i-- && inb(qbase + 5)); /* maybe also ql_zap() */
415 return;
416 }
417 icmd = priv->qlcmd;
418 icmd->result = ql_pcmd(icmd);
419 priv->qlcmd = NULL;
420 /*
421 * If result is CHECK CONDITION done calls qcommand to request
422 * sense
423 */
424 (icmd->scsi_done) (icmd);
425}
426
427irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id)
428{
429 unsigned long flags;
430 struct Scsi_Host *host = dev_id;
431
432 spin_lock_irqsave(host->host_lock, flags);
433 ql_ihandl(dev_id);
434 spin_unlock_irqrestore(host->host_lock, flags);
435 return IRQ_HANDLED;
436}
437
438/*
439 * Queued command
440 */
441
442static int qlogicfas408_queuecommand_lck(struct scsi_cmnd *cmd,
443 void (*done) (struct scsi_cmnd *))
444{
445 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
446 if (scmd_id(cmd) == priv->qinitid) {
447 cmd->result = DID_BAD_TARGET << 16;
448 done(cmd);
449 return 0;
450 }
451
452 cmd->scsi_done = done;
453 /* wait for the last command's interrupt to finish */
454 while (priv->qlcmd != NULL) {
455 barrier();
456 cpu_relax();
457 }
458 ql_icmd(cmd);
459 return 0;
460}
461
462DEF_SCSI_QCMD(qlogicfas408_queuecommand)
463
464/*
465 * Return bios parameters
466 */
467
468int qlogicfas408_biosparam(struct scsi_device *disk, struct block_device *dev,
469 sector_t capacity, int ip[])
470{
471/* This should mimic the DOS Qlogic driver's behavior exactly */
472 ip[0] = 0x40;
473 ip[1] = 0x20;
474 ip[2] = (unsigned long) capacity / (ip[0] * ip[1]);
475 if (ip[2] > 1024) {
476 ip[0] = 0xff;
477 ip[1] = 0x3f;
478 ip[2] = (unsigned long) capacity / (ip[0] * ip[1]);
479#if 0
480 if (ip[2] > 1023)
481 ip[2] = 1023;
482#endif
483 }
484 return 0;
485}
486
487/*
488 * Abort a command in progress
489 */
490
491int qlogicfas408_abort(struct scsi_cmnd *cmd)
492{
493 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
494 priv->qabort = 1;
495 ql_zap(priv);
496 return SUCCESS;
497}
498
499/*
500 * Reset SCSI bus
501 * FIXME: This function is invoked with cmd = NULL directly by
502 * the PCMCIA qlogic_stub code. This wants fixing
503 */
504
505int qlogicfas408_bus_reset(struct scsi_cmnd *cmd)
506{
507 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
508 unsigned long flags;
509
510 priv->qabort = 2;
511
512 spin_lock_irqsave(cmd->device->host->host_lock, flags);
513 ql_zap(priv);
514 spin_unlock_irqrestore(cmd->device->host->host_lock, flags);
515
516 return SUCCESS;
517}
518
519/*
520 * Return info string
521 */
522
523const char *qlogicfas408_info(struct Scsi_Host *host)
524{
525 struct qlogicfas408_priv *priv = get_priv_by_host(host);
526 return priv->qinfo;
527}
528
529/*
530 * Get type of chip
531 */
532
533int qlogicfas408_get_chip_type(int qbase, int int_type)
534{
535 REG1;
536 return inb(qbase + 0xe) & 0xf8;
537}
538
539/*
540 * Perform initialization tasks
541 */
542
543void qlogicfas408_setup(int qbase, int id, int int_type)
544{
545 outb(1, qbase + 8); /* set for PIO pseudo DMA */
546 REG0;
547 outb(0x40 | qlcfg8 | id, qbase + 8); /* (ini) bus id, disable scsi rst */
548 outb(qlcfg5, qbase + 5); /* select timer */
549 outb(qlcfg9, qbase + 9); /* prescaler */
550
551#if QL_RESET_AT_START
552 outb(3, qbase + 3);
553
554 REG1;
555 /* FIXME: timeout */
556 while (inb(qbase + 0xf) & 4)
557 cpu_relax();
558
559 REG0;
560#endif
561}
562
563/*
564 * Checks if this is a QLogic FAS 408
565 */
566
567int qlogicfas408_detect(int qbase, int int_type)
568{
569 REG1;
570 return (((inb(qbase + 0xe) ^ inb(qbase + 0xe)) == 7) &&
571 ((inb(qbase + 0xe) ^ inb(qbase + 0xe)) == 7));
572}
573
574/*
575 * Disable interrupts
576 */
577
578void qlogicfas408_disable_ints(struct qlogicfas408_priv *priv)
579{
580 int qbase = priv->qbase;
581 int int_type = priv->int_type;
582
583 REG1;
584 outb(0, qbase + 0xb); /* disable ints */
585}
586
587/*
588 * Init and exit functions
589 */
590
591static int __init qlogicfas408_init(void)
592{
593 return 0;
594}
595
596static void __exit qlogicfas408_exit(void)
597{
598
599}
600
601MODULE_AUTHOR("Tom Zerucha, Michael Griffith");
602MODULE_DESCRIPTION("Driver for the Qlogic FAS SCSI controllers");
603MODULE_LICENSE("GPL");
604module_init(qlogicfas408_init);
605module_exit(qlogicfas408_exit);
606
607EXPORT_SYMBOL(qlogicfas408_info);
608EXPORT_SYMBOL(qlogicfas408_queuecommand);
609EXPORT_SYMBOL(qlogicfas408_abort);
610EXPORT_SYMBOL(qlogicfas408_bus_reset);
611EXPORT_SYMBOL(qlogicfas408_biosparam);
612EXPORT_SYMBOL(qlogicfas408_ihandl);
613EXPORT_SYMBOL(qlogicfas408_get_chip_type);
614EXPORT_SYMBOL(qlogicfas408_setup);
615EXPORT_SYMBOL(qlogicfas408_detect);
616EXPORT_SYMBOL(qlogicfas408_disable_ints);
617
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 tz@execpc.com
9
10 Additional Code, and much appreciated help by
11 Michael A. Griffith
12 grif@cs.ucr.edu
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.46 1/30/97 - kernel 1.2.0+
22
23 Functions as standalone, loadable, and PCMCIA driver, the latter from
24 Dave Hinds' PCMCIA package.
25
26 Cleaned up 26/10/2002 by Alan Cox <alan@lxorguk.ukuu.org.uk> as part of the 2.5
27 SCSI driver cleanup and audit. This driver still needs work on the
28 following
29 - Non terminating hardware waits
30 - Some layering violations with its pcmcia stub
31
32 Redistributable under terms of the GNU General Public License
33
34 For the avoidance of doubt the "preferred form" of this code is one which
35 is in an open non patent encumbered format. Where cryptographic key signing
36 forms part of the process of creating an executable the information
37 including keys needed to generate an equivalently functional executable
38 are deemed to be part of the source code.
39
40*/
41
42#include <linux/module.h>
43#include <linux/blkdev.h> /* to get disk capacity */
44#include <linux/kernel.h>
45#include <linux/string.h>
46#include <linux/init.h>
47#include <linux/interrupt.h>
48#include <linux/ioport.h>
49#include <linux/proc_fs.h>
50#include <linux/unistd.h>
51#include <linux/spinlock.h>
52#include <linux/stat.h>
53
54#include <asm/io.h>
55#include <asm/irq.h>
56#include <asm/dma.h>
57
58#include <scsi/scsi.h>
59#include <scsi/scsi_cmnd.h>
60#include <scsi/scsi_device.h>
61#include <scsi/scsi_eh.h>
62#include <scsi/scsi_host.h>
63#include <scsi/scsi_tcq.h>
64#include "qlogicfas408.h"
65
66/*----------------------------------------------------------------*/
67static int qlcfg5 = (XTALFREQ << 5); /* 15625/512 */
68static int qlcfg6 = SYNCXFRPD;
69static int qlcfg7 = SYNCOFFST;
70static int qlcfg8 = (SLOWCABLE << 7) | (QL_ENABLE_PARITY << 4);
71static int qlcfg9 = ((XTALFREQ + 4) / 5);
72static int qlcfgc = (FASTCLK << 3) | (FASTSCSI << 4);
73
74/*----------------------------------------------------------------*/
75
76/*----------------------------------------------------------------*/
77/* local functions */
78/*----------------------------------------------------------------*/
79
80/* error recovery - reset everything */
81
82static void ql_zap(struct qlogicfas408_priv *priv)
83{
84 int x;
85 int qbase = priv->qbase;
86 int int_type = priv->int_type;
87
88 x = inb(qbase + 0xd);
89 REG0;
90 outb(3, qbase + 3); /* reset SCSI */
91 outb(2, qbase + 3); /* reset chip */
92 if (x & 0x80)
93 REG1;
94}
95
96/*
97 * Do a pseudo-dma tranfer
98 */
99
100static int ql_pdma(struct qlogicfas408_priv *priv, int phase, char *request,
101 int reqlen)
102{
103 int j;
104 int qbase = priv->qbase;
105 j = 0;
106 if (phase & 1) { /* in */
107#if QL_TURBO_PDMA
108 rtrc(4)
109 /* empty fifo in large chunks */
110 if (reqlen >= 128 && (inb(qbase + 8) & 2)) { /* full */
111 insl(qbase + 4, request, 32);
112 reqlen -= 128;
113 request += 128;
114 }
115 while (reqlen >= 84 && !(j & 0xc0)) /* 2/3 */
116 if ((j = inb(qbase + 8)) & 4)
117 {
118 insl(qbase + 4, request, 21);
119 reqlen -= 84;
120 request += 84;
121 }
122 if (reqlen >= 44 && (inb(qbase + 8) & 8)) { /* 1/3 */
123 insl(qbase + 4, request, 11);
124 reqlen -= 44;
125 request += 44;
126 }
127#endif
128 /* until both empty and int (or until reclen is 0) */
129 rtrc(7)
130 j = 0;
131 while (reqlen && !((j & 0x10) && (j & 0xc0)))
132 {
133 /* while bytes to receive and not empty */
134 j &= 0xc0;
135 while (reqlen && !((j = inb(qbase + 8)) & 0x10))
136 {
137 *request++ = inb(qbase + 4);
138 reqlen--;
139 }
140 if (j & 0x10)
141 j = inb(qbase + 8);
142
143 }
144 } else { /* out */
145#if QL_TURBO_PDMA
146 rtrc(4)
147 if (reqlen >= 128 && inb(qbase + 8) & 0x10) { /* empty */
148 outsl(qbase + 4, request, 32);
149 reqlen -= 128;
150 request += 128;
151 }
152 while (reqlen >= 84 && !(j & 0xc0)) /* 1/3 */
153 if (!((j = inb(qbase + 8)) & 8)) {
154 outsl(qbase + 4, request, 21);
155 reqlen -= 84;
156 request += 84;
157 }
158 if (reqlen >= 40 && !(inb(qbase + 8) & 4)) { /* 2/3 */
159 outsl(qbase + 4, request, 10);
160 reqlen -= 40;
161 request += 40;
162 }
163#endif
164 /* until full and int (or until reclen is 0) */
165 rtrc(7)
166 j = 0;
167 while (reqlen && !((j & 2) && (j & 0xc0))) {
168 /* while bytes to send and not full */
169 while (reqlen && !((j = inb(qbase + 8)) & 2))
170 {
171 outb(*request++, qbase + 4);
172 reqlen--;
173 }
174 if (j & 2)
175 j = inb(qbase + 8);
176 }
177 }
178 /* maybe return reqlen */
179 return inb(qbase + 8) & 0xc0;
180}
181
182/*
183 * Wait for interrupt flag (polled - not real hardware interrupt)
184 */
185
186static int ql_wai(struct qlogicfas408_priv *priv)
187{
188 int k;
189 int qbase = priv->qbase;
190 unsigned long i;
191
192 k = 0;
193 i = jiffies + WATCHDOG;
194 while (time_before(jiffies, i) && !priv->qabort &&
195 !((k = inb(qbase + 4)) & 0xe0)) {
196 barrier();
197 cpu_relax();
198 }
199 if (time_after_eq(jiffies, i))
200 return (DID_TIME_OUT);
201 if (priv->qabort)
202 return (priv->qabort == 1 ? DID_ABORT : DID_RESET);
203 if (k & 0x60)
204 ql_zap(priv);
205 if (k & 0x20)
206 return (DID_PARITY);
207 if (k & 0x40)
208 return (DID_ERROR);
209 return 0;
210}
211
212/*
213 * Initiate scsi command - queueing handler
214 * caller must hold host lock
215 */
216
217static void ql_icmd(struct scsi_cmnd *cmd)
218{
219 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
220 int qbase = priv->qbase;
221 int int_type = priv->int_type;
222 unsigned int i;
223
224 priv->qabort = 0;
225
226 REG0;
227 /* clearing of interrupts and the fifo is needed */
228
229 inb(qbase + 5); /* clear interrupts */
230 if (inb(qbase + 5)) /* if still interrupting */
231 outb(2, qbase + 3); /* reset chip */
232 else if (inb(qbase + 7) & 0x1f)
233 outb(1, qbase + 3); /* clear fifo */
234 while (inb(qbase + 5)); /* clear ints */
235 REG1;
236 outb(1, qbase + 8); /* set for PIO pseudo DMA */
237 outb(0, qbase + 0xb); /* disable ints */
238 inb(qbase + 8); /* clear int bits */
239 REG0;
240 outb(0x40, qbase + 0xb); /* enable features */
241
242 /* configurables */
243 outb(qlcfgc, qbase + 0xc);
244 /* config: no reset interrupt, (initiator) bus id */
245 outb(0x40 | qlcfg8 | priv->qinitid, qbase + 8);
246 outb(qlcfg7, qbase + 7);
247 outb(qlcfg6, qbase + 6);
248 outb(qlcfg5, qbase + 5); /* select timer */
249 outb(qlcfg9 & 7, qbase + 9); /* prescaler */
250/* outb(0x99, qbase + 5); */
251 outb(scmd_id(cmd), qbase + 4);
252
253 for (i = 0; i < cmd->cmd_len; i++)
254 outb(cmd->cmnd[i], qbase + 2);
255
256 priv->qlcmd = cmd;
257 outb(0x41, qbase + 3); /* select and send command */
258}
259
260/*
261 * Process scsi command - usually after interrupt
262 */
263
264static void ql_pcmd(struct scsi_cmnd *cmd)
265{
266 unsigned int i, j;
267 unsigned long k;
268 unsigned int status; /* scsi returned status */
269 unsigned int message; /* scsi returned message */
270 unsigned int phase; /* recorded scsi phase */
271 unsigned int reqlen; /* total length of transfer */
272 char *buf;
273 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
274 int qbase = priv->qbase;
275 int int_type = priv->int_type;
276
277 rtrc(1)
278 j = inb(qbase + 6);
279 i = inb(qbase + 5);
280 if (i == 0x20) {
281 set_host_byte(cmd, DID_NO_CONNECT);
282 return;
283 }
284 i |= inb(qbase + 5); /* the 0x10 bit can be set after the 0x08 */
285 if (i != 0x18) {
286 printk(KERN_ERR "Ql:Bad Interrupt status:%02x\n", i);
287 ql_zap(priv);
288 set_host_byte(cmd, DID_BAD_INTR);
289 return;
290 }
291 j &= 7; /* j = inb( qbase + 7 ) >> 5; */
292
293 /* correct status is supposed to be step 4 */
294 /* it sometimes returns step 3 but with 0 bytes left to send */
295 /* We can try stuffing the FIFO with the max each time, but we will get a
296 sequence of 3 if any bytes are left (but we do flush the FIFO anyway */
297
298 if (j != 3 && j != 4) {
299 printk(KERN_ERR "Ql:Bad sequence for command %d, int %02X, cmdleft = %d\n",
300 j, i, inb(qbase + 7) & 0x1f);
301 ql_zap(priv);
302 set_host_byte(cmd, DID_ERROR);
303 return;
304 }
305
306 if (inb(qbase + 7) & 0x1f) /* if some bytes in fifo */
307 outb(1, qbase + 3); /* clear fifo */
308 /* note that request_bufflen is the total xfer size when sg is used */
309 reqlen = scsi_bufflen(cmd);
310 /* note that it won't work if transfers > 16M are requested */
311 if (reqlen && !((phase = inb(qbase + 4)) & 6)) { /* data phase */
312 struct scatterlist *sg;
313 rtrc(2)
314 outb(reqlen, qbase); /* low-mid xfer cnt */
315 outb(reqlen >> 8, qbase + 1); /* low-mid xfer cnt */
316 outb(reqlen >> 16, qbase + 0xe); /* high xfer cnt */
317 outb(0x90, qbase + 3); /* command do xfer */
318 /* PIO pseudo DMA to buffer or sglist */
319 REG1;
320
321 scsi_for_each_sg(cmd, sg, scsi_sg_count(cmd), i) {
322 if (priv->qabort) {
323 REG0;
324 set_host_byte(cmd,
325 priv->qabort == 1 ?
326 DID_ABORT : DID_RESET);
327 }
328 buf = sg_virt(sg);
329 if (ql_pdma(priv, phase, buf, sg->length))
330 break;
331 }
332 REG0;
333 rtrc(2);
334 /*
335 * Wait for irq (split into second state of irq handler
336 * if this can take time)
337 */
338 if ((k = ql_wai(priv))) {
339 set_host_byte(cmd, k);
340 return;
341 }
342 k = inb(qbase + 5); /* should be 0x10, bus service */
343 }
344
345 /*
346 * Enter Status (and Message In) Phase
347 */
348
349 k = jiffies + WATCHDOG;
350
351 while (time_before(jiffies, k) && !priv->qabort &&
352 !(inb(qbase + 4) & 6))
353 cpu_relax(); /* wait for status phase */
354
355 if (time_after_eq(jiffies, k)) {
356 ql_zap(priv);
357 set_host_byte(cmd, DID_TIME_OUT);
358 return;
359 }
360
361 /* FIXME: timeout ?? */
362 while (inb(qbase + 5))
363 cpu_relax(); /* clear pending ints */
364
365 if (priv->qabort) {
366 set_host_byte(cmd,
367 priv->qabort == 1 ? DID_ABORT : DID_RESET);
368 return;
369 }
370
371 outb(0x11, qbase + 3); /* get status and message */
372 if ((k = ql_wai(priv))) {
373 set_host_byte(cmd, k);
374 return;
375 }
376 i = inb(qbase + 5); /* get chip irq stat */
377 j = inb(qbase + 7) & 0x1f; /* and bytes rec'd */
378 status = inb(qbase + 2);
379 message = inb(qbase + 2);
380
381 /*
382 * Should get function complete int if Status and message, else
383 * bus serv if only status
384 */
385 if (!((i == 8 && j == 2) || (i == 0x10 && j == 1))) {
386 printk(KERN_ERR "Ql:Error during status phase, int=%02X, %d bytes recd\n", i, j);
387 set_host_byte(cmd, DID_ERROR);
388 }
389 outb(0x12, qbase + 3); /* done, disconnect */
390 rtrc(1);
391 if ((k = ql_wai(priv))) {
392 set_host_byte(cmd, k);
393 return;
394 }
395
396 /*
397 * Should get bus service interrupt and disconnect interrupt
398 */
399
400 i = inb(qbase + 5); /* should be bus service */
401 while (!priv->qabort && ((i & 0x20) != 0x20)) {
402 barrier();
403 cpu_relax();
404 i |= inb(qbase + 5);
405 }
406 rtrc(0);
407
408 if (priv->qabort) {
409 set_host_byte(cmd,
410 priv->qabort == 1 ? DID_ABORT : DID_RESET);
411 return;
412 }
413
414 set_host_byte(cmd, DID_OK);
415 if (message != COMMAND_COMPLETE)
416 scsi_msg_to_host_byte(cmd, message);
417 set_status_byte(cmd, status);
418 return;
419}
420
421/*
422 * Interrupt handler
423 */
424
425static void ql_ihandl(void *dev_id)
426{
427 struct scsi_cmnd *icmd;
428 struct Scsi_Host *host = dev_id;
429 struct qlogicfas408_priv *priv = get_priv_by_host(host);
430 int qbase = priv->qbase;
431 REG0;
432
433 if (!(inb(qbase + 4) & 0x80)) /* false alarm? */
434 return;
435
436 if (priv->qlcmd == NULL) { /* no command to process? */
437 int i;
438 i = 16;
439 while (i-- && inb(qbase + 5)); /* maybe also ql_zap() */
440 return;
441 }
442 icmd = priv->qlcmd;
443 ql_pcmd(icmd);
444 priv->qlcmd = NULL;
445 /*
446 * If result is CHECK CONDITION done calls qcommand to request
447 * sense
448 */
449 scsi_done(icmd);
450}
451
452irqreturn_t qlogicfas408_ihandl(int irq, void *dev_id)
453{
454 unsigned long flags;
455 struct Scsi_Host *host = dev_id;
456
457 spin_lock_irqsave(host->host_lock, flags);
458 ql_ihandl(dev_id);
459 spin_unlock_irqrestore(host->host_lock, flags);
460 return IRQ_HANDLED;
461}
462
463/*
464 * Queued command
465 */
466
467static int qlogicfas408_queuecommand_lck(struct scsi_cmnd *cmd)
468{
469 void (*done)(struct scsi_cmnd *) = scsi_done;
470 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
471
472 set_host_byte(cmd, DID_OK);
473 set_status_byte(cmd, SAM_STAT_GOOD);
474 if (scmd_id(cmd) == priv->qinitid) {
475 set_host_byte(cmd, DID_BAD_TARGET);
476 done(cmd);
477 return 0;
478 }
479
480 /* wait for the last command's interrupt to finish */
481 while (priv->qlcmd != NULL) {
482 barrier();
483 cpu_relax();
484 }
485 ql_icmd(cmd);
486 return 0;
487}
488
489DEF_SCSI_QCMD(qlogicfas408_queuecommand)
490
491/*
492 * Return bios parameters
493 */
494
495int qlogicfas408_biosparam(struct scsi_device *disk, struct block_device *dev,
496 sector_t capacity, int ip[])
497{
498/* This should mimic the DOS Qlogic driver's behavior exactly */
499 ip[0] = 0x40;
500 ip[1] = 0x20;
501 ip[2] = (unsigned long) capacity / (ip[0] * ip[1]);
502 if (ip[2] > 1024) {
503 ip[0] = 0xff;
504 ip[1] = 0x3f;
505 ip[2] = (unsigned long) capacity / (ip[0] * ip[1]);
506#if 0
507 if (ip[2] > 1023)
508 ip[2] = 1023;
509#endif
510 }
511 return 0;
512}
513
514/*
515 * Abort a command in progress
516 */
517
518int qlogicfas408_abort(struct scsi_cmnd *cmd)
519{
520 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
521 priv->qabort = 1;
522 ql_zap(priv);
523 return SUCCESS;
524}
525
526/*
527 * Reset SCSI bus
528 * FIXME: This function is invoked with cmd = NULL directly by
529 * the PCMCIA qlogic_stub code. This wants fixing
530 */
531
532int qlogicfas408_host_reset(struct scsi_cmnd *cmd)
533{
534 struct qlogicfas408_priv *priv = get_priv_by_cmd(cmd);
535 unsigned long flags;
536
537 priv->qabort = 2;
538
539 spin_lock_irqsave(cmd->device->host->host_lock, flags);
540 ql_zap(priv);
541 spin_unlock_irqrestore(cmd->device->host->host_lock, flags);
542
543 return SUCCESS;
544}
545
546/*
547 * Return info string
548 */
549
550const char *qlogicfas408_info(struct Scsi_Host *host)
551{
552 struct qlogicfas408_priv *priv = get_priv_by_host(host);
553 return priv->qinfo;
554}
555
556/*
557 * Get type of chip
558 */
559
560int qlogicfas408_get_chip_type(int qbase, int int_type)
561{
562 REG1;
563 return inb(qbase + 0xe) & 0xf8;
564}
565
566/*
567 * Perform initialization tasks
568 */
569
570void qlogicfas408_setup(int qbase, int id, int int_type)
571{
572 outb(1, qbase + 8); /* set for PIO pseudo DMA */
573 REG0;
574 outb(0x40 | qlcfg8 | id, qbase + 8); /* (ini) bus id, disable scsi rst */
575 outb(qlcfg5, qbase + 5); /* select timer */
576 outb(qlcfg9, qbase + 9); /* prescaler */
577
578#if QL_RESET_AT_START
579 outb(3, qbase + 3);
580
581 REG1;
582 /* FIXME: timeout */
583 while (inb(qbase + 0xf) & 4)
584 cpu_relax();
585
586 REG0;
587#endif
588}
589
590/*
591 * Checks if this is a QLogic FAS 408
592 */
593
594int qlogicfas408_detect(int qbase, int int_type)
595{
596 REG1;
597 return (((inb(qbase + 0xe) ^ inb(qbase + 0xe)) == 7) &&
598 ((inb(qbase + 0xe) ^ inb(qbase + 0xe)) == 7));
599}
600
601/*
602 * Disable interrupts
603 */
604
605void qlogicfas408_disable_ints(struct qlogicfas408_priv *priv)
606{
607 int qbase = priv->qbase;
608 int int_type = priv->int_type;
609
610 REG1;
611 outb(0, qbase + 0xb); /* disable ints */
612}
613
614/*
615 * Init and exit functions
616 */
617
618static int __init qlogicfas408_init(void)
619{
620 return 0;
621}
622
623static void __exit qlogicfas408_exit(void)
624{
625
626}
627
628MODULE_AUTHOR("Tom Zerucha, Michael Griffith");
629MODULE_DESCRIPTION("Driver for the Qlogic FAS SCSI controllers");
630MODULE_LICENSE("GPL");
631module_init(qlogicfas408_init);
632module_exit(qlogicfas408_exit);
633
634EXPORT_SYMBOL(qlogicfas408_info);
635EXPORT_SYMBOL(qlogicfas408_queuecommand);
636EXPORT_SYMBOL(qlogicfas408_abort);
637EXPORT_SYMBOL(qlogicfas408_host_reset);
638EXPORT_SYMBOL(qlogicfas408_biosparam);
639EXPORT_SYMBOL(qlogicfas408_ihandl);
640EXPORT_SYMBOL(qlogicfas408_get_chip_type);
641EXPORT_SYMBOL(qlogicfas408_setup);
642EXPORT_SYMBOL(qlogicfas408_detect);
643EXPORT_SYMBOL(qlogicfas408_disable_ints);
644