blob: 4c95abb540571dc301ee3c1385f90c0f15b417ee [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * seagate.c Copyright (C) 1992, 1993 Drew Eckhardt
3 * low level scsi driver for ST01/ST02, Future Domain TMC-885,
4 * TMC-950 by Drew Eckhardt <drew@colorado.edu>
5 *
6 * Note : TMC-880 boards don't work because they have two bits in
7 * the status register flipped, I'll fix this "RSN"
8 * [why do I have strong feeling that above message is from 1993? :-)
9 * pavel@ucw.cz]
10 *
11 * This card does all the I/O via memory mapped I/O, so there is no need
12 * to check or allocate a region of the I/O address space.
13 */
14
15/* 1996 - to use new read{b,w,l}, write{b,w,l}, and phys_to_virt
16 * macros, replaced assembler routines with C. There's probably a
17 * performance hit, but I only have a cdrom and can't tell. Define
18 * SEAGATE_USE_ASM if you want the old assembler code -- SJT
19 *
20 * 1998-jul-29 - created DPRINTK macros and made it work under
21 * linux 2.1.112, simplified some #defines etc. <pavel@ucw.cz>
22 *
23 * Aug 2000 - aeb - deleted seagate_st0x_biosparam(). It would try to
24 * read the physical disk geometry, a bad mistake. Of course it doesn't
25 * matter much what geometry one invents, but on large disks it
26 * returned 256 (or more) heads, causing all kind of failures.
27 * Of course this means that people might see a different geometry now,
28 * so boot parameters may be necessary in some cases.
29 */
30
31/*
32 * Configuration :
33 * To use without BIOS -DOVERRIDE=base_address -DCONTROLLER=FD or SEAGATE
34 * -DIRQ will override the default of 5.
35 * Note: You can now set these options from the kernel's "command line".
36 * The syntax is:
37 *
38 * st0x=ADDRESS,IRQ (for a Seagate controller)
39 * or:
40 * tmc8xx=ADDRESS,IRQ (for a TMC-8xx or TMC-950 controller)
41 * eg:
42 * tmc8xx=0xC8000,15
43 *
44 * will configure the driver for a TMC-8xx style controller using IRQ 15
45 * with a base address of 0xC8000.
46 *
47 * -DARBITRATE
48 * Will cause the host adapter to arbitrate for the
49 * bus for better SCSI-II compatibility, rather than just
50 * waiting for BUS FREE and then doing its thing. Should
51 * let us do one command per Lun when I integrate my
52 * reorganization changes into the distribution sources.
53 *
54 * -DDEBUG=65535
55 * Will activate debug code.
56 *
57 * -DFAST or -DFAST32
58 * Will use blind transfers where possible
59 *
60 * -DPARITY
61 * This will enable parity.
62 *
63 * -DSEAGATE_USE_ASM
64 * Will use older seagate assembly code. should be (very small amount)
65 * Faster.
66 *
67 * -DSLOW_RATE=50
68 * Will allow compatibility with broken devices that don't
69 * handshake fast enough (ie, some CD ROM's) for the Seagate
70 * code.
71 *
72 * 50 is some number, It will let you specify a default
73 * transfer rate if handshaking isn't working correctly.
74 *
75 * -DOLDCNTDATASCEME There is a new sceme to set the CONTROL
76 * and DATA reigsters which complies more closely
77 * with the SCSI2 standard. This hopefully eliminates
78 * the need to swap the order these registers are
79 * 'messed' with. It makes the following two options
80 * obsolete. To reenable the old sceme define this.
81 *
82 * The following to options are patches from the SCSI.HOWTO
83 *
84 * -DSWAPSTAT This will swap the definitions for STAT_MSG and STAT_CD.
85 *
86 * -DSWAPCNTDATA This will swap the order that seagate.c messes with
87 * the CONTROL an DATA registers.
88 */
89
90#include <linux/module.h>
91#include <linux/interrupt.h>
92#include <linux/spinlock.h>
93#include <linux/signal.h>
94#include <linux/string.h>
95#include <linux/proc_fs.h>
96#include <linux/init.h>
97#include <linux/delay.h>
98#include <linux/blkdev.h>
99#include <linux/stat.h>
100
101#include <asm/io.h>
102#include <asm/system.h>
103#include <asm/uaccess.h>
104
105#include "scsi.h"
db9dff32005-04-03 14:53:59 -0500106#include <scsi/scsi_dbg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#include <scsi/scsi_host.h>
108#include "seagate.h"
109
110#include <scsi/scsi_ioctl.h>
111
112#ifdef DEBUG
113#define DPRINTK( when, msg... ) do { if ( (DEBUG & (when)) == (when) ) printk( msg ); } while (0)
114#else
115#define DPRINTK( when, msg... ) do { } while (0)
116#endif
117#define DANY( msg... ) DPRINTK( 0xffff, msg );
118
119#ifndef IRQ
120#define IRQ 5
121#endif
122
123#ifdef FAST32
124#define FAST
125#endif
126
127#undef LINKED /* Linked commands are currently broken! */
128
129#if defined(OVERRIDE) && !defined(CONTROLLER)
130#error Please use -DCONTROLLER=SEAGATE or -DCONTROLLER=FD to override controller type
131#endif
132
133#ifndef __i386__
134#undef SEAGATE_USE_ASM
135#endif
136
137/*
138 Thanks to Brian Antoine for the example code in his Messy-Loss ST-01
139 driver, and Mitsugu Suzuki for information on the ST-01
140 SCSI host.
141*/
142
143/*
144 CONTROL defines
145*/
146
147#define CMD_RST 0x01
148#define CMD_SEL 0x02
149#define CMD_BSY 0x04
150#define CMD_ATTN 0x08
151#define CMD_START_ARB 0x10
152#define CMD_EN_PARITY 0x20
153#define CMD_INTR 0x40
154#define CMD_DRVR_ENABLE 0x80
155
156/*
157 STATUS
158*/
159#ifdef SWAPSTAT
160#define STAT_MSG 0x08
161#define STAT_CD 0x02
162#else
163#define STAT_MSG 0x02
164#define STAT_CD 0x08
165#endif
166
167#define STAT_BSY 0x01
168#define STAT_IO 0x04
169#define STAT_REQ 0x10
170#define STAT_SEL 0x20
171#define STAT_PARITY 0x40
172#define STAT_ARB_CMPL 0x80
173
174/*
175 REQUESTS
176*/
177
178#define REQ_MASK (STAT_CD | STAT_IO | STAT_MSG)
179#define REQ_DATAOUT 0
180#define REQ_DATAIN STAT_IO
181#define REQ_CMDOUT STAT_CD
182#define REQ_STATIN (STAT_CD | STAT_IO)
183#define REQ_MSGOUT (STAT_MSG | STAT_CD)
184#define REQ_MSGIN (STAT_MSG | STAT_CD | STAT_IO)
185
186extern volatile int seagate_st0x_timeout;
187
188#ifdef PARITY
189#define BASE_CMD CMD_EN_PARITY
190#else
191#define BASE_CMD 0
192#endif
193
194/*
195 Debugging code
196*/
197
198#define PHASE_BUS_FREE 1
199#define PHASE_ARBITRATION 2
200#define PHASE_SELECTION 4
201#define PHASE_DATAIN 8
202#define PHASE_DATAOUT 0x10
203#define PHASE_CMDOUT 0x20
204#define PHASE_MSGIN 0x40
205#define PHASE_MSGOUT 0x80
206#define PHASE_STATUSIN 0x100
207#define PHASE_ETC (PHASE_DATAIN | PHASE_DATAOUT | PHASE_CMDOUT | PHASE_MSGIN | PHASE_MSGOUT | PHASE_STATUSIN)
208#define PRINT_COMMAND 0x200
209#define PHASE_EXIT 0x400
210#define PHASE_RESELECT 0x800
211#define DEBUG_FAST 0x1000
212#define DEBUG_SG 0x2000
213#define DEBUG_LINKED 0x4000
214#define DEBUG_BORKEN 0x8000
215
216/*
217 * Control options - these are timeouts specified in .01 seconds.
218 */
219
220/* 30, 20 work */
221#define ST0X_BUS_FREE_DELAY 25
222#define ST0X_SELECTION_DELAY 25
223
224#define SEAGATE 1 /* these determine the type of the controller */
225#define FD 2
226
227#define ST0X_ID_STR "Seagate ST-01/ST-02"
228#define FD_ID_STR "TMC-8XX/TMC-950"
229
230static int internal_command (unsigned char target, unsigned char lun,
231 const void *cmnd,
232 void *buff, int bufflen, int reselect);
233
234static int incommand; /* set if arbitration has finished
235 and we are in some command phase. */
236
237static unsigned int base_address = 0; /* Where the card ROM starts, used to
238 calculate memory mapped register
239 location. */
240
241static void __iomem *st0x_cr_sr; /* control register write, status
242 register read. 256 bytes in
243 length.
244 Read is status of SCSI BUS, as per
245 STAT masks. */
246
247static void __iomem *st0x_dr; /* data register, read write 256
248 bytes in length. */
249
250static volatile int st0x_aborted = 0; /* set when we are aborted, ie by a
251 time out, etc. */
252
253static unsigned char controller_type = 0; /* set to SEAGATE for ST0x
254 boards or FD for TMC-8xx
255 boards */
256static int irq = IRQ;
257
258module_param(base_address, uint, 0);
259module_param(controller_type, byte, 0);
260module_param(irq, int, 0);
261MODULE_LICENSE("GPL");
262
263
264#define retcode(result) (((result) << 16) | (message << 8) | status)
265#define STATUS ((u8) readb(st0x_cr_sr))
266#define DATA ((u8) readb(st0x_dr))
267#define WRITE_CONTROL(d) { writeb((d), st0x_cr_sr); }
268#define WRITE_DATA(d) { writeb((d), st0x_dr); }
269
270#ifndef OVERRIDE
271static unsigned int seagate_bases[] = {
272 0xc8000, 0xca000, 0xcc000,
273 0xce000, 0xdc000, 0xde000
274};
275
276typedef struct {
277 const unsigned char *signature;
278 unsigned offset;
279 unsigned length;
280 unsigned char type;
281} Signature;
282
283static Signature __initdata signatures[] = {
284 {"ST01 v1.7 (C) Copyright 1987 Seagate", 15, 37, SEAGATE},
285 {"SCSI BIOS 2.00 (C) Copyright 1987 Seagate", 15, 40, SEAGATE},
286
287/*
288 * The following two lines are NOT mistakes. One detects ROM revision
289 * 3.0.0, the other 3.2. Since seagate has only one type of SCSI adapter,
290 * and this is not going to change, the "SEAGATE" and "SCSI" together
291 * are probably "good enough"
292 */
293
294 {"SEAGATE SCSI BIOS ", 16, 17, SEAGATE},
295 {"SEAGATE SCSI BIOS ", 17, 17, SEAGATE},
296
297/*
298 * However, future domain makes several incompatible SCSI boards, so specific
299 * signatures must be used.
300 */
301
302 {"FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89", 5, 46, FD},
303 {"FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89", 5, 46, FD},
304 {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90", 5, 47, FD},
305 {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90", 5, 47, FD},
306 {"FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90", 5, 46, FD},
307 {"FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92", 5, 44, FD},
308 {"IBM F1 BIOS V1.1004/30/92", 5, 25, FD},
309 {"FUTURE DOMAIN TMC-950", 5, 21, FD},
310 /* Added for 2.2.16 by Matthias_Heidbrink@b.maus.de */
311 {"IBM F1 V1.2009/22/93", 5, 25, FD},
312};
313
314#define NUM_SIGNATURES (sizeof(signatures) / sizeof(Signature))
315#endif /* n OVERRIDE */
316
317/*
318 * hostno stores the hostnumber, as told to us by the init routine.
319 */
320
321static int hostno = -1;
322static void seagate_reconnect_intr (int, void *, struct pt_regs *);
323static irqreturn_t do_seagate_reconnect_intr (int, void *, struct pt_regs *);
324
325#ifdef FAST
326static int fast = 1;
327#else
328#define fast 0
329#endif
330
331#ifdef SLOW_RATE
332/*
333 * Support for broken devices :
334 * The Seagate board has a handshaking problem. Namely, a lack
335 * thereof for slow devices. You can blast 600K/second through
336 * it if you are polling for each byte, more if you do a blind
337 * transfer. In the first case, with a fast device, REQ will
338 * transition high-low or high-low-high before your loop restarts
339 * and you'll have no problems. In the second case, the board
340 * will insert wait states for up to 13.2 usecs for REQ to
341 * transition low->high, and everything will work.
342 *
343 * However, there's nothing in the state machine that says
344 * you *HAVE* to see a high-low-high set of transitions before
345 * sending the next byte, and slow things like the Trantor CD ROMS
346 * will break because of this.
347 *
348 * So, we need to slow things down, which isn't as simple as it
349 * seems. We can't slow things down period, because then people
350 * who don't recompile their kernels will shoot me for ruining
351 * their performance. We need to do it on a case per case basis.
352 *
353 * The best for performance will be to, only for borken devices
354 * (this is stored on a per-target basis in the scsi_devices array)
355 *
356 * Wait for a low->high transition before continuing with that
357 * transfer. If we timeout, continue anyways. We don't need
358 * a long timeout, because REQ should only be asserted until the
359 * corresponding ACK is received and processed.
360 *
361 * Note that we can't use the system timer for this, because of
362 * resolution, and we *really* can't use the timer chip since
363 * gettimeofday() and the beeper routines use that. So,
364 * the best thing for us to do will be to calibrate a timing
365 * loop in the initialization code using the timer chip before
366 * gettimeofday() can screw with it.
367 *
368 * FIXME: this is broken (not borken :-). Empty loop costs less than
369 * loop with ISA access in it! -- pavel@ucw.cz
370 */
371
372static int borken_calibration = 0;
373
374static void __init borken_init (void)
375{
376 register int count = 0, start = jiffies + 1, stop = start + 25;
377
378 /* FIXME: There may be a better approach, this is a straight port for
379 now */
380 preempt_disable();
381 while (time_before (jiffies, start))
382 cpu_relax();
383 for (; time_before (jiffies, stop); ++count)
384 cpu_relax();
385 preempt_enable();
386
387/*
388 * Ok, we now have a count for .25 seconds. Convert to a
389 * count per second and divide by transfer rate in K. */
390
391 borken_calibration = (count * 4) / (SLOW_RATE * 1024);
392
393 if (borken_calibration < 1)
394 borken_calibration = 1;
395}
396
397static inline void borken_wait (void)
398{
399 register int count;
400
401 for (count = borken_calibration; count && (STATUS & STAT_REQ); --count)
402 cpu_relax();
403
404#if (DEBUG & DEBUG_BORKEN)
405 if (count)
406 printk ("scsi%d : borken timeout\n", hostno);
407#endif
408}
409
410#endif /* def SLOW_RATE */
411
412/* These beasts only live on ISA, and ISA means 8MHz. Each ULOOP()
413 * contains at least one ISA access, which takes more than 0.125
414 * usec. So if we loop 8 times time in usec, we are safe.
415 */
416
417#define ULOOP( i ) for (clock = i*8;;)
418#define TIMEOUT (!(clock--))
419
420int __init seagate_st0x_detect (Scsi_Host_Template * tpnt)
421{
422 struct Scsi_Host *instance;
423 int i, j;
424 unsigned long cr, dr;
425
426 tpnt->proc_name = "seagate";
427/*
428 * First, we try for the manual override.
429 */
430 DANY ("Autodetecting ST0x / TMC-8xx\n");
431
432 if (hostno != -1) {
433 printk (KERN_ERR "seagate_st0x_detect() called twice?!\n");
434 return 0;
435 }
436
437/* If the user specified the controller type from the command line,
438 controller_type will be non-zero, so don't try to detect one */
439
440 if (!controller_type) {
441#ifdef OVERRIDE
442 base_address = OVERRIDE;
443 controller_type = CONTROLLER;
444
445 DANY ("Base address overridden to %x, controller type is %s\n",
446 base_address,
447 controller_type == SEAGATE ? "SEAGATE" : "FD");
448#else /* OVERRIDE */
449/*
450 * To detect this card, we simply look for the signature
451 * from the BIOS version notice in all the possible locations
452 * of the ROM's. This has a nice side effect of not trashing
453 * any register locations that might be used by something else.
454 *
455 * XXX - note that we probably should be probing the address
456 * space for the on-board RAM instead.
457 */
458
459 for (i = 0; i < (sizeof (seagate_bases) / sizeof (unsigned int)); ++i) {
460 void __iomem *p = ioremap(seagate_bases[i], 0x2000);
461 if (!p)
462 continue;
463 for (j = 0; j < NUM_SIGNATURES; ++j)
464 if (check_signature(p + signatures[j].offset, signatures[j].signature, signatures[j].length)) {
465 base_address = seagate_bases[i];
466 controller_type = signatures[j].type;
467 break;
468 }
469 iounmap(p);
470 }
471#endif /* OVERRIDE */
472 }
473 /* (! controller_type) */
474 tpnt->this_id = (controller_type == SEAGATE) ? 7 : 6;
475 tpnt->name = (controller_type == SEAGATE) ? ST0X_ID_STR : FD_ID_STR;
476
477 if (!base_address) {
478 printk(KERN_INFO "seagate: ST0x/TMC-8xx not detected.\n");
479 return 0;
480 }
481
482 cr = base_address + (controller_type == SEAGATE ? 0x1a00 : 0x1c00);
483 dr = cr + 0x200;
484 st0x_cr_sr = ioremap(cr, 0x100);
485 st0x_dr = ioremap(dr, 0x100);
486
487 DANY("%s detected. Base address = %x, cr = %x, dr = %x\n",
488 tpnt->name, base_address, cr, dr);
489
490 /*
491 * At all times, we will use IRQ 5. Should also check for IRQ3
492 * if we lose our first interrupt.
493 */
494 instance = scsi_register (tpnt, 0);
495 if (instance == NULL)
496 return 0;
497
498 hostno = instance->host_no;
499 if (request_irq (irq, do_seagate_reconnect_intr, SA_INTERRUPT, (controller_type == SEAGATE) ? "seagate" : "tmc-8xx", instance)) {
500 printk(KERN_ERR "scsi%d : unable to allocate IRQ%d\n", hostno, irq);
501 return 0;
502 }
503 instance->irq = irq;
504 instance->io_port = base_address;
505#ifdef SLOW_RATE
506 printk(KERN_INFO "Calibrating borken timer... ");
507 borken_init();
508 printk(" %d cycles per transfer\n", borken_calibration);
509#endif
510 printk (KERN_INFO "This is one second... ");
511 {
512 int clock;
513 ULOOP (1 * 1000 * 1000) {
514 STATUS;
515 if (TIMEOUT)
516 break;
517 }
518 }
519
520 printk ("done, %s options:"
521#ifdef ARBITRATE
522 " ARBITRATE"
523#endif
524#ifdef DEBUG
525 " DEBUG"
526#endif
527#ifdef FAST
528 " FAST"
529#ifdef FAST32
530 "32"
531#endif
532#endif
533#ifdef LINKED
534 " LINKED"
535#endif
536#ifdef PARITY
537 " PARITY"
538#endif
539#ifdef SEAGATE_USE_ASM
540 " SEAGATE_USE_ASM"
541#endif
542#ifdef SLOW_RATE
543 " SLOW_RATE"
544#endif
545#ifdef SWAPSTAT
546 " SWAPSTAT"
547#endif
548#ifdef SWAPCNTDATA
549 " SWAPCNTDATA"
550#endif
551 "\n", tpnt->name);
552 return 1;
553}
554
555static const char *seagate_st0x_info (struct Scsi_Host *shpnt)
556{
557 static char buffer[64];
558
559 snprintf(buffer, 64, "%s at irq %d, address 0x%05X",
560 (controller_type == SEAGATE) ? ST0X_ID_STR : FD_ID_STR,
561 irq, base_address);
562 return buffer;
563}
564
565/*
566 * These are our saved pointers for the outstanding command that is
567 * waiting for a reconnect
568 */
569
570static unsigned char current_target, current_lun;
571static unsigned char *current_cmnd, *current_data;
572static int current_nobuffs;
573static struct scatterlist *current_buffer;
574static int current_bufflen;
575
576#ifdef LINKED
577/*
578 * linked_connected indicates whether or not we are currently connected to
579 * linked_target, linked_lun and in an INFORMATION TRANSFER phase,
580 * using linked commands.
581 */
582
583static int linked_connected = 0;
584static unsigned char linked_target, linked_lun;
585#endif
586
587static void (*done_fn) (Scsi_Cmnd *) = NULL;
588static Scsi_Cmnd *SCint = NULL;
589
590/*
591 * These control whether or not disconnect / reconnect will be attempted,
592 * or are being attempted.
593 */
594
595#define NO_RECONNECT 0
596#define RECONNECT_NOW 1
597#define CAN_RECONNECT 2
598
599/*
600 * LINKED_RIGHT indicates that we are currently connected to the correct target
601 * for this command, LINKED_WRONG indicates that we are connected to the wrong
602 * target. Note that these imply CAN_RECONNECT and require defined(LINKED).
603 */
604
605#define LINKED_RIGHT 3
606#define LINKED_WRONG 4
607
608/*
609 * This determines if we are expecting to reconnect or not.
610 */
611
612static int should_reconnect = 0;
613
614/*
615 * The seagate_reconnect_intr routine is called when a target reselects the
616 * host adapter. This occurs on the interrupt triggered by the target
617 * asserting SEL.
618 */
619
620static irqreturn_t do_seagate_reconnect_intr(int irq, void *dev_id,
621 struct pt_regs *regs)
622{
623 unsigned long flags;
624 struct Scsi_Host *dev = dev_id;
625
626 spin_lock_irqsave (dev->host_lock, flags);
627 seagate_reconnect_intr (irq, dev_id, regs);
628 spin_unlock_irqrestore (dev->host_lock, flags);
629 return IRQ_HANDLED;
630}
631
632static void seagate_reconnect_intr (int irq, void *dev_id, struct pt_regs *regs)
633{
634 int temp;
635 Scsi_Cmnd *SCtmp;
636
637 DPRINTK (PHASE_RESELECT, "scsi%d : seagate_reconnect_intr() called\n", hostno);
638
639 if (!should_reconnect)
640 printk(KERN_WARNING "scsi%d: unexpected interrupt.\n", hostno);
641 else {
642 should_reconnect = 0;
643
644 DPRINTK (PHASE_RESELECT, "scsi%d : internal_command(%d, %08x, %08x, RECONNECT_NOW\n",
645 hostno, current_target, current_data, current_bufflen);
646
647 temp = internal_command (current_target, current_lun, current_cmnd, current_data, current_bufflen, RECONNECT_NOW);
648
649 if (msg_byte(temp) != DISCONNECT) {
650 if (done_fn) {
651 DPRINTK(PHASE_RESELECT, "scsi%d : done_fn(%d,%08x)", hostno, hostno, temp);
652 if (!SCint)
653 panic ("SCint == NULL in seagate");
654 SCtmp = SCint;
655 SCint = NULL;
656 SCtmp->result = temp;
657 done_fn(SCtmp);
658 } else
659 printk(KERN_ERR "done_fn() not defined.\n");
660 }
661 }
662}
663
664/*
665 * The seagate_st0x_queue_command() function provides a queued interface
666 * to the seagate SCSI driver. Basically, it just passes control onto the
667 * seagate_command() function, after fixing it so that the done_fn()
668 * is set to the one passed to the function. We have to be very careful,
669 * because there are some commands on some devices that do not disconnect,
670 * and if we simply call the done_fn when the command is done then another
671 * command is started and queue_command is called again... We end up
672 * overflowing the kernel stack, and this tends not to be such a good idea.
673 */
674
675static int recursion_depth = 0;
676
677static int seagate_st0x_queue_command (Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
678{
679 int result, reconnect;
680 Scsi_Cmnd *SCtmp;
681
682 DANY ("seagate: que_command");
683 done_fn = done;
684 current_target = SCpnt->device->id;
685 current_lun = SCpnt->device->lun;
686 current_cmnd = SCpnt->cmnd;
687 current_data = (unsigned char *) SCpnt->request_buffer;
688 current_bufflen = SCpnt->request_bufflen;
689 SCint = SCpnt;
690 if (recursion_depth)
691 return 1;
692 recursion_depth++;
693 do {
694#ifdef LINKED
695 /*
696 * Set linked command bit in control field of SCSI command.
697 */
698
699 current_cmnd[SCpnt->cmd_len] |= 0x01;
700 if (linked_connected) {
701 DPRINTK (DEBUG_LINKED, "scsi%d : using linked commands, current I_T_L nexus is ", hostno);
702 if (linked_target == current_target && linked_lun == current_lun)
703 {
704 DPRINTK(DEBUG_LINKED, "correct\n");
705 reconnect = LINKED_RIGHT;
706 } else {
707 DPRINTK(DEBUG_LINKED, "incorrect\n");
708 reconnect = LINKED_WRONG;
709 }
710 } else
711#endif /* LINKED */
712 reconnect = CAN_RECONNECT;
713
714 result = internal_command(SCint->device->id, SCint->device->lun, SCint->cmnd,
715 SCint->request_buffer, SCint->request_bufflen, reconnect);
716 if (msg_byte(result) == DISCONNECT)
717 break;
718 SCtmp = SCint;
719 SCint = NULL;
720 SCtmp->result = result;
721 done_fn(SCtmp);
722 }
723 while (SCint);
724 recursion_depth--;
725 return 0;
726}
727
728static int internal_command (unsigned char target, unsigned char lun,
729 const void *cmnd, void *buff, int bufflen, int reselect)
730{
731 unsigned char *data = NULL;
732 struct scatterlist *buffer = NULL;
733 int clock, temp, nobuffs = 0, done = 0, len = 0;
734#ifdef DEBUG
735 int transfered = 0, phase = 0, newphase;
736#endif
737 register unsigned char status_read;
738 unsigned char tmp_data, tmp_control, status = 0, message = 0;
739 unsigned transfersize = 0, underflow = 0;
740#ifdef SLOW_RATE
741 int borken = (int) SCint->device->borken; /* Does the current target require
742 Very Slow I/O ? */
743#endif
744
745 incommand = 0;
746 st0x_aborted = 0;
747
748#if (DEBUG & PRINT_COMMAND)
749 printk("scsi%d : target = %d, command = ", hostno, target);
db9dff32005-04-03 14:53:59 -0500750 __scsi_print_command((unsigned char *) cmnd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751#endif
752
753#if (DEBUG & PHASE_RESELECT)
754 switch (reselect) {
755 case RECONNECT_NOW:
756 printk("scsi%d : reconnecting\n", hostno);
757 break;
758#ifdef LINKED
759 case LINKED_RIGHT:
760 printk("scsi%d : connected, can reconnect\n", hostno);
761 break;
762 case LINKED_WRONG:
763 printk("scsi%d : connected to wrong target, can reconnect\n",
764 hostno);
765 break;
766#endif
767 case CAN_RECONNECT:
768 printk("scsi%d : allowed to reconnect\n", hostno);
769 break;
770 default:
771 printk("scsi%d : not allowed to reconnect\n", hostno);
772 }
773#endif
774
775 if (target == (controller_type == SEAGATE ? 7 : 6))
776 return DID_BAD_TARGET;
777
778 /*
779 * We work it differently depending on if this is is "the first time,"
780 * or a reconnect. If this is a reselect phase, then SEL will
781 * be asserted, and we must skip selection / arbitration phases.
782 */
783
784 switch (reselect) {
785 case RECONNECT_NOW:
786 DPRINTK (PHASE_RESELECT, "scsi%d : phase RESELECT \n", hostno);
787 /*
788 * At this point, we should find the logical or of our ID
789 * and the original target's ID on the BUS, with BSY, SEL,
790 * and I/O signals asserted.
791 *
792 * After ARBITRATION phase is completed, only SEL, BSY,
793 * and the target ID are asserted. A valid initiator ID
794 * is not on the bus until IO is asserted, so we must wait
795 * for that.
796 */
797 ULOOP (100 * 1000) {
798 temp = STATUS;
799 if ((temp & STAT_IO) && !(temp & STAT_BSY))
800 break;
801 if (TIMEOUT) {
802 DPRINTK (PHASE_RESELECT, "scsi%d : RESELECT timed out while waiting for IO .\n", hostno);
803 return (DID_BAD_INTR << 16);
804 }
805 }
806
807 /*
808 * After I/O is asserted by the target, we can read our ID
809 * and its ID off of the BUS.
810 */
811
812 if (!((temp = DATA) & (controller_type == SEAGATE ? 0x80 : 0x40))) {
813 DPRINTK (PHASE_RESELECT, "scsi%d : detected reconnect request to different target.\n\tData bus = %d\n", hostno, temp);
814 return (DID_BAD_INTR << 16);
815 }
816
817 if (!(temp & (1 << current_target))) {
818 printk(KERN_WARNING "scsi%d : Unexpected reselect interrupt. Data bus = %d\n", hostno, temp);
819 return (DID_BAD_INTR << 16);
820 }
821
822 buffer = current_buffer;
823 cmnd = current_cmnd; /* WDE add */
824 data = current_data; /* WDE add */
825 len = current_bufflen; /* WDE add */
826 nobuffs = current_nobuffs;
827
828 /*
829 * We have determined that we have been selected. At this
830 * point, we must respond to the reselection by asserting
831 * BSY ourselves
832 */
833
834#if 1
835 WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | CMD_BSY);
836#else
837 WRITE_CONTROL (BASE_CMD | CMD_BSY);
838#endif
839
840 /*
841 * The target will drop SEL, and raise BSY, at which time
842 * we must drop BSY.
843 */
844
845 ULOOP (100 * 1000) {
846 if (!(STATUS & STAT_SEL))
847 break;
848 if (TIMEOUT) {
849 WRITE_CONTROL (BASE_CMD | CMD_INTR);
850 DPRINTK (PHASE_RESELECT, "scsi%d : RESELECT timed out while waiting for SEL.\n", hostno);
851 return (DID_BAD_INTR << 16);
852 }
853 }
854 WRITE_CONTROL (BASE_CMD);
855 /*
856 * At this point, we have connected with the target
857 * and can get on with our lives.
858 */
859 break;
860 case CAN_RECONNECT:
861#ifdef LINKED
862 /*
863 * This is a bletcherous hack, just as bad as the Unix #!
864 * interpreter stuff. If it turns out we are using the wrong
865 * I_T_L nexus, the easiest way to deal with it is to go into
866 * our INFORMATION TRANSFER PHASE code, send a ABORT
867 * message on MESSAGE OUT phase, and then loop back to here.
868 */
869connect_loop:
870#endif
871 DPRINTK (PHASE_BUS_FREE, "scsi%d : phase = BUS FREE \n", hostno);
872
873 /*
874 * BUS FREE PHASE
875 *
876 * On entry, we make sure that the BUS is in a BUS FREE
877 * phase, by insuring that both BSY and SEL are low for
878 * at least one bus settle delay. Several reads help
879 * eliminate wire glitch.
880 */
881
882#ifndef ARBITRATE
883#error FIXME: this is broken: we may not use jiffies here - we are under cli(). It will hardlock.
884 clock = jiffies + ST0X_BUS_FREE_DELAY;
885
886 while (((STATUS | STATUS | STATUS) & (STAT_BSY | STAT_SEL)) && (!st0x_aborted) && time_before (jiffies, clock))
887 cpu_relax();
888
889 if (time_after (jiffies, clock))
890 return retcode (DID_BUS_BUSY);
891 else if (st0x_aborted)
892 return retcode (st0x_aborted);
893#endif
894 DPRINTK (PHASE_SELECTION, "scsi%d : phase = SELECTION\n", hostno);
895
896 clock = jiffies + ST0X_SELECTION_DELAY;
897
898 /*
899 * Arbitration/selection procedure :
900 * 1. Disable drivers
901 * 2. Write HOST adapter address bit
902 * 3. Set start arbitration.
903 * 4. We get either ARBITRATION COMPLETE or SELECT at this
904 * point.
905 * 5. OR our ID and targets on bus.
906 * 6. Enable SCSI drivers and asserted SEL and ATTN
907 */
908
909#ifdef ARBITRATE
910 /* FIXME: verify host lock is always held here */
911 WRITE_CONTROL(0);
912 WRITE_DATA((controller_type == SEAGATE) ? 0x80 : 0x40);
913 WRITE_CONTROL(CMD_START_ARB);
914
915 ULOOP (ST0X_SELECTION_DELAY * 10000) {
916 status_read = STATUS;
917 if (status_read & STAT_ARB_CMPL)
918 break;
919 if (st0x_aborted) /* FIXME: What? We are going to do something even after abort? */
920 break;
921 if (TIMEOUT || (status_read & STAT_SEL)) {
922 printk(KERN_WARNING "scsi%d : arbitration lost or timeout.\n", hostno);
923 WRITE_CONTROL (BASE_CMD);
924 return retcode (DID_NO_CONNECT);
925 }
926 }
927 DPRINTK (PHASE_SELECTION, "scsi%d : arbitration complete\n", hostno);
928#endif
929
930 /*
931 * When the SCSI device decides that we're gawking at it,
932 * it will respond by asserting BUSY on the bus.
933 *
934 * Note : the Seagate ST-01/02 product manual says that we
935 * should twiddle the DATA register before the control
936 * register. However, this does not work reliably so we do
937 * it the other way around.
938 *
939 * Probably could be a problem with arbitration too, we
940 * really should try this with a SCSI protocol or logic
941 * analyzer to see what is going on.
942 */
943 tmp_data = (unsigned char) ((1 << target) | (controller_type == SEAGATE ? 0x80 : 0x40));
944 tmp_control = BASE_CMD | CMD_DRVR_ENABLE | CMD_SEL | (reselect ? CMD_ATTN : 0);
945
946 /* FIXME: verify host lock is always held here */
947#ifdef OLDCNTDATASCEME
948#ifdef SWAPCNTDATA
949 WRITE_CONTROL (tmp_control);
950 WRITE_DATA (tmp_data);
951#else
952 WRITE_DATA (tmp_data);
953 WRITE_CONTROL (tmp_control);
954#endif
955#else
956 tmp_control ^= CMD_BSY; /* This is guesswork. What used to be in driver */
957 WRITE_CONTROL (tmp_control); /* could never work: it sent data into control */
958 WRITE_DATA (tmp_data); /* register and control info into data. Hopefully */
959 tmp_control ^= CMD_BSY; /* fixed, but order of first two may be wrong. */
960 WRITE_CONTROL (tmp_control); /* -- pavel@ucw.cz */
961#endif
962
963 ULOOP (250 * 1000) {
964 if (st0x_aborted) {
965 /*
966 * If we have been aborted, and we have a
967 * command in progress, IE the target
968 * still has BSY asserted, then we will
969 * reset the bus, and notify the midlevel
970 * driver to expect sense.
971 */
972
973 WRITE_CONTROL (BASE_CMD);
974 if (STATUS & STAT_BSY) {
975 printk(KERN_WARNING "scsi%d : BST asserted after we've been aborted.\n", hostno);
976 seagate_st0x_bus_reset(NULL);
977 return retcode (DID_RESET);
978 }
979 return retcode (st0x_aborted);
980 }
981 if (STATUS & STAT_BSY)
982 break;
983 if (TIMEOUT) {
984 DPRINTK (PHASE_SELECTION, "scsi%d : NO CONNECT with target %d, stat = %x \n", hostno, target, STATUS);
985 return retcode (DID_NO_CONNECT);
986 }
987 }
988
989 /* Establish current pointers. Take into account scatter / gather */
990
991 if ((nobuffs = SCint->use_sg)) {
992#if (DEBUG & DEBUG_SG)
993 {
994 int i;
995 printk("scsi%d : scatter gather requested, using %d buffers.\n", hostno, nobuffs);
996 for (i = 0; i < nobuffs; ++i)
997 printk("scsi%d : buffer %d address = %p length = %d\n",
998 hostno, i,
999 page_address(buffer[i].page) + buffer[i].offset,
1000 buffer[i].length);
1001 }
1002#endif
1003
1004 buffer = (struct scatterlist *) SCint->buffer;
1005 len = buffer->length;
1006 data = page_address(buffer->page) + buffer->offset;
1007 } else {
1008 DPRINTK (DEBUG_SG, "scsi%d : scatter gather not requested.\n", hostno);
1009 buffer = NULL;
1010 len = SCint->request_bufflen;
1011 data = (unsigned char *) SCint->request_buffer;
1012 }
1013
1014 DPRINTK (PHASE_DATAIN | PHASE_DATAOUT, "scsi%d : len = %d\n",
1015 hostno, len);
1016
1017 break;
1018#ifdef LINKED
1019 case LINKED_RIGHT:
1020 break;
1021 case LINKED_WRONG:
1022 break;
1023#endif
1024 } /* end of switch(reselect) */
1025
1026 /*
1027 * There are several conditions under which we wish to send a message :
1028 * 1. When we are allowing disconnect / reconnect, and need to
1029 * establish the I_T_L nexus via an IDENTIFY with the DiscPriv bit
1030 * set.
1031 *
1032 * 2. When we are doing linked commands, are have the wrong I_T_L
1033 * nexus established and want to send an ABORT message.
1034 */
1035
1036 /* GCC does not like an ifdef inside a macro, so do it the hard way. */
1037#ifdef LINKED
1038 WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | (((reselect == CAN_RECONNECT)|| (reselect == LINKED_WRONG))? CMD_ATTN : 0));
1039#else
1040 WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | (((reselect == CAN_RECONNECT))? CMD_ATTN : 0));
1041#endif
1042
1043 /*
1044 * INFORMATION TRANSFER PHASE
1045 *
1046 * The nasty looking read / write inline assembler loops we use for
1047 * DATAIN and DATAOUT phases are approximately 4-5 times as fast as
1048 * the 'C' versions - since we're moving 1024 bytes of data, this
1049 * really adds up.
1050 *
1051 * SJT: The nasty-looking assembler is gone, so it's slower.
1052 *
1053 */
1054
1055 DPRINTK (PHASE_ETC, "scsi%d : phase = INFORMATION TRANSFER\n", hostno);
1056
1057 incommand = 1;
1058 transfersize = SCint->transfersize;
1059 underflow = SCint->underflow;
1060
1061 /*
1062 * Now, we poll the device for status information,
1063 * and handle any requests it makes. Note that since we are unsure
1064 * of how much data will be flowing across the system, etc and
1065 * cannot make reasonable timeouts, that we will instead have the
1066 * midlevel driver handle any timeouts that occur in this phase.
1067 */
1068
1069 while (((status_read = STATUS) & STAT_BSY) && !st0x_aborted && !done) {
1070#ifdef PARITY
1071 if (status_read & STAT_PARITY) {
1072 printk(KERN_ERR "scsi%d : got parity error\n", hostno);
1073 st0x_aborted = DID_PARITY;
1074 }
1075#endif
1076 if (status_read & STAT_REQ) {
1077#if ((DEBUG & PHASE_ETC) == PHASE_ETC)
1078 if ((newphase = (status_read & REQ_MASK)) != phase) {
1079 phase = newphase;
1080 switch (phase) {
1081 case REQ_DATAOUT:
1082 printk ("scsi%d : phase = DATA OUT\n", hostno);
1083 break;
1084 case REQ_DATAIN:
1085 printk ("scsi%d : phase = DATA IN\n", hostno);
1086 break;
1087 case REQ_CMDOUT:
1088 printk
1089 ("scsi%d : phase = COMMAND OUT\n", hostno);
1090 break;
1091 case REQ_STATIN:
1092 printk ("scsi%d : phase = STATUS IN\n", hostno);
1093 break;
1094 case REQ_MSGOUT:
1095 printk
1096 ("scsi%d : phase = MESSAGE OUT\n", hostno);
1097 break;
1098 case REQ_MSGIN:
1099 printk ("scsi%d : phase = MESSAGE IN\n", hostno);
1100 break;
1101 default:
1102 printk ("scsi%d : phase = UNKNOWN\n", hostno);
1103 st0x_aborted = DID_ERROR;
1104 }
1105 }
1106#endif
1107 switch (status_read & REQ_MASK) {
1108 case REQ_DATAOUT:
1109 /*
1110 * If we are in fast mode, then we simply splat
1111 * the data out in word-sized chunks as fast as
1112 * we can.
1113 */
1114
1115 if (!len) {
1116#if 0
1117 printk("scsi%d: underflow to target %d lun %d \n", hostno, target, lun);
1118 st0x_aborted = DID_ERROR;
1119 fast = 0;
1120#endif
1121 break;
1122 }
1123
1124 if (fast && transfersize
1125 && !(len % transfersize)
1126 && (len >= transfersize)
1127#ifdef FAST32
1128 && !(transfersize % 4)
1129#endif
1130 ) {
1131 DPRINTK (DEBUG_FAST,
1132 "scsi%d : FAST transfer, underflow = %d, transfersize = %d\n"
1133 " len = %d, data = %08x\n",
1134 hostno, SCint->underflow,
1135 SCint->transfersize, len,
1136 data);
1137
1138 /* SJT: Start. Fast Write */
1139#ifdef SEAGATE_USE_ASM
1140 __asm__ ("cld\n\t"
1141#ifdef FAST32
1142 "shr $2, %%ecx\n\t"
1143 "1:\t"
1144 "lodsl\n\t"
1145 "movl %%eax, (%%edi)\n\t"
1146#else
1147 "1:\t"
1148 "lodsb\n\t"
1149 "movb %%al, (%%edi)\n\t"
1150#endif
1151 "loop 1b;"
1152 /* output */ :
1153 /* input */ :"D" (st0x_dr),
1154 "S"
1155 (data),
1156 "c" (SCint->transfersize)
1157/* clobbered */
1158 : "eax", "ecx",
1159 "esi");
1160#else /* SEAGATE_USE_ASM */
1161 memcpy_toio(st0x_dr, data, transfersize);
1162#endif /* SEAGATE_USE_ASM */
1163/* SJT: End */
1164 len -= transfersize;
1165 data += transfersize;
1166 DPRINTK (DEBUG_FAST, "scsi%d : FAST transfer complete len = %d data = %08x\n", hostno, len, data);
1167 } else {
1168 /*
1169 * We loop as long as we are in a
1170 * data out phase, there is data to
1171 * send, and BSY is still active.
1172 */
1173
1174/* SJT: Start. Slow Write. */
1175#ifdef SEAGATE_USE_ASM
1176
1177 int __dummy_1, __dummy_2;
1178
1179/*
1180 * We loop as long as we are in a data out phase, there is data to send,
1181 * and BSY is still active.
1182 */
1183/* Local variables : len = ecx , data = esi,
1184 st0x_cr_sr = ebx, st0x_dr = edi
1185*/
1186 __asm__ (
1187 /* Test for any data here at all. */
1188 "orl %%ecx, %%ecx\n\t"
1189 "jz 2f\n\t" "cld\n\t"
1190/* "movl st0x_cr_sr, %%ebx\n\t" */
1191/* "movl st0x_dr, %%edi\n\t" */
1192 "1:\t"
1193 "movb (%%ebx), %%al\n\t"
1194 /* Test for BSY */
1195 "test $1, %%al\n\t"
1196 "jz 2f\n\t"
1197 /* Test for data out phase - STATUS & REQ_MASK should be
1198 REQ_DATAOUT, which is 0. */
1199 "test $0xe, %%al\n\t"
1200 "jnz 2f\n\t"
1201 /* Test for REQ */
1202 "test $0x10, %%al\n\t"
1203 "jz 1b\n\t"
1204 "lodsb\n\t"
1205 "movb %%al, (%%edi)\n\t"
1206 "loop 1b\n\t" "2:\n"
1207 /* output */ :"=S" (data), "=c" (len),
1208 "=b"
1209 (__dummy_1),
1210 "=D" (__dummy_2)
1211/* input */
1212 : "0" (data), "1" (len),
1213 "2" (st0x_cr_sr),
1214 "3" (st0x_dr)
1215/* clobbered */
1216 : "eax");
1217#else /* SEAGATE_USE_ASM */
1218 while (len) {
1219 unsigned char stat;
1220
1221 stat = STATUS;
1222 if (!(stat & STAT_BSY)
1223 || ((stat & REQ_MASK) !=
1224 REQ_DATAOUT))
1225 break;
1226 if (stat & STAT_REQ) {
1227 WRITE_DATA (*data++);
1228 --len;
1229 }
1230 }
1231#endif /* SEAGATE_USE_ASM */
1232/* SJT: End. */
1233 }
1234
1235 if (!len && nobuffs) {
1236 --nobuffs;
1237 ++buffer;
1238 len = buffer->length;
1239 data = page_address(buffer->page) + buffer->offset;
1240 DPRINTK (DEBUG_SG,
1241 "scsi%d : next scatter-gather buffer len = %d address = %08x\n",
1242 hostno, len, data);
1243 }
1244 break;
1245
1246 case REQ_DATAIN:
1247#ifdef SLOW_RATE
1248 if (borken) {
1249#if (DEBUG & (PHASE_DATAIN))
1250 transfered += len;
1251#endif
1252 for (; len && (STATUS & (REQ_MASK | STAT_REQ)) == (REQ_DATAIN | STAT_REQ); --len) {
1253 *data++ = DATA;
1254 borken_wait();
1255 }
1256#if (DEBUG & (PHASE_DATAIN))
1257 transfered -= len;
1258#endif
1259 } else
1260#endif
1261
1262 if (fast && transfersize
1263 && !(len % transfersize)
1264 && (len >= transfersize)
1265#ifdef FAST32
1266 && !(transfersize % 4)
1267#endif
1268 ) {
1269 DPRINTK (DEBUG_FAST,
1270 "scsi%d : FAST transfer, underflow = %d, transfersize = %d\n"
1271 " len = %d, data = %08x\n",
1272 hostno, SCint->underflow,
1273 SCint->transfersize, len,
1274 data);
1275
1276/* SJT: Start. Fast Read */
1277#ifdef SEAGATE_USE_ASM
1278 __asm__ ("cld\n\t"
1279#ifdef FAST32
1280 "shr $2, %%ecx\n\t"
1281 "1:\t"
1282 "movl (%%esi), %%eax\n\t"
1283 "stosl\n\t"
1284#else
1285 "1:\t"
1286 "movb (%%esi), %%al\n\t"
1287 "stosb\n\t"
1288#endif
1289 "loop 1b\n\t"
1290 /* output */ :
1291 /* input */ :"S" (st0x_dr),
1292 "D"
1293 (data),
1294 "c" (SCint->transfersize)
1295/* clobbered */
1296 : "eax", "ecx",
1297 "edi");
1298#else /* SEAGATE_USE_ASM */
1299 memcpy_fromio(data, st0x_dr, len);
1300#endif /* SEAGATE_USE_ASM */
1301/* SJT: End */
1302 len -= transfersize;
1303 data += transfersize;
1304#if (DEBUG & PHASE_DATAIN)
1305 printk ("scsi%d: transfered += %d\n", hostno, transfersize);
1306 transfered += transfersize;
1307#endif
1308
1309 DPRINTK (DEBUG_FAST, "scsi%d : FAST transfer complete len = %d data = %08x\n", hostno, len, data);
1310 } else {
1311
1312#if (DEBUG & PHASE_DATAIN)
1313 printk ("scsi%d: transfered += %d\n", hostno, len);
1314 transfered += len; /* Assume we'll transfer it all, then
1315 subtract what we *didn't* transfer */
1316#endif
1317
1318/*
1319 * We loop as long as we are in a data in phase, there is room to read,
1320 * and BSY is still active
1321 */
1322
1323/* SJT: Start. */
1324#ifdef SEAGATE_USE_ASM
1325
1326 int __dummy_3, __dummy_4;
1327
1328/* Dummy clobbering variables for the new gcc-2.95 */
1329
1330/*
1331 * We loop as long as we are in a data in phase, there is room to read,
1332 * and BSY is still active
1333 */
1334 /* Local variables : ecx = len, edi = data
1335 esi = st0x_cr_sr, ebx = st0x_dr */
1336 __asm__ (
1337 /* Test for room to read */
1338 "orl %%ecx, %%ecx\n\t"
1339 "jz 2f\n\t" "cld\n\t"
1340/* "movl st0x_cr_sr, %%esi\n\t" */
1341/* "movl st0x_dr, %%ebx\n\t" */
1342 "1:\t"
1343 "movb (%%esi), %%al\n\t"
1344 /* Test for BSY */
1345 "test $1, %%al\n\t"
1346 "jz 2f\n\t"
1347 /* Test for data in phase - STATUS & REQ_MASK should be REQ_DATAIN,
1348 = STAT_IO, which is 4. */
1349 "movb $0xe, %%ah\n\t"
1350 "andb %%al, %%ah\n\t"
1351 "cmpb $0x04, %%ah\n\t"
1352 "jne 2f\n\t"
1353 /* Test for REQ */
1354 "test $0x10, %%al\n\t"
1355 "jz 1b\n\t"
1356 "movb (%%ebx), %%al\n\t"
1357 "stosb\n\t"
1358 "loop 1b\n\t" "2:\n"
1359 /* output */ :"=D" (data), "=c" (len),
1360 "=S"
1361 (__dummy_3),
1362 "=b" (__dummy_4)
1363/* input */
1364 : "0" (data), "1" (len),
1365 "2" (st0x_cr_sr),
1366 "3" (st0x_dr)
1367/* clobbered */
1368 : "eax");
1369#else /* SEAGATE_USE_ASM */
1370 while (len) {
1371 unsigned char stat;
1372
1373 stat = STATUS;
1374 if (!(stat & STAT_BSY)
1375 || ((stat & REQ_MASK) !=
1376 REQ_DATAIN))
1377 break;
1378 if (stat & STAT_REQ) {
1379 *data++ = DATA;
1380 --len;
1381 }
1382 }
1383#endif /* SEAGATE_USE_ASM */
1384/* SJT: End. */
1385#if (DEBUG & PHASE_DATAIN)
1386 printk ("scsi%d: transfered -= %d\n", hostno, len);
1387 transfered -= len; /* Since we assumed all of Len got *
1388 transfered, correct our mistake */
1389#endif
1390 }
1391
1392 if (!len && nobuffs) {
1393 --nobuffs;
1394 ++buffer;
1395 len = buffer->length;
1396 data = page_address(buffer->page) + buffer->offset;
1397 DPRINTK (DEBUG_SG, "scsi%d : next scatter-gather buffer len = %d address = %08x\n", hostno, len, data);
1398 }
1399 break;
1400
1401 case REQ_CMDOUT:
1402 while (((status_read = STATUS) & STAT_BSY) &&
1403 ((status_read & REQ_MASK) == REQ_CMDOUT))
1404 if (status_read & STAT_REQ) {
1405 WRITE_DATA (*(const unsigned char *) cmnd);
1406 cmnd = 1 + (const unsigned char *)cmnd;
1407#ifdef SLOW_RATE
1408 if (borken)
1409 borken_wait ();
1410#endif
1411 }
1412 break;
1413
1414 case REQ_STATIN:
1415 status = DATA;
1416 break;
1417
1418 case REQ_MSGOUT:
1419 /*
1420 * We can only have sent a MSG OUT if we
1421 * requested to do this by raising ATTN.
1422 * So, we must drop ATTN.
1423 */
1424 WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE);
1425 /*
1426 * If we are reconnecting, then we must
1427 * send an IDENTIFY message in response
1428 * to MSGOUT.
1429 */
1430 switch (reselect) {
1431 case CAN_RECONNECT:
1432 WRITE_DATA (IDENTIFY (1, lun));
1433 DPRINTK (PHASE_RESELECT | PHASE_MSGOUT, "scsi%d : sent IDENTIFY message.\n", hostno);
1434 break;
1435#ifdef LINKED
1436 case LINKED_WRONG:
1437 WRITE_DATA (ABORT);
1438 linked_connected = 0;
1439 reselect = CAN_RECONNECT;
1440 goto connect_loop;
1441 DPRINTK (PHASE_MSGOUT | DEBUG_LINKED, "scsi%d : sent ABORT message to cancel incorrect I_T_L nexus.\n", hostno);
1442#endif /* LINKED */
1443 DPRINTK (DEBUG_LINKED, "correct\n");
1444 default:
1445 WRITE_DATA (NOP);
1446 printk("scsi%d : target %d requested MSGOUT, sent NOP message.\n", hostno, target);
1447 }
1448 break;
1449
1450 case REQ_MSGIN:
1451 switch (message = DATA) {
1452 case DISCONNECT:
1453 DANY("seagate: deciding to disconnect\n");
1454 should_reconnect = 1;
1455 current_data = data; /* WDE add */
1456 current_buffer = buffer;
1457 current_bufflen = len; /* WDE add */
1458 current_nobuffs = nobuffs;
1459#ifdef LINKED
1460 linked_connected = 0;
1461#endif
1462 done = 1;
1463 DPRINTK ((PHASE_RESELECT | PHASE_MSGIN), "scsi%d : disconnected.\n", hostno);
1464 break;
1465
1466#ifdef LINKED
1467 case LINKED_CMD_COMPLETE:
1468 case LINKED_FLG_CMD_COMPLETE:
1469#endif
1470 case COMMAND_COMPLETE:
1471 /*
1472 * Note : we should check for underflow here.
1473 */
1474 DPRINTK(PHASE_MSGIN, "scsi%d : command complete.\n", hostno);
1475 done = 1;
1476 break;
1477 case ABORT:
1478 DPRINTK(PHASE_MSGIN, "scsi%d : abort message.\n", hostno);
1479 done = 1;
1480 break;
1481 case SAVE_POINTERS:
1482 current_buffer = buffer;
1483 current_bufflen = len; /* WDE add */
1484 current_data = data; /* WDE mod */
1485 current_nobuffs = nobuffs;
1486 DPRINTK (PHASE_MSGIN, "scsi%d : pointers saved.\n", hostno);
1487 break;
1488 case RESTORE_POINTERS:
1489 buffer = current_buffer;
1490 cmnd = current_cmnd;
1491 data = current_data; /* WDE mod */
1492 len = current_bufflen;
1493 nobuffs = current_nobuffs;
1494 DPRINTK(PHASE_MSGIN, "scsi%d : pointers restored.\n", hostno);
1495 break;
1496 default:
1497
1498 /*
1499 * IDENTIFY distinguishes itself
1500 * from the other messages by
1501 * setting the high bit.
1502 *
1503 * Note : we need to handle at
1504 * least one outstanding command
1505 * per LUN, and need to hash the
1506 * SCSI command for that I_T_L
1507 * nexus based on the known ID
1508 * (at this point) and LUN.
1509 */
1510
1511 if (message & 0x80) {
1512 DPRINTK (PHASE_MSGIN, "scsi%d : IDENTIFY message received from id %d, lun %d.\n", hostno, target, message & 7);
1513 } else {
1514 /*
1515 * We should go into a
1516 * MESSAGE OUT phase, and
1517 * send a MESSAGE_REJECT
1518 * if we run into a message
1519 * that we don't like. The
1520 * seagate driver needs
1521 * some serious
1522 * restructuring first
1523 * though.
1524 */
1525 DPRINTK (PHASE_MSGIN, "scsi%d : unknown message %d from target %d.\n", hostno, message, target);
1526 }
1527 }
1528 break;
1529 default:
1530 printk(KERN_ERR "scsi%d : unknown phase.\n", hostno);
1531 st0x_aborted = DID_ERROR;
1532 } /* end of switch (status_read & REQ_MASK) */
1533#ifdef SLOW_RATE
1534 /*
1535 * I really don't care to deal with borken devices in
1536 * each single byte transfer case (ie, message in,
1537 * message out, status), so I'll do the wait here if
1538 * necessary.
1539 */
1540 if(borken)
1541 borken_wait();
1542#endif
1543
1544 } /* if(status_read & STAT_REQ) ends */
1545 } /* while(((status_read = STATUS)...) ends */
1546
1547 DPRINTK(PHASE_DATAIN | PHASE_DATAOUT | PHASE_EXIT, "scsi%d : Transfered %d bytes\n", hostno, transfered);
1548
1549#if (DEBUG & PHASE_EXIT)
1550#if 0 /* Doesn't work for scatter/gather */
1551 printk("Buffer : \n");
1552 for(i = 0; i < 20; ++i)
1553 printk("%02x ", ((unsigned char *) data)[i]); /* WDE mod */
1554 printk("\n");
1555#endif
1556 printk("scsi%d : status = ", hostno);
db9dff32005-04-03 14:53:59 -05001557 scsi_print_status(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 printk(" message = %02x\n", message);
1559#endif
1560
1561 /* We shouldn't reach this until *after* BSY has been deasserted */
1562
1563#ifdef LINKED
1564 else
1565 {
1566 /*
1567 * Fix the message byte so that unsuspecting high level drivers
1568 * don't puke when they see a LINKED COMMAND message in place of
1569 * the COMMAND COMPLETE they may be expecting. Shouldn't be
1570 * necessary, but it's better to be on the safe side.
1571 *
1572 * A non LINKED* message byte will indicate that the command
1573 * completed, and we are now disconnected.
1574 */
1575
1576 switch (message) {
1577 case LINKED_CMD_COMPLETE:
1578 case LINKED_FLG_CMD_COMPLETE:
1579 message = COMMAND_COMPLETE;
1580 linked_target = current_target;
1581 linked_lun = current_lun;
1582 linked_connected = 1;
1583 DPRINTK (DEBUG_LINKED, "scsi%d : keeping I_T_L nexus established for linked command.\n", hostno);
1584 /* We also will need to adjust status to accommodate intermediate
1585 conditions. */
1586 if ((status == INTERMEDIATE_GOOD) || (status == INTERMEDIATE_C_GOOD))
1587 status = GOOD;
1588 break;
1589 /*
1590 * We should also handle what are "normal" termination
1591 * messages here (ABORT, BUS_DEVICE_RESET?, and
1592 * COMMAND_COMPLETE individually, and flake if things
1593 * aren't right.
1594 */
1595 default:
1596 DPRINTK (DEBUG_LINKED, "scsi%d : closing I_T_L nexus.\n", hostno);
1597 linked_connected = 0;
1598 }
1599 }
1600#endif /* LINKED */
1601
1602 if (should_reconnect) {
1603 DPRINTK (PHASE_RESELECT, "scsi%d : exiting seagate_st0x_queue_command() with reconnect enabled.\n", hostno);
1604 WRITE_CONTROL (BASE_CMD | CMD_INTR);
1605 } else
1606 WRITE_CONTROL (BASE_CMD);
1607
1608 return retcode (st0x_aborted);
1609} /* end of internal_command */
1610
1611static int seagate_st0x_abort (Scsi_Cmnd * SCpnt)
1612{
1613 st0x_aborted = DID_ABORT;
1614 return SUCCESS;
1615}
1616
1617#undef ULOOP
1618#undef TIMEOUT
1619
1620/*
1621 * the seagate_st0x_reset function resets the SCSI bus
1622 *
1623 * May be called with SCpnt = NULL
1624 */
1625
1626static int seagate_st0x_bus_reset(Scsi_Cmnd * SCpnt)
1627{
1628 /* No timeouts - this command is going to fail because it was reset. */
1629 DANY ("scsi%d: Reseting bus... ", hostno);
1630
1631 /* assert RESET signal on SCSI bus. */
1632 WRITE_CONTROL (BASE_CMD | CMD_RST);
1633
1634 udelay (20 * 1000);
1635
1636 WRITE_CONTROL (BASE_CMD);
1637 st0x_aborted = DID_RESET;
1638
1639 DANY ("done.\n");
1640 return SUCCESS;
1641}
1642
1643static int seagate_st0x_host_reset(Scsi_Cmnd *SCpnt)
1644{
1645 return FAILED;
1646}
1647
1648static int seagate_st0x_device_reset(Scsi_Cmnd *SCpnt)
1649{
1650 return FAILED;
1651}
1652
1653static int seagate_st0x_release(struct Scsi_Host *shost)
1654{
1655 if (shost->irq)
1656 free_irq(shost->irq, shost);
1657 release_region(shost->io_port, shost->n_io_port);
1658 return 0;
1659}
1660
1661static Scsi_Host_Template driver_template = {
1662 .detect = seagate_st0x_detect,
1663 .release = seagate_st0x_release,
1664 .info = seagate_st0x_info,
1665 .queuecommand = seagate_st0x_queue_command,
1666 .eh_abort_handler = seagate_st0x_abort,
1667 .eh_bus_reset_handler = seagate_st0x_bus_reset,
1668 .eh_host_reset_handler = seagate_st0x_host_reset,
1669 .eh_device_reset_handler = seagate_st0x_device_reset,
1670 .can_queue = 1,
1671 .this_id = 7,
1672 .sg_tablesize = SG_ALL,
1673 .cmd_per_lun = 1,
1674 .use_clustering = DISABLE_CLUSTERING,
1675};
1676#include "scsi_module.c"