PM: Remove CONFIG_PM_OPS
[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@lxorguk.ukuu.org.uk>
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_lck(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->serial_number))
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 (scsi_bufflen(cmd)) {
373                 cmd->SCp.buffer = scsi_sglist(cmd);
374                 cmd->SCp.buffers_residual = scsi_sg_count(cmd) - 1;
375                 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
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 = NULL;
381                 cmd->SCp.this_residual = 0;
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->serial_number))
431             return 0;
432 }
433
434 static DEF_SCSI_QCMD(in2000_queuecommand)
435
436
437
438 /*
439  * This routine attempts to start a scsi command. If the host_card is
440  * already connected, we give up immediately. Otherwise, look through
441  * the input_Q, using the first command we find that's intended
442  * for a currently non-busy target/lun.
443  * Note that this function is always called with interrupts already
444  * disabled (either from in2000_queuecommand() or in2000_intr()).
445  */
446 static void in2000_execute(struct Scsi_Host *instance)
447 {
448         struct IN2000_hostdata *hostdata;
449         Scsi_Cmnd *cmd, *prev;
450         int i;
451         unsigned short *sp;
452         unsigned short f;
453         unsigned short flushbuf[16];
454
455
456         hostdata = (struct IN2000_hostdata *) instance->hostdata;
457
458         DB(DB_EXECUTE, printk("EX("))
459
460             if (hostdata->selecting || hostdata->connected) {
461
462                 DB(DB_EXECUTE, printk(")EX-0 "))
463
464                     return;
465         }
466
467         /*
468          * Search through the input_Q for a command destined
469          * for an idle target/lun.
470          */
471
472         cmd = (Scsi_Cmnd *) hostdata->input_Q;
473         prev = NULL;
474         while (cmd) {
475                 if (!(hostdata->busy[cmd->device->id] & (1 << cmd->device->lun)))
476                         break;
477                 prev = cmd;
478                 cmd = (Scsi_Cmnd *) cmd->host_scribble;
479         }
480
481         /* quit if queue empty or all possible targets are busy */
482
483         if (!cmd) {
484
485                 DB(DB_EXECUTE, printk(")EX-1 "))
486
487                     return;
488         }
489
490         /*  remove command from queue */
491
492         if (prev)
493                 prev->host_scribble = cmd->host_scribble;
494         else
495                 hostdata->input_Q = (Scsi_Cmnd *) cmd->host_scribble;
496
497 #ifdef PROC_STATISTICS
498         hostdata->cmd_cnt[cmd->device->id]++;
499 #endif
500
501 /*
502  * Start the selection process
503  */
504
505         if (is_dir_out(cmd))
506                 write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id);
507         else
508                 write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
509
510 /* Now we need to figure out whether or not this command is a good
511  * candidate for disconnect/reselect. We guess to the best of our
512  * ability, based on a set of hierarchical rules. When several
513  * devices are operating simultaneously, disconnects are usually
514  * an advantage. In a single device system, or if only 1 device
515  * is being accessed, transfers usually go faster if disconnects
516  * are not allowed:
517  *
518  * + Commands should NEVER disconnect if hostdata->disconnect =
519  *   DIS_NEVER (this holds for tape drives also), and ALWAYS
520  *   disconnect if hostdata->disconnect = DIS_ALWAYS.
521  * + Tape drive commands should always be allowed to disconnect.
522  * + Disconnect should be allowed if disconnected_Q isn't empty.
523  * + Commands should NOT disconnect if input_Q is empty.
524  * + Disconnect should be allowed if there are commands in input_Q
525  *   for a different target/lun. In this case, the other commands
526  *   should be made disconnect-able, if not already.
527  *
528  * I know, I know - this code would flunk me out of any
529  * "C Programming 101" class ever offered. But it's easy
530  * to change around and experiment with for now.
531  */
532
533         cmd->SCp.phase = 0;     /* assume no disconnect */
534         if (hostdata->disconnect == DIS_NEVER)
535                 goto no;
536         if (hostdata->disconnect == DIS_ALWAYS)
537                 goto yes;
538         if (cmd->device->type == 1)     /* tape drive? */
539                 goto yes;
540         if (hostdata->disconnected_Q)   /* other commands disconnected? */
541                 goto yes;
542         if (!(hostdata->input_Q))       /* input_Q empty? */
543                 goto no;
544         for (prev = (Scsi_Cmnd *) hostdata->input_Q; prev; prev = (Scsi_Cmnd *) prev->host_scribble) {
545                 if ((prev->device->id != cmd->device->id) || (prev->device->lun != cmd->device->lun)) {
546                         for (prev = (Scsi_Cmnd *) hostdata->input_Q; prev; prev = (Scsi_Cmnd *) prev->host_scribble)
547                                 prev->SCp.phase = 1;
548                         goto yes;
549                 }
550         }
551         goto no;
552
553       yes:
554         cmd->SCp.phase = 1;
555
556 #ifdef PROC_STATISTICS
557         hostdata->disc_allowed_cnt[cmd->device->id]++;
558 #endif
559
560       no:
561         write_3393(hostdata, WD_SOURCE_ID, ((cmd->SCp.phase) ? SRCID_ER : 0));
562
563         write_3393(hostdata, WD_TARGET_LUN, cmd->device->lun);
564         write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, hostdata->sync_xfer[cmd->device->id]);
565         hostdata->busy[cmd->device->id] |= (1 << cmd->device->lun);
566
567         if ((hostdata->level2 <= L2_NONE) || (hostdata->sync_stat[cmd->device->id] == SS_UNSET)) {
568
569                 /*
570                  * Do a 'Select-With-ATN' command. This will end with
571                  * one of the following interrupts:
572                  *    CSR_RESEL_AM:  failure - can try again later.
573                  *    CSR_TIMEOUT:   failure - give up.
574                  *    CSR_SELECT:    success - proceed.
575                  */
576
577                 hostdata->selecting = cmd;
578
579 /* Every target has its own synchronous transfer setting, kept in
580  * the sync_xfer array, and a corresponding status byte in sync_stat[].
581  * Each target's sync_stat[] entry is initialized to SS_UNSET, and its
582  * sync_xfer[] entry is initialized to the default/safe value. SS_UNSET
583  * means that the parameters are undetermined as yet, and that we
584  * need to send an SDTR message to this device after selection is
585  * complete. We set SS_FIRST to tell the interrupt routine to do so,
586  * unless we don't want to even _try_ synchronous transfers: In this
587  * case we set SS_SET to make the defaults final.
588  */
589                 if (hostdata->sync_stat[cmd->device->id] == SS_UNSET) {
590                         if (hostdata->sync_off & (1 << cmd->device->id))
591                                 hostdata->sync_stat[cmd->device->id] = SS_SET;
592                         else
593                                 hostdata->sync_stat[cmd->device->id] = SS_FIRST;
594                 }
595                 hostdata->state = S_SELECTING;
596                 write_3393_count(hostdata, 0);  /* this guarantees a DATA_PHASE interrupt */
597                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN);
598         }
599
600         else {
601
602                 /*
603                  * Do a 'Select-With-ATN-Xfer' command. This will end with
604                  * one of the following interrupts:
605                  *    CSR_RESEL_AM:  failure - can try again later.
606                  *    CSR_TIMEOUT:   failure - give up.
607                  *    anything else: success - proceed.
608                  */
609
610                 hostdata->connected = cmd;
611                 write_3393(hostdata, WD_COMMAND_PHASE, 0);
612
613                 /* copy command_descriptor_block into WD chip
614                  * (take advantage of auto-incrementing)
615                  */
616
617                 write1_io(WD_CDB_1, IO_WD_ADDR);
618                 for (i = 0; i < cmd->cmd_len; i++)
619                         write1_io(cmd->cmnd[i], IO_WD_DATA);
620
621                 /* The wd33c93 only knows about Group 0, 1, and 5 commands when
622                  * it's doing a 'select-and-transfer'. To be safe, we write the
623                  * size of the CDB into the OWN_ID register for every case. This
624                  * way there won't be problems with vendor-unique, audio, etc.
625                  */
626
627                 write_3393(hostdata, WD_OWN_ID, cmd->cmd_len);
628
629                 /* When doing a non-disconnect command, we can save ourselves a DATA
630                  * phase interrupt later by setting everything up now. With writes we
631                  * need to pre-fill the fifo; if there's room for the 32 flush bytes,
632                  * put them in there too - that'll avoid a fifo interrupt. Reads are
633                  * somewhat simpler.
634                  * KLUDGE NOTE: It seems that you can't completely fill the fifo here:
635                  * This results in the IO_FIFO_COUNT register rolling over to zero,
636                  * and apparently the gate array logic sees this as empty, not full,
637                  * so the 3393 chip is never signalled to start reading from the
638                  * fifo. Or maybe it's seen as a permanent fifo interrupt condition.
639                  * Regardless, we fix this by temporarily pretending that the fifo
640                  * is 16 bytes smaller. (I see now that the old driver has a comment
641                  * about "don't fill completely" in an analogous place - must be the
642                  * same deal.) This results in CDROM, swap partitions, and tape drives
643                  * needing an extra interrupt per write command - I think we can live
644                  * with that!
645                  */
646
647                 if (!(cmd->SCp.phase)) {
648                         write_3393_count(hostdata, cmd->SCp.this_residual);
649                         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_BUS);
650                         write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter, write mode */
651
652                         if (is_dir_out(cmd)) {
653                                 hostdata->fifo = FI_FIFO_WRITING;
654                                 if ((i = cmd->SCp.this_residual) > (IN2000_FIFO_SIZE - 16))
655                                         i = IN2000_FIFO_SIZE - 16;
656                                 cmd->SCp.have_data_in = i;      /* this much data in fifo */
657                                 i >>= 1;        /* Gulp. Assuming modulo 2. */
658                                 sp = (unsigned short *) cmd->SCp.ptr;
659                                 f = hostdata->io_base + IO_FIFO;
660
661 #ifdef FAST_WRITE_IO
662
663                                 FAST_WRITE2_IO();
664 #else
665                                 while (i--)
666                                         write2_io(*sp++, IO_FIFO);
667
668 #endif
669
670                                 /* Is there room for the flush bytes? */
671
672                                 if (cmd->SCp.have_data_in <= ((IN2000_FIFO_SIZE - 16) - 32)) {
673                                         sp = flushbuf;
674                                         i = 16;
675
676 #ifdef FAST_WRITE_IO
677
678                                         FAST_WRITE2_IO();
679 #else
680                                         while (i--)
681                                                 write2_io(0, IO_FIFO);
682
683 #endif
684
685                                 }
686                         }
687
688                         else {
689                                 write1_io(0, IO_FIFO_READ);     /* put fifo in read mode */
690                                 hostdata->fifo = FI_FIFO_READING;
691                                 cmd->SCp.have_data_in = 0;      /* nothing transferred yet */
692                         }
693
694                 } else {
695                         write_3393_count(hostdata, 0);  /* this guarantees a DATA_PHASE interrupt */
696                 }
697                 hostdata->state = S_RUNNING_LEVEL2;
698                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
699         }
700
701         /*
702          * Since the SCSI bus can handle only 1 connection at a time,
703          * we get out of here now. If the selection fails, or when
704          * the command disconnects, we'll come back to this routine
705          * to search the input_Q again...
706          */
707
708         DB(DB_EXECUTE, printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number))
709
710 }
711
712
713
714 static void transfer_pio(uchar * buf, int cnt, int data_in_dir, struct IN2000_hostdata *hostdata)
715 {
716         uchar asr;
717
718         DB(DB_TRANSFER, printk("(%p,%d,%s)", buf, cnt, data_in_dir ? "in" : "out"))
719
720             write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
721         write_3393_count(hostdata, cnt);
722         write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
723         if (data_in_dir) {
724                 do {
725                         asr = READ_AUX_STAT();
726                         if (asr & ASR_DBR)
727                                 *buf++ = read_3393(hostdata, WD_DATA);
728                 } while (!(asr & ASR_INT));
729         } else {
730                 do {
731                         asr = READ_AUX_STAT();
732                         if (asr & ASR_DBR)
733                                 write_3393(hostdata, WD_DATA, *buf++);
734                 } while (!(asr & ASR_INT));
735         }
736
737         /* Note: we are returning with the interrupt UN-cleared.
738          * Since (presumably) an entire I/O operation has
739          * completed, the bus phase is probably different, and
740          * the interrupt routine will discover this when it
741          * responds to the uncleared int.
742          */
743
744 }
745
746
747
748 static void transfer_bytes(Scsi_Cmnd * cmd, int data_in_dir)
749 {
750         struct IN2000_hostdata *hostdata;
751         unsigned short *sp;
752         unsigned short f;
753         int i;
754
755         hostdata = (struct IN2000_hostdata *) cmd->device->host->hostdata;
756
757 /* Normally, you'd expect 'this_residual' to be non-zero here.
758  * In a series of scatter-gather transfers, however, this
759  * routine will usually be called with 'this_residual' equal
760  * to 0 and 'buffers_residual' non-zero. This means that a
761  * previous transfer completed, clearing 'this_residual', and
762  * now we need to setup the next scatter-gather buffer as the
763  * source or destination for THIS transfer.
764  */
765         if (!cmd->SCp.this_residual && cmd->SCp.buffers_residual) {
766                 ++cmd->SCp.buffer;
767                 --cmd->SCp.buffers_residual;
768                 cmd->SCp.this_residual = cmd->SCp.buffer->length;
769                 cmd->SCp.ptr = sg_virt(cmd->SCp.buffer);
770         }
771
772 /* Set up hardware registers */
773
774         write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, hostdata->sync_xfer[cmd->device->id]);
775         write_3393_count(hostdata, cmd->SCp.this_residual);
776         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_BUS);
777         write1_io(0, IO_FIFO_WRITE);    /* zero counter, assume write */
778
779 /* Reading is easy. Just issue the command and return - we'll
780  * get an interrupt later when we have actual data to worry about.
781  */
782
783         if (data_in_dir) {
784                 write1_io(0, IO_FIFO_READ);
785                 if ((hostdata->level2 >= L2_DATA) || (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
786                         write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
787                         write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
788                         hostdata->state = S_RUNNING_LEVEL2;
789                 } else
790                         write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
791                 hostdata->fifo = FI_FIFO_READING;
792                 cmd->SCp.have_data_in = 0;
793                 return;
794         }
795
796 /* Writing is more involved - we'll start the WD chip and write as
797  * much data to the fifo as we can right now. Later interrupts will
798  * write any bytes that don't make it at this stage.
799  */
800
801         if ((hostdata->level2 >= L2_DATA) || (hostdata->level2 == L2_BASIC && cmd->SCp.phase == 0)) {
802                 write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
803                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
804                 hostdata->state = S_RUNNING_LEVEL2;
805         } else
806                 write_3393_cmd(hostdata, WD_CMD_TRANS_INFO);
807         hostdata->fifo = FI_FIFO_WRITING;
808         sp = (unsigned short *) cmd->SCp.ptr;
809
810         if ((i = cmd->SCp.this_residual) > IN2000_FIFO_SIZE)
811                 i = IN2000_FIFO_SIZE;
812         cmd->SCp.have_data_in = i;
813         i >>= 1;                /* Gulp. We assume this_residual is modulo 2 */
814         f = hostdata->io_base + IO_FIFO;
815
816 #ifdef FAST_WRITE_IO
817
818         FAST_WRITE2_IO();
819 #else
820         while (i--)
821                 write2_io(*sp++, IO_FIFO);
822
823 #endif
824
825 }
826
827
828 /* We need to use spin_lock_irqsave() & spin_unlock_irqrestore() in this
829  * function in order to work in an SMP environment. (I'd be surprised
830  * if the driver is ever used by anyone on a real multi-CPU motherboard,
831  * but it _does_ need to be able to compile and run in an SMP kernel.)
832  */
833
834 static irqreturn_t in2000_intr(int irqnum, void *dev_id)
835 {
836         struct Scsi_Host *instance = dev_id;
837         struct IN2000_hostdata *hostdata;
838         Scsi_Cmnd *patch, *cmd;
839         uchar asr, sr, phs, id, lun, *ucp, msg;
840         int i, j;
841         unsigned long length;
842         unsigned short *sp;
843         unsigned short f;
844         unsigned long flags;
845
846         hostdata = (struct IN2000_hostdata *) instance->hostdata;
847
848 /* Get the spin_lock and disable further ints, for SMP */
849
850         spin_lock_irqsave(instance->host_lock, flags);
851
852 #ifdef PROC_STATISTICS
853         hostdata->int_cnt++;
854 #endif
855
856 /* The IN2000 card has 2 interrupt sources OR'ed onto its IRQ line - the
857  * WD3393 chip and the 2k fifo (which is actually a dual-port RAM combined
858  * with a big logic array, so it's a little different than what you might
859  * expect). As far as I know, there's no reason that BOTH can't be active
860  * at the same time, but there's a problem: while we can read the 3393
861  * to tell if _it_ wants an interrupt, I don't know of a way to ask the
862  * fifo the same question. The best we can do is check the 3393 and if
863  * it _isn't_ the source of the interrupt, then we can be pretty sure
864  * that the fifo is the culprit.
865  *  UPDATE: I have it on good authority (Bill Earnest) that bit 0 of the
866  *          IO_FIFO_COUNT register mirrors the fifo interrupt state. I
867  *          assume that bit clear means interrupt active. As it turns
868  *          out, the driver really doesn't need to check for this after
869  *          all, so my remarks above about a 'problem' can safely be
870  *          ignored. The way the logic is set up, there's no advantage
871  *          (that I can see) to worrying about it.
872  *
873  * It seems that the fifo interrupt signal is negated when we extract
874  * bytes during read or write bytes during write.
875  *  - fifo will interrupt when data is moving from it to the 3393, and
876  *    there are 31 (or less?) bytes left to go. This is sort of short-
877  *    sighted: what if you don't WANT to do more? In any case, our
878  *    response is to push more into the fifo - either actual data or
879  *    dummy bytes if need be. Note that we apparently have to write at
880  *    least 32 additional bytes to the fifo after an interrupt in order
881  *    to get it to release the ones it was holding on to - writing fewer
882  *    than 32 will result in another fifo int.
883  *  UPDATE: Again, info from Bill Earnest makes this more understandable:
884  *          32 bytes = two counts of the fifo counter register. He tells
885  *          me that the fifo interrupt is a non-latching signal derived
886  *          from a straightforward boolean interpretation of the 7
887  *          highest bits of the fifo counter and the fifo-read/fifo-write
888  *          state. Who'd a thought?
889  */
890
891         write1_io(0, IO_LED_ON);
892         asr = READ_AUX_STAT();
893         if (!(asr & ASR_INT)) { /* no WD33c93 interrupt? */
894
895 /* Ok. This is definitely a FIFO-only interrupt.
896  *
897  * If FI_FIFO_READING is set, there are up to 2048 bytes waiting to be read,
898  * maybe more to come from the SCSI bus. Read as many as we can out of the
899  * fifo and into memory at the location of SCp.ptr[SCp.have_data_in], and
900  * update have_data_in afterwards.
901  *
902  * If we have FI_FIFO_WRITING, the FIFO has almost run out of bytes to move
903  * into the WD3393 chip (I think the interrupt happens when there are 31
904  * bytes left, but it may be fewer...). The 3393 is still waiting, so we
905  * shove some more into the fifo, which gets things moving again. If the
906  * original SCSI command specified more than 2048 bytes, there may still
907  * be some of that data left: fine - use it (from SCp.ptr[SCp.have_data_in]).
908  * Don't forget to update have_data_in. If we've already written out the
909  * entire buffer, feed 32 dummy bytes to the fifo - they're needed to
910  * push out the remaining real data.
911  *    (Big thanks to Bill Earnest for getting me out of the mud in here.)
912  */
913
914                 cmd = (Scsi_Cmnd *) hostdata->connected;        /* assume we're connected */
915                 CHECK_NULL(cmd, "fifo_int")
916
917                     if (hostdata->fifo == FI_FIFO_READING) {
918
919                         DB(DB_FIFO, printk("{R:%02x} ", read1_io(IO_FIFO_COUNT)))
920
921                             sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
922                         i = read1_io(IO_FIFO_COUNT) & 0xfe;
923                         i <<= 2;        /* # of words waiting in the fifo */
924                         f = hostdata->io_base + IO_FIFO;
925
926 #ifdef FAST_READ_IO
927
928                         FAST_READ2_IO();
929 #else
930                         while (i--)
931                                 *sp++ = read2_io(IO_FIFO);
932
933 #endif
934
935                         i = sp - (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
936                         i <<= 1;
937                         cmd->SCp.have_data_in += i;
938                 }
939
940                 else if (hostdata->fifo == FI_FIFO_WRITING) {
941
942                         DB(DB_FIFO, printk("{W:%02x} ", read1_io(IO_FIFO_COUNT)))
943
944 /* If all bytes have been written to the fifo, flush out the stragglers.
945  * Note that while writing 16 dummy words seems arbitrary, we don't
946  * have another choice that I can see. What we really want is to read
947  * the 3393 transfer count register (that would tell us how many bytes
948  * needed flushing), but the TRANSFER_INFO command hasn't completed
949  * yet (not enough bytes!) and that register won't be accessible. So,
950  * we use 16 words - a number obtained through trial and error.
951  *  UPDATE: Bill says this is exactly what Always does, so there.
952  *          More thanks due him for help in this section.
953  */
954                             if (cmd->SCp.this_residual == cmd->SCp.have_data_in) {
955                                 i = 16;
956                                 while (i--)     /* write 32 dummy bytes */
957                                         write2_io(0, IO_FIFO);
958                         }
959
960 /* If there are still bytes left in the SCSI buffer, write as many as we
961  * can out to the fifo.
962  */
963
964                         else {
965                                 sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
966                                 i = cmd->SCp.this_residual - cmd->SCp.have_data_in;     /* bytes yet to go */
967                                 j = read1_io(IO_FIFO_COUNT) & 0xfe;
968                                 j <<= 2;        /* how many words the fifo has room for */
969                                 if ((j << 1) > i)
970                                         j = (i >> 1);
971                                 while (j--)
972                                         write2_io(*sp++, IO_FIFO);
973
974                                 i = sp - (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
975                                 i <<= 1;
976                                 cmd->SCp.have_data_in += i;
977                         }
978                 }
979
980                 else {
981                         printk("*** Spurious FIFO interrupt ***");
982                 }
983
984                 write1_io(0, IO_LED_OFF);
985
986 /* release the SMP spin_lock and restore irq state */
987                 spin_unlock_irqrestore(instance->host_lock, flags);
988                 return IRQ_HANDLED;
989         }
990
991 /* This interrupt was triggered by the WD33c93 chip. The fifo interrupt
992  * may also be asserted, but we don't bother to check it: we get more
993  * detailed info from FIFO_READING and FIFO_WRITING (see below).
994  */
995
996         cmd = (Scsi_Cmnd *) hostdata->connected;        /* assume we're connected */
997         sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear the interrupt */
998         phs = read_3393(hostdata, WD_COMMAND_PHASE);
999
1000         if (!cmd && (sr != CSR_RESEL_AM && sr != CSR_TIMEOUT && sr != CSR_SELECT)) {
1001                 printk("\nNR:wd-intr-1\n");
1002                 write1_io(0, IO_LED_OFF);
1003
1004 /* release the SMP spin_lock and restore irq state */
1005                 spin_unlock_irqrestore(instance->host_lock, flags);
1006                 return IRQ_HANDLED;
1007         }
1008
1009         DB(DB_INTR, printk("{%02x:%02x-", asr, sr))
1010
1011 /* After starting a FIFO-based transfer, the next _WD3393_ interrupt is
1012  * guaranteed to be in response to the completion of the transfer.
1013  * If we were reading, there's probably data in the fifo that needs
1014  * to be copied into RAM - do that here. Also, we have to update
1015  * 'this_residual' and 'ptr' based on the contents of the
1016  * TRANSFER_COUNT register, in case the device decided to do an
1017  * intermediate disconnect (a device may do this if it has to
1018  * do a seek,  or just to be nice and let other devices have
1019  * some bus time during long transfers).
1020  * After doing whatever is necessary with the fifo, we go on and
1021  * service the WD3393 interrupt normally.
1022  */
1023             if (hostdata->fifo == FI_FIFO_READING) {
1024
1025 /* buffer index = start-of-buffer + #-of-bytes-already-read */
1026
1027                 sp = (unsigned short *) (cmd->SCp.ptr + cmd->SCp.have_data_in);
1028
1029 /* bytes remaining in fifo = (total-wanted - #-not-got) - #-already-read */
1030
1031                 i = (cmd->SCp.this_residual - read_3393_count(hostdata)) - cmd->SCp.have_data_in;
1032                 i >>= 1;        /* Gulp. We assume this will always be modulo 2 */
1033                 f = hostdata->io_base + IO_FIFO;
1034
1035 #ifdef FAST_READ_IO
1036
1037                 FAST_READ2_IO();
1038 #else
1039                 while (i--)
1040                         *sp++ = read2_io(IO_FIFO);
1041
1042 #endif
1043
1044                 hostdata->fifo = FI_FIFO_UNUSED;
1045                 length = cmd->SCp.this_residual;
1046                 cmd->SCp.this_residual = read_3393_count(hostdata);
1047                 cmd->SCp.ptr += (length - cmd->SCp.this_residual);
1048
1049                 DB(DB_TRANSFER, printk("(%p,%d)", cmd->SCp.ptr, cmd->SCp.this_residual))
1050
1051         }
1052
1053         else if (hostdata->fifo == FI_FIFO_WRITING) {
1054                 hostdata->fifo = FI_FIFO_UNUSED;
1055                 length = cmd->SCp.this_residual;
1056                 cmd->SCp.this_residual = read_3393_count(hostdata);
1057                 cmd->SCp.ptr += (length - cmd->SCp.this_residual);
1058
1059                 DB(DB_TRANSFER, printk("(%p,%d)", cmd->SCp.ptr, cmd->SCp.this_residual))
1060
1061         }
1062
1063 /* Respond to the specific WD3393 interrupt - there are quite a few! */
1064
1065         switch (sr) {
1066
1067         case CSR_TIMEOUT:
1068                 DB(DB_INTR, printk("TIMEOUT"))
1069
1070                     if (hostdata->state == S_RUNNING_LEVEL2)
1071                         hostdata->connected = NULL;
1072                 else {
1073                         cmd = (Scsi_Cmnd *) hostdata->selecting;        /* get a valid cmd */
1074                         CHECK_NULL(cmd, "csr_timeout")
1075                             hostdata->selecting = NULL;
1076                 }
1077
1078                 cmd->result = DID_NO_CONNECT << 16;
1079                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1080                 hostdata->state = S_UNCONNECTED;
1081                 cmd->scsi_done(cmd);
1082
1083 /* We are not connected to a target - check to see if there
1084  * are commands waiting to be executed.
1085  */
1086
1087                 in2000_execute(instance);
1088                 break;
1089
1090
1091 /* Note: this interrupt should not occur in a LEVEL2 command */
1092
1093         case CSR_SELECT:
1094                 DB(DB_INTR, printk("SELECT"))
1095                     hostdata->connected = cmd = (Scsi_Cmnd *) hostdata->selecting;
1096                 CHECK_NULL(cmd, "csr_select")
1097                     hostdata->selecting = NULL;
1098
1099                 /* construct an IDENTIFY message with correct disconnect bit */
1100
1101                 hostdata->outgoing_msg[0] = (0x80 | 0x00 | cmd->device->lun);
1102                 if (cmd->SCp.phase)
1103                         hostdata->outgoing_msg[0] |= 0x40;
1104
1105                 if (hostdata->sync_stat[cmd->device->id] == SS_FIRST) {
1106 #ifdef SYNC_DEBUG
1107                         printk(" sending SDTR ");
1108 #endif
1109
1110                         hostdata->sync_stat[cmd->device->id] = SS_WAITING;
1111
1112                         /* tack on a 2nd message to ask about synchronous transfers */
1113
1114                         hostdata->outgoing_msg[1] = EXTENDED_MESSAGE;
1115                         hostdata->outgoing_msg[2] = 3;
1116                         hostdata->outgoing_msg[3] = EXTENDED_SDTR;
1117                         hostdata->outgoing_msg[4] = OPTIMUM_SX_PER / 4;
1118                         hostdata->outgoing_msg[5] = OPTIMUM_SX_OFF;
1119                         hostdata->outgoing_len = 6;
1120                 } else
1121                         hostdata->outgoing_len = 1;
1122
1123                 hostdata->state = S_CONNECTED;
1124                 break;
1125
1126
1127         case CSR_XFER_DONE | PHS_DATA_IN:
1128         case CSR_UNEXP | PHS_DATA_IN:
1129         case CSR_SRV_REQ | PHS_DATA_IN:
1130                 DB(DB_INTR, printk("IN-%d.%d", cmd->SCp.this_residual, cmd->SCp.buffers_residual))
1131                     transfer_bytes(cmd, DATA_IN_DIR);
1132                 if (hostdata->state != S_RUNNING_LEVEL2)
1133                         hostdata->state = S_CONNECTED;
1134                 break;
1135
1136
1137         case CSR_XFER_DONE | PHS_DATA_OUT:
1138         case CSR_UNEXP | PHS_DATA_OUT:
1139         case CSR_SRV_REQ | PHS_DATA_OUT:
1140                 DB(DB_INTR, printk("OUT-%d.%d", cmd->SCp.this_residual, cmd->SCp.buffers_residual))
1141                     transfer_bytes(cmd, DATA_OUT_DIR);
1142                 if (hostdata->state != S_RUNNING_LEVEL2)
1143                         hostdata->state = S_CONNECTED;
1144                 break;
1145
1146
1147 /* Note: this interrupt should not occur in a LEVEL2 command */
1148
1149         case CSR_XFER_DONE | PHS_COMMAND:
1150         case CSR_UNEXP | PHS_COMMAND:
1151         case CSR_SRV_REQ | PHS_COMMAND:
1152                 DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number))
1153                     transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
1154                 hostdata->state = S_CONNECTED;
1155                 break;
1156
1157
1158         case CSR_XFER_DONE | PHS_STATUS:
1159         case CSR_UNEXP | PHS_STATUS:
1160         case CSR_SRV_REQ | PHS_STATUS:
1161                 DB(DB_INTR, printk("STATUS="))
1162
1163                     cmd->SCp.Status = read_1_byte(hostdata);
1164                 DB(DB_INTR, printk("%02x", cmd->SCp.Status))
1165                     if (hostdata->level2 >= L2_BASIC) {
1166                         sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear interrupt */
1167                         hostdata->state = S_RUNNING_LEVEL2;
1168                         write_3393(hostdata, WD_COMMAND_PHASE, 0x50);
1169                         write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1170                 } else {
1171                         hostdata->state = S_CONNECTED;
1172                 }
1173                 break;
1174
1175
1176         case CSR_XFER_DONE | PHS_MESS_IN:
1177         case CSR_UNEXP | PHS_MESS_IN:
1178         case CSR_SRV_REQ | PHS_MESS_IN:
1179                 DB(DB_INTR, printk("MSG_IN="))
1180
1181                     msg = read_1_byte(hostdata);
1182                 sr = read_3393(hostdata, WD_SCSI_STATUS);       /* clear interrupt */
1183
1184                 hostdata->incoming_msg[hostdata->incoming_ptr] = msg;
1185                 if (hostdata->incoming_msg[0] == EXTENDED_MESSAGE)
1186                         msg = EXTENDED_MESSAGE;
1187                 else
1188                         hostdata->incoming_ptr = 0;
1189
1190                 cmd->SCp.Message = msg;
1191                 switch (msg) {
1192
1193                 case COMMAND_COMPLETE:
1194                         DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number))
1195                             write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1196                         hostdata->state = S_PRE_CMP_DISC;
1197                         break;
1198
1199                 case SAVE_POINTERS:
1200                         DB(DB_INTR, printk("SDP"))
1201                             write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1202                         hostdata->state = S_CONNECTED;
1203                         break;
1204
1205                 case RESTORE_POINTERS:
1206                         DB(DB_INTR, printk("RDP"))
1207                             if (hostdata->level2 >= L2_BASIC) {
1208                                 write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
1209                                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1210                                 hostdata->state = S_RUNNING_LEVEL2;
1211                         } else {
1212                                 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1213                                 hostdata->state = S_CONNECTED;
1214                         }
1215                         break;
1216
1217                 case DISCONNECT:
1218                         DB(DB_INTR, printk("DIS"))
1219                             cmd->device->disconnect = 1;
1220                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1221                         hostdata->state = S_PRE_TMP_DISC;
1222                         break;
1223
1224                 case MESSAGE_REJECT:
1225                         DB(DB_INTR, printk("REJ"))
1226 #ifdef SYNC_DEBUG
1227                             printk("-REJ-");
1228 #endif
1229                         if (hostdata->sync_stat[cmd->device->id] == SS_WAITING)
1230                                 hostdata->sync_stat[cmd->device->id] = SS_SET;
1231                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1232                         hostdata->state = S_CONNECTED;
1233                         break;
1234
1235                 case EXTENDED_MESSAGE:
1236                         DB(DB_INTR, printk("EXT"))
1237
1238                             ucp = hostdata->incoming_msg;
1239
1240 #ifdef SYNC_DEBUG
1241                         printk("%02x", ucp[hostdata->incoming_ptr]);
1242 #endif
1243                         /* Is this the last byte of the extended message? */
1244
1245                         if ((hostdata->incoming_ptr >= 2) && (hostdata->incoming_ptr == (ucp[1] + 1))) {
1246
1247                                 switch (ucp[2]) {       /* what's the EXTENDED code? */
1248                                 case EXTENDED_SDTR:
1249                                         id = calc_sync_xfer(ucp[3], ucp[4]);
1250                                         if (hostdata->sync_stat[cmd->device->id] != SS_WAITING) {
1251
1252 /* A device has sent an unsolicited SDTR message; rather than go
1253  * through the effort of decoding it and then figuring out what
1254  * our reply should be, we're just gonna say that we have a
1255  * synchronous fifo depth of 0. This will result in asynchronous
1256  * transfers - not ideal but so much easier.
1257  * Actually, this is OK because it assures us that if we don't
1258  * specifically ask for sync transfers, we won't do any.
1259  */
1260
1261                                                 write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1262                                                 hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
1263                                                 hostdata->outgoing_msg[1] = 3;
1264                                                 hostdata->outgoing_msg[2] = EXTENDED_SDTR;
1265                                                 hostdata->outgoing_msg[3] = hostdata->default_sx_per / 4;
1266                                                 hostdata->outgoing_msg[4] = 0;
1267                                                 hostdata->outgoing_len = 5;
1268                                                 hostdata->sync_xfer[cmd->device->id] = calc_sync_xfer(hostdata->default_sx_per / 4, 0);
1269                                         } else {
1270                                                 hostdata->sync_xfer[cmd->device->id] = id;
1271                                         }
1272 #ifdef SYNC_DEBUG
1273                                         printk("sync_xfer=%02x", hostdata->sync_xfer[cmd->device->id]);
1274 #endif
1275                                         hostdata->sync_stat[cmd->device->id] = SS_SET;
1276                                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1277                                         hostdata->state = S_CONNECTED;
1278                                         break;
1279                                 case EXTENDED_WDTR:
1280                                         write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1281                                         printk("sending WDTR ");
1282                                         hostdata->outgoing_msg[0] = EXTENDED_MESSAGE;
1283                                         hostdata->outgoing_msg[1] = 2;
1284                                         hostdata->outgoing_msg[2] = EXTENDED_WDTR;
1285                                         hostdata->outgoing_msg[3] = 0;  /* 8 bit transfer width */
1286                                         hostdata->outgoing_len = 4;
1287                                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1288                                         hostdata->state = S_CONNECTED;
1289                                         break;
1290                                 default:
1291                                         write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1292                                         printk("Rejecting Unknown Extended Message(%02x). ", ucp[2]);
1293                                         hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1294                                         hostdata->outgoing_len = 1;
1295                                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1296                                         hostdata->state = S_CONNECTED;
1297                                         break;
1298                                 }
1299                                 hostdata->incoming_ptr = 0;
1300                         }
1301
1302                         /* We need to read more MESS_IN bytes for the extended message */
1303
1304                         else {
1305                                 hostdata->incoming_ptr++;
1306                                 write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1307                                 hostdata->state = S_CONNECTED;
1308                         }
1309                         break;
1310
1311                 default:
1312                         printk("Rejecting Unknown Message(%02x) ", msg);
1313                         write_3393_cmd(hostdata, WD_CMD_ASSERT_ATN);    /* want MESS_OUT */
1314                         hostdata->outgoing_msg[0] = MESSAGE_REJECT;
1315                         hostdata->outgoing_len = 1;
1316                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1317                         hostdata->state = S_CONNECTED;
1318                 }
1319                 break;
1320
1321
1322 /* Note: this interrupt will occur only after a LEVEL2 command */
1323
1324         case CSR_SEL_XFER_DONE:
1325
1326 /* Make sure that reselection is enabled at this point - it may
1327  * have been turned off for the command that just completed.
1328  */
1329
1330                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1331                 if (phs == 0x60) {
1332                         DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number))
1333                             cmd->SCp.Message = COMMAND_COMPLETE;
1334                         lun = read_3393(hostdata, WD_TARGET_LUN);
1335                         DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
1336                             hostdata->connected = NULL;
1337                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1338                         hostdata->state = S_UNCONNECTED;
1339                         if (cmd->SCp.Status == ILLEGAL_STATUS_BYTE)
1340                                 cmd->SCp.Status = lun;
1341                         if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1342                                 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1343                         else
1344                                 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1345                         cmd->scsi_done(cmd);
1346
1347 /* We are no longer connected to a target - check to see if
1348  * there are commands waiting to be executed.
1349  */
1350
1351                         in2000_execute(instance);
1352                 } else {
1353                         printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs, cmd->serial_number);
1354                 }
1355                 break;
1356
1357
1358 /* Note: this interrupt will occur only after a LEVEL2 command */
1359
1360         case CSR_SDP:
1361                 DB(DB_INTR, printk("SDP"))
1362                     hostdata->state = S_RUNNING_LEVEL2;
1363                 write_3393(hostdata, WD_COMMAND_PHASE, 0x41);
1364                 write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1365                 break;
1366
1367
1368         case CSR_XFER_DONE | PHS_MESS_OUT:
1369         case CSR_UNEXP | PHS_MESS_OUT:
1370         case CSR_SRV_REQ | PHS_MESS_OUT:
1371                 DB(DB_INTR, printk("MSG_OUT="))
1372
1373 /* To get here, we've probably requested MESSAGE_OUT and have
1374  * already put the correct bytes in outgoing_msg[] and filled
1375  * in outgoing_len. We simply send them out to the SCSI bus.
1376  * Sometimes we get MESSAGE_OUT phase when we're not expecting
1377  * it - like when our SDTR message is rejected by a target. Some
1378  * targets send the REJECT before receiving all of the extended
1379  * message, and then seem to go back to MESSAGE_OUT for a byte
1380  * or two. Not sure why, or if I'm doing something wrong to
1381  * cause this to happen. Regardless, it seems that sending
1382  * NOP messages in these situations results in no harm and
1383  * makes everyone happy.
1384  */
1385                     if (hostdata->outgoing_len == 0) {
1386                         hostdata->outgoing_len = 1;
1387                         hostdata->outgoing_msg[0] = NOP;
1388                 }
1389                 transfer_pio(hostdata->outgoing_msg, hostdata->outgoing_len, DATA_OUT_DIR, hostdata);
1390                 DB(DB_INTR, printk("%02x", hostdata->outgoing_msg[0]))
1391                     hostdata->outgoing_len = 0;
1392                 hostdata->state = S_CONNECTED;
1393                 break;
1394
1395
1396         case CSR_UNEXP_DISC:
1397
1398 /* I think I've seen this after a request-sense that was in response
1399  * to an error condition, but not sure. We certainly need to do
1400  * something when we get this interrupt - the question is 'what?'.
1401  * Let's think positively, and assume some command has finished
1402  * in a legal manner (like a command that provokes a request-sense),
1403  * so we treat it as a normal command-complete-disconnect.
1404  */
1405
1406
1407 /* Make sure that reselection is enabled at this point - it may
1408  * have been turned off for the command that just completed.
1409  */
1410
1411                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1412                 if (cmd == NULL) {
1413                         printk(" - Already disconnected! ");
1414                         hostdata->state = S_UNCONNECTED;
1415
1416 /* release the SMP spin_lock and restore irq state */
1417                         spin_unlock_irqrestore(instance->host_lock, flags);
1418                         return IRQ_HANDLED;
1419                 }
1420                 DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number))
1421                     hostdata->connected = NULL;
1422                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1423                 hostdata->state = S_UNCONNECTED;
1424                 if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1425                         cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1426                 else
1427                         cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1428                 cmd->scsi_done(cmd);
1429
1430 /* We are no longer connected to a target - check to see if
1431  * there are commands waiting to be executed.
1432  */
1433
1434                 in2000_execute(instance);
1435                 break;
1436
1437
1438         case CSR_DISC:
1439
1440 /* Make sure that reselection is enabled at this point - it may
1441  * have been turned off for the command that just completed.
1442  */
1443
1444                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
1445                 DB(DB_INTR, printk("DISC-%ld", cmd->serial_number))
1446                     if (cmd == NULL) {
1447                         printk(" - Already disconnected! ");
1448                         hostdata->state = S_UNCONNECTED;
1449                 }
1450                 switch (hostdata->state) {
1451                 case S_PRE_CMP_DISC:
1452                         hostdata->connected = NULL;
1453                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1454                         hostdata->state = S_UNCONNECTED;
1455                         DB(DB_INTR, printk(":%d", cmd->SCp.Status))
1456                             if (cmd->cmnd[0] == REQUEST_SENSE && cmd->SCp.Status != GOOD)
1457                                 cmd->result = (cmd->result & 0x00ffff) | (DID_ERROR << 16);
1458                         else
1459                                 cmd->result = cmd->SCp.Status | (cmd->SCp.Message << 8);
1460                         cmd->scsi_done(cmd);
1461                         break;
1462                 case S_PRE_TMP_DISC:
1463                 case S_RUNNING_LEVEL2:
1464                         cmd->host_scribble = (uchar *) hostdata->disconnected_Q;
1465                         hostdata->disconnected_Q = cmd;
1466                         hostdata->connected = NULL;
1467                         hostdata->state = S_UNCONNECTED;
1468
1469 #ifdef PROC_STATISTICS
1470                         hostdata->disc_done_cnt[cmd->device->id]++;
1471 #endif
1472
1473                         break;
1474                 default:
1475                         printk("*** Unexpected DISCONNECT interrupt! ***");
1476                         hostdata->state = S_UNCONNECTED;
1477                 }
1478
1479 /* We are no longer connected to a target - check to see if
1480  * there are commands waiting to be executed.
1481  */
1482
1483                 in2000_execute(instance);
1484                 break;
1485
1486
1487         case CSR_RESEL_AM:
1488                 DB(DB_INTR, printk("RESEL"))
1489
1490                     /* First we have to make sure this reselection didn't */
1491                     /* happen during Arbitration/Selection of some other device. */
1492                     /* If yes, put losing command back on top of input_Q. */
1493                     if (hostdata->level2 <= L2_NONE) {
1494
1495                         if (hostdata->selecting) {
1496                                 cmd = (Scsi_Cmnd *) hostdata->selecting;
1497                                 hostdata->selecting = NULL;
1498                                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1499                                 cmd->host_scribble = (uchar *) hostdata->input_Q;
1500                                 hostdata->input_Q = cmd;
1501                         }
1502                 }
1503
1504                 else {
1505
1506                         if (cmd) {
1507                                 if (phs == 0x00) {
1508                                         hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1509                                         cmd->host_scribble = (uchar *) hostdata->input_Q;
1510                                         hostdata->input_Q = cmd;
1511                                 } else {
1512                                         printk("---%02x:%02x:%02x-TROUBLE: Intrusive ReSelect!---", asr, sr, phs);
1513                                         while (1)
1514                                                 printk("\r");
1515                                 }
1516                         }
1517
1518                 }
1519
1520                 /* OK - find out which device reselected us. */
1521
1522                 id = read_3393(hostdata, WD_SOURCE_ID);
1523                 id &= SRCID_MASK;
1524
1525                 /* and extract the lun from the ID message. (Note that we don't
1526                  * bother to check for a valid message here - I guess this is
1527                  * not the right way to go, but....)
1528                  */
1529
1530                 lun = read_3393(hostdata, WD_DATA);
1531                 if (hostdata->level2 < L2_RESELECT)
1532                         write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
1533                 lun &= 7;
1534
1535                 /* Now we look for the command that's reconnecting. */
1536
1537                 cmd = (Scsi_Cmnd *) hostdata->disconnected_Q;
1538                 patch = NULL;
1539                 while (cmd) {
1540                         if (id == cmd->device->id && lun == cmd->device->lun)
1541                                 break;
1542                         patch = cmd;
1543                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
1544                 }
1545
1546                 /* Hmm. Couldn't find a valid command.... What to do? */
1547
1548                 if (!cmd) {
1549                         printk("---TROUBLE: target %d.%d not in disconnect queue---", id, lun);
1550                         break;
1551                 }
1552
1553                 /* Ok, found the command - now start it up again. */
1554
1555                 if (patch)
1556                         patch->host_scribble = cmd->host_scribble;
1557                 else
1558                         hostdata->disconnected_Q = (Scsi_Cmnd *) cmd->host_scribble;
1559                 hostdata->connected = cmd;
1560
1561                 /* We don't need to worry about 'initialize_SCp()' or 'hostdata->busy[]'
1562                  * because these things are preserved over a disconnect.
1563                  * But we DO need to fix the DPD bit so it's correct for this command.
1564                  */
1565
1566                 if (is_dir_out(cmd))
1567                         write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id);
1568                 else
1569                         write_3393(hostdata, WD_DESTINATION_ID, cmd->device->id | DSTID_DPD);
1570                 if (hostdata->level2 >= L2_RESELECT) {
1571                         write_3393_count(hostdata, 0);  /* we want a DATA_PHASE interrupt */
1572                         write_3393(hostdata, WD_COMMAND_PHASE, 0x45);
1573                         write_3393_cmd(hostdata, WD_CMD_SEL_ATN_XFER);
1574                         hostdata->state = S_RUNNING_LEVEL2;
1575                 } else
1576                         hostdata->state = S_CONNECTED;
1577
1578                 DB(DB_INTR, printk("-%ld", cmd->serial_number))
1579                     break;
1580
1581         default:
1582                 printk("--UNKNOWN INTERRUPT:%02x:%02x:%02x--", asr, sr, phs);
1583         }
1584
1585         write1_io(0, IO_LED_OFF);
1586
1587         DB(DB_INTR, printk("} "))
1588
1589 /* release the SMP spin_lock and restore irq state */
1590             spin_unlock_irqrestore(instance->host_lock, flags);
1591         return IRQ_HANDLED;
1592 }
1593
1594
1595
1596 #define RESET_CARD         0
1597 #define RESET_CARD_AND_BUS 1
1598 #define B_FLAG 0x80
1599
1600 /*
1601  *      Caller must hold instance lock!
1602  */
1603
1604 static int reset_hardware(struct Scsi_Host *instance, int type)
1605 {
1606         struct IN2000_hostdata *hostdata;
1607         int qt, x;
1608
1609         hostdata = (struct IN2000_hostdata *) instance->hostdata;
1610
1611         write1_io(0, IO_LED_ON);
1612         if (type == RESET_CARD_AND_BUS) {
1613                 write1_io(0, IO_CARD_RESET);
1614                 x = read1_io(IO_HARDWARE);
1615         }
1616         x = read_3393(hostdata, WD_SCSI_STATUS);        /* clear any WD intrpt */
1617         write_3393(hostdata, WD_OWN_ID, instance->this_id | OWNID_EAF | OWNID_RAF | OWNID_FS_8);
1618         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1619         write_3393(hostdata, WD_SYNCHRONOUS_TRANSFER, calc_sync_xfer(hostdata->default_sx_per / 4, DEFAULT_SX_OFF));
1620
1621         write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter */
1622         write1_io(0, IO_FIFO_READ);     /* start fifo out in read mode */
1623         write_3393(hostdata, WD_COMMAND, WD_CMD_RESET);
1624         /* FIXME: timeout ?? */
1625         while (!(READ_AUX_STAT() & ASR_INT))
1626                 cpu_relax();    /* wait for RESET to complete */
1627
1628         x = read_3393(hostdata, WD_SCSI_STATUS);        /* clear interrupt */
1629
1630         write_3393(hostdata, WD_QUEUE_TAG, 0xa5);       /* any random number */
1631         qt = read_3393(hostdata, WD_QUEUE_TAG);
1632         if (qt == 0xa5) {
1633                 x |= B_FLAG;
1634                 write_3393(hostdata, WD_QUEUE_TAG, 0);
1635         }
1636         write_3393(hostdata, WD_TIMEOUT_PERIOD, TIMEOUT_PERIOD_VALUE);
1637         write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1638         write1_io(0, IO_LED_OFF);
1639         return x;
1640 }
1641
1642
1643
1644 static int in2000_bus_reset(Scsi_Cmnd * cmd)
1645 {
1646         struct Scsi_Host *instance;
1647         struct IN2000_hostdata *hostdata;
1648         int x;
1649         unsigned long flags;
1650
1651         instance = cmd->device->host;
1652         hostdata = (struct IN2000_hostdata *) instance->hostdata;
1653
1654         printk(KERN_WARNING "scsi%d: Reset. ", instance->host_no);
1655
1656         spin_lock_irqsave(instance->host_lock, flags);
1657
1658         /* do scsi-reset here */
1659         reset_hardware(instance, RESET_CARD_AND_BUS);
1660         for (x = 0; x < 8; x++) {
1661                 hostdata->busy[x] = 0;
1662                 hostdata->sync_xfer[x] = calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF);
1663                 hostdata->sync_stat[x] = SS_UNSET;      /* using default sync values */
1664         }
1665         hostdata->input_Q = NULL;
1666         hostdata->selecting = NULL;
1667         hostdata->connected = NULL;
1668         hostdata->disconnected_Q = NULL;
1669         hostdata->state = S_UNCONNECTED;
1670         hostdata->fifo = FI_FIFO_UNUSED;
1671         hostdata->incoming_ptr = 0;
1672         hostdata->outgoing_len = 0;
1673
1674         cmd->result = DID_RESET << 16;
1675
1676         spin_unlock_irqrestore(instance->host_lock, flags);
1677         return SUCCESS;
1678 }
1679
1680 static int __in2000_abort(Scsi_Cmnd * cmd)
1681 {
1682         struct Scsi_Host *instance;
1683         struct IN2000_hostdata *hostdata;
1684         Scsi_Cmnd *tmp, *prev;
1685         uchar sr, asr;
1686         unsigned long timeout;
1687
1688         instance = cmd->device->host;
1689         hostdata = (struct IN2000_hostdata *) instance->hostdata;
1690
1691         printk(KERN_DEBUG "scsi%d: Abort-", instance->host_no);
1692         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));
1693
1694 /*
1695  * Case 1 : If the command hasn't been issued yet, we simply remove it
1696  *     from the inout_Q.
1697  */
1698
1699         tmp = (Scsi_Cmnd *) hostdata->input_Q;
1700         prev = NULL;
1701         while (tmp) {
1702                 if (tmp == cmd) {
1703                         if (prev)
1704                                 prev->host_scribble = cmd->host_scribble;
1705                         cmd->host_scribble = NULL;
1706                         cmd->result = DID_ABORT << 16;
1707                         printk(KERN_WARNING "scsi%d: Abort - removing command %ld from input_Q. ", instance->host_no, cmd->serial_number);
1708                         cmd->scsi_done(cmd);
1709                         return SUCCESS;
1710                 }
1711                 prev = tmp;
1712                 tmp = (Scsi_Cmnd *) tmp->host_scribble;
1713         }
1714
1715 /*
1716  * Case 2 : If the command is connected, we're going to fail the abort
1717  *     and let the high level SCSI driver retry at a later time or
1718  *     issue a reset.
1719  *
1720  *     Timeouts, and therefore aborted commands, will be highly unlikely
1721  *     and handling them cleanly in this situation would make the common
1722  *     case of noresets less efficient, and would pollute our code.  So,
1723  *     we fail.
1724  */
1725
1726         if (hostdata->connected == cmd) {
1727
1728                 printk(KERN_WARNING "scsi%d: Aborting connected command %ld - ", instance->host_no, cmd->serial_number);
1729
1730                 printk("sending wd33c93 ABORT command - ");
1731                 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
1732                 write_3393_cmd(hostdata, WD_CMD_ABORT);
1733
1734 /* Now we have to attempt to flush out the FIFO... */
1735
1736                 printk("flushing fifo - ");
1737                 timeout = 1000000;
1738                 do {
1739                         asr = READ_AUX_STAT();
1740                         if (asr & ASR_DBR)
1741                                 read_3393(hostdata, WD_DATA);
1742                 } while (!(asr & ASR_INT) && timeout-- > 0);
1743                 sr = read_3393(hostdata, WD_SCSI_STATUS);
1744                 printk("asr=%02x, sr=%02x, %ld bytes un-transferred (timeout=%ld) - ", asr, sr, read_3393_count(hostdata), timeout);
1745
1746                 /*
1747                  * Abort command processed.
1748                  * Still connected.
1749                  * We must disconnect.
1750                  */
1751
1752                 printk("sending wd33c93 DISCONNECT command - ");
1753                 write_3393_cmd(hostdata, WD_CMD_DISCONNECT);
1754
1755                 timeout = 1000000;
1756                 asr = READ_AUX_STAT();
1757                 while ((asr & ASR_CIP) && timeout-- > 0)
1758                         asr = READ_AUX_STAT();
1759                 sr = read_3393(hostdata, WD_SCSI_STATUS);
1760                 printk("asr=%02x, sr=%02x.", asr, sr);
1761
1762                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
1763                 hostdata->connected = NULL;
1764                 hostdata->state = S_UNCONNECTED;
1765                 cmd->result = DID_ABORT << 16;
1766                 cmd->scsi_done(cmd);
1767
1768                 in2000_execute(instance);
1769
1770                 return SUCCESS;
1771         }
1772
1773 /*
1774  * Case 3: If the command is currently disconnected from the bus,
1775  * we're not going to expend much effort here: Let's just return
1776  * an ABORT_SNOOZE and hope for the best...
1777  */
1778
1779         for (tmp = (Scsi_Cmnd *) hostdata->disconnected_Q; tmp; tmp = (Scsi_Cmnd *) tmp->host_scribble)
1780                 if (cmd == tmp) {
1781                         printk(KERN_DEBUG "scsi%d: unable to abort disconnected command.\n", instance->host_no);
1782                         return FAILED;
1783                 }
1784
1785 /*
1786  * Case 4 : If we reached this point, the command was not found in any of
1787  *     the queues.
1788  *
1789  * We probably reached this point because of an unlikely race condition
1790  * between the command completing successfully and the abortion code,
1791  * so we won't panic, but we will notify the user in case something really
1792  * broke.
1793  */
1794
1795         in2000_execute(instance);
1796
1797         printk("scsi%d: warning : SCSI command probably completed successfully" "         before abortion. ", instance->host_no);
1798         return SUCCESS;
1799 }
1800
1801 static int in2000_abort(Scsi_Cmnd * cmd)
1802 {
1803         int rc;
1804
1805         spin_lock_irq(cmd->device->host->host_lock);
1806         rc = __in2000_abort(cmd);
1807         spin_unlock_irq(cmd->device->host->host_lock);
1808
1809         return rc;
1810 }
1811
1812
1813 #define MAX_IN2000_HOSTS 3
1814 #define MAX_SETUP_ARGS ARRAY_SIZE(setup_args)
1815 #define SETUP_BUFFER_SIZE 200
1816 static char setup_buffer[SETUP_BUFFER_SIZE];
1817 static char setup_used[MAX_SETUP_ARGS];
1818 static int done_setup = 0;
1819
1820 static void __init in2000_setup(char *str, int *ints)
1821 {
1822         int i;
1823         char *p1, *p2;
1824
1825         strlcpy(setup_buffer, str, SETUP_BUFFER_SIZE);
1826         p1 = setup_buffer;
1827         i = 0;
1828         while (*p1 && (i < MAX_SETUP_ARGS)) {
1829                 p2 = strchr(p1, ',');
1830                 if (p2) {
1831                         *p2 = '\0';
1832                         if (p1 != p2)
1833                                 setup_args[i] = p1;
1834                         p1 = p2 + 1;
1835                         i++;
1836                 } else {
1837                         setup_args[i] = p1;
1838                         break;
1839                 }
1840         }
1841         for (i = 0; i < MAX_SETUP_ARGS; i++)
1842                 setup_used[i] = 0;
1843         done_setup = 1;
1844 }
1845
1846
1847 /* check_setup_args() returns index if key found, 0 if not
1848  */
1849
1850 static int __init check_setup_args(char *key, int *val, char *buf)
1851 {
1852         int x;
1853         char *cp;
1854
1855         for (x = 0; x < MAX_SETUP_ARGS; x++) {
1856                 if (setup_used[x])
1857                         continue;
1858                 if (!strncmp(setup_args[x], key, strlen(key)))
1859                         break;
1860         }
1861         if (x == MAX_SETUP_ARGS)
1862                 return 0;
1863         setup_used[x] = 1;
1864         cp = setup_args[x] + strlen(key);
1865         *val = -1;
1866         if (*cp != ':')
1867                 return ++x;
1868         cp++;
1869         if ((*cp >= '0') && (*cp <= '9')) {
1870                 *val = simple_strtoul(cp, NULL, 0);
1871         }
1872         return ++x;
1873 }
1874
1875
1876
1877 /* The "correct" (ie portable) way to access memory-mapped hardware
1878  * such as the IN2000 EPROM and dip switch is through the use of
1879  * special macros declared in 'asm/io.h'. We use readb() and readl()
1880  * when reading from the card's BIOS area in in2000_detect().
1881  */
1882 static u32 bios_tab[] in2000__INITDATA = {
1883         0xc8000,
1884         0xd0000,
1885         0xd8000,
1886         0
1887 };
1888
1889 static unsigned short base_tab[] in2000__INITDATA = {
1890         0x220,
1891         0x200,
1892         0x110,
1893         0x100,
1894 };
1895
1896 static int int_tab[] in2000__INITDATA = {
1897         15,
1898         14,
1899         11,
1900         10
1901 };
1902
1903 static int probe_bios(u32 addr, u32 *s1, uchar *switches)
1904 {
1905         void __iomem *p = ioremap(addr, 0x34);
1906         if (!p)
1907                 return 0;
1908         *s1 = readl(p + 0x10);
1909         if (*s1 == 0x41564f4e || readl(p + 0x30) == 0x61776c41) {
1910                 /* Read the switch image that's mapped into EPROM space */
1911                 *switches = ~readb(p + 0x20);
1912                 iounmap(p);
1913                 return 1;
1914         }
1915         iounmap(p);
1916         return 0;
1917 }
1918
1919 static int __init in2000_detect(struct scsi_host_template * tpnt)
1920 {
1921         struct Scsi_Host *instance;
1922         struct IN2000_hostdata *hostdata;
1923         int detect_count;
1924         int bios;
1925         int x;
1926         unsigned short base;
1927         uchar switches;
1928         uchar hrev;
1929         unsigned long flags;
1930         int val;
1931         char buf[32];
1932
1933 /* Thanks to help from Bill Earnest, probing for IN2000 cards is a
1934  * pretty straightforward and fool-proof operation. There are 3
1935  * possible locations for the IN2000 EPROM in memory space - if we
1936  * find a BIOS signature, we can read the dip switch settings from
1937  * the byte at BIOS+32 (shadowed in by logic on the card). From 2
1938  * of the switch bits we get the card's address in IO space. There's
1939  * an image of the dip switch there, also, so we have a way to back-
1940  * check that this really is an IN2000 card. Very nifty. Use the
1941  * 'ioport:xx' command-line parameter if your BIOS EPROM is absent
1942  * or disabled.
1943  */
1944
1945         if (!done_setup && setup_strings)
1946                 in2000_setup(setup_strings, NULL);
1947
1948         detect_count = 0;
1949         for (bios = 0; bios_tab[bios]; bios++) {
1950                 u32 s1 = 0;
1951                 if (check_setup_args("ioport", &val, buf)) {
1952                         base = val;
1953                         switches = ~inb(base + IO_SWITCHES) & 0xff;
1954                         printk("Forcing IN2000 detection at IOport 0x%x ", base);
1955                         bios = 2;
1956                 }
1957 /*
1958  * There have been a couple of BIOS versions with different layouts
1959  * for the obvious ID strings. We look for the 2 most common ones and
1960  * hope that they cover all the cases...
1961  */
1962                 else if (probe_bios(bios_tab[bios], &s1, &switches)) {
1963                         printk("Found IN2000 BIOS at 0x%x ", (unsigned int) bios_tab[bios]);
1964
1965 /* Find out where the IO space is */
1966
1967                         x = switches & (SW_ADDR0 | SW_ADDR1);
1968                         base = base_tab[x];
1969
1970 /* Check for the IN2000 signature in IO space. */
1971
1972                         x = ~inb(base + IO_SWITCHES) & 0xff;
1973                         if (x != switches) {
1974                                 printk("Bad IO signature: %02x vs %02x.\n", x, switches);
1975                                 continue;
1976                         }
1977                 } else
1978                         continue;
1979
1980 /* OK. We have a base address for the IO ports - run a few safety checks */
1981
1982                 if (!(switches & SW_BIT7)) {    /* I _think_ all cards do this */
1983                         printk("There is no IN-2000 SCSI card at IOport 0x%03x!\n", base);
1984                         continue;
1985                 }
1986
1987 /* Let's assume any hardware version will work, although the driver
1988  * has only been tested on 0x21, 0x22, 0x25, 0x26, and 0x27. We'll
1989  * print out the rev number for reference later, but accept them all.
1990  */
1991
1992                 hrev = inb(base + IO_HARDWARE);
1993
1994                 /* Bit 2 tells us if interrupts are disabled */
1995                 if (switches & SW_DISINT) {
1996                         printk("The IN-2000 SCSI card at IOport 0x%03x ", base);
1997                         printk("is not configured for interrupt operation!\n");
1998                         printk("This driver requires an interrupt: cancelling detection.\n");
1999                         continue;
2000                 }
2001
2002 /* Ok. We accept that there's an IN2000 at ioaddr 'base'. Now
2003  * initialize it.
2004  */
2005
2006                 tpnt->proc_name = "in2000";
2007                 instance = scsi_register(tpnt, sizeof(struct IN2000_hostdata));
2008                 if (instance == NULL)
2009                         continue;
2010                 detect_count++;
2011                 hostdata = (struct IN2000_hostdata *) instance->hostdata;
2012                 instance->io_port = hostdata->io_base = base;
2013                 hostdata->dip_switch = switches;
2014                 hostdata->hrev = hrev;
2015
2016                 write1_io(0, IO_FIFO_WRITE);    /* clear fifo counter */
2017                 write1_io(0, IO_FIFO_READ);     /* start fifo out in read mode */
2018                 write1_io(0, IO_INTR_MASK);     /* allow all ints */
2019                 x = int_tab[(switches & (SW_INT0 | SW_INT1)) >> SW_INT_SHIFT];
2020                 if (request_irq(x, in2000_intr, IRQF_DISABLED, "in2000", instance)) {
2021                         printk("in2000_detect: Unable to allocate IRQ.\n");
2022                         detect_count--;
2023                         continue;
2024                 }
2025                 instance->irq = x;
2026                 instance->n_io_port = 13;
2027                 request_region(base, 13, "in2000");     /* lock in this IO space for our use */
2028
2029                 for (x = 0; x < 8; x++) {
2030                         hostdata->busy[x] = 0;
2031                         hostdata->sync_xfer[x] = calc_sync_xfer(DEFAULT_SX_PER / 4, DEFAULT_SX_OFF);
2032                         hostdata->sync_stat[x] = SS_UNSET;      /* using default sync values */
2033 #ifdef PROC_STATISTICS
2034                         hostdata->cmd_cnt[x] = 0;
2035                         hostdata->disc_allowed_cnt[x] = 0;
2036                         hostdata->disc_done_cnt[x] = 0;
2037 #endif
2038                 }
2039                 hostdata->input_Q = NULL;
2040                 hostdata->selecting = NULL;
2041                 hostdata->connected = NULL;
2042                 hostdata->disconnected_Q = NULL;
2043                 hostdata->state = S_UNCONNECTED;
2044                 hostdata->fifo = FI_FIFO_UNUSED;
2045                 hostdata->level2 = L2_BASIC;
2046                 hostdata->disconnect = DIS_ADAPTIVE;
2047                 hostdata->args = DEBUG_DEFAULTS;
2048                 hostdata->incoming_ptr = 0;
2049                 hostdata->outgoing_len = 0;
2050                 hostdata->default_sx_per = DEFAULT_SX_PER;
2051
2052 /* Older BIOS's had a 'sync on/off' switch - use its setting */
2053
2054                 if (s1 == 0x41564f4e && (switches & SW_SYNC_DOS5))
2055                         hostdata->sync_off = 0x00;      /* sync defaults to on */
2056                 else
2057                         hostdata->sync_off = 0xff;      /* sync defaults to off */
2058
2059 #ifdef PROC_INTERFACE
2060                 hostdata->proc = PR_VERSION | PR_INFO | PR_STATISTICS | PR_CONNECTED | PR_INPUTQ | PR_DISCQ | PR_STOP;
2061 #ifdef PROC_STATISTICS
2062                 hostdata->int_cnt = 0;
2063 #endif
2064 #endif
2065
2066                 if (check_setup_args("nosync", &val, buf))
2067                         hostdata->sync_off = val;
2068
2069                 if (check_setup_args("period", &val, buf))
2070                         hostdata->default_sx_per = sx_table[round_period((unsigned int) val)].period_ns;
2071
2072                 if (check_setup_args("disconnect", &val, buf)) {
2073                         if ((val >= DIS_NEVER) && (val <= DIS_ALWAYS))
2074                                 hostdata->disconnect = val;
2075                         else
2076                                 hostdata->disconnect = DIS_ADAPTIVE;
2077                 }
2078
2079                 if (check_setup_args("noreset", &val, buf))
2080                         hostdata->args ^= A_NO_SCSI_RESET;
2081
2082                 if (check_setup_args("level2", &val, buf))
2083                         hostdata->level2 = val;
2084
2085                 if (check_setup_args("debug", &val, buf))
2086                         hostdata->args = (val & DB_MASK);
2087
2088 #ifdef PROC_INTERFACE
2089                 if (check_setup_args("proc", &val, buf))
2090                         hostdata->proc = val;
2091 #endif
2092
2093
2094                 /* FIXME: not strictly needed I think but the called code expects
2095                    to be locked */
2096                 spin_lock_irqsave(instance->host_lock, flags);
2097                 x = reset_hardware(instance, (hostdata->args & A_NO_SCSI_RESET) ? RESET_CARD : RESET_CARD_AND_BUS);
2098                 spin_unlock_irqrestore(instance->host_lock, flags);
2099
2100                 hostdata->microcode = read_3393(hostdata, WD_CDB_1);
2101                 if (x & 0x01) {
2102                         if (x & B_FLAG)
2103                                 hostdata->chip = C_WD33C93B;
2104                         else
2105                                 hostdata->chip = C_WD33C93A;
2106                 } else
2107                         hostdata->chip = C_WD33C93;
2108
2109                 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");
2110                 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);
2111 #ifdef DEBUGGING_ON
2112                 printk("setup_args = ");
2113                 for (x = 0; x < MAX_SETUP_ARGS; x++)
2114                         printk("%s,", setup_args[x]);
2115                 printk("\n");
2116 #endif
2117                 if (hostdata->sync_off == 0xff)
2118                         printk("Sync-transfer DISABLED on all devices: ENABLE from command-line\n");
2119                 printk("IN2000 driver version %s - %s\n", IN2000_VERSION, IN2000_DATE);
2120         }
2121
2122         return detect_count;
2123 }
2124
2125 static int in2000_release(struct Scsi_Host *shost)
2126 {
2127         if (shost->irq)
2128                 free_irq(shost->irq, shost);
2129         if (shost->io_port && shost->n_io_port)
2130                 release_region(shost->io_port, shost->n_io_port);
2131         return 0;
2132 }
2133
2134 /* NOTE: I lifted this function straight out of the old driver,
2135  *       and have not tested it. Presumably it does what it's
2136  *       supposed to do...
2137  */
2138
2139 static int in2000_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int *iinfo)
2140 {
2141         int size;
2142
2143         size = capacity;
2144         iinfo[0] = 64;
2145         iinfo[1] = 32;
2146         iinfo[2] = size >> 11;
2147
2148 /* This should approximate the large drive handling that the DOS ASPI manager
2149    uses.  Drives very near the boundaries may not be handled correctly (i.e.
2150    near 2.0 Gb and 4.0 Gb) */
2151
2152         if (iinfo[2] > 1024) {
2153                 iinfo[0] = 64;
2154                 iinfo[1] = 63;
2155                 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2156         }
2157         if (iinfo[2] > 1024) {
2158                 iinfo[0] = 128;
2159                 iinfo[1] = 63;
2160                 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2161         }
2162         if (iinfo[2] > 1024) {
2163                 iinfo[0] = 255;
2164                 iinfo[1] = 63;
2165                 iinfo[2] = (unsigned long) capacity / (iinfo[0] * iinfo[1]);
2166         }
2167         return 0;
2168 }
2169
2170
2171 static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off, int len, int in)
2172 {
2173
2174 #ifdef PROC_INTERFACE
2175
2176         char *bp;
2177         char tbuf[128];
2178         unsigned long flags;
2179         struct IN2000_hostdata *hd;
2180         Scsi_Cmnd *cmd;
2181         int x, i;
2182         static int stop = 0;
2183
2184         hd = (struct IN2000_hostdata *) instance->hostdata;
2185
2186 /* If 'in' is TRUE we need to _read_ the proc file. We accept the following
2187  * keywords (same format as command-line, but only ONE per read):
2188  *    debug
2189  *    disconnect
2190  *    period
2191  *    resync
2192  *    proc
2193  */
2194
2195         if (in) {
2196                 buf[len] = '\0';
2197                 bp = buf;
2198                 if (!strncmp(bp, "debug:", 6)) {
2199                         bp += 6;
2200                         hd->args = simple_strtoul(bp, NULL, 0) & DB_MASK;
2201                 } else if (!strncmp(bp, "disconnect:", 11)) {
2202                         bp += 11;
2203                         x = simple_strtoul(bp, NULL, 0);
2204                         if (x < DIS_NEVER || x > DIS_ALWAYS)
2205                                 x = DIS_ADAPTIVE;
2206                         hd->disconnect = x;
2207                 } else if (!strncmp(bp, "period:", 7)) {
2208                         bp += 7;
2209                         x = simple_strtoul(bp, NULL, 0);
2210                         hd->default_sx_per = sx_table[round_period((unsigned int) x)].period_ns;
2211                 } else if (!strncmp(bp, "resync:", 7)) {
2212                         bp += 7;
2213                         x = simple_strtoul(bp, NULL, 0);
2214                         for (i = 0; i < 7; i++)
2215                                 if (x & (1 << i))
2216                                         hd->sync_stat[i] = SS_UNSET;
2217                 } else if (!strncmp(bp, "proc:", 5)) {
2218                         bp += 5;
2219                         hd->proc = simple_strtoul(bp, NULL, 0);
2220                 } else if (!strncmp(bp, "level2:", 7)) {
2221                         bp += 7;
2222                         hd->level2 = simple_strtoul(bp, NULL, 0);
2223                 }
2224                 return len;
2225         }
2226
2227         spin_lock_irqsave(instance->host_lock, flags);
2228         bp = buf;
2229         *bp = '\0';
2230         if (hd->proc & PR_VERSION) {
2231                 sprintf(tbuf, "\nVersion %s - %s. Compiled %s %s", IN2000_VERSION, IN2000_DATE, __DATE__, __TIME__);
2232                 strcat(bp, tbuf);
2233         }
2234         if (hd->proc & PR_INFO) {
2235                 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");
2236                 strcat(bp, tbuf);
2237                 strcat(bp, "\nsync_xfer[] =       ");
2238                 for (x = 0; x < 7; x++) {
2239                         sprintf(tbuf, "\t%02x", hd->sync_xfer[x]);
2240                         strcat(bp, tbuf);
2241                 }
2242                 strcat(bp, "\nsync_stat[] =       ");
2243                 for (x = 0; x < 7; x++) {
2244                         sprintf(tbuf, "\t%02x", hd->sync_stat[x]);
2245                         strcat(bp, tbuf);
2246                 }
2247         }
2248 #ifdef PROC_STATISTICS
2249         if (hd->proc & PR_STATISTICS) {
2250                 strcat(bp, "\ncommands issued:    ");
2251                 for (x = 0; x < 7; x++) {
2252                         sprintf(tbuf, "\t%ld", hd->cmd_cnt[x]);
2253                         strcat(bp, tbuf);
2254                 }
2255                 strcat(bp, "\ndisconnects allowed:");
2256                 for (x = 0; x < 7; x++) {
2257                         sprintf(tbuf, "\t%ld", hd->disc_allowed_cnt[x]);
2258                         strcat(bp, tbuf);
2259                 }
2260                 strcat(bp, "\ndisconnects done:   ");
2261                 for (x = 0; x < 7; x++) {
2262                         sprintf(tbuf, "\t%ld", hd->disc_done_cnt[x]);
2263                         strcat(bp, tbuf);
2264                 }
2265                 sprintf(tbuf, "\ninterrupts:      \t%ld", hd->int_cnt);
2266                 strcat(bp, tbuf);
2267         }
2268 #endif
2269         if (hd->proc & PR_CONNECTED) {
2270                 strcat(bp, "\nconnected:     ");
2271                 if (hd->connected) {
2272                         cmd = (Scsi_Cmnd *) hd->connected;
2273                         sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2274                         strcat(bp, tbuf);
2275                 }
2276         }
2277         if (hd->proc & PR_INPUTQ) {
2278                 strcat(bp, "\ninput_Q:       ");
2279                 cmd = (Scsi_Cmnd *) hd->input_Q;
2280                 while (cmd) {
2281                         sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2282                         strcat(bp, tbuf);
2283                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
2284                 }
2285         }
2286         if (hd->proc & PR_DISCQ) {
2287                 strcat(bp, "\ndisconnected_Q:");
2288                 cmd = (Scsi_Cmnd *) hd->disconnected_Q;
2289                 while (cmd) {
2290                         sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
2291                         strcat(bp, tbuf);
2292                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
2293                 }
2294         }
2295         if (hd->proc & PR_TEST) {
2296                 ;               /* insert your own custom function here */
2297         }
2298         strcat(bp, "\n");
2299         spin_unlock_irqrestore(instance->host_lock, flags);
2300         *start = buf;
2301         if (stop) {
2302                 stop = 0;
2303                 return 0;       /* return 0 to signal end-of-file */
2304         }
2305         if (off > 0x40000)      /* ALWAYS stop after 256k bytes have been read */
2306                 stop = 1;
2307         if (hd->proc & PR_STOP) /* stop every other time */
2308                 stop = 1;
2309         return strlen(bp);
2310
2311 #else                           /* PROC_INTERFACE */
2312
2313         return 0;
2314
2315 #endif                          /* PROC_INTERFACE */
2316
2317 }
2318
2319 MODULE_LICENSE("GPL");
2320
2321
2322 static struct scsi_host_template driver_template = {
2323         .proc_name                      = "in2000",
2324         .proc_info                      = in2000_proc_info,
2325         .name                           = "Always IN2000",
2326         .detect                         = in2000_detect, 
2327         .release                        = in2000_release,
2328         .queuecommand                   = in2000_queuecommand,
2329         .eh_abort_handler               = in2000_abort,
2330         .eh_bus_reset_handler           = in2000_bus_reset,
2331         .bios_param                     = in2000_biosparam, 
2332         .can_queue                      = IN2000_CAN_Q,
2333         .this_id                        = IN2000_HOST_ID,
2334         .sg_tablesize                   = IN2000_SG,
2335         .cmd_per_lun                    = IN2000_CPL,
2336         .use_clustering                 = DISABLE_CLUSTERING,
2337 };
2338 #include "scsi_module.c"