1/**************************************************************************
2 * Initio 9100 device driver for Linux.
3 *
4 * Copyright (c) 1994-1998 Initio Corporation
5 * Copyright (c) 1998 Bas Vermeulen <bvermeul@blackstar.xs4all.nl>
6 * Copyright (c) 2004 Christoph Hellwig <hch@lst.de>
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 <bmacy@sunshinecomputing.com>
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
119static unsigned int i91u_debug = DEBUG_DEFAULT;
120#endif
121
122static int initio_tag_enable = 1;
123
124#ifdef DEBUG_i91u
125static int setup_debug = 0;
126#endif
127
128static void i91uSCBPost(u8 * pHcb, u8 * pScb);
129
130/* PCI Devices supported by this driver */
131static 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};
139MODULE_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 ---*/
147static struct scsi_ctrl_blk *initio_find_busy_scb(struct initio_host * host, u16 tarlun);
148static struct scsi_ctrl_blk *initio_find_done_scb(struct initio_host * host);
149
150static int tulip_main(struct initio_host * host);
151
152static int initio_next_state(struct initio_host * host);
153static int initio_state_1(struct initio_host * host);
154static int initio_state_2(struct initio_host * host);
155static int initio_state_3(struct initio_host * host);
156static int initio_state_4(struct initio_host * host);
157static int initio_state_5(struct initio_host * host);
158static int initio_state_6(struct initio_host * host);
159static int initio_state_7(struct initio_host * host);
160static int initio_xfer_data_in(struct initio_host * host);
161static int initio_xfer_data_out(struct initio_host * host);
162static int initio_xpad_in(struct initio_host * host);
163static int initio_xpad_out(struct initio_host * host);
164static int initio_status_msg(struct initio_host * host);
165
166static int initio_msgin(struct initio_host * host);
167static int initio_msgin_sync(struct initio_host * host);
168static int initio_msgin_accept(struct initio_host * host);
169static int initio_msgout_reject(struct initio_host * host);
170static int initio_msgin_extend(struct initio_host * host);
171
172static int initio_msgout_ide(struct initio_host * host);
173static int initio_msgout_abort_targ(struct initio_host * host);
174static int initio_msgout_abort_tag(struct initio_host * host);
175
176static int initio_bus_device_reset(struct initio_host * host);
177static void initio_select_atn(struct initio_host * host, struct scsi_ctrl_blk * scb);
178static void initio_select_atn3(struct initio_host * host, struct scsi_ctrl_blk * scb);
179static void initio_select_atn_stop(struct initio_host * host, struct scsi_ctrl_blk * scb);
180static int int_initio_busfree(struct initio_host * host);
181static int int_initio_scsi_rst(struct initio_host * host);
182static int int_initio_bad_seq(struct initio_host * host);
183static int int_initio_resel(struct initio_host * host);
184static int initio_sync_done(struct initio_host * host);
185static int wdtr_done(struct initio_host * host);
186static int wait_tulip(struct initio_host * host);
187static int initio_wait_done_disc(struct initio_host * host);
188static int initio_wait_disc(struct initio_host * host);
189static void tulip_scsi(struct initio_host * host);
190static int initio_post_scsi_rst(struct initio_host * host);
191
192static void initio_se2_ew_en(unsigned long base);
193static void initio_se2_ew_ds(unsigned long base);
194static int initio_se2_rd_all(unsigned long base);
195static void initio_se2_update_all(unsigned long base);	/* setup default pattern */
196static void initio_read_eeprom(unsigned long base);
197
198/* ---- INTERNAL VARIABLES ---- */
199
200static NVRAM i91unvram;
201static NVRAM *i91unvramp;
202
203static 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
243static 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
256static 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
298/**
299 *	initio_se2_instr	-	bitbang an instruction
300 *	@base: Base of InitIO controller
301 *	@instr: Instruction for serial E2PROM
302 *
303 *	Bitbang an instruction out to the serial E2Prom
304 */
305
306static 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
332/**
333 *	initio_se2_ew_en	-	Enable erase/write
334 *	@base: Base address of InitIO controller
335 *
336 *	Enable erase/write state of serial EEPROM
337 */
338void 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
346/**
347 *	initio_se2_ew_ds	-	Disable erase/write
348 *	@base: Base address of InitIO controller
349 *
350 *	Disable erase/write state of serial EEPROM
351 */
352void 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
360/**
361 *	initio_se2_rd		-	read E2PROM word
362 *	@base: Base of InitIO controller
363 *	@addr: Address of word in E2PROM
364 *
365 *	Read a word from the NV E2PROM device
366 */
367static 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
393/**
394 *	initio_se2_wr		-	read E2PROM word
395 *	@base: Base of InitIO controller
396 *	@addr: Address of word in E2PROM
397 *	@val: Value to write
398 *
399 *	Write a word to the NV E2PROM device. Used when recovering from
400 *	a problem with the NV.
401 */
402static 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
439/**
440 *	initio_se2_rd_all	-	read hostadapter NV configuration
441 *	@base: Base address of InitIO controller
442 *
443 *	Reads the E2PROM data into main memory. Ensures that the checksum
444 *	and header marker are valid. Returns 1 on success -1 on error.
445 */
446
447static 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
470/**
471 *	initio_se2_update_all		-	Update E2PROM
472 *	@base: Base of InitIO controller
473 *
474 *	Update the E2PROM by wrting any changes into the E2PROM
475 *	chip, rewriting the checksum.
476 */
477static 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
500/**
501 *	initio_read_eeprom		-	Retrieve configuration
502 *	@base: Base of InitIO Host Adapter
503 *
504 *	Retrieve the host adapter configuration data from E2Prom. If the
505 *	data is invalid then the defaults are used and are also restored
506 *	into the E2PROM. This forms the access point for the SCSI driver
507 *	into the E2PROM layer, the other functions for the E2PROM are all
508 *	internal use.
509 *
510 *	Must be called single threaded, uses a shared global area.
511 */
512
513static 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
530/**
531 *	initio_stop_bm		-	stop bus master
532 *	@host: InitIO we are stopping
533 *
534 *	Stop any pending DMA operation, aborting the DMA if necessary
535 */
536
537static 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
549/**
550 *	initio_reset_scsi		-	Reset SCSI host controller
551 *	@host: InitIO host to reset
552 *	@seconds: Recovery time
553 *
554 *	Perform a full reset of the SCSI subsystem.
555 */
556
557static 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
576/**
577 *	initio_init		-	set up an InitIO host adapter
578 *	@host: InitIO host adapter
579 *	@num_scbs: Number of SCBS
580 *	@bios_addr: BIOS address
581 *
582 *	Set up the host adapter and devices according to the configuration
583 *	retrieved from the E2PROM.
584 *
585 *	Locking: Calls E2PROM layer code which is not re-enterable so must
586 *	run single threaded for now.
587 */
588
589static 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
679/**
680 *	initio_alloc_scb		-	Allocate an SCB
681 *	@host: InitIO host we are allocating for
682 *
683 *	Walk the SCB list for the controller and allocate a free SCB if
684 *	one exists.
685 */
686static 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
705/**
706 *	initio_release_scb		-	Release an SCB
707 *	@host: InitIO host that owns the SCB
708 *	@cmnd: SCB command block being returned
709 *
710 *	Return an allocated SCB to the host free list
711 */
712
713static 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/***************************************************************************/
735static 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/***************************************************************************/
753static 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
768static 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
795static 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
822static 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/***************************************************************************/
844static 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/***************************************************************************/
865static 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
897struct 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
918static 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
935struct 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
950static 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/***************************************************************************/
1033static 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/************************************************************************/
1052static 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/***************************************************************************/
1083static 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
1101static 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
1173static 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
1268/**
1269 *	initio_next_state		-	Next SCSI state
1270 *	@host: InitIO host we are processing
1271 *
1272 *	Progress the active command block along the state machine
1273 *	until we hit a state which we must wait for activity to occur.
1274 *
1275 *	Returns zero or a negative code.
1276 */
1277
1278static 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
1317/**
1318 *	initio_state_1		-	SCSI state machine
1319 *	@host: InitIO host we are controlling
1320 *
1321 *	Perform SCSI state processing for Select/Attention/Stop
1322 */
1323
1324static 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
1371/**
1372 *	initio_state_2		-	SCSI state machine
1373 *	@host: InitIO host we are controlling
1374 *
1375 * state after selection with attention
1376 * state after selection with attention3
1377 */
1378
1379static 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
1401/**
1402 *	initio_state_3		-	SCSI state machine
1403 *	@host: InitIO host we are controlling
1404 *
1405 * state before CDB xfer is done
1406 */
1407
1408static 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
1468/**
1469 *	initio_state_4		-	SCSI state machine
1470 *	@host: InitIO host we are controlling
1471 *
1472 *	SCSI state machine. State 4
1473 */
1474
1475static 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
1532/**
1533 *	initio_state_5		-	SCSI state machine
1534 *	@host: InitIO host we are controlling
1535 *
1536 *	State after dma xfer done or phase change before xfer done
1537 */
1538
1539static 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
1621/**
1622 *	initio_state_6		-	SCSI state machine
1623 *	@host: InitIO host we are controlling
1624 *
1625 *	State after Data phase
1626 */
1627
1628static 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
1667/**
1668 *	initio_state_7		-	SCSI state machine
1669 *	@host: InitIO host we are controlling
1670 *
1671 */
1672
1673int 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
1695/**
1696 *	initio_xfer_data_in	-	Commence data input
1697 *	@host: InitIO host in use
1698 *
1699 *	Commence a block of data transfer. The transfer itself will
1700 *	be managed by the controller and we will get a completion (or
1701 *	failure) interrupt.
1702 */
1703static 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
1726/**
1727 *	initio_xfer_data_out	-	Commence data output
1728 *	@host: InitIO host in use
1729 *
1730 *	Commence a block of data transfer. The transfer itself will
1731 *	be managed by the controller and we will get a completion (or
1732 *	failure) interrupt.
1733 */
1734
1735static 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
1759int 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
1783int 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
1808int 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 */
1858int 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
1882/**
1883 *	int_initio_scsi_rst	-	SCSI reset occurred
1884 *	@host: Host seeing the reset
1885 *
1886 *	A SCSI bus reset has occurred. Clean up any pending transfer
1887 *	the hardware is doing by DMA and then abort all active and
1888 *	disconnected commands. The mid layer should sort the rest out
1889 *	for us
1890 */
1891
1892static 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
1919/**
1920 *	int_initio_scsi_resel	-	Reselection occurred
1921 *	@host: InitIO host adapter
1922 *
1923 *	A SCSI reselection event has been signalled and the interrupt
1924 *	is now being processed. Work out which command block needs attention
1925 *	and continue processing that command.
1926 */
1927
1928int 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
2001/**
2002 *	int_initio_bad_seq		-	out of phase
2003 *	@host: InitIO host flagging event
2004 *
2005 *	We have ended up out of phase somehow. Reset the host controller
2006 *	and throw all our toys out of the pram. Let the midlayer clean up
2007 */
2008
2009static 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
2026/**
2027 *	initio_msgout_abort_targ		-	abort a tag
2028 *	@host: InitIO host
2029 *
2030 *	Abort when the target/lun does not match or when our SCB is not
2031 *	busy. Used by untagged commands.
2032 */
2033
2034static 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
2049/**
2050 *	initio_msgout_abort_tag		-	abort a tag
2051 *	@host: InitIO host
2052 *
2053 *	Abort when the target/lun does not match or when our SCB is not
2054 *	busy. Used for tagged commands.
2055 */
2056
2057static 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
2073/**
2074 *	initio_msgin		-	Message in
2075 *	@host: InitIO Host
2076 *
2077 *	Process incoming message
2078 */
2079static 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
2129static 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
2144static 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
2151static 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
2240static 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
2270static 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
2285static 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
2307static 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
2335static 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
2345static 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
2360static 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
2377/**
2378 *	initio_bus_device_reset	-	 SCSI Bus Device Reset
2379 *	@host: InitIO host to reset
2380 *
2381 *	Perform a device reset and abort all pending SCBs for the
2382 *	victim device
2383 */
2384int 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
2430static 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
2436static 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
2484static 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
2503static 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
2526/**
2527 *	i91u_intr		-	IRQ handler
2528 *	@irqno: IRQ number
2529 *	@dev_id: IRQ identifier
2530 *
2531 *	Take the relevant locks and then invoke the actual isr processing
2532 *	code under the lock.
2533 */
2534
2535static 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
2551/**
2552 *	initio_build_scb		-	Build the mappings and SCB
2553 *	@host: InitIO host taking the command
2554 *	@cblk: Firmware command block
2555 *	@cmnd: SCSI midlayer command block
2556 *
2557 *	Translate the abstract SCSI command into a firmware command block
2558 *	suitable for feeding to the InitIO host controller. This also requires
2559 *	we build the scatter gather lists and ensure they are mapped properly.
2560 */
2561
2562static 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
2632/**
2633 *	i91u_queuecommand	-	Queue a new command if possible
2634 *	@cmd: SCSI command block from the mid layer
2635 *	@done: Completion handler
2636 *
2637 *	Attempts to queue a new command with the host adapter. Will return
2638 *	zero if successful or indicate a host busy condition if not (which
2639 *	will cause the mid layer to call us again later with the command)
2640 */
2641
2642static 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
2659static DEF_SCSI_QCMD(i91u_queuecommand)
2660
2661/**
2662 *	i91u_bus_reset		-	reset the SCSI bus
2663 *	@cmnd: Command block we want to trigger the reset for
2664 *
2665 *	Initiate a SCSI bus reset sequence
2666 */
2667
2668static 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
2681/**
2682 *	i91u_biospararm			-	return the "logical geometry
2683 *	@sdev: SCSI device
2684 *	@dev; Matching block device
2685 *	@capacity: Sector size of drive
2686 *	@info_array: Return space for BIOS geometry
2687 *
2688 *	Map the device geometry in a manner compatible with the host
2689 *	controller BIOS behaviour.
2690 *
2691 *	FIXME: limited to 2^32 sector devices.
2692 */
2693
2694static 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
2730/**
2731 *	i91u_unmap_scb		-	Unmap a command
2732 *	@pci_dev: PCI device the command is for
2733 *	@cmnd: The command itself
2734 *
2735 *	Unmap any PCI mapping/IOMMU resources allocated when the command
2736 *	was mapped originally as part of initio_build_scb
2737 */
2738
2739static 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
2759/**
2760 *	i91uSCBPost		-	SCSI callback
2761 *	@host: Pointer to host adapter control block.
2762 *	@cmnd: Pointer to SCSI control block.
2763 *
2764 *	This is callback routine be called when tulip finish one
2765 *	SCSI command.
2766 */
2767
2768static 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
2827static 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
2840static 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_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;
2947out_free_irq:
2948	free_irq(pdev->irq, shost);
2949out_free_scbs:
2950	kfree(host->scb);
2951out_release_region:
2952	release_region(host->addr, 256);
2953out_host_put:
2954	scsi_host_put(shost);
2955out_disable_device:
2956	pci_disable_device(pdev);
2957	return error;
2958}
2959
2960/**
2961 *	initio_remove_one	-	control shutdown
2962 *	@pdev:	PCI device being released
2963 *
2964 *	Release the resources assigned to this adapter after it has
2965 *	finished being used.
2966 */
2967
2968static 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
2979MODULE_LICENSE("GPL");
2980
2981static 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};
2989MODULE_DEVICE_TABLE(pci, initio_pci_tbl);
2990
2991static struct pci_driver initio_pci_driver = {
2992	.name		= "initio",
2993	.id_table	= initio_pci_tbl,
2994	.probe		= initio_probe_one,
2995	.remove		= initio_remove_one,
2996};
2997
2998static int __init initio_init_driver(void)
2999{
3000	return pci_register_driver(&initio_pci_driver);
3001}
3002
3003static void __exit initio_exit_driver(void)
3004{
3005	pci_unregister_driver(&initio_pci_driver);
3006}
3007
3008MODULE_DESCRIPTION("Initio INI-9X00U/UW SCSI device driver");
3009MODULE_AUTHOR("Initio Corporation");
3010MODULE_LICENSE("GPL");
3011
3012module_init(initio_init_driver);
3013module_exit(initio_exit_driver);
3014