开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
seagate.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：47k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

seagate.c：源码内容
  1. /*
  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.  */
  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.  */
  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.  */
  90. #include <linux/module.h>
  92. #include <asm/io.h>
  93. #include <asm/system.h>
  94. #include <linux/spinlock.h>
  95. #include <linux/signal.h>
  96. #include <linux/sched.h>
  97. #include <linux/string.h>
  98. #include <linux/proc_fs.h>
  99. #include <linux/init.h>
  100. #include <linux/delay.h>
  101. #include <linux/blk.h>
  102. #include "scsi.h"
  103. #include "hosts.h"
  104. #include "seagate.h"
  105. #include "constants.h"
  106. #include <linux/stat.h>
  107. #include <asm/uaccess.h>
  108. #include "sd.h"
  109. #include <scsi/scsi_ioctl.h>
  111. #ifdef DEBUG
  112. #define DPRINTK( when, msg... ) do { if ( (DEBUG & (when)) == (when) ) printk( msg ); } while (0)
  113. #else
  114. #define DPRINTK( when, msg... ) do { } while (0)
  115. #endif
  116. #define DANY( msg... ) DPRINTK( 0xffff, msg );
  118. #ifndef IRQ
  119. #define IRQ 5
  120. #endif
  122. #ifdef FAST32
  123. #define FAST
  124. #endif
  126. #undef LINKED /* Linked commands are currently broken! */
  128. #if defined(OVERRIDE) && !defined(CONTROLLER)
  129. #error Please use -DCONTROLLER=SEAGATE or -DCONTROLLER=FD to override controller type
  130. #endif
  132. #ifndef __i386__
  133. #undef SEAGATE_USE_ASM
  134. #endif
  136. /*
  137. Thanks to Brian Antoine for the example code in his Messy-Loss ST-01
  138. driver, and Mitsugu Suzuki for information on the ST-01
  139. SCSI host.
  140. */
  142. /*
  143. CONTROL defines
  144. */
  146. #define CMD_RST  0x01
  147. #define CMD_SEL  0x02
  148. #define CMD_BSY  0x04
  149. #define CMD_ATTN     0x08
  150. #define CMD_START_ARB 0x10
  151. #define CMD_EN_PARITY 0x20
  152. #define CMD_INTR 0x40
  153. #define CMD_DRVR_ENABLE 0x80
  155. /*
  156. STATUS
  157. */
  158. #ifdef SWAPSTAT
  159. #define STAT_MSG 0x08
  160. #define STAT_CD 0x02
  161. #else
  162. #define STAT_MSG 0x02
  163. #define STAT_CD 0x08
  164. #endif
  166. #define STAT_BSY 0x01
  167. #define STAT_IO 0x04
  168. #define STAT_REQ 0x10
  169. #define STAT_SEL 0x20
  170. #define STAT_PARITY 0x40
  171. #define STAT_ARB_CMPL 0x80
  173. /* 
  174. REQUESTS
  175. */
  177. #define REQ_MASK (STAT_CD |  STAT_IO | STAT_MSG)
  178. #define REQ_DATAOUT 0
  179. #define REQ_DATAIN STAT_IO
  180. #define REQ_CMDOUT STAT_CD
  181. #define REQ_STATIN (STAT_CD | STAT_IO)
  182. #define REQ_MSGOUT (STAT_MSG | STAT_CD)
  183. #define REQ_MSGIN (STAT_MSG | STAT_CD | STAT_IO)
  185. extern volatile int seagate_st0x_timeout;
  187. #ifdef PARITY
  188. #define BASE_CMD CMD_EN_PARITY
  189. #else
  190. #define BASE_CMD  0
  191. #endif
  193. /*
  194. Debugging code
  195. */
  197. #define PHASE_BUS_FREE 1
  198. #define PHASE_ARBITRATION 2
  199. #define PHASE_SELECTION 4
  200. #define PHASE_DATAIN 8
  201. #define PHASE_DATAOUT 0x10
  202. #define PHASE_CMDOUT 0x20
  203. #define PHASE_MSGIN 0x40
  204. #define PHASE_MSGOUT 0x80
  205. #define PHASE_STATUSIN 0x100
  206. #define PHASE_ETC (PHASE_DATAIN | PHASE_DATAOUT | PHASE_CMDOUT | PHASE_MSGIN | PHASE_MSGOUT | PHASE_STATUSIN)
  207. #define PRINT_COMMAND 0x200
  208. #define PHASE_EXIT 0x400
  209. #define PHASE_RESELECT 0x800
  210. #define DEBUG_FAST 0x1000
  211. #define DEBUG_SG   0x2000
  212. #define DEBUG_LINKED 0x4000
  213. #define DEBUG_BORKEN 0x8000
  215. /* 
  216.  * Control options - these are timeouts specified in .01 seconds.
  217.  */
  219. /* 30, 20 work */
  220. #define ST0X_BUS_FREE_DELAY 25
  221. #define ST0X_SELECTION_DELAY 25
  223. #define SEAGATE 1 /* these determine the type of the controller */
  224. #define FD 2
  226. #define ST0X_ID_STR "Seagate ST-01/ST-02"
  227. #define FD_ID_STR "TMC-8XX/TMC-950"
  229. static int internal_command (unsigned char target, unsigned char lun,
  230.      const void *cmnd,
  231.      void *buff, int bufflen, int reselect);
  233. static int incommand; /* set if arbitration has finished
  234.    and we are in some command phase. */
  236. static unsigned int base_address = 0; /* Where the card ROM starts, used to 
  237.    calculate memory mapped register
  238.    location.  */
  240. static unsigned long st0x_cr_sr; /* control register write, status
  241.    register read.  256 bytes in
  242.    length.
  243.    Read is status of SCSI BUS, as per 
  244.    STAT masks.  */
  246. static unsigned long st0x_dr; /* data register, read write 256
  247.    bytes in length.  */
  249. static volatile int st0x_aborted = 0; /* set when we are aborted, ie by a
  250.    time out, etc.  */
  252. static unsigned char controller_type = 0; /* set to SEAGATE for ST0x
  253.    boards or FD for TMC-8xx
  254.    boards */
  255. static int irq = IRQ;
  257. MODULE_PARM (base_address, "i");
  258. MODULE_PARM (controller_type, "b");
  259. MODULE_PARM (irq, "i");
  260. MODULE_LICENSE("GPL");
  263. #define retcode(result) (((result) << 16) | (message << 8) | status)
  264. #define STATUS ((u8) isa_readb(st0x_cr_sr))
  265. #define DATA ((u8) isa_readb(st0x_dr))
  266. #define WRITE_CONTROL(d) { isa_writeb((d), st0x_cr_sr); }
  267. #define WRITE_DATA(d) { isa_writeb((d), st0x_dr); }
  269. void
  270. st0x_setup (char *str, int *ints)
  271. {
  272. controller_type = SEAGATE;
  273. base_address = ints[1];
  274. irq = ints[2];
  275. }
  277. void
  278. tmc8xx_setup (char *str, int *ints)
  279. {
  280. controller_type = FD;
  281. base_address = ints[1];
  282. irq = ints[2];
  283. }
  285. #ifndef OVERRIDE
  286. static unsigned int seagate_bases[] = {
  287. 0xc8000, 0xca000, 0xcc000,
  288. 0xce000, 0xdc000, 0xde000
  289. };
  291. typedef struct {
  292. const unsigned char *signature;
  293. unsigned offset;
  294. unsigned length;
  295. unsigned char type;
  296. } Signature;
  298. static Signature __initdata signatures[] = {
  299. {"ST01 v1.7  (C) Copyright 1987 Seagate", 15, 37, SEAGATE},
  300. {"SCSI BIOS 2.00  (C) Copyright 1987 Seagate", 15, 40, SEAGATE},
  302. /*
  303.  * The following two lines are NOT mistakes.  One detects ROM revision
  304.  * 3.0.0, the other 3.2.  Since seagate has only one type of SCSI adapter,
  305.  * and this is not going to change, the "SEAGATE" and "SCSI" together
  306.  * are probably "good enough"
  307.  */
  309. {"SEAGATE SCSI BIOS ", 16, 17, SEAGATE},
  310. {"SEAGATE SCSI BIOS ", 17, 17, SEAGATE},
  312. /*
  313.  * However, future domain makes several incompatible SCSI boards, so specific
  314.  * signatures must be used.
  315.  */
  317. {"FUTURE DOMAIN CORP. (C) 1986-1989 V5.0C2/14/89", 5, 46, FD},
  318. {"FUTURE DOMAIN CORP. (C) 1986-1989 V6.0A7/28/89", 5, 46, FD},
  319. {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0105/31/90", 5, 47, FD},
  320. {"FUTURE DOMAIN CORP. (C) 1986-1990 V6.0209/18/90", 5, 47, FD},
  321. {"FUTURE DOMAIN CORP. (C) 1986-1990 V7.009/18/90", 5, 46, FD},
  322. {"FUTURE DOMAIN CORP. (C) 1992 V8.00.004/02/92", 5, 44, FD},
  323. {"IBM F1 BIOS V1.1004/30/92", 5, 25, FD},
  324. {"FUTURE DOMAIN TMC-950", 5, 21, FD},
  325. /* Added for 2.2.16 by Matthias_Heidbrink@b.maus.de */
  326. {"IBM F1 V1.2009/22/93", 5, 25, FD},
  327. };
  329. #define NUM_SIGNATURES (sizeof(signatures) / sizeof(Signature))
  330. #endif /* n OVERRIDE */
  332. /*
  333.  * hostno stores the hostnumber, as told to us by the init routine.
  334.  */
  336. static int hostno = -1;
  337. static void seagate_reconnect_intr (int, void *, struct pt_regs *);
  338. static void do_seagate_reconnect_intr (int, void *, struct pt_regs *);
  340. #ifdef FAST
  341. static int fast = 1;
  342. #else
  343. #define fast 0
  344. #endif
  346. #ifdef SLOW_RATE
  347. /*
  348.  * Support for broken devices :
  349.  * The Seagate board has a handshaking problem.  Namely, a lack
  350.  * thereof for slow devices.  You can blast 600K/second through
  351.  * it if you are polling for each byte, more if you do a blind
  352.  * transfer.  In the first case, with a fast device, REQ will
  353.  * transition high-low or high-low-high before your loop restarts
  354.  * and you'll have no problems.  In the second case, the board
  355.  * will insert wait states for up to 13.2 usecs for REQ to
  356.  * transition low->high, and everything will work.
  357.  *
  358.  * However, there's nothing in the state machine that says
  359.  * you *HAVE* to see a high-low-high set of transitions before
  360.  * sending the next byte, and slow things like the Trantor CD ROMS
  361.  * will break because of this.
  362.  *
  363.  * So, we need to slow things down, which isn't as simple as it
  364.  * seems.  We can't slow things down period, because then people
  365.  * who don't recompile their kernels will shoot me for ruining
  366.  * their performance.  We need to do it on a case per case basis.
  367.  *
  368.  * The best for performance will be to, only for borken devices
  369.  * (this is stored on a per-target basis in the scsi_devices array)
  370.  *
  371.  * Wait for a low->high transition before continuing with that
  372.  * transfer.  If we timeout, continue anyways.  We don't need
  373.  * a long timeout, because REQ should only be asserted until the
  374.  * corresponding ACK is received and processed.
  375.  *
  376.  * Note that we can't use the system timer for this, because of
  377.  * resolution, and we *really* can't use the timer chip since
  378.  * gettimeofday() and the beeper routines use that.  So,
  379.  * the best thing for us to do will be to calibrate a timing
  380.  * loop in the initialization code using the timer chip before
  381.  * gettimeofday() can screw with it.
  382.  *
  383.  * FIXME: this is broken (not borken :-). Empty loop costs less than
  384.  * loop with ISA access in it! -- pavel@ucw.cz
  385.  */
  387. static int borken_calibration = 0;
  389. static void __init borken_init (void)
  390. {
  391. register int count = 0, start = jiffies + 1, stop = start + 25;
  393. while (time_before (jiffies, start)) ;
  394. for (; time_before (jiffies, stop); ++count) ;
  396. /*
  397.  * Ok, we now have a count for .25 seconds.  Convert to a
  398.  * count per second and divide by transfer rate in K.  */
  400. borken_calibration = (count * 4) / (SLOW_RATE * 1024);
  402. if (borken_calibration < 1)
  403. borken_calibration = 1;
  404. }
  406. static inline void borken_wait (void)
  407. {
  408. register int count;
  410. for (count = borken_calibration; count && (STATUS & STAT_REQ);
  411.      --count) ;
  412. #if (DEBUG & DEBUG_BORKEN)
  413. if (count)
  414. printk ("scsi%d : borken timeoutn", hostno);
  415. #endif
  416. }
  418. #endif /* def SLOW_RATE */
  420. /* These beasts only live on ISA, and ISA means 8MHz. Each ULOOP()
  421.  * contains at least one ISA access, which takes more than 0.125
  422.  * usec. So if we loop 8 times time in usec, we are safe.
  423.  */
  425. #define ULOOP( i ) for (clock = i*8;;)
  426. #define TIMEOUT (!(clock--))
  428. int __init seagate_st0x_detect (Scsi_Host_Template * tpnt)
  429. {
  430. struct Scsi_Host *instance;
  431. int i, j;
  433. tpnt->proc_name = "seagate";
  434. /*
  435.  *    First, we try for the manual override.
  436.  */
  437. DANY ("Autodetecting ST0x / TMC-8xxn");
  439. if (hostno != -1) {
  440. printk (KERN_ERR "seagate_st0x_detect() called twice?!n");
  441. return 0;
  442. }
  444. /* If the user specified the controller type from the command line,
  445.    controller_type will be non-zero, so don't try to detect one */
  447. if (!controller_type) {
  448. #ifdef OVERRIDE
  449. base_address = OVERRIDE;
  450. controller_type = CONTROLLER;
  452. DANY ("Base address overridden to %x, controller type is %sn",
  453.       base_address,
  454.       controller_type == SEAGATE ? "SEAGATE" : "FD");
  455. #else /* OVERRIDE */
  456. /*
  457.  *  To detect this card, we simply look for the signature
  458.  *      from the BIOS version notice in all the possible locations
  459.  *      of the ROM's.  This has a nice side effect of not trashing
  460.  *      any register locations that might be used by something else.
  461.  *
  462.  * XXX - note that we probably should be probing the address
  463.  * space for the on-board RAM instead.
  464.  */
  466. for (i = 0;
  467.      i < (sizeof (seagate_bases) / sizeof (unsigned int)); ++i)
  469. for (j = 0; !base_address && j < NUM_SIGNATURES; ++j)
  470. if (isa_check_signature
  471.     (seagate_bases[i] + signatures[j].offset,
  472.      signatures[j].signature,
  473.      signatures[j].length)) {
  474. base_address = seagate_bases[i];
  475. controller_type = signatures[j].type;
  476. }
  477. #endif /* OVERRIDE */
  478. }
  479. /* (! controller_type) */
  480. tpnt->this_id = (controller_type == SEAGATE) ? 7 : 6;
  481. tpnt->name = (controller_type == SEAGATE) ? ST0X_ID_STR : FD_ID_STR;
  483. if (!base_address) {
  484. DANY ("ST0x / TMC-8xx not detected.n");
  485. return 0;
  486. }
  488. st0x_cr_sr =
  489.     base_address + (controller_type == SEAGATE ? 0x1a00 : 0x1c00);
  490. st0x_dr = st0x_cr_sr + 0x200;
  492. DANY ("%s detected. Base address = %x, cr = %x, dr = %xn",
  493.       tpnt->name, base_address, st0x_cr_sr, st0x_dr);
  495. /*
  496.  * At all times, we will use IRQ 5.  Should also check for IRQ3 if we
  497.  *      loose our first interrupt.
  498.  */
  499. instance = scsi_register (tpnt, 0);
  500. if (instance == NULL)
  501. return 0;
  503. hostno = instance->host_no;
  504. if (request_irq (irq, do_seagate_reconnect_intr, SA_INTERRUPT,
  505.  (controller_type == SEAGATE) ? "seagate" : "tmc-8xx",
  506.  NULL)) {
  507. printk ("scsi%d : unable to allocate IRQ%dn", hostno, irq);
  508. return 0;
  509. }
  510. instance->irq = irq;
  511. instance->io_port = base_address;
  512. #ifdef SLOW_RATE
  513. printk (KERN_INFO "Calibrating borken timer... ");
  514. borken_init ();
  515. printk (" %d cycles per transfern", borken_calibration);
  516. #endif
  518. printk (KERN_INFO "This is one second... ");
  519. {
  520. int clock;
  521. ULOOP (1 * 1000 * 1000) {
  522. STATUS;
  523. if (TIMEOUT)
  524. break;
  525. }
  526. }
  528. printk ("done, %s options:"
  529. #ifdef ARBITRATE
  530. " ARBITRATE"
  531. #endif
  532. #ifdef DEBUG
  533. " DEBUG"
  534. #endif
  535. #ifdef FAST
  536. " FAST"
  537. #ifdef FAST32
  538. "32"
  539. #endif
  540. #endif
  541. #ifdef LINKED
  542. " LINKED"
  543. #endif
  544. #ifdef PARITY
  545. " PARITY"
  546. #endif
  547. #ifdef SEAGATE_USE_ASM
  548. " SEAGATE_USE_ASM"
  549. #endif
  550. #ifdef SLOW_RATE
  551. " SLOW_RATE"
  552. #endif
  553. #ifdef SWAPSTAT
  554. " SWAPSTAT"
  555. #endif
  556. #ifdef SWAPCNTDATA
  557. " SWAPCNTDATA"
  558. #endif
  559. "n", tpnt->name);
  560. return 1;
  561. }
  563. const char *
  564. seagate_st0x_info (struct Scsi_Host *shpnt)
  565. {
  566. static char buffer[64];
  568. sprintf (buffer, "%s at irq %d, address 0x%05X",
  569.  (controller_type == SEAGATE) ? ST0X_ID_STR : FD_ID_STR,
  570.  irq, base_address);
  571. return buffer;
  572. }
  574. /*
  575.  * These are our saved pointers for the outstanding command that is
  576.  * waiting for a reconnect
  577.  */
  579. static unsigned char current_target, current_lun;
  580. static unsigned char *current_cmnd, *current_data;
  581. static int current_nobuffs;
  582. static struct scatterlist *current_buffer;
  583. static int current_bufflen;
  585. #ifdef LINKED
  586. /*
  587.  * linked_connected indicates whether or not we are currently connected to
  588.  * linked_target, linked_lun and in an INFORMATION TRANSFER phase,
  589.  * using linked commands.
  590.  */
  592. static int linked_connected = 0;
  593. static unsigned char linked_target, linked_lun;
  594. #endif
  596. static void (*done_fn) (Scsi_Cmnd *) = NULL;
  597. static Scsi_Cmnd *SCint = NULL;
  599. /*
  600.  * These control whether or not disconnect / reconnect will be attempted,
  601.  * or are being attempted.
  602.  */
  604. #define NO_RECONNECT    0
  605. #define RECONNECT_NOW   1
  606. #define CAN_RECONNECT   2
  608. /*
  609.  * LINKED_RIGHT indicates that we are currently connected to the correct target
  610.  * for this command, LINKED_WRONG indicates that we are connected to the wrong
  611.  * target. Note that these imply CAN_RECONNECT and require defined(LINKED).
  612.  */
  614. #define LINKED_RIGHT    3
  615. #define LINKED_WRONG    4
  617. /*
  618.  * This determines if we are expecting to reconnect or not.
  619.  */
  621. static int should_reconnect = 0;
  623. /*
  624.  * The seagate_reconnect_intr routine is called when a target reselects the
  625.  * host adapter.  This occurs on the interrupt triggered by the target
  626.  * asserting SEL.
  627.  */
  629. static void do_seagate_reconnect_intr (int irq, void *dev_id, struct pt_regs *regs)
  630. {
  631. unsigned long flags;
  633. spin_lock_irqsave (&io_request_lock, flags);
  634. seagate_reconnect_intr (irq, dev_id, regs);
  635. spin_unlock_irqrestore (&io_request_lock, flags);
  636. }
  638. static void seagate_reconnect_intr (int irq, void *dev_id, struct pt_regs *regs)
  639. {
  640. int temp;
  641. Scsi_Cmnd *SCtmp;
  643. DPRINTK (PHASE_RESELECT, "scsi%d : seagate_reconnect_intr() calledn",
  644.  hostno);
  646. if (!should_reconnect)
  647. printk ("scsi%d: unexpected interrupt.n", hostno);
  648. else {
  649. should_reconnect = 0;
  651. DPRINTK (PHASE_RESELECT, "scsi%d : internal_command("
  652.  "%d, %08x, %08x, RECONNECT_NOWn", hostno,
  653.  current_target, current_data, current_bufflen);
  655. temp =
  656.     internal_command (current_target, current_lun, current_cmnd,
  657.       current_data, current_bufflen,
  658.       RECONNECT_NOW);
  660. if (msg_byte (temp) != DISCONNECT) {
  661. if (done_fn) {
  662. DPRINTK (PHASE_RESELECT,
  663.  "scsi%d : done_fn(%d,%08x)", hostno,
  664.  hostno, temp);
  665. if (!SCint)
  666. panic ("SCint == NULL in seagate");
  667. SCtmp = SCint;
  668. SCint = NULL;
  669. SCtmp->result = temp;
  670. done_fn (SCtmp);
  671. } else
  672. printk ("done_fn() not defined.n");
  673. }
  674. }
  675. }
  677. /*
  678.  * The seagate_st0x_queue_command() function provides a queued interface
  679.  * to the seagate SCSI driver.  Basically, it just passes control onto the
  680.  * seagate_command() function, after fixing it so that the done_fn()
  681.  * is set to the one passed to the function.  We have to be very careful,
  682.  * because there are some commands on some devices that do not disconnect,
  683.  * and if we simply call the done_fn when the command is done then another
  684.  * command is started and queue_command is called again...  We end up
  685.  * overflowing the kernel stack, and this tends not to be such a good idea.
  686.  */
  688. static int recursion_depth = 0;
  690. int seagate_st0x_queue_command (Scsi_Cmnd * SCpnt, void (*done) (Scsi_Cmnd *))
  691. {
  692. int result, reconnect;
  693. Scsi_Cmnd *SCtmp;
  695. DANY ("seagate: que_command");
  696. done_fn = done;
  697. current_target = SCpnt->target;
  698. current_lun = SCpnt->lun;
  699. (const void *) current_cmnd = SCpnt->cmnd;
  700. current_data = (unsigned char *) SCpnt->request_buffer;
  701. current_bufflen = SCpnt->request_bufflen;
  702. SCint = SCpnt;
  703. if (recursion_depth)
  704. return 0;
  705. recursion_depth++;
  706. do {
  707. #ifdef LINKED
  708. /*
  709.  * Set linked command bit in control field of SCSI command.
  710.  */
  712. current_cmnd[SCpnt->cmd_len] |= 0x01;
  713. if (linked_connected) {
  714. DPRINTK (DEBUG_LINKED,
  715.  "scsi%d : using linked commands, current I_T_L nexus is ",
  716.  hostno);
  717. if ((linked_target == current_target)
  718.     && (linked_lun == current_lun)) {
  719. DPRINTK (DEBUG_LINKED, "correctn");
  720. reconnect = LINKED_RIGHT;
  721. } else {
  722. DPRINTK (DEBUG_LINKED, "incorrectn");
  723. reconnect = LINKED_WRONG;
  724. }
  725. } else
  726. #endif /* LINKED */
  727. reconnect = CAN_RECONNECT;
  729. result =
  730.     internal_command (SCint->target, SCint->lun, SCint->cmnd,
  731.       SCint->request_buffer,
  732.       SCint->request_bufflen, reconnect);
  733. if (msg_byte (result) == DISCONNECT)
  734. break;
  735. SCtmp = SCint;
  736. SCint = NULL;
  737. SCtmp->result = result;
  738. done_fn (SCtmp);
  739. }
  740. while (SCint);
  741. recursion_depth--;
  742. return 0;
  743. }
  745. int seagate_st0x_command (Scsi_Cmnd * SCpnt)
  746. {
  747. return internal_command (SCpnt->target, SCpnt->lun, SCpnt->cmnd,
  748.  SCpnt->request_buffer, SCpnt->request_bufflen,
  749.  (int) NO_RECONNECT);
  750. }
  752. static int internal_command (unsigned char target, unsigned char lun,
  753.   const void *cmnd, void *buff, int bufflen, int reselect)
  754. {
  755. unsigned char *data = NULL;
  756. struct scatterlist *buffer = NULL;
  757. int clock, temp, nobuffs = 0, done = 0, len = 0;
  758. unsigned long flags;
  760. #ifdef DEBUG
  761. int transfered = 0, phase = 0, newphase;
  762. #endif
  764. register unsigned char status_read;
  765. unsigned char tmp_data, tmp_control, status = 0, message = 0;
  767. unsigned transfersize = 0, underflow = 0;
  769. #ifdef SLOW_RATE
  770. int borken = (int) SCint->device->borken; /* Does the current target require
  771.    Very Slow I/O ?  */
  772. #endif
  774. incommand = 0;
  775. st0x_aborted = 0;
  777. #if (DEBUG & PRINT_COMMAND)
  778. printk ("scsi%d : target = %d, command = ", hostno, target);
  779. print_command ((unsigned char *) cmnd);
  780. #endif
  782. #if (DEBUG & PHASE_RESELECT)
  783. switch (reselect) {
  784. case RECONNECT_NOW:
  785. printk ("scsi%d : reconnectingn", hostno);
  786. break;
  787. #ifdef LINKED
  788. case LINKED_RIGHT:
  789. printk ("scsi%d : connected, can reconnectn", hostno);
  790. break;
  791. case LINKED_WRONG:
  792. printk ("scsi%d : connected to wrong target, can reconnectn",
  793. hostno);
  794. break;
  795. #endif
  796. case CAN_RECONNECT:
  797. printk ("scsi%d : allowed to reconnectn", hostno);
  798. break;
  799. default:
  800. printk ("scsi%d : not allowed to reconnectn", hostno);
  801. }
  802. #endif
  804. if (target == (controller_type == SEAGATE ? 7 : 6))
  805. return DID_BAD_TARGET;
  807. /*
  808.  * We work it differently depending on if this is is "the first time,"
  809.  *      or a reconnect.  If this is a reselect phase, then SEL will
  810.  *      be asserted, and we must skip selection / arbitration phases.
  811.  */
  813. switch (reselect) {
  814. case RECONNECT_NOW:
  815. DPRINTK (PHASE_RESELECT, "scsi%d : phase RESELECT n", hostno);
  817. /*
  818.  * At this point, we should find the logical or of our ID and the original
  819.  *      target's ID on the BUS, with BSY, SEL, and I/O signals asserted.
  820.  *
  821.  *      After ARBITRATION phase is completed, only SEL, BSY, and the
  822.  *      target ID are asserted.  A valid initiator ID is not on the bus
  823.  *      until IO is asserted, so we must wait for that.
  824.  */
  825. ULOOP (100 * 1000) {
  826. temp = STATUS;
  827. if ((temp & STAT_IO) && !(temp & STAT_BSY))
  828. break;
  830. if (TIMEOUT) {
  831. DPRINTK (PHASE_RESELECT,
  832.  "scsi%d : RESELECT timed out while waiting for IO .n",
  833.  hostno);
  834. return (DID_BAD_INTR << 16);
  835. }
  836. }
  838. /*
  839.  * After I/O is asserted by the target, we can read our ID and its
  840.  *      ID off of the BUS.
  841.  */
  843. if (!
  844.     ((temp =
  845.       DATA) & (controller_type == SEAGATE ? 0x80 : 0x40))) {
  846. DPRINTK (PHASE_RESELECT,
  847.  "scsi%d : detected reconnect request to different target.n"
  848.  "tData bus = %dn", hostno, temp);
  849. return (DID_BAD_INTR << 16);
  850. }
  852. if (!(temp & (1 << current_target))) {
  853. printk
  854.     ("scsi%d : Unexpected reselect interrupt.  Data bus = %dn",
  855.      hostno, temp);
  856. return (DID_BAD_INTR << 16);
  857. }
  859. buffer = current_buffer;
  860. cmnd = current_cmnd; /* WDE add */
  861. data = current_data; /* WDE add */
  862. len = current_bufflen; /* WDE add */
  863. nobuffs = current_nobuffs;
  865. /*
  866.  * We have determined that we have been selected.  At this point,
  867.  *      we must respond to the reselection by asserting BSY ourselves
  868.  */
  870. #if 1
  871. WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE | CMD_BSY);
  872. #else
  873. WRITE_CONTROL (BASE_CMD | CMD_BSY);
  874. #endif
  876. /*
  877.  * The target will drop SEL, and raise BSY, at which time we must drop
  878.  *      BSY.
  879.  */
  881. ULOOP (100 * 1000) {
  882. if (!(STATUS & STAT_SEL))
  883. break;
  884. if (TIMEOUT) {
  885. WRITE_CONTROL (BASE_CMD | CMD_INTR);
  886. DPRINTK (PHASE_RESELECT,
  887.  "scsi%d : RESELECT timed out while waiting for SEL.n",
  888.  hostno);
  889. return (DID_BAD_INTR << 16);
  890. }
  891. }
  893. WRITE_CONTROL (BASE_CMD);
  895. /*
  896.  * At this point, we have connected with the target and can get
  897.  *      on with our lives.
  898.  */
  899. break;
  900. case CAN_RECONNECT:
  902. #ifdef LINKED
  903. /*
  904.  * This is a bletcherous hack, just as bad as the Unix #! interpreter stuff.
  905.  * If it turns out we are using the wrong I_T_L nexus, the easiest way to deal
  906.  * with it is to go into our INFORMATION TRANSFER PHASE code, send a ABORT
  907.  * message on MESSAGE OUT phase, and then loop back to here.
  908.  */
  910.       connect_loop:
  912. #endif
  914. DPRINTK (PHASE_BUS_FREE, "scsi%d : phase = BUS FREE n",
  915.  hostno);
  917. /*
  918.  *    BUS FREE PHASE
  919.  *
  920.  *      On entry, we make sure that the BUS is in a BUS FREE
  921.  *      phase, by insuring that both BSY and SEL are low for
  922.  *      at least one bus settle delay.  Several reads help
  923.  *      eliminate wire glitch.
  924.  */
  926. #ifndef ARBITRATE
  927. #error FIXME: this is broken: we may not use jiffies here - we are under cli(). It will hardlock.
  928. clock = jiffies + ST0X_BUS_FREE_DELAY;
  930. while (((STATUS | STATUS | STATUS) &
  931. (STAT_BSY | STAT_SEL)) &&
  932.        (!st0x_aborted) && time_before (jiffies, clock)) ;
  934. if (time_after (jiffies, clock))
  935. return retcode (DID_BUS_BUSY);
  936. else if (st0x_aborted)
  937. return retcode (st0x_aborted);
  938. #endif
  940. DPRINTK (PHASE_SELECTION, "scsi%d : phase = SELECTIONn",
  941.  hostno);
  943. clock = jiffies + ST0X_SELECTION_DELAY;
  945. /*
  946.  * Arbitration/selection procedure :
  947.  * 1.  Disable drivers
  948.  * 2.  Write HOST adapter address bit
  949.  * 3.  Set start arbitration.
  950.  * 4.  We get either ARBITRATION COMPLETE or SELECT at this
  951.  *     point.
  952.  * 5.  OR our ID and targets on bus.
  953.  * 6.  Enable SCSI drivers and asserted SEL and ATTN
  954.  */
  956. #ifdef ARBITRATE
  957. save_flags (flags);
  958. cli ();
  959. WRITE_CONTROL (0);
  960. WRITE_DATA ((controller_type == SEAGATE) ? 0x80 : 0x40);
  961. WRITE_CONTROL (CMD_START_ARB);
  962. restore_flags (flags);
  964. ULOOP (ST0X_SELECTION_DELAY * 10000) {
  965. status_read = STATUS;
  966. if (status_read & STAT_ARB_CMPL)
  967. break;
  968. if (st0x_aborted) /* FIXME: What? We are going to do something even after abort? */
  969. break;
  970. if (TIMEOUT || (status_read & STAT_SEL)) {
  971. printk
  972.     ("scsi%d : arbitration lost or timeout.n",
  973.      hostno);
  974. WRITE_CONTROL (BASE_CMD);
  975. return retcode (DID_NO_CONNECT);
  976. }
  977. }
  979. DPRINTK (PHASE_SELECTION, "scsi%d : arbitration completen",
  980.  hostno);
  981. #endif
  983. /*
  984.  *    When the SCSI device decides that we're gawking at it, it will
  985.  *    respond by asserting BUSY on the bus.
  986.  *
  987.  *    Note : the Seagate ST-01/02 product manual says that we should
  988.  *    twiddle the DATA register before the control register.    However,
  989.  *    this does not work reliably so we do it the other way around.
  990.  *
  991.  *    Probably could be a problem with arbitration too, we really should
  992.  *    try this with a SCSI protocol or logic analyzer to see what is
  993.  *    going on.
  994.  */
  995. tmp_data =
  996.     (unsigned char) ((1 << target) |
  997.      (controller_type ==
  998.       SEAGATE ? 0x80 : 0x40));
  999. tmp_control =
  1000.     BASE_CMD | CMD_DRVR_ENABLE | CMD_SEL | (reselect ? CMD_ATTN
  1001.     : 0);
  1003. save_flags (flags);
  1004. cli ();
  1005. #ifdef OLDCNTDATASCEME
  1006. #ifdef SWAPCNTDATA
  1007. WRITE_CONTROL (tmp_control);
  1008. WRITE_DATA (tmp_data);
  1009. #else
  1010. WRITE_DATA (tmp_data);
  1011. WRITE_CONTROL (tmp_control);
  1012. #endif
  1013. #else
  1014. tmp_control ^= CMD_BSY; /* This is guesswork. What used to be in driver    */
  1015. WRITE_CONTROL (tmp_control); /* could never work: it sent data into control     */
  1016. WRITE_DATA (tmp_data); /* register and control info into data. Hopefully  */
  1017. tmp_control ^= CMD_BSY; /* fixed, but order of first two may be wrong.     */
  1018. WRITE_CONTROL (tmp_control); /* -- pavel@ucw.cz   */
  1019. #endif
  1021. restore_flags (flags);
  1023. ULOOP (250 * 1000) {
  1024. if (st0x_aborted) {
  1025. /*
  1026.  * If we have been aborted, and we have a command in progress, IE the
  1027.  *      target still has BSY asserted, then we will reset the bus, and
  1028.  *      notify the midlevel driver to expect sense.
  1029.  */
  1031. WRITE_CONTROL (BASE_CMD);
  1032. if (STATUS & STAT_BSY) {
  1033. printk
  1034.     ("scsi%d : BST asserted after we've been aborted.n",
  1035.      hostno);
  1036. seagate_st0x_reset (NULL, 0);
  1037. return retcode (DID_RESET);
  1038. }
  1039. return retcode (st0x_aborted);
  1040. }
  1041. if (STATUS & STAT_BSY)
  1042. break;
  1043. if (TIMEOUT) {
  1044. DPRINTK (PHASE_SELECTION,
  1045.  "scsi%d : NO CONNECT with target %d, stat = %x n",
  1046.  hostno, target, STATUS);
  1047. return retcode (DID_NO_CONNECT);
  1048. }
  1049. }
  1051. /* Establish current pointers.  Take into account scatter / gather */
  1053. if ((nobuffs = SCint->use_sg)) {
  1054. #if (DEBUG & DEBUG_SG)
  1055. {
  1056. int i;
  1058. printk
  1059.     ("scsi%d : scatter gather requested, using %d buffers.n",
  1060.      hostno, nobuffs);
  1061. for (i = 0; i < nobuffs; ++i)
  1062. printk
  1063.     ("scsi%d : buffer %d address = %08x length = %dn",
  1064.      hostno, i, buffer[i].address,
  1065.      buffer[i].length);
  1066. }
  1067. #endif
  1069. buffer = (struct scatterlist *) SCint->buffer;
  1070. len = buffer->length;
  1071. data = (unsigned char *) buffer->address;
  1072. } else {
  1073. DPRINTK (DEBUG_SG,
  1074.  "scsi%d : scatter gather not requested.n",
  1075.  hostno);
  1076. buffer = NULL;
  1077. len = SCint->request_bufflen;
  1078. data = (unsigned char *) SCint->request_buffer;
  1079. }
  1081. DPRINTK (PHASE_DATAIN | PHASE_DATAOUT, "scsi%d : len = %dn",
  1082.  hostno, len);
  1084. break;
  1085. #ifdef LINKED
  1086. case LINKED_RIGHT:
  1087. break;
  1088. case LINKED_WRONG:
  1089. break;
  1090. #endif
  1091. } /* end of switch(reselect) */
  1093. /*
  1094.  *    There are several conditions under which we wish to send a message :
  1095.  *      1.  When we are allowing disconnect / reconnect, and need to establish
  1096.  *          the I_T_L nexus via an IDENTIFY with the DiscPriv bit set.
  1097.  *
  1098.  *      2.  When we are doing linked commands, are have the wrong I_T_L nexus
  1099.  *          established and want to send an ABORT message.
  1100.  */
  1102. /* GCC does not like an ifdef inside a macro, so do it the hard way. */
  1103. #ifdef LINKED
  1104. WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE |
  1105.        (((reselect == CAN_RECONNECT)
  1106.  || (reselect == LINKED_WRONG)
  1107. )? CMD_ATTN : 0));
  1108. #else
  1109. WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE |
  1110.        (((reselect == CAN_RECONNECT)
  1111. )? CMD_ATTN : 0));
  1112. #endif
  1114. /*
  1115.  *    INFORMATION TRANSFER PHASE
  1116.  *
  1117.  *      The nasty looking read / write inline assembler loops we use for
  1118.  *      DATAIN and DATAOUT phases are approximately 4-5 times as fast as
  1119.  *      the 'C' versions - since we're moving 1024 bytes of data, this
  1120.  *      really adds up.
  1121.  *
  1122.  *      SJT: The nasty-looking assembler is gone, so it's slower.
  1123.  *
  1124.  */
  1126. DPRINTK (PHASE_ETC, "scsi%d : phase = INFORMATION TRANSFERn", hostno);
  1128. incommand = 1;
  1129. transfersize = SCint->transfersize;
  1130. underflow = SCint->underflow;
  1132. /*
  1133.  * Now, we poll the device for status information,
  1134.  *      and handle any requests it makes.  Note that since we are unsure of
  1135.  *      how much data will be flowing across the system, etc and cannot
  1136.  *      make reasonable timeouts, that we will instead have the midlevel
  1137.  *      driver handle any timeouts that occur in this phase.
  1138.  */
  1140. while (((status_read = STATUS) & STAT_BSY) && !st0x_aborted && !done) {
  1141. #ifdef PARITY
  1142. if (status_read & STAT_PARITY) {
  1143. printk ("scsi%d : got parity errorn", hostno);
  1144. st0x_aborted = DID_PARITY;
  1145. }
  1146. #endif
  1148. if (status_read & STAT_REQ) {
  1149. #if ((DEBUG & PHASE_ETC) == PHASE_ETC)
  1150. if ((newphase = (status_read & REQ_MASK)) != phase) {
  1151. phase = newphase;
  1152. switch (phase) {
  1153. case REQ_DATAOUT:
  1154. printk ("scsi%d : phase = DATA OUTn",
  1155. hostno);
  1156. break;
  1157. case REQ_DATAIN:
  1158. printk ("scsi%d : phase = DATA INn",
  1159. hostno);
  1160. break;
  1161. case REQ_CMDOUT:
  1162. printk
  1163.     ("scsi%d : phase = COMMAND OUTn",
  1164.      hostno);
  1165. break;
  1166. case REQ_STATIN:
  1167. printk ("scsi%d : phase = STATUS INn",
  1168. hostno);
  1169. break;
  1170. case REQ_MSGOUT:
  1171. printk
  1172.     ("scsi%d : phase = MESSAGE OUTn",
  1173.      hostno);
  1174. break;
  1175. case REQ_MSGIN:
  1176. printk ("scsi%d : phase = MESSAGE INn",
  1177. hostno);
  1178. break;
  1179. default:
  1180. printk ("scsi%d : phase = UNKNOWNn",
  1181. hostno);
  1182. st0x_aborted = DID_ERROR;
  1183. }
  1184. }
  1185. #endif
  1186. switch (status_read & REQ_MASK) {
  1187. case REQ_DATAOUT:
  1188. /*
  1189.  * If we are in fast mode, then we simply splat the data out
  1190.  * in word-sized chunks as fast as we can.
  1191.  */
  1193. if (!len) {
  1194. #if 0
  1195. printk
  1196.     ("scsi%d: underflow to target %d lun %d n",
  1197.      hostno, target, lun);
  1198. st0x_aborted = DID_ERROR;
  1199. fast = 0;
  1200. #endif
  1201. break;
  1202. }
  1204. if (fast && transfersize
  1205.     && !(len % transfersize)
  1206.     && (len >= transfersize)
  1207. #ifdef FAST32
  1208.     && !(transfersize % 4)
  1209. #endif
  1210.     ) {
  1211. DPRINTK (DEBUG_FAST,
  1212.  "scsi%d : FAST transfer, underflow = %d, transfersize = %dn"
  1213.  "         len = %d, data = %08xn",
  1214.  hostno, SCint->underflow,
  1215.  SCint->transfersize, len,
  1216.  data);
  1218. /* SJT: Start. Fast Write */
  1219. #ifdef SEAGATE_USE_ASM
  1220. __asm__ ("cldnt"
  1221. #ifdef FAST32
  1222.  "shr $2, %%ecxnt"
  1223.  "1:t"
  1224.  "lodslnt"
  1225.  "movl %%eax, (%%edi)nt"
  1226. #else
  1227.  "1:t"
  1228.  "lodsbnt"
  1229.  "movb %%al, (%%edi)nt"
  1230. #endif
  1231.  "loop 1b;"
  1232.       /* output */ :
  1233.       /* input */ :"D" (phys_to_virt (st0x_dr)),
  1234.  "S"
  1235.  (data),
  1236.  "c" (SCint->transfersize)
  1237. /* clobbered */
  1238.       :  "eax", "ecx",
  1239.  "esi");
  1240. #else /* SEAGATE_USE_ASM */
  1241. {
  1242. #ifdef FAST32
  1243. unsigned int *iop =
  1244.     phys_to_virt (st0x_dr);
  1245. const unsigned int *dp =
  1246.     (unsigned int *) data;
  1247. int xferlen = transfersize >> 2;
  1248. #else
  1249. unsigned char *iop =
  1250.     phys_to_virt (st0x_dr);
  1251. const unsigned char *dp = data;
  1252. int xferlen = transfersize;
  1253. #endif
  1254. for (; xferlen; --xferlen)
  1255. *iop = *dp++;
  1256. }
  1257. #endif /* SEAGATE_USE_ASM */
  1258. /* SJT: End */
  1259. len -= transfersize;
  1260. data += transfersize;
  1261. DPRINTK (DEBUG_FAST,
  1262.  "scsi%d : FAST transfer complete len = %d data = %08xn",
  1263.  hostno, len, data);
  1264. } else {
  1265. /*
  1266.  *    We loop as long as we are in a data out phase, there is data to send,
  1267.  *      and BSY is still active.
  1268.  */
  1270. /* SJT: Start. Slow Write. */
  1271. #ifdef SEAGATE_USE_ASM
  1273. int __dummy_1, __dummy_2;
  1275. /*
  1276.  *      We loop as long as we are in a data out phase, there is data to send, 
  1277.  *      and BSY is still active.
  1278.  */
  1279. /* Local variables : len = ecx , data = esi, 
  1280.                      st0x_cr_sr = ebx, st0x_dr =  edi
  1281. */
  1282. __asm__ (
  1283. /* Test for any data here at all. */
  1284. "orl %%ecx, %%ecxnt"
  1285. "jz 2fnt" "cldnt"
  1286. /*                    "movl " SYMBOL_NAME_STR(st0x_cr_sr) ", %%ebxnt"  */
  1287. /*                    "movl " SYMBOL_NAME_STR(st0x_dr) ", %%edint"  */
  1288. "1:t"
  1289. "movb (%%ebx), %%alnt"
  1290. /* Test for BSY */
  1291. "test $1, %%alnt"
  1292. "jz 2fnt"
  1293. /* Test for data out phase - STATUS & REQ_MASK should be 
  1294.    REQ_DATAOUT, which is 0. */
  1295. "test $0xe, %%alnt"
  1296. "jnz 2fnt"
  1297. /* Test for REQ */
  1298. "test $0x10, %%alnt"
  1299. "jz 1bnt"
  1300. "lodsbnt"
  1301. "movb %%al, (%%edi)nt"
  1302. "loop 1bnt" "2:n"
  1303.       /* output */ :"=S" (data), "=c" (len),
  1304. "=b"
  1305. (__dummy_1),
  1306. "=D" (__dummy_2)
  1307. /* input */
  1308.       : "0" (data), "1" (len),
  1309. "2" (phys_to_virt
  1310.      (st0x_cr_sr)),
  1311. "3" (phys_to_virt
  1312.      (st0x_dr))
  1313. /* clobbered */
  1314.       : "eax");
  1315. #else /* SEAGATE_USE_ASM */
  1316. while (len) {
  1317. unsigned char stat;
  1319. stat = STATUS;
  1320. if (!(stat & STAT_BSY)
  1321.     || ((stat & REQ_MASK) !=
  1322. REQ_DATAOUT))
  1323. break;
  1324. if (stat & STAT_REQ) {
  1325. WRITE_DATA (*data++);
  1326. --len;
  1327. }
  1328. }
  1329. #endif /* SEAGATE_USE_ASM */
  1330. /* SJT: End. */
  1331. }
  1333. if (!len && nobuffs) {
  1334. --nobuffs;
  1335. ++buffer;
  1336. len = buffer->length;
  1337. data =
  1338.     (unsigned char *) buffer->address;
  1339. DPRINTK (DEBUG_SG,
  1340.  "scsi%d : next scatter-gather buffer len = %d address = %08xn",
  1341.  hostno, len, data);
  1342. }
  1343. break;
  1345. case REQ_DATAIN:
  1346. #ifdef SLOW_RATE
  1347. if (borken) {
  1348. #if (DEBUG & (PHASE_DATAIN))
  1349. transfered += len;
  1350. #endif
  1351. for (;
  1352.      len
  1353.      && (STATUS & (REQ_MASK | STAT_REQ))
  1354.      == (REQ_DATAIN | STAT_REQ);
  1355.      --len) {
  1356. *data++ = DATA;
  1357. borken_wait ();
  1358. }
  1359. #if (DEBUG & (PHASE_DATAIN))
  1360. transfered -= len;
  1361. #endif
  1362. } else
  1363. #endif
  1365. if (fast && transfersize
  1366.     && !(len % transfersize)
  1367.     && (len >= transfersize)
  1368. #ifdef FAST32
  1369.     && !(transfersize % 4)
  1370. #endif
  1371.     ) {
  1372. DPRINTK (DEBUG_FAST,
  1373.  "scsi%d : FAST transfer, underflow = %d, transfersize = %dn"
  1374.  "         len = %d, data = %08xn",
  1375.  hostno, SCint->underflow,
  1376.  SCint->transfersize, len,
  1377.  data);
  1379. /* SJT: Start. Fast Read */
  1380. #ifdef SEAGATE_USE_ASM
  1381. __asm__ ("cldnt"
  1382. #ifdef FAST32
  1383.  "shr $2, %%ecxnt"
  1384.  "1:t"
  1385.  "movl (%%esi), %%eaxnt"
  1386.  "stoslnt"
  1387. #else
  1388.  "1:t"
  1389.  "movb (%%esi), %%alnt"
  1390.  "stosbnt"
  1391. #endif
  1392.  "loop 1bnt"
  1393.       /* output */ :
  1394.       /* input */ :"S" (phys_to_virt (st0x_dr)),
  1395.  "D"
  1396.  (data),
  1397.  "c" (SCint->transfersize)
  1398. /* clobbered */
  1399.       :  "eax", "ecx",
  1400.  "edi");
  1401. #else /* SEAGATE_USE_ASM */
  1402. {
  1403. #ifdef FAST32
  1404. const unsigned int *iop =
  1405.     phys_to_virt (st0x_dr);
  1406. unsigned int *dp =
  1407.     (unsigned int *) data;
  1408. int xferlen = len >> 2;
  1409. #else
  1410. const unsigned char *iop =
  1411.     phys_to_virt (st0x_dr);
  1412. unsigned char *dp = data;
  1413. int xferlen = len;
  1414. #endif
  1415. for (; xferlen; --xferlen)
  1416. *dp++ = *iop;
  1417. }
  1418. #endif /* SEAGATE_USE_ASM */
  1419. /* SJT: End */
  1420. len -= transfersize;
  1421. data += transfersize;
  1422. #if (DEBUG & PHASE_DATAIN)
  1423. printk ("scsi%d: transfered += %dn",
  1424. hostno, transfersize);
  1425. transfered += transfersize;
  1426. #endif
  1428. DPRINTK (DEBUG_FAST,
  1429.  "scsi%d : FAST transfer complete len = %d data = %08xn",
  1430.  hostno, len, data);
  1431. } else {
  1433. #if (DEBUG & PHASE_DATAIN)
  1434. printk ("scsi%d: transfered += %dn",
  1435. hostno, len);
  1436. transfered += len; /* Assume we'll transfer it all, then
  1437.    subtract what we *didn't* transfer */
  1438. #endif
  1440. /*
  1441.  * We loop as long as we are in a data in phase, there is room to read,
  1442.  *      and BSY is still active
  1443.  */
  1445. /* SJT: Start. */
  1446. #ifdef SEAGATE_USE_ASM
  1448. int __dummy_3, __dummy_4;
  1450. /* Dummy clobbering variables for the new gcc-2.95 */
  1452. /*
  1453.  *      We loop as long as we are in a data in phase, there is room to read, 
  1454.  *      and BSY is still active
  1455.  */
  1456. /* Local variables : ecx = len, edi = data
  1457.    esi = st0x_cr_sr, ebx = st0x_dr */
  1458. __asm__ (
  1459. /* Test for room to read */
  1460. "orl %%ecx, %%ecxnt"
  1461. "jz 2fnt" "cldnt"
  1462. /*                "movl " SYMBOL_NAME_STR(st0x_cr_sr) ", %%esint"  */
  1463. /*                "movl " SYMBOL_NAME_STR(st0x_dr) ", %%ebxnt"  */
  1464. "1:t"
  1465. "movb (%%esi), %%alnt"
  1466. /* Test for BSY */
  1467. "test $1, %%alnt"
  1468. "jz 2fnt"
  1469. /* Test for data in phase - STATUS & REQ_MASK should be REQ_DATAIN, 
  1470.    = STAT_IO, which is 4. */
  1471. "movb $0xe, %%ahnt"
  1472. "andb %%al, %%ahnt"
  1473. "cmpb $0x04, %%ahnt"
  1474. "jne 2fnt"
  1475. /* Test for REQ */
  1476. "test $0x10, %%alnt"
  1477. "jz 1bnt"
  1478. "movb (%%ebx), %%alnt"
  1479. "stosbnt"
  1480. "loop 1bnt" "2:n"
  1481.       /* output */ :"=D" (data), "=c" (len),
  1482. "=S"
  1483. (__dummy_3),
  1484. "=b" (__dummy_4)
  1485. /* input */
  1486.       : "0" (data), "1" (len),
  1487. "2" (phys_to_virt
  1488.      (st0x_cr_sr)),
  1489. "3" (phys_to_virt
  1490.      (st0x_dr))
  1491. /* clobbered */
  1492.       : "eax");
  1493. #else /* SEAGATE_USE_ASM */
  1494. while (len) {
  1495. unsigned char stat;
  1497. stat = STATUS;
  1498. if (!(stat & STAT_BSY)
  1499.     || ((stat & REQ_MASK) !=
  1500. REQ_DATAIN))
  1501. break;
  1502. if (stat & STAT_REQ) {
  1503. *data++ = DATA;
  1504. --len;
  1505. }
  1506. }
  1507. #endif /* SEAGATE_USE_ASM */
  1508. /* SJT: End. */
  1509. #if (DEBUG & PHASE_DATAIN)
  1510. printk ("scsi%d: transfered -= %dn",
  1511. hostno, len);
  1512. transfered -= len; /* Since we assumed all of Len got  *
  1513.    transfered, correct our mistake */
  1514. #endif
  1515. }
  1517. if (!len && nobuffs) {
  1518. --nobuffs;
  1519. ++buffer;
  1520. len = buffer->length;
  1521. data =
  1522.     (unsigned char *) buffer->address;
  1523. DPRINTK (DEBUG_SG,
  1524.  "scsi%d : next scatter-gather buffer len = %d address = %08xn",
  1525.  hostno, len, data);
  1526. }
  1528. break;
  1530. case REQ_CMDOUT:
  1531. while (((status_read = STATUS) & STAT_BSY) &&
  1532.        ((status_read & REQ_MASK) == REQ_CMDOUT))
  1533. if (status_read & STAT_REQ) {
  1534. WRITE_DATA (*
  1535.     (const unsigned char
  1536.      *) cmnd);
  1537. cmnd =
  1538.     1 +
  1539.     (const unsigned char *)
  1540.     cmnd;
  1541. #ifdef SLOW_RATE
  1542. if (borken)
  1543. borken_wait ();
  1544. #endif
  1545. }
  1546. break;
  1548. case REQ_STATIN:
  1549. status = DATA;
  1550. break;
  1552. case REQ_MSGOUT:
  1553. /*
  1554.  * We can only have sent a MSG OUT if we requested to do this
  1555.  *      by raising ATTN.  So, we must drop ATTN.
  1556.  */
  1558. WRITE_CONTROL (BASE_CMD | CMD_DRVR_ENABLE);
  1559. /*
  1560.  * If we are reconnecting, then we must send an IDENTIFY message in
  1561.  *      response  to MSGOUT.
  1562.  */
  1563. switch (reselect) {
  1564. case CAN_RECONNECT:
  1565. WRITE_DATA (IDENTIFY (1, lun));
  1567. DPRINTK (PHASE_RESELECT | PHASE_MSGOUT,
  1568.  "scsi%d : sent IDENTIFY message.n",
  1569.  hostno);
  1570. break;
  1571. #ifdef LINKED
  1572. case LINKED_WRONG:
  1573. WRITE_DATA (ABORT);
  1574. linked_connected = 0;
  1575. reselect = CAN_RECONNECT;
  1576. goto connect_loop;
  1577. DPRINTK (PHASE_MSGOUT | DEBUG_LINKED,
  1578.  "scsi%d : sent ABORT message to cancel incorrect I_T_L nexus.n",
  1579.  hostno);
  1580. #endif /* LINKED */
  1581. DPRINTK (DEBUG_LINKED, "correctn");
  1582. default:
  1583. WRITE_DATA (NOP);
  1584. printk
  1585.     ("scsi%d : target %d requested MSGOUT, sent NOP message.n",
  1586.      hostno, target);
  1587. }
  1588. break;
  1590. case REQ_MSGIN:
  1591. switch (message = DATA) {
  1592. case DISCONNECT:
  1593. DANY ("seagate: deciding to disconnectn");
  1594. should_reconnect = 1;
  1595. current_data = data; /* WDE add */
  1596. current_buffer = buffer;
  1597. current_bufflen = len; /* WDE add */
  1598. current_nobuffs = nobuffs;
  1599. #ifdef LINKED
  1600. linked_connected = 0;
  1601. #endif
  1602. done = 1;
  1603. DPRINTK ((PHASE_RESELECT | PHASE_MSGIN),
  1604.  "scsi%d : disconnected.n",
  1605.  hostno);
  1606. break;
  1608. #ifdef LINKED
  1609. case LINKED_CMD_COMPLETE:
  1610. case LINKED_FLG_CMD_COMPLETE:
  1611. #endif
  1612. case COMMAND_COMPLETE:
  1613. /*
  1614.  * Note : we should check for underflow here.
  1615.  */
  1616. DPRINTK (PHASE_MSGIN,
  1617.  "scsi%d : command complete.n",
  1618.  hostno);
  1619. done = 1;
  1620. break;
  1621. case ABORT:
  1622. DPRINTK (PHASE_MSGIN,
  1623.  "scsi%d : abort message.n",
  1624.  hostno);
  1625. done = 1;
  1626. break;
  1627. case SAVE_POINTERS:
  1628. current_buffer = buffer;
  1629. current_bufflen = len; /* WDE add */
  1630. current_data = data; /* WDE mod */
  1631. current_nobuffs = nobuffs;
  1632. DPRINTK (PHASE_MSGIN,
  1633.  "scsi%d : pointers saved.n",
  1634.  hostno);
  1635. break;
  1636. case RESTORE_POINTERS:
  1637. buffer = current_buffer;
  1638. cmnd = current_cmnd;
  1639. data = current_data; /* WDE mod */
  1640. len = current_bufflen;
  1641. nobuffs = current_nobuffs;
  1642. DPRINTK (PHASE_MSGIN,
  1643.  "scsi%d : pointers restored.n",
  1644.  hostno);
  1645. break;
  1646. default:
  1648. /*
  1649.  * IDENTIFY distinguishes itself from the other messages by setting the
  1650.  *      high byte. [FIXME: should not this read "the high bit"? - pavel@ucw.cz]
  1651.  *
  1652.  *      Note : we need to handle at least one outstanding command per LUN,
  1653.  *      and need to hash the SCSI command for that I_T_L nexus based on the
  1654.  *      known ID (at this point) and LUN.
  1655.  */
  1657. if (message & 0x80) {
  1658. DPRINTK (PHASE_MSGIN,
  1659.  "scsi%d : IDENTIFY message received from id %d, lun %d.n",
  1660.  hostno, target,
  1661.  message & 7);
  1662. } else {
  1664. /*
  1665.  *      We should go into a MESSAGE OUT phase, and send  a MESSAGE_REJECT
  1666.  *      if we run into a message that we don't like.  The seagate driver
  1667.  *      needs some serious restructuring first though.
  1668.  */
  1670. DPRINTK (PHASE_MSGIN,
  1671.  "scsi%d : unknown message %d from target %d.n",
  1672.  hostno, message,
  1673.  target);
  1674. }
  1675. }
  1676. break;
  1678. default:
  1679. printk ("scsi%d : unknown phase.n", hostno);
  1680. st0x_aborted = DID_ERROR;
  1681. } /* end of switch (status_read &
  1682.    REQ_MASK) */
  1684. #ifdef SLOW_RATE
  1685. /*
  1686.  * I really don't care to deal with borken devices in each single
  1687.  * byte transfer case (ie, message in, message out, status), so
  1688.  * I'll do the wait here if necessary.
  1689.  */
  1690. if (borken)
  1691. borken_wait ();
  1692. #endif
  1694. } /* if(status_read & STAT_REQ) ends */
  1695. } /* while(((status_read = STATUS)...)
  1696.    ends */
  1698. DPRINTK (PHASE_DATAIN | PHASE_DATAOUT | PHASE_EXIT,
  1699.  "scsi%d : Transfered %d bytesn", hostno, transfered);
  1701. #if (DEBUG & PHASE_EXIT)
  1702. #if 0 /* Doesn't work for scatter/gather */
  1703. printk ("Buffer : n");
  1704. for (i = 0; i < 20; ++i)
  1705. printk ("%02x  ", ((unsigned char *) data)[i]); /* WDE mod */
  1706. printk ("n");
  1707. #endif
  1708. printk ("scsi%d : status = ", hostno);
  1709. print_status (status);
  1710. printk ("message = %02xn", message);
  1711. #endif
  1713. /* We shouldn't reach this until *after* BSY has been deasserted */
  1715. #ifdef LINKED
  1716. else
  1717. {
  1718. /*
  1719.  * Fix the message byte so that unsuspecting high level drivers don't
  1720.  * puke when they see a LINKED COMMAND message in place of the COMMAND
  1721.  * COMPLETE they may be expecting.  Shouldn't be necessary, but it's
  1722.  * better to be on the safe side.
  1723.  *
  1724.  * A non LINKED* message byte will indicate that the command completed,
  1725.  * and we are now disconnected.
  1726.  */
  1728. switch (message) {
  1729. case LINKED_CMD_COMPLETE:
  1730. case LINKED_FLG_CMD_COMPLETE:
  1731. message = COMMAND_COMPLETE;
  1732. linked_target = current_target;
  1733. linked_lun = current_lun;
  1734. linked_connected = 1;
  1735. DPRINTK (DEBUG_LINKED,
  1736.  "scsi%d : keeping I_T_L nexus established"
  1737.  "for linked command.n", hostno);
  1738. /* We also will need to adjust status to accommodate intermediate
  1739.    conditions. */
  1740. if ((status == INTERMEDIATE_GOOD) ||
  1741.     (status == INTERMEDIATE_C_GOOD))
  1742. status = GOOD;
  1744. break;
  1745. /*
  1746.  * We should also handle what are "normal" termination messages
  1747.  * here (ABORT, BUS_DEVICE_RESET?, and COMMAND_COMPLETE individually,
  1748.  * and flake if things aren't right.
  1749.  */
  1750. default:
  1751. DPRINTK (DEBUG_LINKED,
  1752.  "scsi%d : closing I_T_L nexus.n", hostno);
  1753. linked_connected = 0;
  1754. }
  1755. }
  1756. #endif /* LINKED */
  1758. if (should_reconnect) {
  1759. DPRINTK (PHASE_RESELECT,
  1760.  "scsi%d : exiting seagate_st0x_queue_command()"
  1761.  "with reconnect enabled.n", hostno);
  1762. WRITE_CONTROL (BASE_CMD | CMD_INTR);
  1763. } else
  1764. WRITE_CONTROL (BASE_CMD);
  1766. return retcode (st0x_aborted);
  1767. } /* end of internal_command */
  1769. static int seagate_st0x_abort (Scsi_Cmnd * SCpnt)
  1770. {
  1771. st0x_aborted = DID_ABORT;
  1772. return SCSI_ABORT_PENDING;
  1773. }
  1775. #undef ULOOP
  1776. #undef TIMEOUT
  1778. /*
  1779.  * the seagate_st0x_reset function resets the SCSI bus 
  1780.  */
  1782. static int seagate_st0x_reset (Scsi_Cmnd * SCpnt, unsigned int reset_flags)
  1783. {
  1784. /* No timeouts - this command is going to fail because it was reset. */
  1785. DANY ("scsi%d: Reseting bus... ", hostno);
  1787. /* assert  RESET signal on SCSI bus.  */
  1788. WRITE_CONTROL (BASE_CMD | CMD_RST);
  1790. udelay (20 * 1000);
  1792. WRITE_CONTROL (BASE_CMD);
  1793. st0x_aborted = DID_RESET;
  1795. DANY ("done.n");
  1796. return SCSI_RESET_WAKEUP;
  1797. }
  1799. /* Eventually this will go into an include file, but this will be later */
  1800. static Scsi_Host_Template driver_template = SEAGATE_ST0X;
  1802. #include "scsi_module.c"