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