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