[SCSI] fix up request buffer reference in various scsi drivers
[linux-2.6.git] / drivers / scsi / in2000.c
1 /*
2  *    in2000.c -  Linux device driver for the
3  *                Always IN2000 ISA SCSI card.
4  *
5  * Copyright (c) 1996 John Shifflett, GeoLog Consulting
6  *    john@geolog.com
7  *    jshiffle@netcom.com
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2, or (at your option)
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * For the avoidance of doubt the "preferred form" of this code is one which
20  * is in an open non patent encumbered format. Where cryptographic key signing
21  * forms part of the process of creating an executable the information
22  * including keys needed to generate an equivalently functional executable
23  * are deemed to be part of the source code.
24  *
25  * Drew Eckhardt's excellent 'Generic NCR5380' sources provided
26  * much of the inspiration and some of the code for this driver.
27  * The Linux IN2000 driver distributed in the Linux kernels through
28  * version 1.2.13 was an extremely valuable reference on the arcane
29  * (and still mysterious) workings of the IN2000's fifo. It also
30  * is where I lifted in2000_biosparam(), the gist of the card
31  * detection scheme, and other bits of code. Many thanks to the
32  * talented and courageous people who wrote, contributed to, and
33  * maintained that driver (including Brad McLean, Shaun Savage,
34  * Bill Earnest, Larry Doolittle, Roger Sunshine, John Luckey,
35  * Matt Postiff, Peter Lu, zerucha@shell.portal.com, and Eric
36  * Youngdale). I should also mention the driver written by
37  * Hamish Macdonald for the (GASP!) Amiga A2091 card, included
38  * in the Linux-m68k distribution; it gave me a good initial
39  * understanding of the proper way to run a WD33c93 chip, and I
40  * ended up stealing lots of code from it.
41  *
42  * _This_ driver is (I feel) an improvement over the old one in
43  * several respects:
44  *    -  All problems relating to the data size of a SCSI request are
45  *          gone (as far as I know). The old driver couldn't handle
46  *          swapping to partitions because that involved 4k blocks, nor
47  *          could it deal with the st.c tape driver unmodified, because
48  *          that usually involved 4k - 32k blocks. The old driver never
49  *          quite got away from a morbid dependence on 2k block sizes -
50  *          which of course is the size of the card's fifo.
51  *
52  *    -  Target Disconnection/Reconnection is now supported. Any
53  *          system with more than one device active on the SCSI bus
54  *          will benefit from this. The driver defaults to what I'm
55  *          calling 'adaptive disconnect' - meaning that each command
56  *          is evaluated individually as to whether or not it should
57  *          be run with the option to disconnect/reselect (if the
58  *          device chooses), or as a "SCSI-bus-hog".
59  *
60  *    -  Synchronous data transfers are now supported. Because there
61  *          are a few devices (and many improperly terminated systems)
62  *          that choke when doing sync, the default is sync DISABLED
63  *          for all devices. This faster protocol can (and should!)
64  *          be enabled on selected devices via the command-line.
65  *
66  *    -  Runtime operating parameters can now be specified through
67  *       either the LILO or the 'insmod' command line. For LILO do:
68  *          "in2000=blah,blah,blah"
69  *       and with insmod go like:
70  *          "insmod /usr/src/linux/modules/in2000.o setup_strings=blah,blah"
71  *       The defaults should be good for most people. See the comment
72  *       for 'setup_strings' below for more details.
73  *
74  *    -  The old driver relied exclusively on what the Western Digital
75  *          docs call "Combination Level 2 Commands", which are a great
76  *          idea in that the CPU is relieved of a lot of interrupt
77  *          overhead. However, by accepting a certain (user-settable)
78  *          amount of additional interrupts, this driver achieves
79  *          better control over the SCSI bus, and data transfers are
80  *          almost as fast while being much easier to define, track,
81  *          and debug.
82  *
83  *    -  You can force detection of a card whose BIOS has been disabled.
84  *
85  *    -  Multiple IN2000 cards might almost be supported. I've tried to
86  *       keep it in mind, but have no way to test...
87  *
88  *
89  * TODO:
90  *       tagged queuing. multiple cards.
91  *
92  *
93  * NOTE:
94  *       When using this or any other SCSI driver as a module, you'll
95  *       find that with the stock kernel, at most _two_ SCSI hard
96  *       drives will be linked into the device list (ie, usable).
97  *       If your IN2000 card has more than 2 disks on its bus, you
98  *       might want to change the define of 'SD_EXTRA_DEVS' in the
99  *       'hosts.h' file from 2 to whatever is appropriate. It took
100  *       me a while to track down this surprisingly obscure and
101  *       undocumented little "feature".
102  *
103  *
104  * People with bug reports, wish-lists, complaints, comments,
105  * or improvements are asked to pah-leeez email me (John Shifflett)
106  * at john@geolog.com or jshiffle@netcom.com! I'm anxious to get
107  * this thing into as good a shape as possible, and I'm positive
108  * there are lots of lurking bugs and "Stupid Places".
109  *
110  * Updated for Linux 2.5 by Alan Cox <alan@redhat.com>
111  *      - Using new_eh handler
112  *      - Hopefully got all the locking right again
113  *      See "FIXME" notes for items that could do with more work
114  */
115
116 #include <linux/module.h>
117 #include <linux/blkdev.h>
118 #include <linux/interrupt.h>
119 #include <linux/string.h>
120 #include <linux/delay.h>
121 #include <linux/proc_fs.h>
122 #include <linux/ioport.h>
123 #include <linux/stat.h>
124
125 #include <asm/io.h>
126 #include <asm/system.h>
127
128 #include "scsi.h"
129 #include <scsi/scsi_host.h>
130
131 #define IN2000_VERSION    "1.33-2.5"
132 #define IN2000_DATE       "2002/11/03"
133
134 #include "in2000.h"
135
136
137 /*
138  * 'setup_strings' is a single string used to pass operating parameters and
139  * settings from the kernel/module command-line to the driver. 'setup_args[]'
140  * is an array of strings that define the compile-time default values for
141  * these settings. If Linux boots with a LILO or insmod command-line, those
142  * settings are combined with 'setup_args[]'. Note that LILO command-lines
143  * are prefixed with "in2000=" while insmod uses a "setup_strings=" prefix.
144  * The driver recognizes the following keywords (lower case required) and
145  * arguments:
146  *
147  * -  ioport:addr    -Where addr is IO address of a (usually ROM-less) card.
148  * -  noreset        -No optional args. Prevents SCSI bus reset at boot time.
149  * -  nosync:x       -x is a bitmask where the 1st 7 bits correspond with
150  *                    the 7 possible SCSI devices (bit 0 for device #0, etc).
151  *                    Set a bit to PREVENT sync negotiation on that device.
152  *                    The driver default is sync DISABLED on all devices.
153  * -  period:ns      -ns is the minimum # of nanoseconds in a SCSI data transfer
154  *                    period. Default is 500; acceptable values are 250 - 1000.
155  * -  disconnect:x   -x = 0 to never allow disconnects, 2 to always allow them.
156  *                    x = 1 does 'adaptive' disconnects, which is the default
157  *                    and generally the best choice.
158  * -  debug:x        -If 'DEBUGGING_ON' is defined, x is a bitmask that causes
159  *                    various types of debug output to printed - see the DB_xxx
160  *                    defines in in2000.h
161  * -  proc:x         -If 'PROC_INTERFACE' is defined, x is a bitmask that
162  *                    determines how the /proc interface works and what it
163  *                    does - see the PR_xxx defines in in2000.h
164  *
165  * Syntax Notes:
166  * -  Numeric arguments can be decimal or the '0x' form of hex notation. There
167  *    _must_ be a colon between a keyword and its numeric argument, with no
168  *    spaces.
169  * -  Keywords are separated by commas, no spaces, in the standard kernel
170  *    command-line manner.
171  * -  A keyword in the 'nth' comma-separated command-line member will overwrite
172  *    the 'nth' element of setup_args[]. A blank command-line member (in
173  *    other words, a comma with no preceding keyword) will _not_ overwrite
174  *    the corresponding setup_args[] element.
175  *
176  * A few LILO examples (for insmod, use 'setup_strings' instead of 'in2000'):
177  * -  in2000=ioport:0x220,noreset
178  * -  in2000=period:250,disconnect:2,nosync:0x03
179  * -  in2000=debug:0x1e
180  * -  in2000=proc:3
181  */
182
183 /* Normally, no defaults are specified... */
184 static char *setup_args[] = { "", "", "", "", "", "", "", "", "" };
185
186 /* filled in by 'insmod' */
187 static char *setup_strings;
188
189 module_param(setup_strings, charp, 0);
190
191 static inline uchar read_3393(struct IN2000_hostdata *hostdata, uchar reg_num)
192 {
193         write1_io(reg_num, IO_WD_ADDR);
194         return read1_io(IO_WD_DATA);
195 }
196
197
198 #define READ_AUX_STAT() read1_io(IO_WD_ASR)
199
200
201 static inline void write_3393(struct IN2000_hostdata *hostdata, uchar reg_num, uchar value)
202 {
203         write1_io(reg_num, IO_WD_ADDR);
204         write1_io(value, IO_WD_DATA);
205 }
206
207
208 static inline void write_3393_cmd(struct IN2000_hostdata *hostdata, uchar cmd)
209 {
210 /*   while (READ_AUX_STAT() & ASR_CIP)
211       printk("|");*/
212         write1_io(WD_COMMAND, IO_WD_ADDR);
213         write1_io(cmd, IO_WD_DATA);
214 }
215
216
217 static uchar read_1_byte(struct IN2000_hostdata *hostdata)
218 {
219         uchar asr, x = 0;
220
221         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
222         write_3393_cmd(hostdata, WD_CMD_TRANS_INFO | 0x80);
223         do {
224                 asr = READ_AUX_STAT();
225                 if (asr & ASR_DBR)
226                         x = read_3393(hostdata, WD_DATA);
227         } while (!(asr & ASR_INT));
228         return x;
229 }
230
231
232 static void write_3393_count(struct IN2000_hostdata *hostdata, unsigned long value)
233 {
234         write1_io(WD_TRANSFER_COUNT_MSB, IO_WD_ADDR);
235         write1_io((value >> 16), IO_WD_DATA);
236         write1_io((value >> 8), IO_WD_DATA);
237         write1_io(value, IO_WD_DATA);
238 }
239
240
241 static unsigned long read_3393_count(struct IN2000_hostdata *hostdata)
242 {
243         unsigned long value;
244
245         write1_io(WD_TRANSFER_COUNT_MSB, IO_WD_ADDR);
246         value = read1_io(IO_WD_DATA) << 16;
247         value |= read1_io(IO_WD_DATA) << 8;
248         value |= read1_io(IO_WD_DATA);
249         return value;
250 }
251
252
253 /* The 33c93 needs to be told which direction a command transfers its
254  * data; we use this function to figure it out. Returns true if there
255  * will be a DATA_OUT phase with this command, false otherwise.
256  * (Thanks to Joerg Dorchain for the research and suggestion.)
257  */
258 static int is_dir_out(Scsi_Cmnd * cmd)
259 {
260         switch (cmd->cmnd[0]) {
261         case WRITE_6:
262         case WRITE_10:
263         case WRITE_12:
264         case WRITE_LONG:
265         case WRITE_SAME:
266         case WRITE_BUFFER:
267         case WRITE_VERIFY:
268         case WRITE_VERIFY_12:
269         case COMPARE:
270         case COPY:
271         case COPY_VERIFY:
272         case SEARCH_EQUAL:
273         case SEARCH_HIGH:
274         case SEARCH_LOW:
275         case SEARCH_EQUAL_12:
276         case SEARCH_HIGH_12:
277         case SEARCH_LOW_12:
278         case FORMAT_UNIT:
279         case REASSIGN_BLOCKS:
280         case RESERVE:
281         case MODE_SELECT:
282         case MODE_SELECT_10:
283         case LOG_SELECT:
284         case SEND_DIAGNOSTIC:
285         case CHANGE_DEFINITION:
286         case UPDATE_BLOCK:
287         case SET_WINDOW:
288         case MEDIUM_SCAN:
289         case SEND_VOLUME_TAG:
290         case 0xea:
291                 return 1;
292         default:
293                 return 0;
294         }
295 }
296
297
298
299 static struct sx_period sx_table[] = {
300         {1, 0x20},
301         {252, 0x20},
302         {376, 0x30},
303         {500, 0x40},
304         {624, 0x50},
305         {752, 0x60},
306         {876, 0x70},
307         {1000, 0x00},
308         {0, 0}
309 };
310
311 static int round_period(unsigned int period)
312 {
313         int x;
314
315         for (x = 1; sx_table[x].period_ns; x++) {
316                 if ((period <= sx_table[x - 0].period_ns) && (period > sx_table[x - 1].period_ns)) {
317                         return x;
318                 }
319         }
320         return 7;
321 }
322
323 static uchar calc_sync_xfer(unsigned int period, unsigned int offset)
324 {
325         uchar result;
326
327         period *= 4;            /* convert SDTR code to ns */
328         result = sx_table[round_period(period)].reg_value;
329         result |= (offset < OPTIMUM_SX_OFF) ? offset : OPTIMUM_SX_OFF;
330         return result;
331 }
332
333
334
335 static void in2000_execute(struct Scsi_Host *instance);
336
337 static int in2000_queuecommand(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
338 {
339         struct Scsi_Host *instance;
340         struct IN2000_hostdata *hostdata;
341         Scsi_Cmnd *tmp;
342
343         instance = cmd->device->host;
344         hostdata = (struct IN2000_hostdata *) instance->hostdata;
345
346         DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x-%ld(", cmd->cmnd[0], cmd->pid))
347
348 /* Set up a few fields in the Scsi_Cmnd structure for our own use:
349  *  - host_scribble is the pointer to the next cmd in the input queue
350  *  - scsi_done points to the routine we call when a cmd is finished
351  *  - result is what you'd expect
352  */
353             cmd->host_scribble = NULL;
354         cmd->scsi_done = done;
355         cmd->result = 0;
356
357 /* We use the Scsi_Pointer structure that's included with each command
358  * as a scratchpad (as it's intended to be used!). The handy thing about
359  * the SCp.xxx fields is that they're always associated with a given
360  * cmd, and are preserved across disconnect-reselect. This means we
361  * can pretty much ignore SAVE_POINTERS and RESTORE_POINTERS messages
362  * if we keep all the critical pointers and counters in SCp:
363  *  - SCp.ptr is the pointer into the RAM buffer
364  *  - SCp.this_residual is the size of that buffer
365  *  - SCp.buffer points to the current scatter-gather buffer
366  *  - SCp.buffers_residual tells us how many S.G. buffers there are
367  *  - SCp.have_data_in helps keep track of >2048 byte transfers
368  *  - SCp.sent_command is not used
369  *  - SCp.phase records this command's SRCID_ER bit setting
370  */
371
372         if (cmd->use_sg) {
373                 cmd->SCp.buffer = (struct scatterlist *) cmd->request_buffer;
374                 cmd->SCp.buffers_residual = cmd->use_sg - 1;
375                 cmd->SCp.ptr = (char *) page_address(cmd->SCp.buffer->page) + cmd->SCp.buffer->offset;
376                 cmd->SCp.this_residual = cmd->SCp.buffer->length;
377         } else {
378                 cmd->SCp.buffer = NULL;
379                 cmd->SCp.buffers_residual = 0;
380                 cmd->SCp.ptr = (char *) cmd->request_buffer;
381                 cmd->SCp.this_residual = cmd->request_bufflen;
382         }
383         cmd->SCp.have_data_in = 0;
384
385 /* We don't set SCp.phase here - that's done in in2000_execute() */
386
387 /* WD docs state that at the conclusion of a "LEVEL2" command, the
388  * status byte can be retrieved from the LUN register. Apparently,
389  * this is the case only for *uninterrupted* LEVEL2 commands! If
390  * there are any unexpected phases entered, even if they are 100%
391  * legal (different devices may choose to do things differently),
392  * the LEVEL2 command sequence is exited. This often occurs prior
393  * to receiving the status byte, in which case the driver does a
394  * status phase interrupt and gets the status byte on its own.
395  * While such a command can then be "resumed" (ie restarted to
396  * finish up as a LEVEL2 command), the LUN register will NOT be
397  * a valid status byte at the command's conclusion, and we must
398  * use the byte obtained during the earlier interrupt. Here, we
399  * preset SCp.Status to an illegal value (0xff) so that when
400  * this command finally completes, we can tell where the actual
401  * status byte is stored.
402  */
403
404         cmd->SCp.Status = ILLEGAL_STATUS_BYTE;
405
406 /* We need to disable interrupts before messing with the input
407  * queue and calling in2000_execute().
408  */
409
410         /*
411          * Add the cmd to the end of 'input_Q'. Note that REQUEST_SENSE
412          * commands are added to the head of the queue so that the desired
413          * sense data is not lost before REQUEST_SENSE executes.
414          */
415
416         if (!(hostdata->input_Q) || (cmd->cmnd[0] == REQUEST_SENSE)) {
417                 cmd->host_scribble = (uchar *) hostdata->input_Q;
418                 hostdata->input_Q = cmd;
419         } else {                /* find the end of the queue */
420                 for (tmp = (Scsi_Cmnd *) hostdata->input_Q; tmp->host_scribble; tmp = (Scsi_Cmnd *) tmp->host_scribble);
421                 tmp->host_scribble = (uchar *) cmd;
422         }
423
424 /* We know that there's at least one command in 'input_Q' now.
425  * Go see if any of them are runnable!
426  */
427
428         in2000_execute(cmd->device->host);
429
430         DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->pid))
431             return 0;
432 }
433
434
435
436 /*
437  * This routine attempts to start a scsi command. If the host_card is
438  * already connected, we give up immediately. Otherwise, look through
439  * the input_Q, using the first command we find that's intended
440  * for a currently non-busy target/lun.
441  * Note that this function is always called with interrupts already
442  * disabled (either from in2000_queuecommand() or in2000_intr()).
443  */
444 static void in2000_execute(struct Scsi_Host *instance)
445 {
446         struct IN2000_hostdata *hostdata;
447         Scsi_Cmnd *cmd, *prev;
448         int i;
449         unsigned short *sp;
450         unsigned short f;
451         unsigned short flushbuf[16];
452
453
454         hostdata = (struct IN2000_hostdata *) instance->hostdata;
455
456         DB(DB_EXECUTE, printk("EX("))
457
458             if (hostdata->selecting || hostdata->connected) {
459
460                 DB(DB_EXECUTE, printk(")EX-0 "))
461
462                     return;
463         }
464
465         /*
466          * Search through the input_Q for a command destined
467          * for an idle target/lun.
468          */
469
470         cmd = (Scsi_Cmnd *) hostdata->input_Q;
471         prev = NULL;
472         while (cmd) {
473                 if (!(hostdata->busy[cmd->device->id] & (1 << cmd->device->lun)))
474                         break;
475                 prev = cmd;
476                 cmd = (Scsi_Cmnd *) cmd->host_scribble;
477         }
478
479         /* quit if queue empty or all possible targets are busy */
480
481         if (!cmd) {
482
483                 DB(DB_EXECUTE, printk(")EX-1 "))
484
485                     return;
486         }
487
488         /*  remove command from queue */
489
490         if (prev)
491                 prev->host_scribble = cmd->host_scribble;
492         else
493                 hostdata->input_Q = (Scsi_Cmnd *) cmd->host_scribble;
494
495 #ifdef PROC_STATISTICS
496         hostdata->cmd_cnt[cmd->device->id]++;
497 #endif
498
499 /*
500  * Start the selection process
501  */
502
503         if (is_dir_out(cmd))
504                 write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id);
505         else
506                 write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
507
508 /* Now we need to figure out whether or not this command is a good
509  * candidate for disconnect/reselect. We guess to the best of our
510  * ability, based on a set of hierarchical rules. When several
511  * devices are operating simultaneously, disconnects are usually
512  * an advantage. In a single device system, or if only 1 device
513  * is being accessed, transfers usually go faster if disconnects
514  * are not allowed:
515  *
516  * + Commands should NEVER disconnect if hostdata->disconnect =
517  *   DIS_NEVER (this holds for tape drives also), and ALWAYS
518  *   disconnect if hostdata->disconnect = DIS_ALWAYS.
519  * + Tape drive commands should always be allowed to disconnect.
520  * + Disconnect should be allowed if disconnected_Q isn't empty.
521  * + Commands should NOT disconnect if input_Q is empty.
522  * + Disconnect should be allowed if there are commands in input_Q
523  *   for a different target/lun. In this case, the other commands
524  *   should be made disconnect-able, if not already.
525  *
526  * I know, I know - this code would flunk me out of any
527  * "C Programming 101" class ever offered. But it's easy
528  * to change around and experiment with for now.
529  */
530
531         cmd->SCp.phase = 0;     /* assume no disconnect */
532         if (hostdata->disconnect == DIS_NEVER)
533                 goto no;
534         if (hostdata->disconnect == DIS_ALWAYS)
535                 goto yes;
536         if (cmd->device->type == 1)     /* tape drive? */
537                 goto yes;
538         if (hostdata->disconnected_Q)   /* other commands disconnected? */
539                 goto yes;
540         if (!(hostdata->input_Q))       /* input_Q empty? */
541                 goto no;
542         for (prev = (Scsi_Cmnd *) hostdata->input_Q; prev; prev = (Scsi_Cmnd *) prev->host_scribble) {
543                 if ((prev->device->id != cmd->device->id) || (prev->device->lun != cmd->device->lun)) {
544                         for (prev = (Scsi_Cmnd *) hostdata->input_Q; prev; prev = (Scsi_Cmnd *) prev->host_scribble)
545                                 prev->SCp.phase = 1;
546                         goto yes;
547                 }
548         }
549         goto no;
550
551       yes:
552         cmd->SCp.phase = 1;
553
554 #ifdef PROC_STATISTICS
555         hostdata->disc_allowed_cnt[cmd->device->id]++;
556 #endif
557
558       no:
559         write_3393(hostdata, WD_SOURCE_ID, ((cmd->SCp.phase) ? SRCID_ER : 0));
560
561         write_3393(hostdata, WD_TARGET_LUN, cmd->device->lun);
562         write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, hostdata->sync_xfer[cmd->device->id]);
563         hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
564
565         if ((hostdata->level2 <= L2_NONE) || (hostdata->sync_stat[cmd->device->id] == SS_UNSET)) {
566
567                 /*
568                  * Do a 'Select-With-ATN' command. This will end with
569                  * one of the following interrupts:
570                  *    CSR_RESEL_AM:  failure - can try again later.
571                  *    CSR_TIMEOUT:   failure - give up.
572                  *    CSR_SELECT:    success - proceed.
573                  */
574
575                 hostdata->selecting = cmd;
576
577 /* Every target has its own synchronous transfer setting, kept in
578  * the sync_xfer array, and a corresponding status byte in sync_stat[].
579  * Each target's sync_stat[] entry is initialized to SS_UNSET, and its
580  * sync_xfer[] entry is initialized to the default/safe value. SS_UNSET
581  * means that the parameters are undetermined as yet, and that we
582  * need to send an SDTR message to this device after selection is
583  * complete. We set SS_FIRST to tell the interrupt routine to do so,
584  * unless we don't want to even _try_ synchronous transfers: In this
585  * case we set SS_SET to make the defaults final.
586  */
587                 if (hostdata->sync_stat[cmd->device->id] == SS_UNSET) {
588                         if (hostdata->sync_off & (1 << cmd->device->id))
589                                 hostdata->sync_stat[cmd->device->id] = SS_SET;
590                         else
591                                 hostdata->sync_stat[cmd->device->id] = SS_FIRST;
592                 }
593                 hostdata->state = S_SELECTING;
594                 write_3393_count(hostdata, 0);  /* this guarantees a DATA_PHASE interrupt */
595                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN);
596         }
597
598         else {
599
600                 /*
601                  * Do a 'Select-With-ATN-Xfer' command. This will end with
602                  * one of the following interrupts:
603                  *    CSR_RESEL_AM:  failure - can try again later.
604                  *    CSR_TIMEOUT:   failure - give up.
605                  *    anything else: success - proceed.
606                  */
607
608                 hostdata->connected = cmd;
609                 write_3393(hostdata, WD_COMMAND_PHASE, 0);
610
611                 /* copy command_descriptor_block into WD chip
612                  * (take advantage of auto-incrementing)
613                  */
614
615                 write1_io(WD_CDB_1, IO_WD_ADDR);
616                 for (i = 0; i < cmd->cmd_len; i++)
617                         write1_io(cmd->cmnd[i], IO_WD_DATA);
618
619                 /* The wd33c93 only knows about Group 0, 1, and 5 commands when
620                  * it's doing a 'select-and-transfer'. To be safe, we write the
621                  * size of the CDB into the OWN_ID register for every case. This
622                  * way there won't be problems with vendor-unique, audio, etc.
623                  */
624
625                 write_3393(hostdata, WD_OWN_ID, cmd->cmd_len);
626
627                 /* When doing a non-disconnect command, we can save ourselves a DATA
628                  * phase interrupt later by setting everything up now. With writes we
629                  * need to pre-fill the fifo; if there's room for the 32 flush bytes,
630                  * put them in there too - that'll avoid a fifo interrupt. Reads are
631                  * somewhat simpler.
632                  * KLUDGE NOTE: It seems that you can't completely fill the fifo here:
633                  * This results in the IO_FIFO_COUNT register rolling over to zero,
634                  * and apparently the gate array logic sees this as empty, not full,
635                  * so the 3393 chip is never signalled to start reading from the
636                  * fifo. Or maybe it's seen as a permanent fifo interrupt condition.
637                  * Regardless, we fix this by temporarily pretending that the fifo
638                  * is 16 bytes smaller. (I see now that the old driver has a comment
639                  * about "don't fill completely" in an analogous place - must be the
640                  * same deal.) This results in CDROM, swap partitions, and tape drives
641                  * needing an extra interrupt per write command - I think we can live
642                  * with that!
643                  */
644
645                 if (!(cmd->SCp.phase)) {
646                         write_3393_count(hostdata, cmd->SCp.this_residual);
647                         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_BUS);
648                         write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter, write mode */
649
650                         if (is_dir_out(cmd)) {
651                                 hostdata->fifo = FI_FIFO_WRITING;
652                                 if ((i = cmd->SCp.this_residual) > (IN2000_FIFO_SIZE - 16))
653                                         i = IN2000_FIFO_SIZE - 16;
654                                 cmd->SCp.have_data_in = i;      /* this much data in fifo */
655                                 i >>= 1;        /* Gulp. Assuming modulo 2. */
656                                 sp = (unsigned short *) cmd->SCp.ptr;
657                                 f = hostdata->io_base + IO_FIFO;
658
659 #ifdef FAST_WRITE_IO
660
661                                 FAST_WRITE2_IO();
662 #else
663                                 while (i--)
664                                         write2_io(*sp++, IO_FIFO);
665
666 #endif
667
668                                 /* Is there room for the flush bytes? */
669
670                                 if (cmd->SCp.have_data_in <= ((IN2000_FIFO_SIZE - 16) - 32)) {
671                                         sp = flushbuf;
672                                         i = 16;
673
674 #ifdef FAST_WRITE_IO
675
676                                         FAST_WRITE2_IO();
677 #else
678                                         while (i--)
679                                                 write2_io(0, IO_FIFO);
680
681 #endif
682
683                                 }
684                         }
685
686                         else {
687                                 write1_io(0, IO_FIFO_READ);     /* put fifo in read mode */
688                                 hostdata->fifo = FI_FIFO_READING;
689                                 cmd->SCp.have_data_in = 0;      /* nothing transferred yet */
690                         }
691
692                 } else {
693                         write_3393_count(hostdata, 0);  /* this guarantees a DATA_PHASE interrupt */
694                 }
695                 hostdata->state = S_RUNNING_LEVEL2;
696                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
697         }
698
699         /*
700          * Since the SCSI bus can handle only 1 connection at a time,
701          * we get out of here now. If the selection fails, or when
702          * the command disconnects, we'll come back to this routine
703          * to search the input_Q again...
704          */
705
706         DB(DB_EXECUTE, printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->pid))
707
708 }
709
710
711
712 static void transfer_pio(uchar * buf, int cnt, int data_in_dir, struct IN2000_hostdata *hostdata)
713 {
714         uchar asr;
715
716         DB(DB_TRANSFER, printk("(%p,%d,%s)", buf, cnt, data_in_dir ? "in" : "out"))
717
718             write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
719         write_3393_count(hostdata, cnt);
720         write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
721         if (data_in_dir) {
722                 do {
723                         asr = READ_AUX_STAT();
724                         if (asr & ASR_DBR)
725                                 *buf++ = read_3393(hostdata, WD_DATA);
726                 } while (!(asr & ASR_INT));
727         } else {
728                 do {
729                         asr = READ_AUX_STAT();
730                         if (asr & ASR_DBR)
731                                 write_3393(hostdata, WD_DATA, *buf++);
732                 } while (!(asr & ASR_INT));
733         }
734
735         /* Note: we are returning with the interrupt UN-cleared.
736          * Since (presumably) an entire I/O operation has
737          * completed, the bus phase is probably different, and
738          * the interrupt routine will discover this when it
739          * responds to the uncleared int.
740          */
741
742 }
743
744
745
746 static void transfer_bytes(Scsi_Cmnd * cmd, int data_in_dir)
747 {
748         struct IN2000_hostdata *hostdata;
749         unsigned short *sp;
750         unsigned short f;
751         int i;
752
753         hostdata = (struct IN2000_hostdata *) cmd->device->host->hostdata;
754
755 /* Normally, you'd expect 'this_residual' to be non-zero here.
756  * In a series of scatter-gather transfers, however, this
757  * routine will usually be called with 'this_residual' equal
758  * to 0 and 'buffers_residual' non-zero. This means that a
759  * previous transfer completed, clearing 'this_residual', and
760  * now we need to setup the next scatter-gather buffer as the
761  * source or destination for THIS transfer.
762  */
763         if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
764                 ++cmd->SCp.buffer;
765                 --cmd->SCp.buffers_residual;
766                 cmd->SCp.this_residual = cmd->SCp.buffer->length;
767                 cmd->SCp.ptr = page_address(cmd->SCp.buffer->page) + cmd->SCp.buffer->offset;
768         }
769
770 /* Set up hardware registers */
771
772         write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, hostdata->sync_xfer[cmd->device->id]);
773         write_3393_count(hostdata, cmd->SCp.this_residual);
774         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_BUS);
775         write1_io(0, IO_FIFO_WRITE);    /* zero counter, assume write */
776
777 /* Reading is easy. Just issue the command and return - we'll
778  * get an interrupt later when we have actual data to worry about.
779  */
780
781         if (data_in_dir) {
782                 write1_io(0, IO_FIFO_READ);
783                 if ((hostdata->level2 >= L2_DATA) || (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
784                         write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
785                         write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
786                         hostdata->state = S_RUNNING_LEVEL2;
787                 } else
788                         write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
789                 hostdata->fifo = FI_FIFO_READING;
790                 cmd->SCp.have_data_in = 0;
791                 return;
792         }
793
794 /* Writing is more involved - we'll start the WD chip and write as
795  * much data to the fifo as we can right now. Later interrupts will
796  * write any bytes that don't make it at this stage.
797  */
798
799         if ((hostdata->level2 >= L2_DATA) || (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
800                 write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
801                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
802                 hostdata->state = S_RUNNING_LEVEL2;
803         } else
804                 write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
805         hostdata->fifo = FI_FIFO_WRITING;
806         sp = (unsigned short *) cmd->SCp.ptr;
807
808         if ((i = cmd->SCp.this_residual) > IN2000_FIFO_SIZE)
809                 i = IN2000_FIFO_SIZE;
810         cmd->SCp.have_data_in = i;
811         i >>= 1;                /* Gulp. We assume this_residual is modulo 2 */
812         f = hostdata->io_base + IO_FIFO;
813
814 #ifdef FAST_WRITE_IO
815
816         FAST_WRITE2_IO();
817 #else
818         while (i--)
819                 write2_io(*sp++, IO_FIFO);
820
821 #endif
822
823 }
824
825
826 /* We need to use spin_lock_irqsave() & spin_unlock_irqrestore() in this
827  * function in order to work in an SMP environment. (I'd be surprised
828  * if the driver is ever used by anyone on a real multi-CPU motherboard,
829  * but it _does_ need to be able to compile and run in an SMP kernel.)
830  */
831
832 static irqreturn_t in2000_intr(int irqnum, void *dev_id, struct pt_regs *ptregs)
833 {
834         struct Scsi_Host *instance = dev_id;
835         struct IN2000_hostdata *hostdata;
836         Scsi_Cmnd *patch, *cmd;
837         uchar asr, sr, phs, id, lun, *ucp, msg;
838         int i, j;
839         unsigned long length;
840         unsigned short *sp;
841         unsigned short f;
842         unsigned long flags;
843
844         hostdata = (struct IN2000_hostdata *) instance->hostdata;
845
846 /* Get the spin_lock and disable further ints, for SMP */
847
848         spin_lock_irqsave(instance->host_lock, flags);
849
850 #ifdef PROC_STATISTICS
851         hostdata->int_cnt++;
852 #endif
853
854 /* The IN2000 card has 2 interrupt sources OR'ed onto its IRQ line - the
855  * WD3393 chip and the 2k fifo (which is actually a dual-port RAM combined
856  * with a big logic array, so it's a little different than what you might
857  * expect). As far as I know, there's no reason that BOTH can't be active
858  * at the same time, but there's a problem: while we can read the 3393
859  * to tell if _it_ wants an interrupt, I don't know of a way to ask the
860  * fifo the same question. The best we can do is check the 3393 and if
861  * it _isn't_ the source of the interrupt, then we can be pretty sure
862  * that the fifo is the culprit.
863  *  UPDATE: I have it on good authority (Bill Earnest) that bit 0 of the
864  *          IO_FIFO_COUNT register mirrors the fifo interrupt state. I
865  *          assume that bit clear means interrupt active. As it turns
866  *          out, the driver really doesn't need to check for this after
867  *          all, so my remarks above about a 'problem' can safely be
868  *          ignored. The way the logic is set up, there's no advantage
869  *          (that I can see) to worrying about it.
870  *
871  * It seems that the fifo interrupt signal is negated when we extract
872  * bytes during read or write bytes during write.
873  *  - fifo will interrupt when data is moving from it to the 3393, and
874  *    there are 31 (or less?) bytes left to go. This is sort of short-
875  *    sighted: what if you don't WANT to do more? In any case, our
876  *    response is to push more into the fifo - either actual data or
877  *    dummy bytes if need be. Note that we apparently have to write at
878  *    least 32 additional bytes to the fifo after an interrupt in order
879  *    to get it to release the ones it was holding on to - writing fewer
880  *    than 32 will result in another fifo int.
881  *  UPDATE: Again, info from Bill Earnest makes this more understandable:
882  *          32 bytes = two counts of the fifo counter register. He tells
883  *          me that the fifo interrupt is a non-latching signal derived
884  *          from a straightforward boolean interpretation of the 7
885  *          highest bits of the fifo counter and the fifo-read/fifo-write
886  *          state. Who'd a thought?
887  */
888
889         write1_io(0, IO_LED_ON);
890         asr = READ_AUX_STAT();
891         if (!(asr & ASR_INT)) { /* no WD33c93 interrupt? */
892
893 /* Ok. This is definitely a FIFO-only interrupt.
894  *
895  * If FI_FIFO_READING is set, there are up to 2048 bytes waiting to be read,
896  * maybe more to come from the SCSI bus. Read as many as we can out of the
897  * fifo and into memory at the location of SCp.ptr[SCp.have_data_in], and
898  * update have_data_in afterwards.
899  *
900  * If we have FI_FIFO_WRITING, the FIFO has almost run out of bytes to move
901  * into the WD3393 chip (I think the interrupt happens when there are 31
902  * bytes left, but it may be fewer...). The 3393 is still waiting, so we
903  * shove some more into the fifo, which gets things moving again. If the
904  * original SCSI command specified more than 2048 bytes, there may still
905  * be some of that data left: fine - use it (from SCp.ptr[SCp.have_data_in]).
906  * Don't forget to update have_data_in. If we've already written out the
907  * entire buffer, feed 32 dummy bytes to the fifo - they're needed to
908  * push out the remaining real data.
909  *    (Big thanks to Bill Earnest for getting me out of the mud in here.)
910  */
911
912                 cmd = (Scsi_Cmnd *) hostdata->connected;        /* assume we're connected */
913                 CHECK_NULL(cmd, "fifo_int")
914
915                     if (hostdata->fifo == FI_FIFO_READING) {
916
917                         DB(DB_FIFO, printk("{R:%02x} ", read1_io(IO_FIFO_COUNT)))
918
919                             sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
920                         i = read1_io(IO_FIFO_COUNT) & 0xfe;
921                         i <<= 2;        /* # of words waiting in the fifo */
922                         f = hostdata->io_base + IO_FIFO;
923
924 #ifdef FAST_READ_IO
925
926                         FAST_READ2_IO();
927 #else
928                         while (i--)
929                                 *sp++ = read2_io(IO_FIFO);
930
931 #endif
932
933                         i = sp - (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
934                         i <<= 1;
935                         cmd->SCp.have_data_in += i;
936                 }
937
938                 else if (hostdata->fifo == FI_FIFO_WRITING) {
939
940                         DB(DB_FIFO, printk("{W:%02x} ", read1_io(IO_FIFO_COUNT)))
941
942 /* If all bytes have been written to the fifo, flush out the stragglers.
943  * Note that while writing 16 dummy words seems arbitrary, we don't
944  * have another choice that I can see. What we really want is to read
945  * the 3393 transfer count register (that would tell us how many bytes
946  * needed flushing), but the TRANSFER_INFO command hasn't completed
947  * yet (not enough bytes!) and that register won't be accessible. So,
948  * we use 16 words - a number obtained through trial and error.
949  *  UPDATE: Bill says this is exactly what Always does, so there.
950  *          More thanks due him for help in this section.
951  */
952                             if (cmd->SCp.this_residual == cmd->SCp.have_data_in) {
953                                 i = 16;
954                                 while (i--)     /* write 32 dummy bytes */
955                                         write2_io(0, IO_FIFO);
956                         }
957
958 /* If there are still bytes left in the SCSI buffer, write as many as we
959  * can out to the fifo.
960  */
961
962                         else {
963                                 sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
964                                 i = cmd->SCp.this_residual - cmd->SCp.have_data_in;     /* bytes yet to go */
965                                 j = read1_io(IO_FIFO_COUNT) & 0xfe;
966                                 j <<= 2;        /* how many words the fifo has room for */
967                                 if ((j << 1) > i)
968                                         j = (i >> 1);
969                                 while (j--)
970                                         write2_io(*sp++, IO_FIFO);
971
972                                 i = sp - (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
973                                 i <<= 1;
974                                 cmd->SCp.have_data_in += i;
975                         }
976                 }
977
978                 else {
979                         printk("*** Spurious FIFO interrupt ***");
980                 }
981
982                 write1_io(0, IO_LED_OFF);
983
984 /* release the SMP spin_lock and restore irq state */
985                 spin_unlock_irqrestore(instance->host_lock, flags);
986                 return IRQ_HANDLED;
987         }
988
989 /* This interrupt was triggered by the WD33c93 chip. The fifo interrupt
990  * may also be asserted, but we don't bother to check it: we get more
991  * detailed info from FIFO_READING and FIFO_WRITING (see below).
992  */
993
994         cmd = (Scsi_Cmnd *) hostdata->connected;        /* assume we're connected */
995         sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear the interrupt */
996         phs = read_3393(hostdata, WD_COMMAND_PHASE);
997
998         if (!cmd && (sr != CSR_RESEL_AM && sr != CSR_TIMEOUT && sr != CSR_SELECT)) {
999                 printk("\nNR:wd-intr-1\n");
1000                 write1_io(0, IO_LED_OFF);
1001
1002 /* release the SMP spin_lock and restore irq state */
1003                 spin_unlock_irqrestore(instance->host_lock, flags);
1004                 return IRQ_HANDLED;
1005         }
1006
1007         DB(DB_INTR, printk("{%02x:%02x-", asr, sr))
1008
1009 /* After starting a FIFO-based transfer, the next _WD3393_ interrupt is
1010  * guaranteed to be in response to the completion of the transfer.
1011  * If we were reading, there's probably data in the fifo that needs
1012  * to be copied into RAM - do that here. Also, we have to update
1013  * 'this_residual' and 'ptr' based on the contents of the
1014  * TRANSFER_COUNT register, in case the device decided to do an
1015  * intermediate disconnect (a device may do this if it has to
1016  * do a seek,  or just to be nice and let other devices have
1017  * some bus time during long transfers).
1018  * After doing whatever is necessary with the fifo, we go on and
1019  * service the WD3393 interrupt normally.
1020  */
1021             if (hostdata->fifo == FI_FIFO_READING) {
1022
1023 /* buffer index = start-of-buffer + #-of-bytes-already-read */
1024
1025                 sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
1026
1027 /* bytes remaining in fifo = (total-wanted - #-not-got) - #-already-read */
1028
1029                 i = (cmd->SCp.this_residual - read_3393_count(hostdata)) - cmd->SCp.have_data_in;
1030                 i >>= 1;        /* Gulp. We assume this will always be modulo 2 */
1031                 f = hostdata->io_base + IO_FIFO;
1032
1033 #ifdef FAST_READ_IO
1034
1035                 FAST_READ2_IO();
1036 #else
1037                 while (i--)
1038                         *sp++ = read2_io(IO_FIFO);
1039
1040 #endif
1041
1042                 hostdata->fifo = FI_FIFO_UNUSED;
1043                 length = cmd->SCp.this_residual;
1044                 cmd->SCp.this_residual = read_3393_count(hostdata);
1045                 cmd->SCp.ptr += (length - cmd->SCp.this_residual);
1046
1047                 DB(DB_TRANSFER, printk("(%p,%d)", cmd->SCp.ptr, cmd->SCp.this_residual))
1048
1049         }
1050
1051         else if (hostdata->fifo == FI_FIFO_WRITING) {
1052                 hostdata->fifo = FI_FIFO_UNUSED;
1053                 length = cmd->SCp.this_residual;
1054                 cmd->SCp.this_residual = read_3393_count(hostdata);
1055                 cmd->SCp.ptr += (length - cmd->SCp.this_residual);
1056
1057                 DB(DB_TRANSFER, printk("(%p,%d)", cmd->SCp.ptr, cmd->SCp.this_residual))
1058
1059         }
1060
1061 /* Respond to the specific WD3393 interrupt - there are quite a few! */
1062
1063         switch (sr) {
1064
1065         case CSR_TIMEOUT:
1066                 DB(DB_INTR, printk("TIMEOUT"))
1067
1068                     if (hostdata->state == S_RUNNING_LEVEL2)
1069                         hostdata->connected = NULL;
1070                 else {
1071                         cmd = (Scsi_Cmnd *) hostdata->selecting;        /* get a valid cmd */
1072                         CHECK_NULL(cmd, "csr_timeout")
1073                             hostdata->selecting = NULL;
1074                 }
1075
1076                 cmd->result = DID_NO_CONNECT << 16;
1077                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1078                 hostdata->state = S_UNCONNECTED;
1079                 cmd->scsi_done(cmd);
1080
1081 /* We are not connected to a target - check to see if there
1082  * are commands waiting to be executed.
1083  */
1084
1085                 in2000_execute(instance);
1086                 break;
1087
1088
1089 /* Note: this interrupt should not occur in a LEVEL2 command */
1090
1091         case CSR_SELECT:
1092                 DB(DB_INTR, printk("SELECT"))
1093                     hostdata->connected = cmd = (Scsi_Cmnd *) hostdata->selecting;
1094                 CHECK_NULL(cmd, "csr_select")
1095                     hostdata->selecting = NULL;
1096
1097                 /* construct an IDENTIFY message with correct disconnect bit */
1098
1099                 hostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->device->lun);
1100                 if (cmd->SCp.phase)
1101                         hostdata->outgoing_msg[0] |= 0x40;
1102
1103                 if (hostdata->sync_stat[cmd->device->id] == SS_FIRST) {
1104 #ifdef SYNC_DEBUG
1105                         printk(" sending SDTR ");
1106 #endif
1107
1108                         hostdata->sync_stat[cmd->device->id] = SS_WAITING;
1109
1110                         /* tack on a 2nd message to ask about synchronous transfers */
1111
1112                         hostdata->outgoing_msg[1] = EXTENDED_MESSAGE;
1113                         hostdata->outgoing_msg[2] = 3;
1114                         hostdata->outgoing_msg[3] = EXTENDED_SDTR;
1115                         hostdata->outgoing_msg[4] = OPTIMUM_SX_PER / 4;
1116                         hostdata->outgoing_msg[5] = OPTIMUM_SX_OFF;
1117                         hostdata->outgoing_len = 6;
1118                 } else
1119                         hostdata->outgoing_len = 1;
1120
1121                 hostdata->state = S_CONNECTED;
1122                 break;
1123
1124
1125         case CSR_XFER_DONE | PHS_DATA_IN:
1126         case CSR_UNEXP | PHS_DATA_IN:
1127         case CSR_SRV_REQ | PHS_DATA_IN:
1128                 DB(DB_INTR, printk("IN-%d.%d", cmd->SCp.this_residual, cmd->SCp.buffers_residual))
1129                     transfer_bytes(cmd, DATA_IN_DIR);
1130                 if (hostdata->state != S_RUNNING_LEVEL2)
1131                         hostdata->state = S_CONNECTED;
1132                 break;
1133
1134
1135         case CSR_XFER_DONE | PHS_DATA_OUT:
1136         case CSR_UNEXP | PHS_DATA_OUT:
1137         case CSR_SRV_REQ | PHS_DATA_OUT:
1138                 DB(DB_INTR, printk("OUT-%d.%d", cmd->SCp.this_residual, cmd->SCp.buffers_residual))
1139                     transfer_bytes(cmd, DATA_OUT_DIR);
1140                 if (hostdata->state != S_RUNNING_LEVEL2)
1141                         hostdata->state = S_CONNECTED;
1142                 break;
1143
1144
1145 /* Note: this interrupt should not occur in a LEVEL2 command */
1146
1147         case CSR_XFER_DONE | PHS_COMMAND:
1148         case CSR_UNEXP | PHS_COMMAND:
1149         case CSR_SRV_REQ | PHS_COMMAND:
1150                 DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->pid))
1151                     transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
1152                 hostdata->state = S_CONNECTED;
1153                 break;
1154
1155
1156         case CSR_XFER_DONE | PHS_STATUS:
1157         case CSR_UNEXP | PHS_STATUS:
1158         case CSR_SRV_REQ | PHS_STATUS:
1159                 DB(DB_INTR, printk("STATUS="))
1160
1161                     cmd->SCp.Status = read_1_byte(hostdata);
1162                 DB(DB_INTR, printk("%02x", cmd->SCp.Status))
1163                     if (hostdata->level2 >= L2_BASIC) {
1164                         sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear interrupt */
1165                         hostdata->state = S_RUNNING_LEVEL2;
1166                         write_3393(hostdata, WD_COMMAND_PHASE, 0x50);
1167                         write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1168                 } else {
1169                         hostdata->state = S_CONNECTED;
1170                 }
1171                 break;
1172
1173
1174         case CSR_XFER_DONE | PHS_MESS_IN:
1175         case CSR_UNEXP | PHS_MESS_IN:
1176         case CSR_SRV_REQ | PHS_MESS_IN:
1177                 DB(DB_INTR, printk("MSG_IN="))
1178
1179                     msg = read_1_byte(hostdata);
1180                 sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear interrupt */
1181
1182                 hostdata->incoming_msg[hostdata->incoming_ptr] = msg;
1183                 if (hostdata->incoming_msg[0] == EXTENDED_MESSAGE)
1184                         msg = EXTENDED_MESSAGE;
1185                 else
1186                         hostdata->incoming_ptr = 0;
1187
1188                 cmd->SCp.Message = msg;
1189                 switch (msg) {
1190
1191                 case COMMAND_COMPLETE:
1192                         DB(DB_INTR, printk("CCMP-%ld", cmd->pid))
1193                             write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1194                         hostdata->state = S_PRE_CMP_DISC;
1195                         break;
1196
1197                 case SAVE_POINTERS:
1198                         DB(DB_INTR, printk("SDP"))
1199                             write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1200                         hostdata->state = S_CONNECTED;
1201                         break;
1202
1203                 case RESTORE_POINTERS:
1204                         DB(DB_INTR, printk("RDP"))
1205                             if (hostdata->level2 >= L2_BASIC) {
1206                                 write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
1207                                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1208                                 hostdata->state = S_RUNNING_LEVEL2;
1209                         } else {
1210                                 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1211                                 hostdata->state = S_CONNECTED;
1212                         }
1213                         break;
1214
1215                 case DISCONNECT:
1216                         DB(DB_INTR, printk("DIS"))
1217                             cmd->device->disconnect = 1;
1218                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1219                         hostdata->state = S_PRE_TMP_DISC;
1220                         break;
1221
1222                 case MESSAGE_REJECT:
1223                         DB(DB_INTR, printk("REJ"))
1224 #ifdef SYNC_DEBUG
1225                             printk("-REJ-");
1226 #endif
1227                         if (hostdata->sync_stat[cmd->device->id] == SS_WAITING)
1228                                 hostdata->sync_stat[cmd->device->id] = SS_SET;
1229                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1230                         hostdata->state = S_CONNECTED;
1231                         break;
1232
1233                 case EXTENDED_MESSAGE:
1234                         DB(DB_INTR, printk("EXT"))
1235
1236                             ucp = hostdata->incoming_msg;
1237
1238 #ifdef SYNC_DEBUG
1239                         printk("%02x", ucp[hostdata->incoming_ptr]);
1240 #endif
1241                         /* Is this the last byte of the extended message? */
1242
1243                         if ((hostdata->incoming_ptr >= 2) && (hostdata->incoming_ptr == (ucp[1] + 1))) {
1244
1245                                 switch (ucp[2]) {       /* what's the EXTENDED code? */
1246                                 case EXTENDED_SDTR:
1247                                         id = calc_sync_xfer(ucp[3], ucp[4]);
1248                                         if (hostdata->sync_stat[cmd->device->id] != SS_WAITING) {
1249
1250 /* A device has sent an unsolicited SDTR message; rather than go
1251  * through the effort of decoding it and then figuring out what
1252  * our reply should be, we're just gonna say that we have a
1253  * synchronous fifo depth of 0. This will result in asynchronous
1254  * transfers - not ideal but so much easier.
1255  * Actually, this is OK because it assures us that if we don't
1256  * specifically ask for sync transfers, we won't do any.
1257  */
1258
1259                                                 write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1260                                                 hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
1261                                                 hostdata->outgoing_msg[1] = 3;
1262                                                 hostdata->outgoing_msg[2] = EXTENDED_SDTR;
1263                                                 hostdata->outgoing_msg[3] = hostdata->default_sx_per / 4;
1264                                                 hostdata->outgoing_msg[4] = 0;
1265                                                 hostdata->outgoing_len = 5;
1266                                                 hostdata->sync_xfer[cmd->device->id] = calc_sync_xfer(hostdata->default_sx_per / 4, 0);
1267                                         } else {
1268                                                 hostdata->sync_xfer[cmd->device->id] = id;
1269                                         }
1270 #ifdef SYNC_DEBUG
1271                                         printk("sync_xfer=%02x", hostdata->sync_xfer[cmd->device->id]);
1272 #endif
1273                                         hostdata->sync_stat[cmd->device->id] = SS_SET;
1274                                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1275                                         hostdata->state = S_CONNECTED;
1276                                         break;
1277                                 case EXTENDED_WDTR:
1278                                         write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1279                                         printk("sending WDTR ");
1280                                         hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
1281                                         hostdata->outgoing_msg[1] = 2;
1282                                         hostdata->outgoing_msg[2] = EXTENDED_WDTR;
1283                                         hostdata->outgoing_msg[3] = 0;  /* 8 bit transfer width */
1284                                         hostdata->outgoing_len = 4;
1285                                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1286                                         hostdata->state = S_CONNECTED;
1287                                         break;
1288                                 default:
1289                                         write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1290                                         printk("Rejecting Unknown Extended Message(%02x). ", ucp[2]);
1291                                         hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1292                                         hostdata->outgoing_len = 1;
1293                                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1294                                         hostdata->state = S_CONNECTED;
1295                                         break;
1296                                 }
1297                                 hostdata->incoming_ptr = 0;
1298                         }
1299
1300                         /* We need to read more MESS_IN bytes for the extended message */
1301
1302                         else {
1303                                 hostdata->incoming_ptr++;
1304                                 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1305                                 hostdata->state = S_CONNECTED;
1306                         }
1307                         break;
1308
1309                 default:
1310                         printk("Rejecting Unknown Message(%02x) ", msg);
1311                         write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1312                         hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1313                         hostdata->outgoing_len = 1;
1314                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1315                         hostdata->state = S_CONNECTED;
1316                 }
1317                 break;
1318
1319
1320 /* Note: this interrupt will occur only after a LEVEL2 command */
1321
1322         case CSR_SEL_XFER_DONE:
1323
1324 /* Make sure that reselection is enabled at this point - it may
1325  * have been turned off for the command that just completed.
1326  */
1327
1328                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1329                 if (phs == 0x60) {
1330                         DB(DB_INTR, printk("SX-DONE-%ld", cmd->pid))
1331                             cmd->SCp.Message = COMMAND_COMPLETE;
1332                         lun = read_3393(hostdata, WD_TARGET_LUN);
1333                         DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
1334                             hostdata->connected = NULL;
1335                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1336                         hostdata->state = S_UNCONNECTED;
1337                         if (cmd->SCp.Status == ILLEGAL_STATUS_BYTE)
1338                                 cmd->SCp.Status = lun;
1339                         if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1340                                 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1341                         else
1342                                 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1343                         cmd->scsi_done(cmd);
1344
1345 /* We are no longer connected to a target - check to see if
1346  * there are commands waiting to be executed.
1347  */
1348
1349                         in2000_execute(instance);
1350                 } else {
1351                         printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs, cmd->pid);
1352                 }
1353                 break;
1354
1355
1356 /* Note: this interrupt will occur only after a LEVEL2 command */
1357
1358         case CSR_SDP:
1359                 DB(DB_INTR, printk("SDP"))
1360                     hostdata->state = S_RUNNING_LEVEL2;
1361                 write_3393(hostdata, WD_COMMAND_PHASE, 0x41);
1362                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1363                 break;
1364
1365
1366         case CSR_XFER_DONE | PHS_MESS_OUT:
1367         case CSR_UNEXP | PHS_MESS_OUT:
1368         case CSR_SRV_REQ | PHS_MESS_OUT:
1369                 DB(DB_INTR, printk("MSG_OUT="))
1370
1371 /* To get here, we've probably requested MESSAGE_OUT and have
1372  * already put the correct bytes in outgoing_msg[] and filled
1373  * in outgoing_len. We simply send them out to the SCSI bus.
1374  * Sometimes we get MESSAGE_OUT phase when we're not expecting
1375  * it - like when our SDTR message is rejected by a target. Some
1376  * targets send the REJECT before receiving all of the extended
1377  * message, and then seem to go back to MESSAGE_OUT for a byte
1378  * or two. Not sure why, or if I'm doing something wrong to
1379  * cause this to happen. Regardless, it seems that sending
1380  * NOP messages in these situations results in no harm and
1381  * makes everyone happy.
1382  */
1383                     if (hostdata->outgoing_len == 0) {
1384                         hostdata->outgoing_len = 1;
1385                         hostdata->outgoing_msg[0] = NOP;
1386                 }
1387                 transfer_pio(hostdata->outgoing_msg, hostdata->outgoing_len, DATA_OUT_DIR, hostdata);
1388                 DB(DB_INTR, printk("%02x", hostdata->outgoing_msg[0]))
1389                     hostdata->outgoing_len = 0;
1390                 hostdata->state = S_CONNECTED;
1391                 break;
1392
1393
1394         case CSR_UNEXP_DISC:
1395
1396 /* I think I've seen this after a request-sense that was in response
1397  * to an error condition, but not sure. We certainly need to do
1398  * something when we get this interrupt - the question is 'what?'.
1399  * Let's think positively, and assume some command has finished
1400  * in a legal manner (like a command that provokes a request-sense),
1401  * so we treat it as a normal command-complete-disconnect.
1402  */
1403
1404
1405 /* Make sure that reselection is enabled at this point - it may
1406  * have been turned off for the command that just completed.
1407  */
1408
1409                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1410                 if (cmd == NULL) {
1411                         printk(" - Already disconnected! ");
1412                         hostdata->state = S_UNCONNECTED;
1413
1414 /* release the SMP spin_lock and restore irq state */
1415                         spin_unlock_irqrestore(instance->host_lock, flags);
1416                         return IRQ_HANDLED;
1417                 }
1418                 DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->pid))
1419                     hostdata->connected = NULL;
1420                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1421                 hostdata->state = S_UNCONNECTED;
1422                 if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1423                         cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1424                 else
1425                         cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1426                 cmd->scsi_done(cmd);
1427
1428 /* We are no longer connected to a target - check to see if
1429  * there are commands waiting to be executed.
1430  */
1431
1432                 in2000_execute(instance);
1433                 break;
1434
1435
1436         case CSR_DISC:
1437
1438 /* Make sure that reselection is enabled at this point - it may
1439  * have been turned off for the command that just completed.
1440  */
1441
1442                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1443                 DB(DB_INTR, printk("DISC-%ld", cmd->pid))
1444                     if (cmd == NULL) {
1445                         printk(" - Already disconnected! ");
1446                         hostdata->state = S_UNCONNECTED;
1447                 }
1448                 switch (hostdata->state) {
1449                 case S_PRE_CMP_DISC:
1450                         hostdata->connected = NULL;
1451                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1452                         hostdata->state = S_UNCONNECTED;
1453                         DB(DB_INTR, printk(":%d", cmd->SCp.Status))
1454                             if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1455                                 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1456                         else
1457                                 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1458                         cmd->scsi_done(cmd);
1459                         break;
1460                 case S_PRE_TMP_DISC:
1461                 case S_RUNNING_LEVEL2:
1462                         cmd->host_scribble = (uchar *) hostdata->disconnected_Q;
1463                         hostdata->disconnected_Q = cmd;
1464                         hostdata->connected = NULL;
1465                         hostdata->state = S_UNCONNECTED;
1466
1467 #ifdef PROC_STATISTICS
1468                         hostdata->disc_done_cnt[cmd->device->id]++;
1469 #endif
1470
1471                         break;
1472                 default:
1473                         printk("*** Unexpected DISCONNECT interrupt! ***");
1474                         hostdata->state = S_UNCONNECTED;
1475                 }
1476
1477 /* We are no longer connected to a target - check to see if
1478  * there are commands waiting to be executed.
1479  */
1480
1481                 in2000_execute(instance);
1482                 break;
1483
1484
1485         case CSR_RESEL_AM:
1486                 DB(DB_INTR, printk("RESEL"))
1487
1488                     /* First we have to make sure this reselection didn't */
1489                     /* happen during Arbitration/Selection of some other device. */
1490                     /* If yes, put losing command back on top of input_Q. */
1491                     if (hostdata->level2 <= L2_NONE) {
1492
1493                         if (hostdata->selecting) {
1494                                 cmd = (Scsi_Cmnd *) hostdata->selecting;
1495                                 hostdata->selecting = NULL;
1496                                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1497                                 cmd->host_scribble = (uchar *) hostdata->input_Q;
1498                                 hostdata->input_Q = cmd;
1499                         }
1500                 }
1501
1502                 else {
1503
1504                         if (cmd) {
1505                                 if (phs == 0x00) {
1506                                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1507                                         cmd->host_scribble = (uchar *) hostdata->input_Q;
1508                                         hostdata->input_Q = cmd;
1509                                 } else {
1510                                         printk("---%02x:%02x:%02x-TROUBLE: Intrusive ReSelect!---", asr, sr, phs);
1511                                         while (1)
1512                                                 printk("\r");
1513                                 }
1514                         }
1515
1516                 }
1517
1518                 /* OK - find out which device reselected us. */
1519
1520                 id = read_3393(hostdata, WD_SOURCE_ID);
1521                 id &= SRCID_MASK;
1522
1523                 /* and extract the lun from the ID message. (Note that we don't
1524                  * bother to check for a valid message here - I guess this is
1525                  * not the right way to go, but....)
1526                  */
1527
1528                 lun = read_3393(hostdata, WD_DATA);
1529                 if (hostdata->level2 < L2_RESELECT)
1530                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1531                 lun &= 7;
1532
1533                 /* Now we look for the command that's reconnecting. */
1534
1535                 cmd = (Scsi_Cmnd *) hostdata->disconnected_Q;
1536                 patch = NULL;
1537                 while (cmd) {
1538                         if (id == cmd->device->id && lun == cmd->device->lun)
1539                                 break;
1540                         patch = cmd;
1541                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
1542                 }
1543
1544                 /* Hmm. Couldn't find a valid command.... What to do? */
1545
1546                 if (!cmd) {
1547                         printk("---TROUBLE: target %d.%d not in disconnect queue---", id, lun);
1548                         break;
1549                 }
1550
1551                 /* Ok, found the command - now start it up again. */
1552
1553                 if (patch)
1554                         patch->host_scribble = cmd->host_scribble;
1555                 else
1556                         hostdata->disconnected_Q = (Scsi_Cmnd *) cmd->host_scribble;
1557                 hostdata->connected = cmd;
1558
1559                 /* We don't need to worry about 'initialize_SCp()' or 'hostdata->busy[]'
1560                  * because these things are preserved over a disconnect.
1561                  * But we DO need to fix the DPD bit so it's correct for this command.
1562                  */
1563
1564                 if (is_dir_out(cmd))
1565                         write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id);
1566                 else
1567                         write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
1568                 if (hostdata->level2 >= L2_RESELECT) {
1569                         write_3393_count(hostdata, 0);  /* we want a DATA_PHASE interrupt */
1570                         write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
1571                         write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1572                         hostdata->state = S_RUNNING_LEVEL2;
1573                 } else
1574                         hostdata->state = S_CONNECTED;
1575
1576                 DB(DB_INTR, printk("-%ld", cmd->pid))
1577                     break;
1578
1579         default:
1580                 printk("--UNKNOWN INTERRUPT:%02x:%02x:%02x--", asr, sr, phs);
1581         }
1582
1583         write1_io(0, IO_LED_OFF);
1584
1585         DB(DB_INTR, printk("} "))
1586
1587 /* release the SMP spin_lock and restore irq state */
1588             spin_unlock_irqrestore(instance->host_lock, flags);
1589         return IRQ_HANDLED;
1590 }
1591
1592
1593
1594 #define RESET_CARD         0
1595 #define RESET_CARD_AND_BUS 1
1596 #define B_FLAG 0x80
1597
1598 /*
1599  *      Caller must hold instance lock!
1600  */
1601
1602 static int reset_hardware(struct Scsi_Host *instance, int type)
1603 {
1604         struct IN2000_hostdata *hostdata;
1605         int qt, x;
1606
1607         hostdata = (struct IN2000_hostdata *) instance->hostdata;
1608
1609         write1_io(0, IO_LED_ON);
1610         if (type == RESET_CARD_AND_BUS) {
1611                 write1_io(0, IO_CARD_RESET);
1612                 x = read1_io(IO_HARDWARE);
1613         }
1614         x = read_3393(hostdata, WD_SCSI_STATUS);        /* clear any WD intrpt */
1615         write_3393(hostdata, WD_OWN_ID, instance->this_id | OWNID_EAF | OWNID_RAF | OWNID_FS_8);
1616         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1617         write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, calc_sync_xfer(hostdata->default_sx_per / 4, DEFAULT_SX_OFF));
1618
1619         write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter */
1620         write1_io(0, IO_FIFO_READ);     /* start fifo out in read mode */
1621         write_3393(hostdata, WD_COMMAND, WD_CMD_RESET);
1622         /* FIXME: timeout ?? */
1623         while (!(READ_AUX_STAT() & ASR_INT))
1624                 cpu_relax();    /* wait for RESET to complete */
1625
1626         x = read_3393(hostdata, WD_SCSI_STATUS);        /* clear interrupt */
1627
1628         write_3393(hostdata, WD_QUEUE_TAG, 0xa5);       /* any random number */
1629         qt = read_3393(hostdata, WD_QUEUE_TAG);
1630         if (qt == 0xa5) {
1631                 x |= B_FLAG;
1632                 write_3393(hostdata, WD_QUEUE_TAG, 0);
1633         }
1634         write_3393(hostdata, WD_TIMEOUT_PERIOD, TIMEOUT_PERIOD_VALUE);
1635         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1636         write1_io(0, IO_LED_OFF);
1637         return x;
1638 }
1639
1640
1641
1642 static int in2000_bus_reset(Scsi_Cmnd * cmd)
1643 {
1644         struct Scsi_Host *instance;
1645         struct IN2000_hostdata *hostdata;
1646         int x;
1647         unsigned long flags;
1648
1649         instance = cmd->device->host;
1650         hostdata = (struct IN2000_hostdata *) instance->hostdata;
1651
1652         printk(KERN_WARNING "scsi%d: Reset. ", instance->host_no);
1653
1654         spin_lock_irqsave(instance->host_lock, flags);
1655
1656         /* do scsi-reset here */
1657         reset_hardware(instance, RESET_CARD_AND_BUS);
1658         for (x = 0; x < 8; x++) {
1659                 hostdata->busy[x] = 0;
1660                 hostdata->sync_xfer[x] = calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF);
1661                 hostdata->sync_stat[x] = SS_UNSET;      /* using default sync values */
1662         }
1663         hostdata->input_Q = NULL;
1664         hostdata->selecting = NULL;
1665         hostdata->connected = NULL;
1666         hostdata->disconnected_Q = NULL;
1667         hostdata->state = S_UNCONNECTED;
1668         hostdata->fifo = FI_FIFO_UNUSED;
1669         hostdata->incoming_ptr = 0;
1670         hostdata->outgoing_len = 0;
1671
1672         cmd->result = DID_RESET << 16;
1673
1674         spin_unlock_irqrestore(instance->host_lock, flags);
1675         return SUCCESS;
1676 }
1677
1678 static int __in2000_abort(Scsi_Cmnd * cmd)
1679 {
1680         struct Scsi_Host *instance;
1681         struct IN2000_hostdata *hostdata;
1682         Scsi_Cmnd *tmp, *prev;
1683         uchar sr, asr;
1684         unsigned long timeout;
1685
1686         instance = cmd->device->host;
1687         hostdata = (struct IN2000_hostdata *) instance->hostdata;
1688
1689         printk(KERN_DEBUG "scsi%d: Abort-", instance->host_no);
1690         printk("(asr=%02x,count=%ld,resid=%d,buf_resid=%d,have_data=%d,FC=%02x)- ", READ_AUX_STAT(), read_3393_count(hostdata), cmd->SCp.this_residual, cmd->SCp.buffers_residual, cmd->SCp.have_data_in, read1_io(IO_FIFO_COUNT));
1691
1692 /*
1693  * Case 1 : If the command hasn't been issued yet, we simply remove it
1694  *     from the inout_Q.
1695  */
1696
1697         tmp = (Scsi_Cmnd *) hostdata->input_Q;
1698         prev = NULL;
1699         while (tmp) {
1700                 if (tmp == cmd) {
1701                         if (prev)
1702                                 prev->host_scribble = cmd->host_scribble;
1703                         cmd->host_scribble = NULL;
1704                         cmd->result = DID_ABORT << 16;
1705                         printk(KERN_WARNING "scsi%d: Abort - removing command %ld from input_Q. ", instance->host_no, cmd->pid);
1706                         cmd->scsi_done(cmd);
1707                         return SUCCESS;
1708                 }
1709                 prev = tmp;
1710                 tmp = (Scsi_Cmnd *) tmp->host_scribble;
1711         }
1712
1713 /*
1714  * Case 2 : If the command is connected, we're going to fail the abort
1715  *     and let the high level SCSI driver retry at a later time or
1716  *     issue a reset.
1717  *
1718  *     Timeouts, and therefore aborted commands, will be highly unlikely
1719  *     and handling them cleanly in this situation would make the common
1720  *     case of noresets less efficient, and would pollute our code.  So,
1721  *     we fail.
1722  */
1723
1724         if (hostdata->connected == cmd) {
1725
1726                 printk(KERN_WARNING "scsi%d: Aborting connected command %ld - ", instance->host_no, cmd->pid);
1727
1728                 printk("sending wd33c93 ABORT command - ");
1729                 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1730                 write_3393_cmd(hostdata, WD_CMD_ABORT);
1731
1732 /* Now we have to attempt to flush out the FIFO... */
1733
1734                 printk("flushing fifo - ");
1735                 timeout = 1000000;
1736                 do {
1737                         asr = READ_AUX_STAT();
1738                         if (asr & ASR_DBR)
1739                                 read_3393(hostdata, WD_DATA);
1740                 } while (!(asr & ASR_INT) && timeout-- > 0);
1741                 sr = read_3393(hostdata, WD_SCSI_STATUS);
1742                 printk("asr=%02x, sr=%02x, %ld bytes un-transferred (timeout=%ld) - ", asr, sr, read_3393_count(hostdata), timeout);
1743
1744                 /*
1745                  * Abort command processed.
1746                  * Still connected.
1747                  * We must disconnect.
1748                  */
1749
1750                 printk("sending wd33c93 DISCONNECT command - ");
1751                 write_3393_cmd(hostdata, WD_CMD_DISCONNECT);
1752
1753                 timeout = 1000000;
1754                 asr = READ_AUX_STAT();
1755                 while ((asr & ASR_CIP) && timeout-- > 0)
1756                         asr = READ_AUX_STAT();
1757                 sr = read_3393(hostdata, WD_SCSI_STATUS);
1758                 printk("asr=%02x, sr=%02x.", asr, sr);
1759
1760                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1761                 hostdata->connected = NULL;
1762                 hostdata->state = S_UNCONNECTED;
1763                 cmd->result = DID_ABORT << 16;
1764                 cmd->scsi_done(cmd);
1765
1766                 in2000_execute(instance);
1767
1768                 return SUCCESS;
1769         }
1770
1771 /*
1772  * Case 3: If the command is currently disconnected from the bus,
1773  * we're not going to expend much effort here: Let's just return
1774  * an ABORT_SNOOZE and hope for the best...
1775  */
1776
1777         for (tmp = (Scsi_Cmnd *) hostdata->disconnected_Q; tmp; tmp = (Scsi_Cmnd *) tmp->host_scribble)
1778                 if (cmd == tmp) {
1779                         printk(KERN_DEBUG "scsi%d: unable to abort disconnected command.\n", instance->host_no);
1780                         return FAILED;
1781                 }
1782
1783 /*
1784  * Case 4 : If we reached this point, the command was not found in any of
1785  *     the queues.
1786  *
1787  * We probably reached this point because of an unlikely race condition
1788  * between the command completing successfully and the abortion code,
1789  * so we won't panic, but we will notify the user in case something really
1790  * broke.
1791  */
1792
1793         in2000_execute(instance);
1794
1795         printk("scsi%d: warning : SCSI command probably completed successfully" "         before abortion. ", instance->host_no);
1796         return SUCCESS;
1797 }
1798
1799 static int in2000_abort(Scsi_Cmnd * cmd)
1800 {
1801         int rc;
1802
1803         spin_lock_irq(cmd->device->host->host_lock);
1804         rc = __in2000_abort(cmd);
1805         spin_unlock_irq(cmd->device->host->host_lock);
1806
1807         return rc;
1808 }
1809
1810
1811 #define MAX_IN2000_HOSTS 3
1812 #define MAX_SETUP_ARGS (sizeof(setup_args) / sizeof(char *))
1813 #define SETUP_BUFFER_SIZE 200
1814 static char setup_buffer[SETUP_BUFFER_SIZE];
1815 static char setup_used[MAX_SETUP_ARGS];
1816 static int done_setup = 0;
1817
1818 static void __init in2000_setup(char *str, int *ints)
1819 {
1820         int i;
1821         char *p1, *p2;
1822
1823         strlcpy(setup_buffer, str, SETUP_BUFFER_SIZE);
1824         p1 = setup_buffer;
1825         i = 0;
1826         while (*p1 && (i < MAX_SETUP_ARGS)) {
1827                 p2 = strchr(p1, ',');
1828                 if (p2) {
1829                         *p2 = '\0';
1830                         if (p1 != p2)
1831                                 setup_args[i] = p1;
1832                         p1 = p2 + 1;
1833                         i++;
1834                 } else {
1835                         setup_args[i] = p1;
1836                         break;
1837                 }
1838         }
1839         for (i = 0; i < MAX_SETUP_ARGS; i++)
1840                 setup_used[i] = 0;
1841         done_setup = 1;
1842 }
1843
1844
1845 /* check_setup_args() returns index if key found, 0 if not
1846  */
1847
1848 static int __init check_setup_args(char *key, int *val, char *buf)
1849 {
1850         int x;
1851         char *cp;
1852
1853         for (x = 0; x < MAX_SETUP_ARGS; x++) {
1854                 if (setup_used[x])
1855                         continue;
1856                 if (!strncmp(setup_args[x], key, strlen(key)))
1857                         break;
1858         }
1859         if (x == MAX_SETUP_ARGS)
1860                 return 0;
1861         setup_used[x] = 1;
1862         cp = setup_args[x] + strlen(key);
1863         *val = -1;
1864         if (*cp != ':')
1865                 return ++x;
1866         cp++;
1867         if ((*cp >= '0') && (*cp <= '9')) {
1868                 *val = simple_strtoul(cp, NULL, 0);
1869         }
1870         return ++x;
1871 }
1872
1873
1874
1875 /* The "correct" (ie portable) way to access memory-mapped hardware
1876  * such as the IN2000 EPROM and dip switch is through the use of
1877  * special macros declared in 'asm/io.h'. We use readb() and readl()
1878  * when reading from the card's BIOS area in in2000_detect().
1879  */
1880 static u32 bios_tab[] in2000__INITDATA = {
1881         0xc8000,
1882         0xd0000,
1883         0xd8000,
1884         0
1885 };
1886
1887 static unsigned short base_tab[] in2000__INITDATA = {
1888         0x220,
1889         0x200,
1890         0x110,
1891         0x100,
1892 };
1893
1894 static int int_tab[] in2000__INITDATA = {
1895         15,
1896         14,
1897         11,
1898         10
1899 };
1900
1901 static int probe_bios(u32 addr, u32 *s1, uchar *switches)
1902 {
1903         void __iomem *p = ioremap(addr, 0x34);
1904         if (!p)
1905                 return 0;
1906         *s1 = readl(p + 0x10);
1907         if (*s1 == 0x41564f4e || readl(p + 0x30) == 0x61776c41) {
1908                 /* Read the switch image that's mapped into EPROM space */
1909                 *switches = ~readb(p + 0x20);
1910                 iounmap(p);
1911                 return 1;
1912         }
1913         iounmap(p);
1914         return 0;
1915 }
1916
1917 static int __init in2000_detect(struct scsi_host_template * tpnt)
1918 {
1919         struct Scsi_Host *instance;
1920         struct IN2000_hostdata *hostdata;
1921         int detect_count;
1922         int bios;
1923         int x;
1924         unsigned short base;
1925         uchar switches;
1926         uchar hrev;
1927         unsigned long flags;
1928         int val;
1929         char buf[32];
1930
1931 /* Thanks to help from Bill Earnest, probing for IN2000 cards is a
1932  * pretty straightforward and fool-proof operation. There are 3
1933  * possible locations for the IN2000 EPROM in memory space - if we
1934  * find a BIOS signature, we can read the dip switch settings from
1935  * the byte at BIOS+32 (shadowed in by logic on the card). From 2
1936  * of the switch bits we get the card's address in IO space. There's
1937  * an image of the dip switch there, also, so we have a way to back-
1938  * check that this really is an IN2000 card. Very nifty. Use the
1939  * 'ioport:xx' command-line parameter if your BIOS EPROM is absent
1940  * or disabled.
1941  */
1942
1943         if (!done_setup && setup_strings)
1944                 in2000_setup(setup_strings, NULL);
1945
1946         detect_count = 0;
1947         for (bios = 0; bios_tab[bios]; bios++) {
1948                 u32 s1 = 0;
1949                 if (check_setup_args("ioport", &val, buf)) {
1950                         base = val;
1951                         switches = ~inb(base + IO_SWITCHES) & 0xff;
1952                         printk("Forcing IN2000 detection at IOport 0x%x ", base);
1953                         bios = 2;
1954                 }
1955 /*
1956  * There have been a couple of BIOS versions with different layouts
1957  * for the obvious ID strings. We look for the 2 most common ones and
1958  * hope that they cover all the cases...
1959  */
1960                 else if (probe_bios(bios_tab[bios], &s1, &switches)) {
1961                         printk("Found IN2000 BIOS at 0x%x ", (unsigned int) bios_tab[bios]);
1962
1963 /* Find out where the IO space is */
1964
1965                         x = switches & (SW_ADDR0 | SW_ADDR1);
1966                         base = base_tab[x];
1967
1968 /* Check for the IN2000 signature in IO space. */
1969
1970                         x = ~inb(base + IO_SWITCHES) & 0xff;
1971                         if (x != switches) {
1972                                 printk("Bad IO signature: %02x vs %02x.\n", x, switches);
1973                                 continue;
1974                         }
1975                 } else
1976                         continue;
1977
1978 /* OK. We have a base address for the IO ports - run a few safety checks */
1979
1980                 if (!(switches & SW_BIT7)) {    /* I _think_ all cards do this */
1981                         printk("There is no IN-2000 SCSI card at IOport 0x%03x!\n", base);
1982                         continue;
1983                 }
1984
1985 /* Let's assume any hardware version will work, although the driver
1986  * has only been tested on 0x21, 0x22, 0x25, 0x26, and 0x27. We'll
1987  * print out the rev number for reference later, but accept them all.
1988  */
1989
1990                 hrev = inb(base + IO_HARDWARE);
1991
1992                 /* Bit 2 tells us if interrupts are disabled */
1993                 if (switches & SW_DISINT) {
1994                         printk("The IN-2000 SCSI card at IOport 0x%03x ", base);
1995                         printk("is not configured for interrupt operation!\n");
1996                         printk("This driver requires an interrupt: cancelling detection.\n");
1997                         continue;
1998                 }
1999
2000 /* Ok. We accept that there's an IN2000 at ioaddr 'base'. Now
2001  * initialize it.
2002  */
2003
2004                 tpnt->proc_name = "in2000";
2005                 instance = scsi_register(tpnt, sizeof(struct IN2000_hostdata));
2006                 if (instance == NULL)
2007                         continue;
2008                 detect_count++;
2009                 hostdata = (struct IN2000_hostdata *) instance->hostdata;
2010                 instance->io_port = hostdata->io_base = base;
2011                 hostdata->dip_switch = switches;
2012                 hostdata->hrev = hrev;
2013
2014                 write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter */
2015                 write1_io(0, IO_FIFO_READ);     /* start fifo out in read mode */
2016                 write1_io(0, IO_INTR_MASK);     /* allow all ints */
2017                 x = int_tab[(switches & (SW_INT0 | SW_INT1)) >> SW_INT_SHIFT];
2018                 if (request_irq(x, in2000_intr, SA_INTERRUPT, "in2000", instance)) {
2019                         printk("in2000_detect: Unable to allocate IRQ.\n");
2020                         detect_count--;
2021                         continue;
2022                 }
2023                 instance->irq = x;
2024                 instance->n_io_port = 13;
2025                 request_region(base, 13, "in2000");     /* lock in this IO space for our use */
2026
2027                 for (x = 0; x < 8; x++) {
2028                         hostdata->busy[x] = 0;
2029                         hostdata->sync_xfer[x] = calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF);
2030                         hostdata->sync_stat[x] = SS_UNSET;      /* using default sync values */
2031 #ifdef PROC_STATISTICS
2032                         hostdata->cmd_cnt[x] = 0;
2033                         hostdata->disc_allowed_cnt[x] = 0;
2034                         hostdata->disc_done_cnt[x] = 0;
2035 #endif
2036                 }
2037                 hostdata->input_Q = NULL;
2038                 hostdata->selecting = NULL;
2039                 hostdata->connected = NULL;
2040                 hostdata->disconnected_Q = NULL;
2041                 hostdata->state = S_UNCONNECTED;
2042                 hostdata->fifo = FI_FIFO_UNUSED;
2043                 hostdata->level2 = L2_BASIC;
2044                 hostdata->disconnect = DIS_ADAPTIVE;
2045                 hostdata->args = DEBUG_DEFAULTS;
2046                 hostdata->incoming_ptr = 0;
2047                 hostdata->outgoing_len = 0;
2048                 hostdata->default_sx_per = DEFAULT_SX_PER;
2049
2050 /* Older BIOS's had a 'sync on/off' switch - use its setting */
2051
2052                 if (s1 == 0x41564f4e && (switches & SW_SYNC_DOS5))
2053                         hostdata->sync_off = 0x00;      /* sync defaults to on */
2054                 else
2055                         hostdata->sync_off = 0xff;      /* sync defaults to off */
2056
2057 #ifdef PROC_INTERFACE
2058                 hostdata->proc = PR_VERSION | PR_INFO | PR_STATISTICS | PR_CONNECTED | PR_INPUTQ | PR_DISCQ | PR_STOP;
2059 #ifdef PROC_STATISTICS
2060                 hostdata->int_cnt = 0;
2061 #endif
2062 #endif
2063
2064                 if (check_setup_args("nosync", &val, buf))
2065                         hostdata->sync_off = val;
2066
2067                 if (check_setup_args("period", &val, buf))
2068                         hostdata->default_sx_per = sx_table[round_period((unsigned int) val)].period_ns;
2069
2070                 if (check_setup_args("disconnect", &val, buf)) {
2071                         if ((val >= DIS_NEVER) && (val <= DIS_ALWAYS))
2072                                 hostdata->disconnect = val;
2073                         else
2074                                 hostdata->disconnect = DIS_ADAPTIVE;
2075                 }
2076
2077                 if (check_setup_args("noreset", &val, buf))
2078                         hostdata->args ^= A_NO_SCSI_RESET;
2079
2080                 if (check_setup_args("level2", &val, buf))
2081                         hostdata->level2 = val;
2082
2083                 if (check_setup_args("debug", &val, buf))
2084                         hostdata->args = (val & DB_MASK);
2085
2086 #ifdef PROC_INTERFACE
2087                 if (check_setup_args("proc", &val, buf))
2088                         hostdata->proc = val;
2089 #endif
2090
2091
2092                 /* FIXME: not strictly needed I think but the called code expects
2093                    to be locked */
2094                 spin_lock_irqsave(instance->host_lock, flags);
2095                 x = reset_hardware(instance, (hostdata->args & A_NO_SCSI_RESET) ? RESET_CARD : RESET_CARD_AND_BUS);
2096                 spin_unlock_irqrestore(instance->host_lock, flags);
2097
2098                 hostdata->microcode = read_3393(hostdata, WD_CDB_1);
2099                 if (x & 0x01) {
2100                         if (x & B_FLAG)
2101                                 hostdata->chip = C_WD33C93B;
2102                         else
2103                                 hostdata->chip = C_WD33C93A;
2104                 } else
2105                         hostdata->chip = C_WD33C93;
2106
2107                 printk("dip_switch=%02x irq=%d ioport=%02x floppy=%s sync/DOS5=%s ", (switches & 0x7f), instance->irq, hostdata->io_base, (switches & SW_FLOPPY) ? "Yes" : "No", (switches & SW_SYNC_DOS5) ? "Yes" : "No");
2108                 printk("hardware_ver=%02x chip=%s microcode=%02x\n", hrev, (hostdata->chip == C_WD33C93) ? "WD33c93" : (hostdata->chip == C_WD33C93A) ? "WD33c93A" : (hostdata->chip == C_WD33C93B) ? "WD33c93B" : "unknown", hostdata->microcode);
2109 #ifdef DEBUGGING_ON
2110                 printk("setup_args = ");
2111                 for (x = 0; x < MAX_SETUP_ARGS; x++)
2112                         printk("%s,", setup_args[x]);
2113                 printk("\n");
2114 #endif
2115                 if (hostdata->sync_off == 0xff)
2116                         printk("Sync-transfer DISABLED on all devices: ENABLE from command-line\n");
2117                 printk("IN2000 driver version %s - %s\n", IN2000_VERSION, IN2000_DATE);
2118         }
2119
2120         return detect_count;
2121 }
2122
2123 static int in2000_release(struct Scsi_Host *shost)
2124 {
2125         if (shost->irq)
2126                 free_irq(shost->irq, shost);
2127         if (shost->io_port && shost->n_io_port)
2128                 release_region(shost->io_port, shost->n_io_port);
2129         return 0;
2130 }
2131
2132 /* NOTE: I lifted this function straight out of the old driver,
2133  *       and have not tested it. Presumably it does what it's
2134  *       supposed to do...
2135  */
2136
2137 static int in2000_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int *iinfo)
2138 {
2139         int size;
2140
2141         size = capacity;
2142         iinfo[0] = 64;
2143         iinfo[1] = 32;
2144         iinfo[2] = size >> 11;
2145
2146 /* This should approximate the large drive handling that the DOS ASPI manager
2147    uses.  Drives very near the boundaries may not be handled correctly (i.e.
2148    near 2.0 Gb and 4.0 Gb) */
2149
2150         if (iinfo[2] > 1024) {
2151                 iinfo[0] = 64;
2152                 iinfo[1] = 63;
2153                 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2154         }
2155         if (iinfo[2] > 1024) {
2156                 iinfo[0] = 128;
2157                 iinfo[1] = 63;
2158                 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2159         }
2160         if (iinfo[2] > 1024) {
2161                 iinfo[0] = 255;
2162                 iinfo[1] = 63;
2163                 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2164         }
2165         return 0;
2166 }
2167
2168
2169 static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off, int len, int in)
2170 {
2171
2172 #ifdef PROC_INTERFACE
2173
2174         char *bp;
2175         char tbuf[128];
2176         unsigned long flags;
2177         struct IN2000_hostdata *hd;
2178         Scsi_Cmnd *cmd;
2179         int x, i;
2180         static int stop = 0;
2181
2182         hd = (struct IN2000_hostdata *) instance->hostdata;
2183
2184 /* If 'in' is TRUE we need to _read_ the proc file. We accept the following
2185  * keywords (same format as command-line, but only ONE per read):
2186  *    debug
2187  *    disconnect
2188  *    period
2189  *    resync
2190  *    proc
2191  */
2192
2193         if (in) {
2194                 buf[len] = '\0';
2195                 bp = buf;
2196                 if (!strncmp(bp, "debug:", 6)) {
2197                         bp += 6;
2198                         hd->args = simple_strtoul(bp, NULL, 0) & DB_MASK;
2199                 } else if (!strncmp(bp, "disconnect:", 11)) {
2200                         bp += 11;
2201                         x = simple_strtoul(bp, NULL, 0);
2202                         if (x < DIS_NEVER || x > DIS_ALWAYS)
2203                                 x = DIS_ADAPTIVE;
2204                         hd->disconnect = x;
2205                 } else if (!strncmp(bp, "period:", 7)) {
2206                         bp += 7;
2207                         x = simple_strtoul(bp, NULL, 0);
2208                         hd->default_sx_per = sx_table[round_period((unsigned int) x)].period_ns;
2209                 } else if (!strncmp(bp, "resync:", 7)) {
2210                         bp += 7;
2211                         x = simple_strtoul(bp, NULL, 0);
2212                         for (i = 0; i < 7; i++)
2213                                 if (x & (1 << i))
2214                                         hd->sync_stat[i] = SS_UNSET;
2215                 } else if (!strncmp(bp, "proc:", 5)) {
2216                         bp += 5;
2217                         hd->proc = simple_strtoul(bp, NULL, 0);
2218                 } else if (!strncmp(bp, "level2:", 7)) {
2219                         bp += 7;
2220                         hd->level2 = simple_strtoul(bp, NULL, 0);
2221                 }
2222                 return len;
2223         }
2224
2225         spin_lock_irqsave(instance->host_lock, flags);
2226         bp = buf;
2227         *bp = '\0';
2228         if (hd->proc & PR_VERSION) {
2229                 sprintf(tbuf, "\nVersion %s - %s. Compiled %s %s", IN2000_VERSION, IN2000_DATE, __DATE__, __TIME__);
2230                 strcat(bp, tbuf);
2231         }
2232         if (hd->proc & PR_INFO) {
2233                 sprintf(tbuf, "\ndip_switch=%02x: irq=%d io=%02x floppy=%s sync/DOS5=%s", (hd->dip_switch & 0x7f), instance->irq, hd->io_base, (hd->dip_switch & 0x40) ? "Yes" : "No", (hd->dip_switch & 0x20) ? "Yes" : "No");
2234                 strcat(bp, tbuf);
2235                 strcat(bp, "\nsync_xfer[] =       ");
2236                 for (x = 0; x < 7; x++) {
2237                         sprintf(tbuf, "\t%02x", hd->sync_xfer[x]);
2238                         strcat(bp, tbuf);
2239                 }
2240                 strcat(bp, "\nsync_stat[] =       ");
2241                 for (x = 0; x < 7; x++) {
2242                         sprintf(tbuf, "\t%02x", hd->sync_stat[x]);
2243                         strcat(bp, tbuf);
2244                 }
2245         }
2246 #ifdef PROC_STATISTICS
2247         if (hd->proc & PR_STATISTICS) {
2248                 strcat(bp, "\ncommands issued:    ");
2249                 for (x = 0; x < 7; x++) {
2250                         sprintf(tbuf, "\t%ld", hd->cmd_cnt[x]);
2251                         strcat(bp, tbuf);
2252                 }
2253                 strcat(bp, "\ndisconnects allowed:");
2254                 for (x = 0; x < 7; x++) {
2255                         sprintf(tbuf, "\t%ld", hd->disc_allowed_cnt[x]);
2256                         strcat(bp, tbuf);
2257                 }
2258                 strcat(bp, "\ndisconnects done:   ");
2259                 for (x = 0; x < 7; x++) {
2260                         sprintf(tbuf, "\t%ld", hd->disc_done_cnt[x]);
2261                         strcat(bp, tbuf);
2262                 }
2263                 sprintf(tbuf, "\ninterrupts:      \t%ld", hd->int_cnt);
2264                 strcat(bp, tbuf);
2265         }
2266 #endif
2267         if (hd->proc & PR_CONNECTED) {
2268                 strcat(bp, "\nconnected:     ");
2269                 if (hd->connected) {
2270                         cmd = (Scsi_Cmnd *) hd->connected;
2271                         sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->pid, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2272                         strcat(bp, tbuf);
2273                 }
2274         }
2275         if (hd->proc & PR_INPUTQ) {
2276                 strcat(bp, "\ninput_Q:       ");
2277                 cmd = (Scsi_Cmnd *) hd->input_Q;
2278                 while (cmd) {
2279                         sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->pid, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2280                         strcat(bp, tbuf);
2281                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
2282                 }
2283         }
2284         if (hd->proc & PR_DISCQ) {
2285                 strcat(bp, "\ndisconnected_Q:");
2286                 cmd = (Scsi_Cmnd *) hd->disconnected_Q;
2287                 while (cmd) {
2288                         sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->pid, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2289                         strcat(bp, tbuf);
2290                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
2291                 }
2292         }
2293         if (hd->proc & PR_TEST) {
2294                 ;               /* insert your own custom function here */
2295         }
2296         strcat(bp, "\n");
2297         spin_unlock_irqrestore(instance->host_lock, flags);
2298         *start = buf;
2299         if (stop) {
2300                 stop = 0;
2301                 return 0;       /* return 0 to signal end-of-file */
2302         }
2303         if (off > 0x40000)      /* ALWAYS stop after 256k bytes have been read */
2304                 stop = 1;
2305         if (hd->proc & PR_STOP) /* stop every other time */
2306                 stop = 1;
2307         return strlen(bp);
2308
2309 #else                           /* PROC_INTERFACE */
2310
2311         return 0;
2312
2313 #endif                          /* PROC_INTERFACE */
2314
2315 }
2316
2317 MODULE_LICENSE("GPL");
2318
2319
2320 static struct scsi_host_template driver_template = {
2321         .proc_name                      = "in2000",
2322         .proc_info                      = in2000_proc_info,
2323         .name                           = "Always IN2000",
2324         .detect                         = in2000_detect, 
2325         .release                        = in2000_release,
2326         .queuecommand                   = in2000_queuecommand,
2327         .eh_abort_handler               = in2000_abort,
2328         .eh_bus_reset_handler           = in2000_bus_reset,
2329         .bios_param                     = in2000_biosparam, 
2330         .can_queue                      = IN2000_CAN_Q,
2331         .this_id                        = IN2000_HOST_ID,
2332         .sg_tablesize                   = IN2000_SG,
2333         .cmd_per_lun                    = IN2000_CPL,
2334         .use_clustering                 = DISABLE_CLUSTERING,
2335 };
2336 #include "scsi_module.c"