Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
initio.c
Go to the documentation of this file.
1 /**************************************************************************
2  * Initio 9100 device driver for Linux.
3  *
4  * Copyright (c) 1994-1998 Initio Corporation
5  * Copyright (c) 1998 Bas Vermeulen <[email protected]>
6  * Copyright (c) 2004 Christoph Hellwig <[email protected]>
7  * Copyright (c) 2007 Red Hat
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2, or (at your option)
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; see the file COPYING. If not, write to
21  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22  *
23  *
24  *************************************************************************
25  *
26  * DESCRIPTION:
27  *
28  * This is the Linux low-level SCSI driver for Initio INI-9X00U/UW SCSI host
29  * adapters
30  *
31  * 08/06/97 hc - v1.01h
32  * - Support inic-940 and inic-935
33  * 09/26/97 hc - v1.01i
34  * - Make correction from J.W. Schultz suggestion
35  * 10/13/97 hc - Support reset function
36  * 10/21/97 hc - v1.01j
37  * - Support 32 LUN (SCSI 3)
38  * 01/14/98 hc - v1.01k
39  * - Fix memory allocation problem
40  * 03/04/98 hc - v1.01l
41  * - Fix tape rewind which will hang the system problem
42  * - Set can_queue to initio_num_scb
43  * 06/25/98 hc - v1.01m
44  * - Get it work for kernel version >= 2.1.75
45  * - Dynamic assign SCSI bus reset holding time in initio_init()
46  * 07/02/98 hc - v1.01n
47  * - Support 0002134A
48  * 08/07/98 hc - v1.01o
49  * - Change the initio_abort_srb routine to use scsi_done. <01>
50  * 09/07/98 hl - v1.02
51  * - Change the INI9100U define and proc_dir_entry to
52  * reflect the newer Kernel 2.1.118, but the v1.o1o
53  * should work with Kernel 2.1.118.
54  * 09/20/98 wh - v1.02a
55  * - Support Abort command.
56  * - Handle reset routine.
57  * 09/21/98 hl - v1.03
58  * - remove comments.
59  * 12/09/98 bv - v1.03a
60  * - Removed unused code
61  * 12/13/98 bv - v1.03b
62  * - Remove cli() locking for kernels >= 2.1.95. This uses
63  * spinlocks to serialize access to the pSRB_head and
64  * pSRB_tail members of the HCS structure.
65  * 09/01/99 bv - v1.03d
66  * - Fixed a deadlock problem in SMP.
67  * 21/01/99 bv - v1.03e
68  * - Add support for the Domex 3192U PCI SCSI
69  * This is a slightly modified patch by
70  * Brian Macy <[email protected]>
71  * 22/02/99 bv - v1.03f
72  * - Didn't detect the INIC-950 in 2.0.x correctly.
73  * Now fixed.
74  * 05/07/99 bv - v1.03g
75  * - Changed the assumption that HZ = 100
76  * 10/17/03 mc - v1.04
77  * - added new DMA API support
78  * 06/01/04 jmd - v1.04a
79  * - Re-add reset_bus support
80  **************************************************************************/
81 
82 #include <linux/module.h>
83 #include <linux/errno.h>
84 #include <linux/delay.h>
85 #include <linux/pci.h>
86 #include <linux/init.h>
87 #include <linux/blkdev.h>
88 #include <linux/spinlock.h>
89 #include <linux/stat.h>
90 #include <linux/kernel.h>
91 #include <linux/proc_fs.h>
92 #include <linux/string.h>
93 #include <linux/interrupt.h>
94 #include <linux/ioport.h>
95 #include <linux/slab.h>
96 #include <linux/jiffies.h>
97 #include <linux/dma-mapping.h>
98 #include <asm/io.h>
99 
100 #include <scsi/scsi.h>
101 #include <scsi/scsi_cmnd.h>
102 #include <scsi/scsi_device.h>
103 #include <scsi/scsi_host.h>
104 #include <scsi/scsi_tcq.h>
105 
106 #include "initio.h"
107 
108 #define SENSE_SIZE 14
109 
110 #define i91u_MAXQUEUE 2
111 #define i91u_REVID "Initio INI-9X00U/UW SCSI device driver; Revision: 1.04a"
112 
113 #define I950_DEVICE_ID 0x9500 /* Initio's inic-950 product ID */
114 #define I940_DEVICE_ID 0x9400 /* Initio's inic-940 product ID */
115 #define I935_DEVICE_ID 0x9401 /* Initio's inic-935 product ID */
116 #define I920_DEVICE_ID 0x0002 /* Initio's other product ID */
117 
118 #ifdef DEBUG_i91u
119 static unsigned int i91u_debug = DEBUG_DEFAULT;
120 #endif
121 
122 static int initio_tag_enable = 1;
123 
124 #ifdef DEBUG_i91u
125 static int setup_debug = 0;
126 #endif
127 
128 static void i91uSCBPost(u8 * pHcb, u8 * pScb);
129 
130 /* PCI Devices supported by this driver */
131 static struct pci_device_id i91u_pci_devices[] = {
132  { PCI_VENDOR_ID_INIT, I950_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
133  { PCI_VENDOR_ID_INIT, I940_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
134  { PCI_VENDOR_ID_INIT, I935_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
135  { PCI_VENDOR_ID_INIT, I920_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
136  { PCI_VENDOR_ID_DOMEX, I920_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
137  { }
138 };
139 MODULE_DEVICE_TABLE(pci, i91u_pci_devices);
140 
141 #define DEBUG_INTERRUPT 0
142 #define DEBUG_QUEUE 0
143 #define DEBUG_STATE 0
144 #define INT_DISC 0
145 
146 /*--- forward references ---*/
147 static struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun);
148 static struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host);
149 
150 static int tulip_main(struct initio_host * host);
151 
152 static int initio_next_state(struct initio_host * host);
153 static int initio_state_1(struct initio_host * host);
154 static int initio_state_2(struct initio_host * host);
155 static int initio_state_3(struct initio_host * host);
156 static int initio_state_4(struct initio_host * host);
157 static int initio_state_5(struct initio_host * host);
158 static int initio_state_6(struct initio_host * host);
159 static int initio_state_7(struct initio_host * host);
160 static int initio_xfer_data_in(struct initio_host * host);
161 static int initio_xfer_data_out(struct initio_host * host);
162 static int initio_xpad_in(struct initio_host * host);
163 static int initio_xpad_out(struct initio_host * host);
164 static int initio_status_msg(struct initio_host * host);
165 
166 static int initio_msgin(struct initio_host * host);
167 static int initio_msgin_sync(struct initio_host * host);
168 static int initio_msgin_accept(struct initio_host * host);
169 static int initio_msgout_reject(struct initio_host * host);
170 static int initio_msgin_extend(struct initio_host * host);
171 
172 static int initio_msgout_ide(struct initio_host * host);
173 static int initio_msgout_abort_targ(struct initio_host * host);
174 static int initio_msgout_abort_tag(struct initio_host * host);
175 
176 static int initio_bus_device_reset(struct initio_host * host);
177 static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb);
178 static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb);
179 static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb);
180 static int int_initio_busfree(struct initio_host * host);
181 static int int_initio_scsi_rst(struct initio_host * host);
182 static int int_initio_bad_seq(struct initio_host * host);
183 static int int_initio_resel(struct initio_host * host);
184 static int initio_sync_done(struct initio_host * host);
185 static int wdtr_done(struct initio_host * host);
186 static int wait_tulip(struct initio_host * host);
187 static int initio_wait_done_disc(struct initio_host * host);
188 static int initio_wait_disc(struct initio_host * host);
189 static void tulip_scsi(struct initio_host * host);
190 static int initio_post_scsi_rst(struct initio_host * host);
191 
192 static void initio_se2_ew_en(unsigned long base);
193 static void initio_se2_ew_ds(unsigned long base);
194 static int initio_se2_rd_all(unsigned long base);
195 static void initio_se2_update_all(unsigned long base); /* setup default pattern */
196 static void initio_read_eeprom(unsigned long base);
197 
198 /* ---- INTERNAL VARIABLES ---- */
199 
200 static NVRAM i91unvram;
201 static NVRAM *i91unvramp;
202 
203 static u8 i91udftNvRam[64] =
204 {
205  /*----------- header -----------*/
206  0x25, 0xc9, /* Signature */
207  0x40, /* Size */
208  0x01, /* Revision */
209  /* -- Host Adapter Structure -- */
210  0x95, /* ModelByte0 */
211  0x00, /* ModelByte1 */
212  0x00, /* ModelInfo */
213  0x01, /* NumOfCh */
214  NBC1_DEFAULT, /* BIOSConfig1 */
215  0, /* BIOSConfig2 */
216  0, /* HAConfig1 */
217  0, /* HAConfig2 */
218  /* SCSI channel 0 and target Structure */
219  7, /* SCSIid */
220  NCC1_DEFAULT, /* SCSIconfig1 */
221  0, /* SCSIconfig2 */
222  0x10, /* NumSCSItarget */
223 
224  NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
225  NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
226  NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
227  NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
228 
229  /* SCSI channel 1 and target Structure */
230  7, /* SCSIid */
231  NCC1_DEFAULT, /* SCSIconfig1 */
232  0, /* SCSIconfig2 */
233  0x10, /* NumSCSItarget */
234 
235  NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
236  NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
237  NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
238  NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT, NTC_DEFAULT,
239  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
240  0, 0}; /* - CheckSum - */
241 
242 
243 static u8 initio_rate_tbl[8] = /* fast 20 */
244 {
245  /* nanosecond divide by 4 */
246  12, /* 50ns, 20M */
247  18, /* 75ns, 13.3M */
248  25, /* 100ns, 10M */
249  31, /* 125ns, 8M */
250  37, /* 150ns, 6.6M */
251  43, /* 175ns, 5.7M */
252  50, /* 200ns, 5M */
253  62 /* 250ns, 4M */
254 };
255 
256 static void initio_do_pause(unsigned amount)
257 {
258  /* Pause for amount jiffies */
259  unsigned long the_time = jiffies + amount;
260 
261  while (time_before_eq(jiffies, the_time))
262  cpu_relax();
263 }
264 
265 /*-- forward reference --*/
266 
267 /******************************************************************
268  Input: instruction for Serial E2PROM
269 
270  EX: se2_rd(0 call se2_instr() to send address and read command
271 
272  StartBit OP_Code Address Data
273  --------- -------- ------------------ -------
274  1 1 , 0 A5,A4,A3,A2,A1,A0 D15-D0
275 
276  +-----------------------------------------------------
277  |
278  CS -----+
279  +--+ +--+ +--+ +--+ +--+
280  ^ | ^ | ^ | ^ | ^ |
281  | | | | | | | | | |
282  CLK -------+ +--+ +--+ +--+ +--+ +--
283  (leading edge trigger)
284 
285  +--1-----1--+
286  | SB OP | OP A5 A4
287  DI ----+ +--0------------------
288  (address and cmd sent to nvram)
289 
290  -------------------------------------------+
291  |
292  DO +---
293  (data sent from nvram)
294 
295 
296 ******************************************************************/
297 
306 static void initio_se2_instr(unsigned long base, u8 instr)
307 {
308  int i;
309  u8 b;
310 
311  outb(SE2CS | SE2DO, base + TUL_NVRAM); /* cs+start bit */
312  udelay(30);
313  outb(SE2CS | SE2CLK | SE2DO, base + TUL_NVRAM); /* +CLK */
314  udelay(30);
315 
316  for (i = 0; i < 8; i++) {
317  if (instr & 0x80)
318  b = SE2CS | SE2DO; /* -CLK+dataBit */
319  else
320  b = SE2CS; /* -CLK */
321  outb(b, base + TUL_NVRAM);
322  udelay(30);
323  outb(b | SE2CLK, base + TUL_NVRAM); /* +CLK */
324  udelay(30);
325  instr <<= 1;
326  }
327  outb(SE2CS, base + TUL_NVRAM); /* -CLK */
328  udelay(30);
329 }
330 
331 
338 void initio_se2_ew_en(unsigned long base)
339 {
340  initio_se2_instr(base, 0x30); /* EWEN */
341  outb(0, base + TUL_NVRAM); /* -CS */
342  udelay(30);
343 }
344 
345 
352 void initio_se2_ew_ds(unsigned long base)
353 {
354  initio_se2_instr(base, 0); /* EWDS */
355  outb(0, base + TUL_NVRAM); /* -CS */
356  udelay(30);
357 }
358 
359 
367 static u16 initio_se2_rd(unsigned long base, u8 addr)
368 {
369  u8 instr, rb;
370  u16 val = 0;
371  int i;
372 
373  instr = (u8) (addr | 0x80);
374  initio_se2_instr(base, instr); /* READ INSTR */
375 
376  for (i = 15; i >= 0; i--) {
377  outb(SE2CS | SE2CLK, base + TUL_NVRAM); /* +CLK */
378  udelay(30);
379  outb(SE2CS, base + TUL_NVRAM); /* -CLK */
380 
381  /* sample data after the following edge of clock */
382  rb = inb(base + TUL_NVRAM);
383  rb &= SE2DI;
384  val += (rb << i);
385  udelay(30); /* 6/20/95 */
386  }
387 
388  outb(0, base + TUL_NVRAM); /* no chip select */
389  udelay(30);
390  return val;
391 }
392 
402 static void initio_se2_wr(unsigned long base, u8 addr, u16 val)
403 {
404  u8 rb;
405  u8 instr;
406  int i;
407 
408  instr = (u8) (addr | 0x40);
409  initio_se2_instr(base, instr); /* WRITE INSTR */
410  for (i = 15; i >= 0; i--) {
411  if (val & 0x8000)
412  outb(SE2CS | SE2DO, base + TUL_NVRAM); /* -CLK+dataBit 1 */
413  else
414  outb(SE2CS, base + TUL_NVRAM); /* -CLK+dataBit 0 */
415  udelay(30);
416  outb(SE2CS | SE2CLK, base + TUL_NVRAM); /* +CLK */
417  udelay(30);
418  val <<= 1;
419  }
420  outb(SE2CS, base + TUL_NVRAM); /* -CLK */
421  udelay(30);
422  outb(0, base + TUL_NVRAM); /* -CS */
423  udelay(30);
424 
425  outb(SE2CS, base + TUL_NVRAM); /* +CS */
426  udelay(30);
427 
428  for (;;) {
429  outb(SE2CS | SE2CLK, base + TUL_NVRAM); /* +CLK */
430  udelay(30);
431  outb(SE2CS, base + TUL_NVRAM); /* -CLK */
432  udelay(30);
433  if ((rb = inb(base + TUL_NVRAM)) & SE2DI)
434  break; /* write complete */
435  }
436  outb(0, base + TUL_NVRAM); /* -CS */
437 }
438 
447 static int initio_se2_rd_all(unsigned long base)
448 {
449  int i;
450  u16 chksum = 0;
451  u16 *np;
452 
453  i91unvramp = &i91unvram;
454  np = (u16 *) i91unvramp;
455  for (i = 0; i < 32; i++)
456  *np++ = initio_se2_rd(base, i);
457 
458  /* Is signature "ini" ok ? */
459  if (i91unvramp->NVM_Signature != INI_SIGNATURE)
460  return -1;
461  /* Is ckecksum ok ? */
462  np = (u16 *) i91unvramp;
463  for (i = 0; i < 31; i++)
464  chksum += *np++;
465  if (i91unvramp->NVM_CheckSum != chksum)
466  return -1;
467  return 1;
468 }
469 
477 static void initio_se2_update_all(unsigned long base)
478 { /* setup default pattern */
479  int i;
480  u16 chksum = 0;
481  u16 *np, *np1;
482 
483  i91unvramp = &i91unvram;
484  /* Calculate checksum first */
485  np = (u16 *) i91udftNvRam;
486  for (i = 0; i < 31; i++)
487  chksum += *np++;
488  *np = chksum;
489  initio_se2_ew_en(base); /* Enable write */
490 
491  np = (u16 *) i91udftNvRam;
492  np1 = (u16 *) i91unvramp;
493  for (i = 0; i < 32; i++, np++, np1++) {
494  if (*np != *np1)
495  initio_se2_wr(base, i, *np);
496  }
497  initio_se2_ew_ds(base); /* Disable write */
498 }
499 
513 static void initio_read_eeprom(unsigned long base)
514 {
515  u8 gctrl;
516 
517  i91unvramp = &i91unvram;
518  /* Enable EEProm programming */
519  gctrl = inb(base + TUL_GCTRL);
520  outb(gctrl | TUL_GCTRL_EEPROM_BIT, base + TUL_GCTRL);
521  if (initio_se2_rd_all(base) != 1) {
522  initio_se2_update_all(base); /* setup default pattern */
523  initio_se2_rd_all(base); /* load again */
524  }
525  /* Disable EEProm programming */
526  gctrl = inb(base + TUL_GCTRL);
527  outb(gctrl & ~TUL_GCTRL_EEPROM_BIT, base + TUL_GCTRL);
528 }
529 
537 static void initio_stop_bm(struct initio_host * host)
538 {
539 
540  if (inb(host->addr + TUL_XStatus) & XPEND) { /* if DMA xfer is pending, abort DMA xfer */
541  outb(TAX_X_ABT | TAX_X_CLR_FIFO, host->addr + TUL_XCmd);
542  /* wait Abort DMA xfer done */
543  while ((inb(host->addr + TUL_Int) & XABT) == 0)
544  cpu_relax();
545  }
546  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
547 }
548 
557 static int initio_reset_scsi(struct initio_host * host, int seconds)
558 {
559  outb(TSC_RST_BUS, host->addr + TUL_SCtrl0);
560 
561  while (!((host->jsint = inb(host->addr + TUL_SInt)) & TSS_SCSIRST_INT))
562  cpu_relax();
563 
564  /* reset tulip chip */
565  outb(0, host->addr + TUL_SSignal);
566 
567  /* Stall for a while, wait for target's firmware ready,make it 2 sec ! */
568  /* SONY 5200 tape drive won't work if only stall for 1 sec */
569  /* FIXME: this is a very long busy wait right now */
570  initio_do_pause(seconds * HZ);
571 
572  inb(host->addr + TUL_SInt);
573  return SCSI_RESET_SUCCESS;
574 }
575 
589 static void initio_init(struct initio_host * host, u8 *bios_addr)
590 {
591  int i;
592  u8 *flags;
593  u8 *heads;
594 
595  /* Get E2Prom configuration */
596  initio_read_eeprom(host->addr);
597  if (i91unvramp->NVM_SCSIInfo[0].NVM_NumOfTarg == 8)
598  host->max_tar = 8;
599  else
600  host->max_tar = 16;
601 
602  host->config = i91unvramp->NVM_SCSIInfo[0].NVM_ChConfig1;
603 
604  host->scsi_id = i91unvramp->NVM_SCSIInfo[0].NVM_ChSCSIID;
605  host->idmask = ~(1 << host->scsi_id);
606 
607 #ifdef CHK_PARITY
608  /* Enable parity error response */
609  outb(inb(host->addr + TUL_PCMD) | 0x40, host->addr + TUL_PCMD);
610 #endif
611 
612  /* Mask all the interrupt */
613  outb(0x1F, host->addr + TUL_Mask);
614 
615  initio_stop_bm(host);
616  /* --- Initialize the tulip --- */
617  outb(TSC_RST_CHIP, host->addr + TUL_SCtrl0);
618 
619  /* program HBA's SCSI ID */
620  outb(host->scsi_id << 4, host->addr + TUL_SScsiId);
621 
622  /* Enable Initiator Mode ,phase latch,alternate sync period mode,
623  disable SCSI reset */
624  if (host->config & HCC_EN_PAR)
625  host->sconf1 = (TSC_INITDEFAULT | TSC_EN_SCSI_PAR);
626  else
627  host->sconf1 = (TSC_INITDEFAULT);
628  outb(host->sconf1, host->addr + TUL_SConfig);
629 
630  /* Enable HW reselect */
631  outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
632 
633  outb(0, host->addr + TUL_SPeriod);
634 
635  /* selection time out = 250 ms */
636  outb(153, host->addr + TUL_STimeOut);
637 
638  /* Enable SCSI terminator */
639  outb((host->config & (HCC_ACT_TERM1 | HCC_ACT_TERM2)),
640  host->addr + TUL_XCtrl);
641  outb(((host->config & HCC_AUTO_TERM) >> 4) |
642  (inb(host->addr + TUL_GCTRL1) & 0xFE),
643  host->addr + TUL_GCTRL1);
644 
645  for (i = 0,
646  flags = & (i91unvramp->NVM_SCSIInfo[0].NVM_Targ0Config),
647  heads = bios_addr + 0x180;
648  i < host->max_tar;
649  i++, flags++) {
650  host->targets[i].flags = *flags & ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
651  if (host->targets[i].flags & TCF_EN_255)
652  host->targets[i].drv_flags = TCF_DRV_255_63;
653  else
654  host->targets[i].drv_flags = 0;
655  host->targets[i].js_period = 0;
656  host->targets[i].sconfig0 = host->sconf1;
657  host->targets[i].heads = *heads++;
658  if (host->targets[i].heads == 255)
659  host->targets[i].drv_flags = TCF_DRV_255_63;
660  else
661  host->targets[i].drv_flags = 0;
662  host->targets[i].sectors = *heads++;
663  host->targets[i].flags &= ~TCF_BUSY;
664  host->act_tags[i] = 0;
665  host->max_tags[i] = 0xFF;
666  } /* for */
667  printk("i91u: PCI Base=0x%04X, IRQ=%d, BIOS=0x%04X0, SCSI ID=%d\n",
668  host->addr, host->pci_dev->irq,
669  host->bios_addr, host->scsi_id);
670  /* Reset SCSI Bus */
671  if (host->config & HCC_SCSI_RESET) {
672  printk(KERN_INFO "i91u: Reset SCSI Bus ... \n");
673  initio_reset_scsi(host, 10);
674  }
675  outb(0x17, host->addr + TUL_SCFG1);
676  outb(0xE9, host->addr + TUL_SIntEnable);
677 }
678 
686 static struct scsi_ctrl_blk *initio_alloc_scb(struct initio_host *host)
687 {
688  struct scsi_ctrl_blk *scb;
689  unsigned long flags;
690 
691  spin_lock_irqsave(&host->avail_lock, flags);
692  if ((scb = host->first_avail) != NULL) {
693 #if DEBUG_QUEUE
694  printk("find scb at %p\n", scb);
695 #endif
696  if ((host->first_avail = scb->next) == NULL)
697  host->last_avail = NULL;
698  scb->next = NULL;
699  scb->status = SCB_RENT;
700  }
701  spin_unlock_irqrestore(&host->avail_lock, flags);
702  return scb;
703 }
704 
713 static void initio_release_scb(struct initio_host * host, struct scsi_ctrl_blk * cmnd)
714 {
715  unsigned long flags;
716 
717 #if DEBUG_QUEUE
718  printk("Release SCB %p; ", cmnd);
719 #endif
720  spin_lock_irqsave(&(host->avail_lock), flags);
721  cmnd->srb = NULL;
722  cmnd->status = 0;
723  cmnd->next = NULL;
724  if (host->last_avail != NULL) {
725  host->last_avail->next = cmnd;
726  host->last_avail = cmnd;
727  } else {
728  host->first_avail = cmnd;
729  host->last_avail = cmnd;
730  }
731  spin_unlock_irqrestore(&(host->avail_lock), flags);
732 }
733 
734 /***************************************************************************/
735 static void initio_append_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
736 {
737 
738 #if DEBUG_QUEUE
739  printk("Append pend SCB %p; ", scbp);
740 #endif
741  scbp->status = SCB_PEND;
742  scbp->next = NULL;
743  if (host->last_pending != NULL) {
744  host->last_pending->next = scbp;
745  host->last_pending = scbp;
746  } else {
747  host->first_pending = scbp;
748  host->last_pending = scbp;
749  }
750 }
751 
752 /***************************************************************************/
753 static void initio_push_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
754 {
755 
756 #if DEBUG_QUEUE
757  printk("Push pend SCB %p; ", scbp);
758 #endif
759  scbp->status = SCB_PEND;
760  if ((scbp->next = host->first_pending) != NULL) {
761  host->first_pending = scbp;
762  } else {
763  host->first_pending = scbp;
764  host->last_pending = scbp;
765  }
766 }
767 
768 static struct scsi_ctrl_blk *initio_find_first_pend_scb(struct initio_host * host)
769 {
770  struct scsi_ctrl_blk *first;
771 
772 
773  first = host->first_pending;
774  while (first != NULL) {
775  if (first->opcode != ExecSCSI)
776  return first;
777  if (first->tagmsg == 0) {
778  if ((host->act_tags[first->target] == 0) &&
779  !(host->targets[first->target].flags & TCF_BUSY))
780  return first;
781  } else {
782  if ((host->act_tags[first->target] >=
783  host->max_tags[first->target]) |
784  (host->targets[first->target].flags & TCF_BUSY)) {
785  first = first->next;
786  continue;
787  }
788  return first;
789  }
790  first = first->next;
791  }
792  return first;
793 }
794 
795 static void initio_unlink_pend_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
796 {
797  struct scsi_ctrl_blk *tmp, *prev;
798 
799 #if DEBUG_QUEUE
800  printk("unlink pend SCB %p; ", scb);
801 #endif
802 
803  prev = tmp = host->first_pending;
804  while (tmp != NULL) {
805  if (scb == tmp) { /* Unlink this SCB */
806  if (tmp == host->first_pending) {
807  if ((host->first_pending = tmp->next) == NULL)
808  host->last_pending = NULL;
809  } else {
810  prev->next = tmp->next;
811  if (tmp == host->last_pending)
812  host->last_pending = prev;
813  }
814  tmp->next = NULL;
815  break;
816  }
817  prev = tmp;
818  tmp = tmp->next;
819  }
820 }
821 
822 static void initio_append_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
823 {
824 
825 #if DEBUG_QUEUE
826  printk("append busy SCB %p; ", scbp);
827 #endif
828  if (scbp->tagmsg)
829  host->act_tags[scbp->target]++;
830  else
831  host->targets[scbp->target].flags |= TCF_BUSY;
832  scbp->status = SCB_BUSY;
833  scbp->next = NULL;
834  if (host->last_busy != NULL) {
835  host->last_busy->next = scbp;
836  host->last_busy = scbp;
837  } else {
838  host->first_busy = scbp;
839  host->last_busy = scbp;
840  }
841 }
842 
843 /***************************************************************************/
844 static struct scsi_ctrl_blk *initio_pop_busy_scb(struct initio_host * host)
845 {
846  struct scsi_ctrl_blk *tmp;
847 
848 
849  if ((tmp = host->first_busy) != NULL) {
850  if ((host->first_busy = tmp->next) == NULL)
851  host->last_busy = NULL;
852  tmp->next = NULL;
853  if (tmp->tagmsg)
854  host->act_tags[tmp->target]--;
855  else
856  host->targets[tmp->target].flags &= ~TCF_BUSY;
857  }
858 #if DEBUG_QUEUE
859  printk("Pop busy SCB %p; ", tmp);
860 #endif
861  return tmp;
862 }
863 
864 /***************************************************************************/
865 static void initio_unlink_busy_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
866 {
867  struct scsi_ctrl_blk *tmp, *prev;
868 
869 #if DEBUG_QUEUE
870  printk("unlink busy SCB %p; ", scb);
871 #endif
872 
873  prev = tmp = host->first_busy;
874  while (tmp != NULL) {
875  if (scb == tmp) { /* Unlink this SCB */
876  if (tmp == host->first_busy) {
877  if ((host->first_busy = tmp->next) == NULL)
878  host->last_busy = NULL;
879  } else {
880  prev->next = tmp->next;
881  if (tmp == host->last_busy)
882  host->last_busy = prev;
883  }
884  tmp->next = NULL;
885  if (tmp->tagmsg)
886  host->act_tags[tmp->target]--;
887  else
888  host->targets[tmp->target].flags &= ~TCF_BUSY;
889  break;
890  }
891  prev = tmp;
892  tmp = tmp->next;
893  }
894  return;
895 }
896 
897 struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun)
898 {
899  struct scsi_ctrl_blk *tmp, *prev;
900  u16 scbp_tarlun;
901 
902 
903  prev = tmp = host->first_busy;
904  while (tmp != NULL) {
905  scbp_tarlun = (tmp->lun << 8) | (tmp->target);
906  if (scbp_tarlun == tarlun) { /* Unlink this SCB */
907  break;
908  }
909  prev = tmp;
910  tmp = tmp->next;
911  }
912 #if DEBUG_QUEUE
913  printk("find busy SCB %p; ", tmp);
914 #endif
915  return tmp;
916 }
917 
918 static void initio_append_done_scb(struct initio_host * host, struct scsi_ctrl_blk * scbp)
919 {
920 #if DEBUG_QUEUE
921  printk("append done SCB %p; ", scbp);
922 #endif
923 
924  scbp->status = SCB_DONE;
925  scbp->next = NULL;
926  if (host->last_done != NULL) {
927  host->last_done->next = scbp;
928  host->last_done = scbp;
929  } else {
930  host->first_done = scbp;
931  host->last_done = scbp;
932  }
933 }
934 
935 struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host)
936 {
937  struct scsi_ctrl_blk *tmp;
938 
939  if ((tmp = host->first_done) != NULL) {
940  if ((host->first_done = tmp->next) == NULL)
941  host->last_done = NULL;
942  tmp->next = NULL;
943  }
944 #if DEBUG_QUEUE
945  printk("find done SCB %p; ",tmp);
946 #endif
947  return tmp;
948 }
949 
950 static int initio_abort_srb(struct initio_host * host, struct scsi_cmnd *srbp)
951 {
952  unsigned long flags;
953  struct scsi_ctrl_blk *tmp, *prev;
954 
955  spin_lock_irqsave(&host->semaph_lock, flags);
956 
957  if ((host->semaph == 0) && (host->active == NULL)) {
958  /* disable Jasmin SCSI Int */
959  outb(0x1F, host->addr + TUL_Mask);
960  spin_unlock_irqrestore(&host->semaph_lock, flags);
961  /* FIXME: synchronize_irq needed ? */
962  tulip_main(host);
963  spin_lock_irqsave(&host->semaph_lock, flags);
964  host->semaph = 1;
965  outb(0x0F, host->addr + TUL_Mask);
966  spin_unlock_irqrestore(&host->semaph_lock, flags);
967  return SCSI_ABORT_SNOOZE;
968  }
969  prev = tmp = host->first_pending; /* Check Pend queue */
970  while (tmp != NULL) {
971  /* 07/27/98 */
972  if (tmp->srb == srbp) {
973  if (tmp == host->active) {
974  spin_unlock_irqrestore(&host->semaph_lock, flags);
975  return SCSI_ABORT_BUSY;
976  } else if (tmp == host->first_pending) {
977  if ((host->first_pending = tmp->next) == NULL)
978  host->last_pending = NULL;
979  } else {
980  prev->next = tmp->next;
981  if (tmp == host->last_pending)
982  host->last_pending = prev;
983  }
984  tmp->hastat = HOST_ABORTED;
985  tmp->flags |= SCF_DONE;
986  if (tmp->flags & SCF_POST)
987  (*tmp->post) ((u8 *) host, (u8 *) tmp);
988  spin_unlock_irqrestore(&host->semaph_lock, flags);
989  return SCSI_ABORT_SUCCESS;
990  }
991  prev = tmp;
992  tmp = tmp->next;
993  }
994 
995  prev = tmp = host->first_busy; /* Check Busy queue */
996  while (tmp != NULL) {
997  if (tmp->srb == srbp) {
998  if (tmp == host->active) {
999  spin_unlock_irqrestore(&host->semaph_lock, flags);
1000  return SCSI_ABORT_BUSY;
1001  } else if (tmp->tagmsg == 0) {
1002  spin_unlock_irqrestore(&host->semaph_lock, flags);
1003  return SCSI_ABORT_BUSY;
1004  } else {
1005  host->act_tags[tmp->target]--;
1006  if (tmp == host->first_busy) {
1007  if ((host->first_busy = tmp->next) == NULL)
1008  host->last_busy = NULL;
1009  } else {
1010  prev->next = tmp->next;
1011  if (tmp == host->last_busy)
1012  host->last_busy = prev;
1013  }
1014  tmp->next = NULL;
1015 
1016 
1017  tmp->hastat = HOST_ABORTED;
1018  tmp->flags |= SCF_DONE;
1019  if (tmp->flags & SCF_POST)
1020  (*tmp->post) ((u8 *) host, (u8 *) tmp);
1021  spin_unlock_irqrestore(&host->semaph_lock, flags);
1022  return SCSI_ABORT_SUCCESS;
1023  }
1024  }
1025  prev = tmp;
1026  tmp = tmp->next;
1027  }
1028  spin_unlock_irqrestore(&host->semaph_lock, flags);
1029  return SCSI_ABORT_NOT_RUNNING;
1030 }
1031 
1032 /***************************************************************************/
1033 static int initio_bad_seq(struct initio_host * host)
1034 {
1035  struct scsi_ctrl_blk *scb;
1036 
1037  printk("initio_bad_seg c=%d\n", host->index);
1038 
1039  if ((scb = host->active) != NULL) {
1040  initio_unlink_busy_scb(host, scb);
1041  scb->hastat = HOST_BAD_PHAS;
1042  scb->tastat = 0;
1043  initio_append_done_scb(host, scb);
1044  }
1045  initio_stop_bm(host);
1046  initio_reset_scsi(host, 8); /* 7/29/98 */
1047  return initio_post_scsi_rst(host);
1048 }
1049 
1050 
1051 /************************************************************************/
1052 static void initio_exec_scb(struct initio_host * host, struct scsi_ctrl_blk * scb)
1053 {
1054  unsigned long flags;
1055 
1056  scb->mode = 0;
1057 
1058  scb->sgidx = 0;
1059  scb->sgmax = scb->sglen;
1060 
1061  spin_lock_irqsave(&host->semaph_lock, flags);
1062 
1063  initio_append_pend_scb(host, scb); /* Append this SCB to Pending queue */
1064 
1065 /* VVVVV 07/21/98 */
1066  if (host->semaph == 1) {
1067  /* Disable Jasmin SCSI Int */
1068  outb(0x1F, host->addr + TUL_Mask);
1069  host->semaph = 0;
1070  spin_unlock_irqrestore(&host->semaph_lock, flags);
1071 
1072  tulip_main(host);
1073 
1074  spin_lock_irqsave(&host->semaph_lock, flags);
1075  host->semaph = 1;
1076  outb(0x0F, host->addr + TUL_Mask);
1077  }
1078  spin_unlock_irqrestore(&host->semaph_lock, flags);
1079  return;
1080 }
1081 
1082 /***************************************************************************/
1083 static int initio_isr(struct initio_host * host)
1084 {
1085  if (inb(host->addr + TUL_Int) & TSS_INT_PENDING) {
1086  if (host->semaph == 1) {
1087  outb(0x1F, host->addr + TUL_Mask);
1088  /* Disable Tulip SCSI Int */
1089  host->semaph = 0;
1090 
1091  tulip_main(host);
1092 
1093  host->semaph = 1;
1094  outb(0x0F, host->addr + TUL_Mask);
1095  return 1;
1096  }
1097  }
1098  return 0;
1099 }
1100 
1101 static int tulip_main(struct initio_host * host)
1102 {
1103  struct scsi_ctrl_blk *scb;
1104 
1105  for (;;) {
1106  tulip_scsi(host); /* Call tulip_scsi */
1107 
1108  /* Walk the list of completed SCBs */
1109  while ((scb = initio_find_done_scb(host)) != NULL) { /* find done entry */
1110  if (scb->tastat == INI_QUEUE_FULL) {
1111  host->max_tags[scb->target] =
1112  host->act_tags[scb->target] - 1;
1113  scb->tastat = 0;
1114  initio_append_pend_scb(host, scb);
1115  continue;
1116  }
1117  if (!(scb->mode & SCM_RSENS)) { /* not in auto req. sense mode */
1118  if (scb->tastat == 2) {
1119 
1120  /* clr sync. nego flag */
1121 
1122  if (scb->flags & SCF_SENSE) {
1123  u8 len;
1124  len = scb->senselen;
1125  if (len == 0)
1126  len = 1;
1127  scb->buflen = scb->senselen;
1128  scb->bufptr = scb->senseptr;
1129  scb->flags &= ~(SCF_SG | SCF_DIR); /* for xfer_data_in */
1130  /* so, we won't report wrong direction in xfer_data_in,
1131  and won't report HOST_DO_DU in state_6 */
1132  scb->mode = SCM_RSENS;
1133  scb->ident &= 0xBF; /* Disable Disconnect */
1134  scb->tagmsg = 0;
1135  scb->tastat = 0;
1136  scb->cdblen = 6;
1137  scb->cdb[0] = SCSICMD_RequestSense;
1138  scb->cdb[1] = 0;
1139  scb->cdb[2] = 0;
1140  scb->cdb[3] = 0;
1141  scb->cdb[4] = len;
1142  scb->cdb[5] = 0;
1143  initio_push_pend_scb(host, scb);
1144  break;
1145  }
1146  }
1147  } else { /* in request sense mode */
1148 
1149  if (scb->tastat == 2) { /* check contition status again after sending
1150  requset sense cmd 0x3 */
1151  scb->hastat = HOST_BAD_PHAS;
1152  }
1153  scb->tastat = 2;
1154  }
1155  scb->flags |= SCF_DONE;
1156  if (scb->flags & SCF_POST) {
1157  /* FIXME: only one post method and lose casts */
1158  (*scb->post) ((u8 *) host, (u8 *) scb);
1159  }
1160  } /* while */
1161  /* find_active: */
1162  if (inb(host->addr + TUL_SStatus0) & TSS_INT_PENDING)
1163  continue;
1164  if (host->active) /* return to OS and wait for xfer_done_ISR/Selected_ISR */
1165  return 1; /* return to OS, enable interrupt */
1166  /* Check pending SCB */
1167  if (initio_find_first_pend_scb(host) == NULL)
1168  return 1; /* return to OS, enable interrupt */
1169  } /* End of for loop */
1170  /* statement won't reach here */
1171 }
1172 
1173 static void tulip_scsi(struct initio_host * host)
1174 {
1175  struct scsi_ctrl_blk *scb;
1176  struct target_control *active_tc;
1177 
1178  /* make sure to service interrupt asap */
1179  if ((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) & TSS_INT_PENDING) {
1180  host->phase = host->jsstatus0 & TSS_PH_MASK;
1181  host->jsstatus1 = inb(host->addr + TUL_SStatus1);
1182  host->jsint = inb(host->addr + TUL_SInt);
1183  if (host->jsint & TSS_SCSIRST_INT) { /* SCSI bus reset detected */
1184  int_initio_scsi_rst(host);
1185  return;
1186  }
1187  if (host->jsint & TSS_RESEL_INT) { /* if selected/reselected interrupt */
1188  if (int_initio_resel(host) == 0)
1189  initio_next_state(host);
1190  return;
1191  }
1192  if (host->jsint & TSS_SEL_TIMEOUT) {
1193  int_initio_busfree(host);
1194  return;
1195  }
1196  if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */
1197  int_initio_busfree(host); /* unexpected bus free or sel timeout */
1198  return;
1199  }
1200  if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV)) { /* func complete or Bus service */
1201  if ((scb = host->active) != NULL)
1202  initio_next_state(host);
1203  return;
1204  }
1205  }
1206  if (host->active != NULL)
1207  return;
1208 
1209  if ((scb = initio_find_first_pend_scb(host)) == NULL)
1210  return;
1211 
1212  /* program HBA's SCSI ID & target SCSI ID */
1213  outb((host->scsi_id << 4) | (scb->target & 0x0F),
1214  host->addr + TUL_SScsiId);
1215  if (scb->opcode == ExecSCSI) {
1216  active_tc = &host->targets[scb->target];
1217 
1218  if (scb->tagmsg)
1219  active_tc->drv_flags |= TCF_DRV_EN_TAG;
1220  else
1221  active_tc->drv_flags &= ~TCF_DRV_EN_TAG;
1222 
1223  outb(active_tc->js_period, host->addr + TUL_SPeriod);
1224  if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) { /* do wdtr negotiation */
1225  initio_select_atn_stop(host, scb);
1226  } else {
1227  if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) { /* do sync negotiation */
1228  initio_select_atn_stop(host, scb);
1229  } else {
1230  if (scb->tagmsg)
1231  initio_select_atn3(host, scb);
1232  else
1233  initio_select_atn(host, scb);
1234  }
1235  }
1236  if (scb->flags & SCF_POLL) {
1237  while (wait_tulip(host) != -1) {
1238  if (initio_next_state(host) == -1)
1239  break;
1240  }
1241  }
1242  } else if (scb->opcode == BusDevRst) {
1243  initio_select_atn_stop(host, scb);
1244  scb->next_state = 8;
1245  if (scb->flags & SCF_POLL) {
1246  while (wait_tulip(host) != -1) {
1247  if (initio_next_state(host) == -1)
1248  break;
1249  }
1250  }
1251  } else if (scb->opcode == AbortCmd) {
1252  if (initio_abort_srb(host, scb->srb) != 0) {
1253  initio_unlink_pend_scb(host, scb);
1254  initio_release_scb(host, scb);
1255  } else {
1256  scb->opcode = BusDevRst;
1257  initio_select_atn_stop(host, scb);
1258  scb->next_state = 8;
1259  }
1260  } else {
1261  initio_unlink_pend_scb(host, scb);
1262  scb->hastat = 0x16; /* bad command */
1263  initio_append_done_scb(host, scb);
1264  }
1265  return;
1266 }
1267 
1278 static int initio_next_state(struct initio_host * host)
1279 {
1280  int next;
1281 
1282  next = host->active->next_state;
1283  for (;;) {
1284  switch (next) {
1285  case 1:
1286  next = initio_state_1(host);
1287  break;
1288  case 2:
1289  next = initio_state_2(host);
1290  break;
1291  case 3:
1292  next = initio_state_3(host);
1293  break;
1294  case 4:
1295  next = initio_state_4(host);
1296  break;
1297  case 5:
1298  next = initio_state_5(host);
1299  break;
1300  case 6:
1301  next = initio_state_6(host);
1302  break;
1303  case 7:
1304  next = initio_state_7(host);
1305  break;
1306  case 8:
1307  return initio_bus_device_reset(host);
1308  default:
1309  return initio_bad_seq(host);
1310  }
1311  if (next <= 0)
1312  return next;
1313  }
1314 }
1315 
1316 
1324 static int initio_state_1(struct initio_host * host)
1325 {
1326  struct scsi_ctrl_blk *scb = host->active;
1327  struct target_control *active_tc = host->active_tc;
1328 #if DEBUG_STATE
1329  printk("-s1-");
1330 #endif
1331 
1332  /* Move the SCB from pending to busy */
1333  initio_unlink_pend_scb(host, scb);
1334  initio_append_busy_scb(host, scb);
1335 
1336  outb(active_tc->sconfig0, host->addr + TUL_SConfig );
1337  /* ATN on */
1338  if (host->phase == MSG_OUT) {
1339  outb(TSC_EN_BUS_IN | TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
1340  outb(scb->ident, host->addr + TUL_SFifo);
1341 
1342  if (scb->tagmsg) {
1343  outb(scb->tagmsg, host->addr + TUL_SFifo);
1344  outb(scb->tagid, host->addr + TUL_SFifo);
1345  }
1346  if ((active_tc->flags & (TCF_WDTR_DONE | TCF_NO_WDTR)) == 0) {
1347  active_tc->flags |= TCF_WDTR_DONE;
1348  outb(MSG_EXTEND, host->addr + TUL_SFifo);
1349  outb(2, host->addr + TUL_SFifo); /* Extended msg length */
1350  outb(3, host->addr + TUL_SFifo); /* Sync request */
1351  outb(1, host->addr + TUL_SFifo); /* Start from 16 bits */
1352  } else if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) {
1353  active_tc->flags |= TCF_SYNC_DONE;
1354  outb(MSG_EXTEND, host->addr + TUL_SFifo);
1355  outb(3, host->addr + TUL_SFifo); /* extended msg length */
1356  outb(1, host->addr + TUL_SFifo); /* sync request */
1357  outb(initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], host->addr + TUL_SFifo);
1358  outb(MAX_OFFSET, host->addr + TUL_SFifo); /* REQ/ACK offset */
1359  }
1360  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1361  if (wait_tulip(host) == -1)
1362  return -1;
1363  }
1364  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1365  outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), host->addr + TUL_SSignal);
1366  /* Into before CDB xfer */
1367  return 3;
1368 }
1369 
1370 
1379 static int initio_state_2(struct initio_host * host)
1380 {
1381  struct scsi_ctrl_blk *scb = host->active;
1382  struct target_control *active_tc = host->active_tc;
1383 #if DEBUG_STATE
1384  printk("-s2-");
1385 #endif
1386 
1387  initio_unlink_pend_scb(host, scb);
1388  initio_append_busy_scb(host, scb);
1389 
1390  outb(active_tc->sconfig0, host->addr + TUL_SConfig);
1391 
1392  if (host->jsstatus1 & TSS_CMD_PH_CMP)
1393  return 4;
1394 
1395  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1396  outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)), host->addr + TUL_SSignal);
1397  /* Into before CDB xfer */
1398  return 3;
1399 }
1400 
1408 static int initio_state_3(struct initio_host * host)
1409 {
1410  struct scsi_ctrl_blk *scb = host->active;
1411  struct target_control *active_tc = host->active_tc;
1412  int i;
1413 
1414 #if DEBUG_STATE
1415  printk("-s3-");
1416 #endif
1417  for (;;) {
1418  switch (host->phase) {
1419  case CMD_OUT: /* Command out phase */
1420  for (i = 0; i < (int) scb->cdblen; i++)
1421  outb(scb->cdb[i], host->addr + TUL_SFifo);
1422  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1423  if (wait_tulip(host) == -1)
1424  return -1;
1425  if (host->phase == CMD_OUT)
1426  return initio_bad_seq(host);
1427  return 4;
1428 
1429  case MSG_IN: /* Message in phase */
1430  scb->next_state = 3;
1431  if (initio_msgin(host) == -1)
1432  return -1;
1433  break;
1434 
1435  case STATUS_IN: /* Status phase */
1436  if (initio_status_msg(host) == -1)
1437  return -1;
1438  break;
1439 
1440  case MSG_OUT: /* Message out phase */
1441  if (active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) {
1442  outb(MSG_NOP, host->addr + TUL_SFifo); /* msg nop */
1443  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1444  if (wait_tulip(host) == -1)
1445  return -1;
1446  } else {
1447  active_tc->flags |= TCF_SYNC_DONE;
1448 
1449  outb(MSG_EXTEND, host->addr + TUL_SFifo);
1450  outb(3, host->addr + TUL_SFifo); /* ext. msg len */
1451  outb(1, host->addr + TUL_SFifo); /* sync request */
1452  outb(initio_rate_tbl[active_tc->flags & TCF_SCSI_RATE], host->addr + TUL_SFifo);
1453  outb(MAX_OFFSET, host->addr + TUL_SFifo); /* REQ/ACK offset */
1454  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1455  if (wait_tulip(host) == -1)
1456  return -1;
1457  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1458  outb(inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7), host->addr + TUL_SSignal);
1459 
1460  }
1461  break;
1462  default:
1463  return initio_bad_seq(host);
1464  }
1465  }
1466 }
1467 
1475 static int initio_state_4(struct initio_host * host)
1476 {
1477  struct scsi_ctrl_blk *scb = host->active;
1478 
1479 #if DEBUG_STATE
1480  printk("-s4-");
1481 #endif
1482  if ((scb->flags & SCF_DIR) == SCF_NO_XF) {
1483  return 6; /* Go to state 6 (After data) */
1484  }
1485  for (;;) {
1486  if (scb->buflen == 0)
1487  return 6;
1488 
1489  switch (host->phase) {
1490 
1491  case STATUS_IN: /* Status phase */
1492  if ((scb->flags & SCF_DIR) != 0) /* if direction bit set then report data underrun */
1493  scb->hastat = HOST_DO_DU;
1494  if ((initio_status_msg(host)) == -1)
1495  return -1;
1496  break;
1497 
1498  case MSG_IN: /* Message in phase */
1499  scb->next_state = 0x4;
1500  if (initio_msgin(host) == -1)
1501  return -1;
1502  break;
1503 
1504  case MSG_OUT: /* Message out phase */
1505  if (host->jsstatus0 & TSS_PAR_ERROR) {
1506  scb->buflen = 0;
1507  scb->hastat = HOST_DO_DU;
1508  if (initio_msgout_ide(host) == -1)
1509  return -1;
1510  return 6;
1511  } else {
1512  outb(MSG_NOP, host->addr + TUL_SFifo); /* msg nop */
1513  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1514  if (wait_tulip(host) == -1)
1515  return -1;
1516  }
1517  break;
1518 
1519  case DATA_IN: /* Data in phase */
1520  return initio_xfer_data_in(host);
1521 
1522  case DATA_OUT: /* Data out phase */
1523  return initio_xfer_data_out(host);
1524 
1525  default:
1526  return initio_bad_seq(host);
1527  }
1528  }
1529 }
1530 
1531 
1539 static int initio_state_5(struct initio_host * host)
1540 {
1541  struct scsi_ctrl_blk *scb = host->active;
1542  long cnt, xcnt; /* cannot use unsigned !! code: if (xcnt < 0) */
1543 
1544 #if DEBUG_STATE
1545  printk("-s5-");
1546 #endif
1547  /*------ get remaining count -------*/
1548  cnt = inl(host->addr + TUL_SCnt0) & 0x0FFFFFF;
1549 
1550  if (inb(host->addr + TUL_XCmd) & 0x20) {
1551  /* ----------------------- DATA_IN ----------------------------- */
1552  /* check scsi parity error */
1553  if (host->jsstatus0 & TSS_PAR_ERROR)
1554  scb->hastat = HOST_DO_DU;
1555  if (inb(host->addr + TUL_XStatus) & XPEND) { /* DMA xfer pending, Send STOP */
1556  /* tell Hardware scsi xfer has been terminated */
1557  outb(inb(host->addr + TUL_XCtrl) | 0x80, host->addr + TUL_XCtrl);
1558  /* wait until DMA xfer not pending */
1559  while (inb(host->addr + TUL_XStatus) & XPEND)
1560  cpu_relax();
1561  }
1562  } else {
1563  /*-------- DATA OUT -----------*/
1564  if ((inb(host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0) {
1565  if (host->active_tc->js_period & TSC_WIDE_SCSI)
1566  cnt += (inb(host->addr + TUL_SFifoCnt) & 0x1F) << 1;
1567  else
1568  cnt += (inb(host->addr + TUL_SFifoCnt) & 0x1F);
1569  }
1570  if (inb(host->addr + TUL_XStatus) & XPEND) { /* if DMA xfer is pending, abort DMA xfer */
1571  outb(TAX_X_ABT, host->addr + TUL_XCmd);
1572  /* wait Abort DMA xfer done */
1573  while ((inb(host->addr + TUL_Int) & XABT) == 0)
1574  cpu_relax();
1575  }
1576  if ((cnt == 1) && (host->phase == DATA_OUT)) {
1577  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1578  if (wait_tulip(host) == -1)
1579  return -1;
1580  cnt = 0;
1581  } else {
1582  if ((inb(host->addr + TUL_SStatus1) & TSS_XFER_CMP) == 0)
1583  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1584  }
1585  }
1586  if (cnt == 0) {
1587  scb->buflen = 0;
1588  return 6; /* After Data */
1589  }
1590  /* Update active data pointer */
1591  xcnt = (long) scb->buflen - cnt; /* xcnt== bytes already xferred */
1592  scb->buflen = (u32) cnt; /* cnt == bytes left to be xferred */
1593  if (scb->flags & SCF_SG) {
1594  struct sg_entry *sgp;
1595  unsigned long i;
1596 
1597  sgp = &scb->sglist[scb->sgidx];
1598  for (i = scb->sgidx; i < scb->sgmax; sgp++, i++) {
1599  xcnt -= (long) sgp->len;
1600  if (xcnt < 0) { /* this sgp xfer half done */
1601  xcnt += (long) sgp->len; /* xcnt == bytes xferred in this sgp */
1602  sgp->data += (u32) xcnt; /* new ptr to be xfer */
1603  sgp->len -= (u32) xcnt; /* new len to be xfer */
1604  scb->bufptr += ((u32) (i - scb->sgidx) << 3);
1605  /* new SG table ptr */
1606  scb->sglen = (u8) (scb->sgmax - i);
1607  /* new SG table len */
1608  scb->sgidx = (u16) i;
1609  /* for next disc and come in this loop */
1610  return 4; /* Go to state 4 */
1611  }
1612  /* else (xcnt >= 0 , i.e. this sgp already xferred */
1613  } /* for */
1614  return 6; /* Go to state 6 */
1615  } else {
1616  scb->bufptr += (u32) xcnt;
1617  }
1618  return 4; /* Go to state 4 */
1619 }
1620 
1628 static int initio_state_6(struct initio_host * host)
1629 {
1630  struct scsi_ctrl_blk *scb = host->active;
1631 
1632 #if DEBUG_STATE
1633  printk("-s6-");
1634 #endif
1635  for (;;) {
1636  switch (host->phase) {
1637  case STATUS_IN: /* Status phase */
1638  if ((initio_status_msg(host)) == -1)
1639  return -1;
1640  break;
1641 
1642  case MSG_IN: /* Message in phase */
1643  scb->next_state = 6;
1644  if ((initio_msgin(host)) == -1)
1645  return -1;
1646  break;
1647 
1648  case MSG_OUT: /* Message out phase */
1649  outb(MSG_NOP, host->addr + TUL_SFifo); /* msg nop */
1650  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1651  if (wait_tulip(host) == -1)
1652  return -1;
1653  break;
1654 
1655  case DATA_IN: /* Data in phase */
1656  return initio_xpad_in(host);
1657 
1658  case DATA_OUT: /* Data out phase */
1659  return initio_xpad_out(host);
1660 
1661  default:
1662  return initio_bad_seq(host);
1663  }
1664  }
1665 }
1666 
1673 int initio_state_7(struct initio_host * host)
1674 {
1675  int cnt, i;
1676 
1677 #if DEBUG_STATE
1678  printk("-s7-");
1679 #endif
1680  /* flush SCSI FIFO */
1681  cnt = inb(host->addr + TUL_SFifoCnt) & 0x1F;
1682  if (cnt) {
1683  for (i = 0; i < cnt; i++)
1684  inb(host->addr + TUL_SFifo);
1685  }
1686  switch (host->phase) {
1687  case DATA_IN: /* Data in phase */
1688  case DATA_OUT: /* Data out phase */
1689  return initio_bad_seq(host);
1690  default:
1691  return 6; /* Go to state 6 */
1692  }
1693 }
1694 
1703 static int initio_xfer_data_in(struct initio_host * host)
1704 {
1705  struct scsi_ctrl_blk *scb = host->active;
1706 
1707  if ((scb->flags & SCF_DIR) == SCF_DOUT)
1708  return 6; /* wrong direction */
1709 
1710  outl(scb->buflen, host->addr + TUL_SCnt0);
1711  outb(TSC_XF_DMA_IN, host->addr + TUL_SCmd); /* 7/25/95 */
1712 
1713  if (scb->flags & SCF_SG) { /* S/G xfer */
1714  outl(((u32) scb->sglen) << 3, host->addr + TUL_XCntH);
1715  outl(scb->bufptr, host->addr + TUL_XAddH);
1716  outb(TAX_SG_IN, host->addr + TUL_XCmd);
1717  } else {
1718  outl(scb->buflen, host->addr + TUL_XCntH);
1719  outl(scb->bufptr, host->addr + TUL_XAddH);
1720  outb(TAX_X_IN, host->addr + TUL_XCmd);
1721  }
1722  scb->next_state = 0x5;
1723  return 0; /* return to OS, wait xfer done , let jas_isr come in */
1724 }
1725 
1735 static int initio_xfer_data_out(struct initio_host * host)
1736 {
1737  struct scsi_ctrl_blk *scb = host->active;
1738 
1739  if ((scb->flags & SCF_DIR) == SCF_DIN)
1740  return 6; /* wrong direction */
1741 
1742  outl(scb->buflen, host->addr + TUL_SCnt0);
1743  outb(TSC_XF_DMA_OUT, host->addr + TUL_SCmd);
1744 
1745  if (scb->flags & SCF_SG) { /* S/G xfer */
1746  outl(((u32) scb->sglen) << 3, host->addr + TUL_XCntH);
1747  outl(scb->bufptr, host->addr + TUL_XAddH);
1748  outb(TAX_SG_OUT, host->addr + TUL_XCmd);
1749  } else {
1750  outl(scb->buflen, host->addr + TUL_XCntH);
1751  outl(scb->bufptr, host->addr + TUL_XAddH);
1752  outb(TAX_X_OUT, host->addr + TUL_XCmd);
1753  }
1754 
1755  scb->next_state = 0x5;
1756  return 0; /* return to OS, wait xfer done , let jas_isr come in */
1757 }
1758 
1759 int initio_xpad_in(struct initio_host * host)
1760 {
1761  struct scsi_ctrl_blk *scb = host->active;
1762  struct target_control *active_tc = host->active_tc;
1763 
1764  if ((scb->flags & SCF_DIR) != SCF_NO_DCHK)
1765  scb->hastat = HOST_DO_DU; /* over run */
1766  for (;;) {
1767  if (active_tc->js_period & TSC_WIDE_SCSI)
1768  outl(2, host->addr + TUL_SCnt0);
1769  else
1770  outl(1, host->addr + TUL_SCnt0);
1771 
1772  outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1773  if (wait_tulip(host) == -1)
1774  return -1;
1775  if (host->phase != DATA_IN) {
1776  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1777  return 6;
1778  }
1779  inb(host->addr + TUL_SFifo);
1780  }
1781 }
1782 
1783 int initio_xpad_out(struct initio_host * host)
1784 {
1785  struct scsi_ctrl_blk *scb = host->active;
1786  struct target_control *active_tc = host->active_tc;
1787 
1788  if ((scb->flags & SCF_DIR) != SCF_NO_DCHK)
1789  scb->hastat = HOST_DO_DU; /* over run */
1790  for (;;) {
1791  if (active_tc->js_period & TSC_WIDE_SCSI)
1792  outl(2, host->addr + TUL_SCnt0);
1793  else
1794  outl(1, host->addr + TUL_SCnt0);
1795 
1796  outb(0, host->addr + TUL_SFifo);
1797  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1798  if ((wait_tulip(host)) == -1)
1799  return -1;
1800  if (host->phase != DATA_OUT) { /* Disable wide CPU to allow read 16 bits */
1801  outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1);
1802  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1803  return 6;
1804  }
1805  }
1806 }
1807 
1808 int initio_status_msg(struct initio_host * host)
1809 { /* status & MSG_IN */
1810  struct scsi_ctrl_blk *scb = host->active;
1811  u8 msg;
1812 
1813  outb(TSC_CMD_COMP, host->addr + TUL_SCmd);
1814  if (wait_tulip(host) == -1)
1815  return -1;
1816 
1817  /* get status */
1818  scb->tastat = inb(host->addr + TUL_SFifo);
1819 
1820  if (host->phase == MSG_OUT) {
1821  if (host->jsstatus0 & TSS_PAR_ERROR)
1822  outb(MSG_PARITY, host->addr + TUL_SFifo);
1823  else
1824  outb(MSG_NOP, host->addr + TUL_SFifo);
1825  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1826  return wait_tulip(host);
1827  }
1828  if (host->phase == MSG_IN) {
1829  msg = inb(host->addr + TUL_SFifo);
1830  if (host->jsstatus0 & TSS_PAR_ERROR) { /* Parity error */
1831  if ((initio_msgin_accept(host)) == -1)
1832  return -1;
1833  if (host->phase != MSG_OUT)
1834  return initio_bad_seq(host);
1835  outb(MSG_PARITY, host->addr + TUL_SFifo);
1836  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
1837  return wait_tulip(host);
1838  }
1839  if (msg == 0) { /* Command complete */
1840 
1841  if ((scb->tastat & 0x18) == 0x10) /* No link support */
1842  return initio_bad_seq(host);
1843  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1844  outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
1845  return initio_wait_done_disc(host);
1846 
1847  }
1848  if (msg == MSG_LINK_COMP || msg == MSG_LINK_FLAG) {
1849  if ((scb->tastat & 0x18) == 0x10)
1850  return initio_msgin_accept(host);
1851  }
1852  }
1853  return initio_bad_seq(host);
1854 }
1855 
1856 
1857 /* scsi bus free */
1858 int int_initio_busfree(struct initio_host * host)
1859 {
1860  struct scsi_ctrl_blk *scb = host->active;
1861 
1862  if (scb != NULL) {
1863  if (scb->status & SCB_SELECT) { /* selection timeout */
1864  initio_unlink_pend_scb(host, scb);
1865  scb->hastat = HOST_SEL_TOUT;
1866  initio_append_done_scb(host, scb);
1867  } else { /* Unexpected bus free */
1868  initio_unlink_busy_scb(host, scb);
1869  scb->hastat = HOST_BUS_FREE;
1870  initio_append_done_scb(host, scb);
1871  }
1872  host->active = NULL;
1873  host->active_tc = NULL;
1874  }
1875  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */
1876  outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
1877  outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */
1878  return -1;
1879 }
1880 
1881 
1892 static int int_initio_scsi_rst(struct initio_host * host)
1893 {
1894  struct scsi_ctrl_blk *scb;
1895  int i;
1896 
1897  /* if DMA xfer is pending, abort DMA xfer */
1898  if (inb(host->addr + TUL_XStatus) & 0x01) {
1899  outb(TAX_X_ABT | TAX_X_CLR_FIFO, host->addr + TUL_XCmd);
1900  /* wait Abort DMA xfer done */
1901  while ((inb(host->addr + TUL_Int) & 0x04) == 0)
1902  cpu_relax();
1903  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
1904  }
1905  /* Abort all active & disconnected scb */
1906  while ((scb = initio_pop_busy_scb(host)) != NULL) {
1907  scb->hastat = HOST_BAD_PHAS;
1908  initio_append_done_scb(host, scb);
1909  }
1910  host->active = NULL;
1911  host->active_tc = NULL;
1912 
1913  /* clr sync nego. done flag */
1914  for (i = 0; i < host->max_tar; i++)
1915  host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
1916  return -1;
1917 }
1918 
1928 int int_initio_resel(struct initio_host * host)
1929 {
1930  struct scsi_ctrl_blk *scb;
1931  struct target_control *active_tc;
1932  u8 tag, msg = 0;
1933  u8 tar, lun;
1934 
1935  if ((scb = host->active) != NULL) {
1936  /* FIXME: Why check and not just clear ? */
1937  if (scb->status & SCB_SELECT) /* if waiting for selection complete */
1938  scb->status &= ~SCB_SELECT;
1939  host->active = NULL;
1940  }
1941  /* --------- get target id---------------------- */
1942  tar = inb(host->addr + TUL_SBusId);
1943  /* ------ get LUN from Identify message----------- */
1944  lun = inb(host->addr + TUL_SIdent) & 0x0F;
1945  /* 07/22/98 from 0x1F -> 0x0F */
1946  active_tc = &host->targets[tar];
1947  host->active_tc = active_tc;
1948  outb(active_tc->sconfig0, host->addr + TUL_SConfig);
1949  outb(active_tc->js_period, host->addr + TUL_SPeriod);
1950 
1951  /* ------------- tag queueing ? ------------------- */
1952  if (active_tc->drv_flags & TCF_DRV_EN_TAG) {
1953  if ((initio_msgin_accept(host)) == -1)
1954  return -1;
1955  if (host->phase != MSG_IN)
1956  goto no_tag;
1957  outl(1, host->addr + TUL_SCnt0);
1958  outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1959  if (wait_tulip(host) == -1)
1960  return -1;
1961  msg = inb(host->addr + TUL_SFifo); /* Read Tag Message */
1962 
1963  if (msg < MSG_STAG || msg > MSG_OTAG) /* Is simple Tag */
1964  goto no_tag;
1965 
1966  if (initio_msgin_accept(host) == -1)
1967  return -1;
1968 
1969  if (host->phase != MSG_IN)
1970  goto no_tag;
1971 
1972  outl(1, host->addr + TUL_SCnt0);
1973  outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
1974  if (wait_tulip(host) == -1)
1975  return -1;
1976  tag = inb(host->addr + TUL_SFifo); /* Read Tag ID */
1977  scb = host->scb + tag;
1978  if (scb->target != tar || scb->lun != lun) {
1979  return initio_msgout_abort_tag(host);
1980  }
1981  if (scb->status != SCB_BUSY) { /* 03/24/95 */
1982  return initio_msgout_abort_tag(host);
1983  }
1984  host->active = scb;
1985  if ((initio_msgin_accept(host)) == -1)
1986  return -1;
1987  } else { /* No tag */
1988  no_tag:
1989  if ((scb = initio_find_busy_scb(host, tar | (lun << 8))) == NULL) {
1990  return initio_msgout_abort_targ(host);
1991  }
1992  host->active = scb;
1993  if (!(active_tc->drv_flags & TCF_DRV_EN_TAG)) {
1994  if ((initio_msgin_accept(host)) == -1)
1995  return -1;
1996  }
1997  }
1998  return 0;
1999 }
2000 
2009 static int int_initio_bad_seq(struct initio_host * host)
2010 { /* target wrong phase */
2011  struct scsi_ctrl_blk *scb;
2012  int i;
2013 
2014  initio_reset_scsi(host, 10);
2015 
2016  while ((scb = initio_pop_busy_scb(host)) != NULL) {
2017  scb->hastat = HOST_BAD_PHAS;
2018  initio_append_done_scb(host, scb);
2019  }
2020  for (i = 0; i < host->max_tar; i++)
2021  host->targets[i].flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
2022  return -1;
2023 }
2024 
2025 
2034 static int initio_msgout_abort_targ(struct initio_host * host)
2035 {
2036 
2037  outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2038  if (initio_msgin_accept(host) == -1)
2039  return -1;
2040  if (host->phase != MSG_OUT)
2041  return initio_bad_seq(host);
2042 
2043  outb(MSG_ABORT, host->addr + TUL_SFifo);
2044  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2045 
2046  return initio_wait_disc(host);
2047 }
2048 
2057 static int initio_msgout_abort_tag(struct initio_host * host)
2058 {
2059 
2060  outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2061  if (initio_msgin_accept(host) == -1)
2062  return -1;
2063  if (host->phase != MSG_OUT)
2064  return initio_bad_seq(host);
2065 
2066  outb(MSG_ABORT_TAG, host->addr + TUL_SFifo);
2067  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2068 
2069  return initio_wait_disc(host);
2070 
2071 }
2072 
2079 static int initio_msgin(struct initio_host * host)
2080 {
2081  struct target_control *active_tc;
2082 
2083  for (;;) {
2084  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2085 
2086  outl(1, host->addr + TUL_SCnt0);
2087  outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2088  if (wait_tulip(host) == -1)
2089  return -1;
2090 
2091  switch (inb(host->addr + TUL_SFifo)) {
2092  case MSG_DISC: /* Disconnect msg */
2093  outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2094  return initio_wait_disc(host);
2095  case MSG_SDP:
2096  case MSG_RESTORE:
2097  case MSG_NOP:
2098  initio_msgin_accept(host);
2099  break;
2100  case MSG_REJ: /* Clear ATN first */
2101  outb((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)),
2102  host->addr + TUL_SSignal);
2103  active_tc = host->active_tc;
2104  if ((active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0) /* do sync nego */
2105  outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN),
2106  host->addr + TUL_SSignal);
2107  initio_msgin_accept(host);
2108  break;
2109  case MSG_EXTEND: /* extended msg */
2110  initio_msgin_extend(host);
2111  break;
2112  case MSG_IGNOREWIDE:
2113  initio_msgin_accept(host);
2114  break;
2115  case MSG_COMP:
2116  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2117  outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2118  return initio_wait_done_disc(host);
2119  default:
2120  initio_msgout_reject(host);
2121  break;
2122  }
2123  if (host->phase != MSG_IN)
2124  return host->phase;
2125  }
2126  /* statement won't reach here */
2127 }
2128 
2129 static int initio_msgout_reject(struct initio_host * host)
2130 {
2131  outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2132 
2133  if (initio_msgin_accept(host) == -1)
2134  return -1;
2135 
2136  if (host->phase == MSG_OUT) {
2137  outb(MSG_REJ, host->addr + TUL_SFifo); /* Msg reject */
2138  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2139  return wait_tulip(host);
2140  }
2141  return host->phase;
2142 }
2143 
2144 static int initio_msgout_ide(struct initio_host * host)
2145 {
2146  outb(MSG_IDE, host->addr + TUL_SFifo); /* Initiator Detected Error */
2147  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2148  return wait_tulip(host);
2149 }
2150 
2151 static int initio_msgin_extend(struct initio_host * host)
2152 {
2153  u8 len, idx;
2154 
2155  if (initio_msgin_accept(host) != MSG_IN)
2156  return host->phase;
2157 
2158  /* Get extended msg length */
2159  outl(1, host->addr + TUL_SCnt0);
2160  outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2161  if (wait_tulip(host) == -1)
2162  return -1;
2163 
2164  len = inb(host->addr + TUL_SFifo);
2165  host->msg[0] = len;
2166  for (idx = 1; len != 0; len--) {
2167 
2168  if ((initio_msgin_accept(host)) != MSG_IN)
2169  return host->phase;
2170  outl(1, host->addr + TUL_SCnt0);
2171  outb(TSC_XF_FIFO_IN, host->addr + TUL_SCmd);
2172  if (wait_tulip(host) == -1)
2173  return -1;
2174  host->msg[idx++] = inb(host->addr + TUL_SFifo);
2175  }
2176  if (host->msg[1] == 1) { /* if it's synchronous data transfer request */
2177  u8 r;
2178  if (host->msg[0] != 3) /* if length is not right */
2179  return initio_msgout_reject(host);
2180  if (host->active_tc->flags & TCF_NO_SYNC_NEGO) { /* Set OFFSET=0 to do async, nego back */
2181  host->msg[3] = 0;
2182  } else {
2183  if (initio_msgin_sync(host) == 0 &&
2184  (host->active_tc->flags & TCF_SYNC_DONE)) {
2185  initio_sync_done(host);
2186  return initio_msgin_accept(host);
2187  }
2188  }
2189 
2190  r = inb(host->addr + TUL_SSignal);
2191  outb((r & (TSC_SET_ACK | 7)) | TSC_SET_ATN,
2192  host->addr + TUL_SSignal);
2193  if (initio_msgin_accept(host) != MSG_OUT)
2194  return host->phase;
2195  /* sync msg out */
2196  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0);
2197 
2198  initio_sync_done(host);
2199 
2200  outb(MSG_EXTEND, host->addr + TUL_SFifo);
2201  outb(3, host->addr + TUL_SFifo);
2202  outb(1, host->addr + TUL_SFifo);
2203  outb(host->msg[2], host->addr + TUL_SFifo);
2204  outb(host->msg[3], host->addr + TUL_SFifo);
2205  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2206  return wait_tulip(host);
2207  }
2208  if (host->msg[0] != 2 || host->msg[1] != 3)
2209  return initio_msgout_reject(host);
2210  /* if it's WIDE DATA XFER REQ */
2211  if (host->active_tc->flags & TCF_NO_WDTR) {
2212  host->msg[2] = 0;
2213  } else {
2214  if (host->msg[2] > 2) /* > 32 bits */
2215  return initio_msgout_reject(host);
2216  if (host->msg[2] == 2) { /* == 32 */
2217  host->msg[2] = 1;
2218  } else {
2219  if ((host->active_tc->flags & TCF_NO_WDTR) == 0) {
2220  wdtr_done(host);
2221  if ((host->active_tc->flags & (TCF_SYNC_DONE | TCF_NO_SYNC_NEGO)) == 0)
2222  outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2223  return initio_msgin_accept(host);
2224  }
2225  }
2226  }
2227  outb(((inb(host->addr + TUL_SSignal) & (TSC_SET_ACK | 7)) | TSC_SET_ATN), host->addr + TUL_SSignal);
2228 
2229  if (initio_msgin_accept(host) != MSG_OUT)
2230  return host->phase;
2231  /* WDTR msg out */
2232  outb(MSG_EXTEND, host->addr + TUL_SFifo);
2233  outb(2, host->addr + TUL_SFifo);
2234  outb(3, host->addr + TUL_SFifo);
2235  outb(host->msg[2], host->addr + TUL_SFifo);
2236  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2237  return wait_tulip(host);
2238 }
2239 
2240 static int initio_msgin_sync(struct initio_host * host)
2241 {
2242  char default_period;
2243 
2244  default_period = initio_rate_tbl[host->active_tc->flags & TCF_SCSI_RATE];
2245  if (host->msg[3] > MAX_OFFSET) {
2246  host->msg[3] = MAX_OFFSET;
2247  if (host->msg[2] < default_period) {
2248  host->msg[2] = default_period;
2249  return 1;
2250  }
2251  if (host->msg[2] >= 59) /* Change to async */
2252  host->msg[3] = 0;
2253  return 1;
2254  }
2255  /* offset requests asynchronous transfers ? */
2256  if (host->msg[3] == 0) {
2257  return 0;
2258  }
2259  if (host->msg[2] < default_period) {
2260  host->msg[2] = default_period;
2261  return 1;
2262  }
2263  if (host->msg[2] >= 59) {
2264  host->msg[3] = 0;
2265  return 1;
2266  }
2267  return 0;
2268 }
2269 
2270 static int wdtr_done(struct initio_host * host)
2271 {
2272  host->active_tc->flags &= ~TCF_SYNC_DONE;
2273  host->active_tc->flags |= TCF_WDTR_DONE;
2274 
2275  host->active_tc->js_period = 0;
2276  if (host->msg[2]) /* if 16 bit */
2277  host->active_tc->js_period |= TSC_WIDE_SCSI;
2278  host->active_tc->sconfig0 &= ~TSC_ALT_PERIOD;
2279  outb(host->active_tc->sconfig0, host->addr + TUL_SConfig);
2280  outb(host->active_tc->js_period, host->addr + TUL_SPeriod);
2281 
2282  return 1;
2283 }
2284 
2285 static int initio_sync_done(struct initio_host * host)
2286 {
2287  int i;
2288 
2289  host->active_tc->flags |= TCF_SYNC_DONE;
2290 
2291  if (host->msg[3]) {
2292  host->active_tc->js_period |= host->msg[3];
2293  for (i = 0; i < 8; i++) {
2294  if (initio_rate_tbl[i] >= host->msg[2]) /* pick the big one */
2295  break;
2296  }
2297  host->active_tc->js_period |= (i << 4);
2298  host->active_tc->sconfig0 |= TSC_ALT_PERIOD;
2299  }
2300  outb(host->active_tc->sconfig0, host->addr + TUL_SConfig);
2301  outb(host->active_tc->js_period, host->addr + TUL_SPeriod);
2302 
2303  return -1;
2304 }
2305 
2306 
2307 static int initio_post_scsi_rst(struct initio_host * host)
2308 {
2309  struct scsi_ctrl_blk *scb;
2310  struct target_control *active_tc;
2311  int i;
2312 
2313  host->active = NULL;
2314  host->active_tc = NULL;
2315  host->flags = 0;
2316 
2317  while ((scb = initio_pop_busy_scb(host)) != NULL) {
2318  scb->hastat = HOST_BAD_PHAS;
2319  initio_append_done_scb(host, scb);
2320  }
2321  /* clear sync done flag */
2322  active_tc = &host->targets[0];
2323  for (i = 0; i < host->max_tar; active_tc++, i++) {
2324  active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
2325  /* Initialize the sync. xfer register values to an asyn xfer */
2326  active_tc->js_period = 0;
2327  active_tc->sconfig0 = host->sconf1;
2328  host->act_tags[0] = 0; /* 07/22/98 */
2329  host->targets[i].flags &= ~TCF_BUSY; /* 07/22/98 */
2330  } /* for */
2331 
2332  return -1;
2333 }
2334 
2335 static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb)
2336 {
2337  scb->status |= SCB_SELECT;
2338  scb->next_state = 0x1;
2339  host->active = scb;
2340  host->active_tc = &host->targets[scb->target];
2341  outb(TSC_SELATNSTOP, host->addr + TUL_SCmd);
2342 }
2343 
2344 
2345 static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb)
2346 {
2347  int i;
2348 
2349  scb->status |= SCB_SELECT;
2350  scb->next_state = 0x2;
2351 
2352  outb(scb->ident, host->addr + TUL_SFifo);
2353  for (i = 0; i < (int) scb->cdblen; i++)
2354  outb(scb->cdb[i], host->addr + TUL_SFifo);
2355  host->active_tc = &host->targets[scb->target];
2356  host->active = scb;
2357  outb(TSC_SEL_ATN, host->addr + TUL_SCmd);
2358 }
2359 
2360 static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb)
2361 {
2362  int i;
2363 
2364  scb->status |= SCB_SELECT;
2365  scb->next_state = 0x2;
2366 
2367  outb(scb->ident, host->addr + TUL_SFifo);
2368  outb(scb->tagmsg, host->addr + TUL_SFifo);
2369  outb(scb->tagid, host->addr + TUL_SFifo);
2370  for (i = 0; i < scb->cdblen; i++)
2371  outb(scb->cdb[i], host->addr + TUL_SFifo);
2372  host->active_tc = &host->targets[scb->target];
2373  host->active = scb;
2374  outb(TSC_SEL_ATN3, host->addr + TUL_SCmd);
2375 }
2376 
2384 int initio_bus_device_reset(struct initio_host * host)
2385 {
2386  struct scsi_ctrl_blk *scb = host->active;
2387  struct target_control *active_tc = host->active_tc;
2388  struct scsi_ctrl_blk *tmp, *prev;
2389  u8 tar;
2390 
2391  if (host->phase != MSG_OUT)
2392  return int_initio_bad_seq(host); /* Unexpected phase */
2393 
2394  initio_unlink_pend_scb(host, scb);
2395  initio_release_scb(host, scb);
2396 
2397 
2398  tar = scb->target; /* target */
2399  active_tc->flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE | TCF_BUSY);
2400  /* clr sync. nego & WDTR flags 07/22/98 */
2401 
2402  /* abort all SCB with same target */
2403  prev = tmp = host->first_busy; /* Check Busy queue */
2404  while (tmp != NULL) {
2405  if (tmp->target == tar) {
2406  /* unlink it */
2407  if (tmp == host->first_busy) {
2408  if ((host->first_busy = tmp->next) == NULL)
2409  host->last_busy = NULL;
2410  } else {
2411  prev->next = tmp->next;
2412  if (tmp == host->last_busy)
2413  host->last_busy = prev;
2414  }
2415  tmp->hastat = HOST_ABORTED;
2416  initio_append_done_scb(host, tmp);
2417  }
2418  /* Previous haven't change */
2419  else {
2420  prev = tmp;
2421  }
2422  tmp = tmp->next;
2423  }
2424  outb(MSG_DEVRST, host->addr + TUL_SFifo);
2425  outb(TSC_XF_FIFO_OUT, host->addr + TUL_SCmd);
2426  return initio_wait_disc(host);
2427 
2428 }
2429 
2430 static int initio_msgin_accept(struct initio_host * host)
2431 {
2432  outb(TSC_MSG_ACCEPT, host->addr + TUL_SCmd);
2433  return wait_tulip(host);
2434 }
2435 
2436 static int wait_tulip(struct initio_host * host)
2437 {
2438 
2439  while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0))
2440  & TSS_INT_PENDING))
2441  cpu_relax();
2442 
2443  host->jsint = inb(host->addr + TUL_SInt);
2444  host->phase = host->jsstatus0 & TSS_PH_MASK;
2445  host->jsstatus1 = inb(host->addr + TUL_SStatus1);
2446 
2447  if (host->jsint & TSS_RESEL_INT) /* if SCSI bus reset detected */
2448  return int_initio_resel(host);
2449  if (host->jsint & TSS_SEL_TIMEOUT) /* if selected/reselected timeout interrupt */
2450  return int_initio_busfree(host);
2451  if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */
2452  return int_initio_scsi_rst(host);
2453 
2454  if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */
2455  if (host->flags & HCF_EXPECT_DONE_DISC) {
2456  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */
2457  initio_unlink_busy_scb(host, host->active);
2458  host->active->hastat = 0;
2459  initio_append_done_scb(host, host->active);
2460  host->active = NULL;
2461  host->active_tc = NULL;
2462  host->flags &= ~HCF_EXPECT_DONE_DISC;
2463  outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2464  outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */
2465  return -1;
2466  }
2467  if (host->flags & HCF_EXPECT_DISC) {
2468  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */
2469  host->active = NULL;
2470  host->active_tc = NULL;
2471  host->flags &= ~HCF_EXPECT_DISC;
2472  outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2473  outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */
2474  return -1;
2475  }
2476  return int_initio_busfree(host);
2477  }
2478  /* The old code really does the below. Can probably be removed */
2479  if (host->jsint & (TSS_FUNC_COMP | TSS_BUS_SERV))
2480  return host->phase;
2481  return host->phase;
2482 }
2483 
2484 static int initio_wait_disc(struct initio_host * host)
2485 {
2486  while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0)) & TSS_INT_PENDING))
2487  cpu_relax();
2488 
2489  host->jsint = inb(host->addr + TUL_SInt);
2490 
2491  if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */
2492  return int_initio_scsi_rst(host);
2493  if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */
2494  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */
2495  outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2496  outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */
2497  host->active = NULL;
2498  return -1;
2499  }
2500  return initio_bad_seq(host);
2501 }
2502 
2503 static int initio_wait_done_disc(struct initio_host * host)
2504 {
2505  while (!((host->jsstatus0 = inb(host->addr + TUL_SStatus0))
2506  & TSS_INT_PENDING))
2507  cpu_relax();
2508 
2509  host->jsint = inb(host->addr + TUL_SInt);
2510 
2511  if (host->jsint & TSS_SCSIRST_INT) /* if SCSI bus reset detected */
2512  return int_initio_scsi_rst(host);
2513  if (host->jsint & TSS_DISC_INT) { /* BUS disconnection */
2514  outb(TSC_FLUSH_FIFO, host->addr + TUL_SCtrl0); /* Flush SCSI FIFO */
2515  outb(TSC_INITDEFAULT, host->addr + TUL_SConfig);
2516  outb(TSC_HW_RESELECT, host->addr + TUL_SCtrl1); /* Enable HW reselect */
2517  initio_unlink_busy_scb(host, host->active);
2518 
2519  initio_append_done_scb(host, host->active);
2520  host->active = NULL;
2521  return -1;
2522  }
2523  return initio_bad_seq(host);
2524 }
2525 
2535 static irqreturn_t i91u_intr(int irqno, void *dev_id)
2536 {
2537  struct Scsi_Host *dev = dev_id;
2538  unsigned long flags;
2539  int r;
2540 
2541  spin_lock_irqsave(dev->host_lock, flags);
2542  r = initio_isr((struct initio_host *)dev->hostdata);
2543  spin_unlock_irqrestore(dev->host_lock, flags);
2544  if (r)
2545  return IRQ_HANDLED;
2546  else
2547  return IRQ_NONE;
2548 }
2549 
2550 
2562 static void initio_build_scb(struct initio_host * host, struct scsi_ctrl_blk * cblk, struct scsi_cmnd * cmnd)
2563 { /* Create corresponding SCB */
2564  struct scatterlist *sglist;
2565  struct sg_entry *sg; /* Pointer to SG list */
2566  int i, nseg;
2567  long total_len;
2568  dma_addr_t dma_addr;
2569 
2570  /* Fill in the command headers */
2571  cblk->post = i91uSCBPost; /* i91u's callback routine */
2572  cblk->srb = cmnd;
2573  cblk->opcode = ExecSCSI;
2574  cblk->flags = SCF_POST; /* After SCSI done, call post routine */
2575  cblk->target = cmnd->device->id;
2576  cblk->lun = cmnd->device->lun;
2577  cblk->ident = cmnd->device->lun | DISC_ALLOW;
2578 
2579  cblk->flags |= SCF_SENSE; /* Turn on auto request sense */
2580 
2581  /* Map the sense buffer into bus memory */
2582  dma_addr = dma_map_single(&host->pci_dev->dev, cmnd->sense_buffer,
2583  SENSE_SIZE, DMA_FROM_DEVICE);
2584  cblk->senseptr = (u32)dma_addr;
2585  cblk->senselen = SENSE_SIZE;
2586  cmnd->SCp.ptr = (char *)(unsigned long)dma_addr;
2587  cblk->cdblen = cmnd->cmd_len;
2588 
2589  /* Clear the returned status */
2590  cblk->hastat = 0;
2591  cblk->tastat = 0;
2592  /* Command the command */
2593  memcpy(cblk->cdb, cmnd->cmnd, cmnd->cmd_len);
2594 
2595  /* Set up tags */
2596  if (cmnd->device->tagged_supported) { /* Tag Support */
2597  cblk->tagmsg = SIMPLE_QUEUE_TAG; /* Do simple tag only */
2598  } else {
2599  cblk->tagmsg = 0; /* No tag support */
2600  }
2601 
2602  /* todo handle map_sg error */
2603  nseg = scsi_dma_map(cmnd);
2604  BUG_ON(nseg < 0);
2605  if (nseg) {
2606  dma_addr = dma_map_single(&host->pci_dev->dev, &cblk->sglist[0],
2607  sizeof(struct sg_entry) * TOTAL_SG_ENTRY,
2608  DMA_BIDIRECTIONAL);
2609  cblk->bufptr = (u32)dma_addr;
2610  cmnd->SCp.dma_handle = dma_addr;
2611 
2612  cblk->sglen = nseg;
2613 
2614  cblk->flags |= SCF_SG; /* Turn on SG list flag */
2615  total_len = 0;
2616  sg = &cblk->sglist[0];
2617  scsi_for_each_sg(cmnd, sglist, cblk->sglen, i) {
2618  sg->data = cpu_to_le32((u32)sg_dma_address(sglist));
2619  sg->len = cpu_to_le32((u32)sg_dma_len(sglist));
2620  total_len += sg_dma_len(sglist);
2621  ++sg;
2622  }
2623 
2624  cblk->buflen = (scsi_bufflen(cmnd) > total_len) ?
2625  total_len : scsi_bufflen(cmnd);
2626  } else { /* No data transfer required */
2627  cblk->buflen = 0;
2628  cblk->sglen = 0;
2629  }
2630 }
2631 
2642 static int i91u_queuecommand_lck(struct scsi_cmnd *cmd,
2643  void (*done)(struct scsi_cmnd *))
2644 {
2645  struct initio_host *host = (struct initio_host *) cmd->device->host->hostdata;
2646  struct scsi_ctrl_blk *cmnd;
2647 
2648  cmd->scsi_done = done;
2649 
2650  cmnd = initio_alloc_scb(host);
2651  if (!cmnd)
2652  return SCSI_MLQUEUE_HOST_BUSY;
2653 
2654  initio_build_scb(host, cmnd, cmd);
2655  initio_exec_scb(host, cmnd);
2656  return 0;
2657 }
2658 
2659 static DEF_SCSI_QCMD(i91u_queuecommand)
2660 
2661 
2668 static int i91u_bus_reset(struct scsi_cmnd * cmnd)
2669 {
2670  struct initio_host *host;
2671 
2672  host = (struct initio_host *) cmnd->device->host->hostdata;
2673 
2674  spin_lock_irq(cmnd->device->host->host_lock);
2675  initio_reset_scsi(host, 0);
2676  spin_unlock_irq(cmnd->device->host->host_lock);
2677 
2678  return SUCCESS;
2679 }
2680 
2694 static int i91u_biosparam(struct scsi_device *sdev, struct block_device *dev,
2695  sector_t capacity, int *info_array)
2696 {
2697  struct initio_host *host; /* Point to Host adapter control block */
2698  struct target_control *tc;
2699 
2700  host = (struct initio_host *) sdev->host->hostdata;
2701  tc = &host->targets[sdev->id];
2702 
2703  if (tc->heads) {
2704  info_array[0] = tc->heads;
2705  info_array[1] = tc->sectors;
2706  info_array[2] = (unsigned long)capacity / tc->heads / tc->sectors;
2707  } else {
2708  if (tc->drv_flags & TCF_DRV_255_63) {
2709  info_array[0] = 255;
2710  info_array[1] = 63;
2711  info_array[2] = (unsigned long)capacity / 255 / 63;
2712  } else {
2713  info_array[0] = 64;
2714  info_array[1] = 32;
2715  info_array[2] = (unsigned long)capacity >> 11;
2716  }
2717  }
2718 
2719 #if defined(DEBUG_BIOSPARAM)
2720  if (i91u_debug & debug_biosparam) {
2721  printk("bios geometry: head=%d, sec=%d, cyl=%d\n",
2722  info_array[0], info_array[1], info_array[2]);
2723  printk("WARNING: check, if the bios geometry is correct.\n");
2724  }
2725 #endif
2726 
2727  return 0;
2728 }
2729 
2739 static void i91u_unmap_scb(struct pci_dev *pci_dev, struct scsi_cmnd *cmnd)
2740 {
2741  /* auto sense buffer */
2742  if (cmnd->SCp.ptr) {
2743  dma_unmap_single(&pci_dev->dev,
2744  (dma_addr_t)((unsigned long)cmnd->SCp.ptr),
2745  SENSE_SIZE, DMA_FROM_DEVICE);
2746  cmnd->SCp.ptr = NULL;
2747  }
2748 
2749  /* request buffer */
2750  if (scsi_sg_count(cmnd)) {
2751  dma_unmap_single(&pci_dev->dev, cmnd->SCp.dma_handle,
2752  sizeof(struct sg_entry) * TOTAL_SG_ENTRY,
2753  DMA_BIDIRECTIONAL);
2754 
2755  scsi_dma_unmap(cmnd);
2756  }
2757 }
2758 
2768 static void i91uSCBPost(u8 * host_mem, u8 * cblk_mem)
2769 {
2770  struct scsi_cmnd *cmnd; /* Pointer to SCSI request block */
2771  struct initio_host *host;
2772  struct scsi_ctrl_blk *cblk;
2773 
2774  host = (struct initio_host *) host_mem;
2775  cblk = (struct scsi_ctrl_blk *) cblk_mem;
2776  if ((cmnd = cblk->srb) == NULL) {
2777  printk(KERN_ERR "i91uSCBPost: SRB pointer is empty\n");
2778  WARN_ON(1);
2779  initio_release_scb(host, cblk); /* Release SCB for current channel */
2780  return;
2781  }
2782 
2783  /*
2784  * Remap the firmware error status into a mid layer one
2785  */
2786  switch (cblk->hastat) {
2787  case 0x0:
2788  case 0xa: /* Linked command complete without error and linked normally */
2789  case 0xb: /* Linked command complete without error interrupt generated */
2790  cblk->hastat = 0;
2791  break;
2792 
2793  case 0x11: /* Selection time out-The initiator selection or target
2794  reselection was not complete within the SCSI Time out period */
2795  cblk->hastat = DID_TIME_OUT;
2796  break;
2797 
2798  case 0x14: /* Target bus phase sequence failure-An invalid bus phase or bus
2799  phase sequence was requested by the target. The host adapter
2800  will generate a SCSI Reset Condition, notifying the host with
2801  a SCRD interrupt */
2802  cblk->hastat = DID_RESET;
2803  break;
2804 
2805  case 0x1a: /* SCB Aborted. 07/21/98 */
2806  cblk->hastat = DID_ABORT;
2807  break;
2808 
2809  case 0x12: /* Data overrun/underrun-The target attempted to transfer more data
2810  than was allocated by the Data Length field or the sum of the
2811  Scatter / Gather Data Length fields. */
2812  case 0x13: /* Unexpected bus free-The target dropped the SCSI BSY at an unexpected time. */
2813  case 0x16: /* Invalid SCB Operation Code. */
2814 
2815  default:
2816  printk("ini9100u: %x %x\n", cblk->hastat, cblk->tastat);
2817  cblk->hastat = DID_ERROR; /* Couldn't find any better */
2818  break;
2819  }
2820 
2821  cmnd->result = cblk->tastat | (cblk->hastat << 16);
2822  i91u_unmap_scb(host->pci_dev, cmnd);
2823  cmnd->scsi_done(cmnd); /* Notify system DONE */
2824  initio_release_scb(host, cblk); /* Release SCB for current channel */
2825 }
2826 
2827 static struct scsi_host_template initio_template = {
2828  .proc_name = "INI9100U",
2829  .name = "Initio INI-9X00U/UW SCSI device driver",
2830  .queuecommand = i91u_queuecommand,
2831  .eh_bus_reset_handler = i91u_bus_reset,
2832  .bios_param = i91u_biosparam,
2833  .can_queue = MAX_TARGETS * i91u_MAXQUEUE,
2834  .this_id = 1,
2835  .sg_tablesize = SG_ALL,
2836  .cmd_per_lun = 1,
2837  .use_clustering = ENABLE_CLUSTERING,
2838 };
2839 
2840 static int initio_probe_one(struct pci_dev *pdev,
2841  const struct pci_device_id *id)
2842 {
2843  struct Scsi_Host *shost;
2844  struct initio_host *host;
2845  u32 reg;
2846  u16 bios_seg;
2847  struct scsi_ctrl_blk *scb, *tmp, *prev = NULL /* silence gcc */;
2848  int num_scb, i, error;
2849 
2850  error = pci_enable_device(pdev);
2851  if (error)
2852  return error;
2853 
2854  pci_read_config_dword(pdev, 0x44, (u32 *) & reg);
2855  bios_seg = (u16) (reg & 0xFF);
2856  if (((reg & 0xFF00) >> 8) == 0xFF)
2857  reg = 0;
2858  bios_seg = (bios_seg << 8) + ((u16) ((reg & 0xFF00) >> 8));
2859 
2860  if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
2861  printk(KERN_WARNING "i91u: Could not set 32 bit DMA mask\n");
2862  error = -ENODEV;
2863  goto out_disable_device;
2864  }
2865  shost = scsi_host_alloc(&initio_template, sizeof(struct initio_host));
2866  if (!shost) {
2867  printk(KERN_WARNING "initio: Could not allocate host structure.\n");
2868  error = -ENOMEM;
2869  goto out_disable_device;
2870  }
2871  host = (struct initio_host *)shost->hostdata;
2872  memset(host, 0, sizeof(struct initio_host));
2873  host->addr = pci_resource_start(pdev, 0);
2874  host->bios_addr = bios_seg;
2875 
2876  if (!request_region(host->addr, 256, "i91u")) {
2877  printk(KERN_WARNING "initio: I/O port range 0x%x is busy.\n", host->addr);
2878  error = -ENODEV;
2879  goto out_host_put;
2880  }
2881 
2882  if (initio_tag_enable) /* 1.01i */
2883  num_scb = MAX_TARGETS * i91u_MAXQUEUE;
2884  else
2885  num_scb = MAX_TARGETS + 3; /* 1-tape, 1-CD_ROM, 1- extra */
2886 
2887  for (; num_scb >= MAX_TARGETS + 3; num_scb--) {
2888  i = num_scb * sizeof(struct scsi_ctrl_blk);
2889  if ((scb = kzalloc(i, GFP_DMA)) != NULL)
2890  break;
2891  }
2892 
2893  if (!scb) {
2894  printk(KERN_WARNING "initio: Cannot allocate SCB array.\n");
2895  error = -ENOMEM;
2896  goto out_release_region;
2897  }
2898 
2899  host->pci_dev = pdev;
2900 
2901  host->semaph = 1;
2902  spin_lock_init(&host->semaph_lock);
2903  host->num_scbs = num_scb;
2904  host->scb = scb;
2905  host->next_pending = scb;
2906  host->next_avail = scb;
2907  for (i = 0, tmp = scb; i < num_scb; i++, tmp++) {
2908  tmp->tagid = i;
2909  if (i != 0)
2910  prev->next = tmp;
2911  prev = tmp;
2912  }
2913  prev->next = NULL;
2914  host->scb_end = tmp;
2915  host->first_avail = scb;
2916  host->last_avail = prev;
2917  spin_lock_init(&host->avail_lock);
2918 
2919  initio_init(host, phys_to_virt(((u32)bios_seg << 4)));
2920 
2921  host->jsstatus0 = 0;
2922 
2923  shost->io_port = host->addr;
2924  shost->n_io_port = 0xff;
2925  shost->can_queue = num_scb; /* 03/05/98 */
2926  shost->unique_id = host->addr;
2927  shost->max_id = host->max_tar;
2928  shost->max_lun = 32; /* 10/21/97 */
2929  shost->irq = pdev->irq;
2930  shost->this_id = host->scsi_id; /* Assign HCS index */
2931  shost->base = host->addr;
2932  shost->sg_tablesize = TOTAL_SG_ENTRY;
2933 
2934  error = request_irq(pdev->irq, i91u_intr, IRQF_DISABLED|IRQF_SHARED, "i91u", shost);
2935  if (error < 0) {
2936  printk(KERN_WARNING "initio: Unable to request IRQ %d\n", pdev->irq);
2937  goto out_free_scbs;
2938  }
2939 
2940  pci_set_drvdata(pdev, shost);
2941 
2942  error = scsi_add_host(shost, &pdev->dev);
2943  if (error)
2944  goto out_free_irq;
2945  scsi_scan_host(shost);
2946  return 0;
2947 out_free_irq:
2948  free_irq(pdev->irq, shost);
2949 out_free_scbs:
2950  kfree(host->scb);
2951 out_release_region:
2952  release_region(host->addr, 256);
2953 out_host_put:
2954  scsi_host_put(shost);
2955 out_disable_device:
2956  pci_disable_device(pdev);
2957  return error;
2958 }
2959 
2968 static void initio_remove_one(struct pci_dev *pdev)
2969 {
2970  struct Scsi_Host *host = pci_get_drvdata(pdev);
2971  struct initio_host *s = (struct initio_host *)host->hostdata;
2972  scsi_remove_host(host);
2973  free_irq(pdev->irq, host);
2974  release_region(s->addr, 256);
2975  scsi_host_put(host);
2976  pci_disable_device(pdev);
2977 }
2978 
2979 MODULE_LICENSE("GPL");
2980 
2981 static struct pci_device_id initio_pci_tbl[] = {
2982  {PCI_VENDOR_ID_INIT, 0x9500, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2983  {PCI_VENDOR_ID_INIT, 0x9400, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2984  {PCI_VENDOR_ID_INIT, 0x9401, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2985  {PCI_VENDOR_ID_INIT, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2986  {PCI_VENDOR_ID_DOMEX, 0x0002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2987  {0,}
2988 };
2989 MODULE_DEVICE_TABLE(pci, initio_pci_tbl);
2990 
2991 static struct pci_driver initio_pci_driver = {
2992  .name = "initio",
2993  .id_table = initio_pci_tbl,
2994  .probe = initio_probe_one,
2995  .remove = __devexit_p(initio_remove_one),
2996 };
2997 
2998 static int __init initio_init_driver(void)
2999 {
3000  return pci_register_driver(&initio_pci_driver);
3001 }
3002 
3003 static void __exit initio_exit_driver(void)
3004 {
3005  pci_unregister_driver(&initio_pci_driver);
3006 }
3007 
3008 MODULE_DESCRIPTION("Initio INI-9X00U/UW SCSI device driver");
3009 MODULE_AUTHOR("Initio Corporation");
3010 MODULE_LICENSE("GPL");
3011 
3012 module_init(initio_init_driver);
3013 module_exit(initio_exit_driver);
Generated on Thu Jan 10 2013 14:21:09 for Linux Kernel by   doxygen 1.8.2