xref: /openbmc/linux/drivers/scsi/53c700.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
1 /* -*- mode: c; c-basic-offset: 8 -*- */
2 
3 /* NCR (or Symbios) 53c700 and 53c700-66 Driver
4  *
5  * Copyright (C) 2001 by James.Bottomley@HansenPartnership.com
6 **-----------------------------------------------------------------------------
7 **
8 **  This program is free software; you can redistribute it and/or modify
9 **  it under the terms of the GNU General Public License as published by
10 **  the Free Software Foundation; either version 2 of the License, or
11 **  (at your option) any later version.
12 **
13 **  This program is distributed in the hope that it will be useful,
14 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
15 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 **  GNU General Public License for more details.
17 **
18 **  You should have received a copy of the GNU General Public License
19 **  along with this program; if not, write to the Free Software
20 **  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 **
22 **-----------------------------------------------------------------------------
23  */
24 
25 /* Notes:
26  *
27  * This driver is designed exclusively for these chips (virtually the
28  * earliest of the scripts engine chips).  They need their own drivers
29  * because they are missing so many of the scripts and snazzy register
30  * features of their elder brothers (the 710, 720 and 770).
31  *
32  * The 700 is the lowliest of the line, it can only do async SCSI.
33  * The 700-66 can at least do synchronous SCSI up to 10MHz.
34  *
35  * The 700 chip has no host bus interface logic of its own.  However,
36  * it is usually mapped to a location with well defined register
37  * offsets.  Therefore, if you can determine the base address and the
38  * irq your board incorporating this chip uses, you can probably use
39  * this driver to run it (although you'll probably have to write a
40  * minimal wrapper for the purpose---see the NCR_D700 driver for
41  * details about how to do this).
42  *
43  *
44  * TODO List:
45  *
46  * 1. Better statistics in the proc fs
47  *
48  * 2. Implement message queue (queues SCSI messages like commands) and make
49  *    the abort and device reset functions use them.
50  * */
51 
52 /* CHANGELOG
53  *
54  * Version 2.8
55  *
56  * Fixed bad bug affecting tag starvation processing (previously the
57  * driver would hang the system if too many tags starved.  Also fixed
58  * bad bug having to do with 10 byte command processing and REQUEST
59  * SENSE (the command would loop forever getting a transfer length
60  * mismatch in the CMD phase).
61  *
62  * Version 2.7
63  *
64  * Fixed scripts problem which caused certain devices (notably CDRWs)
65  * to hang on initial INQUIRY.  Updated NCR_700_readl/writel to use
66  * __raw_readl/writel for parisc compatibility (Thomas
67  * Bogendoerfer). Added missing SCp->request_bufflen initialisation
68  * for sense requests (Ryan Bradetich).
69  *
70  * Version 2.6
71  *
72  * Following test of the 64 bit parisc kernel by Richard Hirst,
73  * several problems have now been corrected.  Also adds support for
74  * consistent memory allocation.
75  *
76  * Version 2.5
77  *
78  * More Compatibility changes for 710 (now actually works).  Enhanced
79  * support for odd clock speeds which constrain SDTR negotiations.
80  * correct cacheline separation for scsi messages and status for
81  * incoherent architectures.  Use of the pci mapping functions on
82  * buffers to begin support for 64 bit drivers.
83  *
84  * Version 2.4
85  *
86  * Added support for the 53c710 chip (in 53c700 emulation mode only---no
87  * special 53c710 instructions or registers are used).
88  *
89  * Version 2.3
90  *
91  * More endianness/cache coherency changes.
92  *
93  * Better bad device handling (handles devices lying about tag
94  * queueing support and devices which fail to provide sense data on
95  * contingent allegiance conditions)
96  *
97  * Many thanks to Richard Hirst <rhirst@linuxcare.com> for patiently
98  * debugging this driver on the parisc architecture and suggesting
99  * many improvements and bug fixes.
100  *
101  * Thanks also go to Linuxcare Inc. for providing several PARISC
102  * machines for me to debug the driver on.
103  *
104  * Version 2.2
105  *
106  * Made the driver mem or io mapped; added endian invariance; added
107  * dma cache flushing operations for architectures which need it;
108  * added support for more varied clocking speeds.
109  *
110  * Version 2.1
111  *
112  * Initial modularisation from the D700.  See NCR_D700.c for the rest of
113  * the changelog.
114  * */
115 #define NCR_700_VERSION "2.8"
116 
117 #include <linux/kernel.h>
118 #include <linux/types.h>
119 #include <linux/string.h>
120 #include <linux/ioport.h>
121 #include <linux/delay.h>
122 #include <linux/spinlock.h>
123 #include <linux/completion.h>
124 #include <linux/init.h>
125 #include <linux/proc_fs.h>
126 #include <linux/blkdev.h>
127 #include <linux/module.h>
128 #include <linux/interrupt.h>
129 #include <linux/device.h>
130 #include <asm/dma.h>
131 #include <asm/system.h>
132 #include <asm/io.h>
133 #include <asm/pgtable.h>
134 #include <asm/byteorder.h>
135 
136 #include <scsi/scsi.h>
137 #include <scsi/scsi_cmnd.h>
138 #include <scsi/scsi_dbg.h>
139 #include <scsi/scsi_eh.h>
140 #include <scsi/scsi_host.h>
141 #include <scsi/scsi_tcq.h>
142 #include <scsi/scsi_transport.h>
143 #include <scsi/scsi_transport_spi.h>
144 
145 #include "53c700.h"
146 
147 /* NOTE: For 64 bit drivers there are points in the code where we use
148  * a non dereferenceable pointer to point to a structure in dma-able
149  * memory (which is 32 bits) so that we can use all of the structure
150  * operations but take the address at the end.  This macro allows us
151  * to truncate the 64 bit pointer down to 32 bits without the compiler
152  * complaining */
153 #define to32bit(x)	((__u32)((unsigned long)(x)))
154 
155 #ifdef NCR_700_DEBUG
156 #define STATIC
157 #else
158 #define STATIC static
159 #endif
160 
161 MODULE_AUTHOR("James Bottomley");
162 MODULE_DESCRIPTION("53c700 and 53c700-66 Driver");
163 MODULE_LICENSE("GPL");
164 
165 /* This is the script */
166 #include "53c700_d.h"
167 
168 
169 STATIC int NCR_700_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *));
170 STATIC int NCR_700_abort(struct scsi_cmnd * SCpnt);
171 STATIC int NCR_700_bus_reset(struct scsi_cmnd * SCpnt);
172 STATIC int NCR_700_host_reset(struct scsi_cmnd * SCpnt);
173 STATIC void NCR_700_chip_setup(struct Scsi_Host *host);
174 STATIC void NCR_700_chip_reset(struct Scsi_Host *host);
175 STATIC int NCR_700_slave_alloc(struct scsi_device *SDpnt);
176 STATIC int NCR_700_slave_configure(struct scsi_device *SDpnt);
177 STATIC void NCR_700_slave_destroy(struct scsi_device *SDpnt);
178 static int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth);
179 static int NCR_700_change_queue_type(struct scsi_device *SDpnt, int depth);
180 
181 STATIC struct device_attribute *NCR_700_dev_attrs[];
182 
183 STATIC struct scsi_transport_template *NCR_700_transport_template = NULL;
184 
185 static char *NCR_700_phase[] = {
186 	"",
187 	"after selection",
188 	"before command phase",
189 	"after command phase",
190 	"after status phase",
191 	"after data in phase",
192 	"after data out phase",
193 	"during data phase",
194 };
195 
196 static char *NCR_700_condition[] = {
197 	"",
198 	"NOT MSG_OUT",
199 	"UNEXPECTED PHASE",
200 	"NOT MSG_IN",
201 	"UNEXPECTED MSG",
202 	"MSG_IN",
203 	"SDTR_MSG RECEIVED",
204 	"REJECT_MSG RECEIVED",
205 	"DISCONNECT_MSG RECEIVED",
206 	"MSG_OUT",
207 	"DATA_IN",
208 
209 };
210 
211 static char *NCR_700_fatal_messages[] = {
212 	"unexpected message after reselection",
213 	"still MSG_OUT after message injection",
214 	"not MSG_IN after selection",
215 	"Illegal message length received",
216 };
217 
218 static char *NCR_700_SBCL_bits[] = {
219 	"IO ",
220 	"CD ",
221 	"MSG ",
222 	"ATN ",
223 	"SEL ",
224 	"BSY ",
225 	"ACK ",
226 	"REQ ",
227 };
228 
229 static char *NCR_700_SBCL_to_phase[] = {
230 	"DATA_OUT",
231 	"DATA_IN",
232 	"CMD_OUT",
233 	"STATE",
234 	"ILLEGAL PHASE",
235 	"ILLEGAL PHASE",
236 	"MSG OUT",
237 	"MSG IN",
238 };
239 
240 /* This translates the SDTR message offset and period to a value
241  * which can be loaded into the SXFER_REG.
242  *
243  * NOTE: According to SCSI-2, the true transfer period (in ns) is
244  *       actually four times this period value */
245 static inline __u8
246 NCR_700_offset_period_to_sxfer(struct NCR_700_Host_Parameters *hostdata,
247 			       __u8 offset, __u8 period)
248 {
249 	int XFERP;
250 
251 	__u8 min_xferp = (hostdata->chip710
252 			  ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
253 	__u8 max_offset = (hostdata->chip710
254 			   ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET);
255 
256 	if(offset == 0)
257 		return 0;
258 
259 	if(period < hostdata->min_period) {
260 		printk(KERN_WARNING "53c700: Period %dns is less than this chip's minimum, setting to %d\n", period*4, NCR_700_MIN_PERIOD*4);
261 		period = hostdata->min_period;
262 	}
263 	XFERP = (period*4 * hostdata->sync_clock)/1000 - 4;
264 	if(offset > max_offset) {
265 		printk(KERN_WARNING "53c700: Offset %d exceeds chip maximum, setting to %d\n",
266 		       offset, max_offset);
267 		offset = max_offset;
268 	}
269 	if(XFERP < min_xferp) {
270 		printk(KERN_WARNING "53c700: XFERP %d is less than minium, setting to %d\n",
271 		       XFERP,  min_xferp);
272 		XFERP =  min_xferp;
273 	}
274 	return (offset & 0x0f) | (XFERP & 0x07)<<4;
275 }
276 
277 static inline __u8
278 NCR_700_get_SXFER(struct scsi_device *SDp)
279 {
280 	struct NCR_700_Host_Parameters *hostdata =
281 		(struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
282 
283 	return NCR_700_offset_period_to_sxfer(hostdata,
284 					      spi_offset(SDp->sdev_target),
285 					      spi_period(SDp->sdev_target));
286 }
287 
288 struct Scsi_Host *
289 NCR_700_detect(struct scsi_host_template *tpnt,
290 	       struct NCR_700_Host_Parameters *hostdata, struct device *dev)
291 {
292 	dma_addr_t pScript, pSlots;
293 	__u8 *memory;
294 	__u32 *script;
295 	struct Scsi_Host *host;
296 	static int banner = 0;
297 	int j;
298 
299 	if(tpnt->sdev_attrs == NULL)
300 		tpnt->sdev_attrs = NCR_700_dev_attrs;
301 
302 	memory = dma_alloc_noncoherent(hostdata->dev, TOTAL_MEM_SIZE,
303 				       &pScript, GFP_KERNEL);
304 	if(memory == NULL) {
305 		printk(KERN_ERR "53c700: Failed to allocate memory for driver, detatching\n");
306 		return NULL;
307 	}
308 
309 	script = (__u32 *)memory;
310 	hostdata->msgin = memory + MSGIN_OFFSET;
311 	hostdata->msgout = memory + MSGOUT_OFFSET;
312 	hostdata->status = memory + STATUS_OFFSET;
313 	/* all of these offsets are L1_CACHE_BYTES separated.  It is fatal
314 	 * if this isn't sufficient separation to avoid dma flushing issues */
315 	BUG_ON(!dma_is_consistent(hostdata->dev, pScript) && L1_CACHE_BYTES < dma_get_cache_alignment());
316 	hostdata->slots = (struct NCR_700_command_slot *)(memory + SLOTS_OFFSET);
317 	hostdata->dev = dev;
318 
319 	pSlots = pScript + SLOTS_OFFSET;
320 
321 	/* Fill in the missing routines from the host template */
322 	tpnt->queuecommand = NCR_700_queuecommand;
323 	tpnt->eh_abort_handler = NCR_700_abort;
324 	tpnt->eh_bus_reset_handler = NCR_700_bus_reset;
325 	tpnt->eh_host_reset_handler = NCR_700_host_reset;
326 	tpnt->can_queue = NCR_700_COMMAND_SLOTS_PER_HOST;
327 	tpnt->sg_tablesize = NCR_700_SG_SEGMENTS;
328 	tpnt->cmd_per_lun = NCR_700_CMD_PER_LUN;
329 	tpnt->use_clustering = ENABLE_CLUSTERING;
330 	tpnt->slave_configure = NCR_700_slave_configure;
331 	tpnt->slave_destroy = NCR_700_slave_destroy;
332 	tpnt->slave_alloc = NCR_700_slave_alloc;
333 	tpnt->change_queue_depth = NCR_700_change_queue_depth;
334 	tpnt->change_queue_type = NCR_700_change_queue_type;
335 
336 	if(tpnt->name == NULL)
337 		tpnt->name = "53c700";
338 	if(tpnt->proc_name == NULL)
339 		tpnt->proc_name = "53c700";
340 
341 	host = scsi_host_alloc(tpnt, 4);
342 	if (!host)
343 		return NULL;
344 	memset(hostdata->slots, 0, sizeof(struct NCR_700_command_slot)
345 	       * NCR_700_COMMAND_SLOTS_PER_HOST);
346 	for (j = 0; j < NCR_700_COMMAND_SLOTS_PER_HOST; j++) {
347 		dma_addr_t offset = (dma_addr_t)((unsigned long)&hostdata->slots[j].SG[0]
348 					  - (unsigned long)&hostdata->slots[0].SG[0]);
349 		hostdata->slots[j].pSG = (struct NCR_700_SG_List *)((unsigned long)(pSlots + offset));
350 		if(j == 0)
351 			hostdata->free_list = &hostdata->slots[j];
352 		else
353 			hostdata->slots[j-1].ITL_forw = &hostdata->slots[j];
354 		hostdata->slots[j].state = NCR_700_SLOT_FREE;
355 	}
356 
357 	for (j = 0; j < ARRAY_SIZE(SCRIPT); j++)
358 		script[j] = bS_to_host(SCRIPT[j]);
359 
360 	/* adjust all labels to be bus physical */
361 	for (j = 0; j < PATCHES; j++)
362 		script[LABELPATCHES[j]] = bS_to_host(pScript + SCRIPT[LABELPATCHES[j]]);
363 	/* now patch up fixed addresses. */
364 	script_patch_32(hostdata->dev, script, MessageLocation,
365 			pScript + MSGOUT_OFFSET);
366 	script_patch_32(hostdata->dev, script, StatusAddress,
367 			pScript + STATUS_OFFSET);
368 	script_patch_32(hostdata->dev, script, ReceiveMsgAddress,
369 			pScript + MSGIN_OFFSET);
370 
371 	hostdata->script = script;
372 	hostdata->pScript = pScript;
373 	dma_sync_single_for_device(hostdata->dev, pScript, sizeof(SCRIPT), DMA_TO_DEVICE);
374 	hostdata->state = NCR_700_HOST_FREE;
375 	hostdata->cmd = NULL;
376 	host->max_id = 8;
377 	host->max_lun = NCR_700_MAX_LUNS;
378 	BUG_ON(NCR_700_transport_template == NULL);
379 	host->transportt = NCR_700_transport_template;
380 	host->unique_id = (unsigned long)hostdata->base;
381 	hostdata->eh_complete = NULL;
382 	host->hostdata[0] = (unsigned long)hostdata;
383 	/* kick the chip */
384 	NCR_700_writeb(0xff, host, CTEST9_REG);
385 	if (hostdata->chip710)
386 		hostdata->rev = (NCR_700_readb(host, CTEST8_REG)>>4) & 0x0f;
387 	else
388 		hostdata->rev = (NCR_700_readb(host, CTEST7_REG)>>4) & 0x0f;
389 	hostdata->fast = (NCR_700_readb(host, CTEST9_REG) == 0);
390 	if (banner == 0) {
391 		printk(KERN_NOTICE "53c700: Version " NCR_700_VERSION " By James.Bottomley@HansenPartnership.com\n");
392 		banner = 1;
393 	}
394 	printk(KERN_NOTICE "scsi%d: %s rev %d %s\n", host->host_no,
395 	       hostdata->chip710 ? "53c710" :
396 	       (hostdata->fast ? "53c700-66" : "53c700"),
397 	       hostdata->rev, hostdata->differential ?
398 	       "(Differential)" : "");
399 	/* reset the chip */
400 	NCR_700_chip_reset(host);
401 
402 	if (scsi_add_host(host, dev)) {
403 		dev_printk(KERN_ERR, dev, "53c700: scsi_add_host failed\n");
404 		scsi_host_put(host);
405 		return NULL;
406 	}
407 
408 	spi_signalling(host) = hostdata->differential ? SPI_SIGNAL_HVD :
409 		SPI_SIGNAL_SE;
410 
411 	return host;
412 }
413 
414 int
415 NCR_700_release(struct Scsi_Host *host)
416 {
417 	struct NCR_700_Host_Parameters *hostdata =
418 		(struct NCR_700_Host_Parameters *)host->hostdata[0];
419 
420 	dma_free_noncoherent(hostdata->dev, TOTAL_MEM_SIZE,
421 			       hostdata->script, hostdata->pScript);
422 	return 1;
423 }
424 
425 static inline __u8
426 NCR_700_identify(int can_disconnect, __u8 lun)
427 {
428 	return IDENTIFY_BASE |
429 		((can_disconnect) ? 0x40 : 0) |
430 		(lun & NCR_700_LUN_MASK);
431 }
432 
433 /*
434  * Function : static int data_residual (Scsi_Host *host)
435  *
436  * Purpose : return residual data count of what's in the chip.  If you
437  * really want to know what this function is doing, it's almost a
438  * direct transcription of the algorithm described in the 53c710
439  * guide, except that the DBC and DFIFO registers are only 6 bits
440  * wide on a 53c700.
441  *
442  * Inputs : host - SCSI host */
443 static inline int
444 NCR_700_data_residual (struct Scsi_Host *host) {
445 	struct NCR_700_Host_Parameters *hostdata =
446 		(struct NCR_700_Host_Parameters *)host->hostdata[0];
447 	int count, synchronous = 0;
448 	unsigned int ddir;
449 
450 	if(hostdata->chip710) {
451 		count = ((NCR_700_readb(host, DFIFO_REG) & 0x7f) -
452 			 (NCR_700_readl(host, DBC_REG) & 0x7f)) & 0x7f;
453 	} else {
454 		count = ((NCR_700_readb(host, DFIFO_REG) & 0x3f) -
455 			 (NCR_700_readl(host, DBC_REG) & 0x3f)) & 0x3f;
456 	}
457 
458 	if(hostdata->fast)
459 		synchronous = NCR_700_readb(host, SXFER_REG) & 0x0f;
460 
461 	/* get the data direction */
462 	ddir = NCR_700_readb(host, CTEST0_REG) & 0x01;
463 
464 	if (ddir) {
465 		/* Receive */
466 		if (synchronous)
467 			count += (NCR_700_readb(host, SSTAT2_REG) & 0xf0) >> 4;
468 		else
469 			if (NCR_700_readb(host, SSTAT1_REG) & SIDL_REG_FULL)
470 				++count;
471 	} else {
472 		/* Send */
473 		__u8 sstat = NCR_700_readb(host, SSTAT1_REG);
474 		if (sstat & SODL_REG_FULL)
475 			++count;
476 		if (synchronous && (sstat & SODR_REG_FULL))
477 			++count;
478 	}
479 #ifdef NCR_700_DEBUG
480 	if(count)
481 		printk("RESIDUAL IS %d (ddir %d)\n", count, ddir);
482 #endif
483 	return count;
484 }
485 
486 /* print out the SCSI wires and corresponding phase from the SBCL register
487  * in the chip */
488 static inline char *
489 sbcl_to_string(__u8 sbcl)
490 {
491 	int i;
492 	static char ret[256];
493 
494 	ret[0]='\0';
495 	for(i=0; i<8; i++) {
496 		if((1<<i) & sbcl)
497 			strcat(ret, NCR_700_SBCL_bits[i]);
498 	}
499 	strcat(ret, NCR_700_SBCL_to_phase[sbcl & 0x07]);
500 	return ret;
501 }
502 
503 static inline __u8
504 bitmap_to_number(__u8 bitmap)
505 {
506 	__u8 i;
507 
508 	for(i=0; i<8 && !(bitmap &(1<<i)); i++)
509 		;
510 	return i;
511 }
512 
513 /* Pull a slot off the free list */
514 STATIC struct NCR_700_command_slot *
515 find_empty_slot(struct NCR_700_Host_Parameters *hostdata)
516 {
517 	struct NCR_700_command_slot *slot = hostdata->free_list;
518 
519 	if(slot == NULL) {
520 		/* sanity check */
521 		if(hostdata->command_slot_count != NCR_700_COMMAND_SLOTS_PER_HOST)
522 			printk(KERN_ERR "SLOTS FULL, but count is %d, should be %d\n", hostdata->command_slot_count, NCR_700_COMMAND_SLOTS_PER_HOST);
523 		return NULL;
524 	}
525 
526 	if(slot->state != NCR_700_SLOT_FREE)
527 		/* should panic! */
528 		printk(KERN_ERR "BUSY SLOT ON FREE LIST!!!\n");
529 
530 
531 	hostdata->free_list = slot->ITL_forw;
532 	slot->ITL_forw = NULL;
533 
534 
535 	/* NOTE: set the state to busy here, not queued, since this
536 	 * indicates the slot is in use and cannot be run by the IRQ
537 	 * finish routine.  If we cannot queue the command when it
538 	 * is properly build, we then change to NCR_700_SLOT_QUEUED */
539 	slot->state = NCR_700_SLOT_BUSY;
540 	slot->flags = 0;
541 	hostdata->command_slot_count++;
542 
543 	return slot;
544 }
545 
546 STATIC void
547 free_slot(struct NCR_700_command_slot *slot,
548 	  struct NCR_700_Host_Parameters *hostdata)
549 {
550 	if((slot->state & NCR_700_SLOT_MASK) != NCR_700_SLOT_MAGIC) {
551 		printk(KERN_ERR "53c700: SLOT %p is not MAGIC!!!\n", slot);
552 	}
553 	if(slot->state == NCR_700_SLOT_FREE) {
554 		printk(KERN_ERR "53c700: SLOT %p is FREE!!!\n", slot);
555 	}
556 
557 	slot->resume_offset = 0;
558 	slot->cmnd = NULL;
559 	slot->state = NCR_700_SLOT_FREE;
560 	slot->ITL_forw = hostdata->free_list;
561 	hostdata->free_list = slot;
562 	hostdata->command_slot_count--;
563 }
564 
565 
566 /* This routine really does very little.  The command is indexed on
567    the ITL and (if tagged) the ITLQ lists in _queuecommand */
568 STATIC void
569 save_for_reselection(struct NCR_700_Host_Parameters *hostdata,
570 		     struct scsi_cmnd *SCp, __u32 dsp)
571 {
572 	/* Its just possible that this gets executed twice */
573 	if(SCp != NULL) {
574 		struct NCR_700_command_slot *slot =
575 			(struct NCR_700_command_slot *)SCp->host_scribble;
576 
577 		slot->resume_offset = dsp;
578 	}
579 	hostdata->state = NCR_700_HOST_FREE;
580 	hostdata->cmd = NULL;
581 }
582 
583 STATIC inline void
584 NCR_700_unmap(struct NCR_700_Host_Parameters *hostdata, struct scsi_cmnd *SCp,
585 	      struct NCR_700_command_slot *slot)
586 {
587 	if(SCp->sc_data_direction != DMA_NONE &&
588 	   SCp->sc_data_direction != DMA_BIDIRECTIONAL) {
589 		if(SCp->use_sg) {
590 			dma_unmap_sg(hostdata->dev, SCp->request_buffer,
591 				     SCp->use_sg, SCp->sc_data_direction);
592 		} else {
593 			dma_unmap_single(hostdata->dev, slot->dma_handle,
594 					 SCp->request_bufflen,
595 					 SCp->sc_data_direction);
596 		}
597 	}
598 }
599 
600 STATIC inline void
601 NCR_700_scsi_done(struct NCR_700_Host_Parameters *hostdata,
602 	       struct scsi_cmnd *SCp, int result)
603 {
604 	hostdata->state = NCR_700_HOST_FREE;
605 	hostdata->cmd = NULL;
606 
607 	if(SCp != NULL) {
608 		struct NCR_700_command_slot *slot =
609 			(struct NCR_700_command_slot *)SCp->host_scribble;
610 
611 		dma_unmap_single(hostdata->dev, slot->pCmd,
612 				 sizeof(SCp->cmnd), DMA_TO_DEVICE);
613 		if (slot->flags == NCR_700_FLAG_AUTOSENSE) {
614 			char *cmnd = NCR_700_get_sense_cmnd(SCp->device);
615 #ifdef NCR_700_DEBUG
616 			printk(" ORIGINAL CMD %p RETURNED %d, new return is %d sense is\n",
617 			       SCp, SCp->cmnd[7], result);
618 			scsi_print_sense("53c700", SCp);
619 
620 #endif
621 			dma_unmap_single(hostdata->dev, slot->dma_handle, sizeof(SCp->sense_buffer), DMA_FROM_DEVICE);
622 			/* restore the old result if the request sense was
623 			 * successful */
624 			if (result == 0)
625 				result = cmnd[7];
626 			/* restore the original length */
627 			SCp->cmd_len = cmnd[8];
628 		} else
629 			NCR_700_unmap(hostdata, SCp, slot);
630 
631 		free_slot(slot, hostdata);
632 #ifdef NCR_700_DEBUG
633 		if(NCR_700_get_depth(SCp->device) == 0 ||
634 		   NCR_700_get_depth(SCp->device) > SCp->device->queue_depth)
635 			printk(KERN_ERR "Invalid depth in NCR_700_scsi_done(): %d\n",
636 			       NCR_700_get_depth(SCp->device));
637 #endif /* NCR_700_DEBUG */
638 		NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) - 1);
639 
640 		SCp->host_scribble = NULL;
641 		SCp->result = result;
642 		SCp->scsi_done(SCp);
643 	} else {
644 		printk(KERN_ERR "53c700: SCSI DONE HAS NULL SCp\n");
645 	}
646 }
647 
648 
649 STATIC void
650 NCR_700_internal_bus_reset(struct Scsi_Host *host)
651 {
652 	/* Bus reset */
653 	NCR_700_writeb(ASSERT_RST, host, SCNTL1_REG);
654 	udelay(50);
655 	NCR_700_writeb(0, host, SCNTL1_REG);
656 
657 }
658 
659 STATIC void
660 NCR_700_chip_setup(struct Scsi_Host *host)
661 {
662 	struct NCR_700_Host_Parameters *hostdata =
663 		(struct NCR_700_Host_Parameters *)host->hostdata[0];
664 	__u32 dcntl_extra = 0;
665 	__u8 min_period;
666 	__u8 min_xferp = (hostdata->chip710 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
667 
668 	if(hostdata->chip710) {
669 		__u8 burst_disable = 0;
670 		__u8 burst_length = 0;
671 
672 		switch (hostdata->burst_length) {
673 			case 1:
674 			        burst_length = BURST_LENGTH_1;
675 			        break;
676 			case 2:
677 			        burst_length = BURST_LENGTH_2;
678 			        break;
679 			case 4:
680 			        burst_length = BURST_LENGTH_4;
681 			        break;
682 			case 8:
683 			        burst_length = BURST_LENGTH_8;
684 			        break;
685 			default:
686 			        burst_disable = BURST_DISABLE;
687 			        break;
688 		}
689 		dcntl_extra = COMPAT_700_MODE;
690 
691 		NCR_700_writeb(dcntl_extra, host, DCNTL_REG);
692 		NCR_700_writeb(burst_length | hostdata->dmode_extra,
693 			       host, DMODE_710_REG);
694 		NCR_700_writeb(burst_disable | (hostdata->differential ?
695 						DIFF : 0), host, CTEST7_REG);
696 		NCR_700_writeb(BTB_TIMER_DISABLE, host, CTEST0_REG);
697 		NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY | PARITY
698 			       | AUTO_ATN, host, SCNTL0_REG);
699 	} else {
700 		NCR_700_writeb(BURST_LENGTH_8 | hostdata->dmode_extra,
701 			       host, DMODE_700_REG);
702 		NCR_700_writeb(hostdata->differential ?
703 			       DIFF : 0, host, CTEST7_REG);
704 		if(hostdata->fast) {
705 			/* this is for 700-66, does nothing on 700 */
706 			NCR_700_writeb(LAST_DIS_ENBL | ENABLE_ACTIVE_NEGATION
707 				       | GENERATE_RECEIVE_PARITY, host,
708 				       CTEST8_REG);
709 		} else {
710 			NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY
711 				       | PARITY | AUTO_ATN, host, SCNTL0_REG);
712 		}
713 	}
714 
715 	NCR_700_writeb(1 << host->this_id, host, SCID_REG);
716 	NCR_700_writeb(0, host, SBCL_REG);
717 	NCR_700_writeb(ASYNC_OPERATION, host, SXFER_REG);
718 
719 	NCR_700_writeb(PHASE_MM_INT | SEL_TIMEOUT_INT | GROSS_ERR_INT | UX_DISC_INT
720 	     | RST_INT | PAR_ERR_INT | SELECT_INT, host, SIEN_REG);
721 
722 	NCR_700_writeb(ABORT_INT | INT_INST_INT | ILGL_INST_INT, host, DIEN_REG);
723 	NCR_700_writeb(ENABLE_SELECT, host, SCNTL1_REG);
724 	if(hostdata->clock > 75) {
725 		printk(KERN_ERR "53c700: Clock speed %dMHz is too high: 75Mhz is the maximum this chip can be driven at\n", hostdata->clock);
726 		/* do the best we can, but the async clock will be out
727 		 * of spec: sync divider 2, async divider 3 */
728 		DEBUG(("53c700: sync 2 async 3\n"));
729 		NCR_700_writeb(SYNC_DIV_2_0, host, SBCL_REG);
730 		NCR_700_writeb(ASYNC_DIV_3_0 | dcntl_extra, host, DCNTL_REG);
731 		hostdata->sync_clock = hostdata->clock/2;
732 	} else	if(hostdata->clock > 50  && hostdata->clock <= 75) {
733 		/* sync divider 1.5, async divider 3 */
734 		DEBUG(("53c700: sync 1.5 async 3\n"));
735 		NCR_700_writeb(SYNC_DIV_1_5, host, SBCL_REG);
736 		NCR_700_writeb(ASYNC_DIV_3_0 | dcntl_extra, host, DCNTL_REG);
737 		hostdata->sync_clock = hostdata->clock*2;
738 		hostdata->sync_clock /= 3;
739 
740 	} else if(hostdata->clock > 37 && hostdata->clock <= 50) {
741 		/* sync divider 1, async divider 2 */
742 		DEBUG(("53c700: sync 1 async 2\n"));
743 		NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
744 		NCR_700_writeb(ASYNC_DIV_2_0 | dcntl_extra, host, DCNTL_REG);
745 		hostdata->sync_clock = hostdata->clock;
746 	} else if(hostdata->clock > 25 && hostdata->clock <=37) {
747 		/* sync divider 1, async divider 1.5 */
748 		DEBUG(("53c700: sync 1 async 1.5\n"));
749 		NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
750 		NCR_700_writeb(ASYNC_DIV_1_5 | dcntl_extra, host, DCNTL_REG);
751 		hostdata->sync_clock = hostdata->clock;
752 	} else {
753 		DEBUG(("53c700: sync 1 async 1\n"));
754 		NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
755 		NCR_700_writeb(ASYNC_DIV_1_0 | dcntl_extra, host, DCNTL_REG);
756 		/* sync divider 1, async divider 1 */
757 		hostdata->sync_clock = hostdata->clock;
758 	}
759 	/* Calculate the actual minimum period that can be supported
760 	 * by our synchronous clock speed.  See the 710 manual for
761 	 * exact details of this calculation which is based on a
762 	 * setting of the SXFER register */
763 	min_period = 1000*(4+min_xferp)/(4*hostdata->sync_clock);
764 	hostdata->min_period = NCR_700_MIN_PERIOD;
765 	if(min_period > NCR_700_MIN_PERIOD)
766 		hostdata->min_period = min_period;
767 }
768 
769 STATIC void
770 NCR_700_chip_reset(struct Scsi_Host *host)
771 {
772 	struct NCR_700_Host_Parameters *hostdata =
773 		(struct NCR_700_Host_Parameters *)host->hostdata[0];
774 	if(hostdata->chip710) {
775 		NCR_700_writeb(SOFTWARE_RESET_710, host, ISTAT_REG);
776 		udelay(100);
777 
778 		NCR_700_writeb(0, host, ISTAT_REG);
779 	} else {
780 		NCR_700_writeb(SOFTWARE_RESET, host, DCNTL_REG);
781 		udelay(100);
782 
783 		NCR_700_writeb(0, host, DCNTL_REG);
784 	}
785 
786 	mdelay(1000);
787 
788 	NCR_700_chip_setup(host);
789 }
790 
791 /* The heart of the message processing engine is that the instruction
792  * immediately after the INT is the normal case (and so must be CLEAR
793  * ACK).  If we want to do something else, we call that routine in
794  * scripts and set temp to be the normal case + 8 (skipping the CLEAR
795  * ACK) so that the routine returns correctly to resume its activity
796  * */
797 STATIC __u32
798 process_extended_message(struct Scsi_Host *host,
799 			 struct NCR_700_Host_Parameters *hostdata,
800 			 struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps)
801 {
802 	__u32 resume_offset = dsp, temp = dsp + 8;
803 	__u8 pun = 0xff, lun = 0xff;
804 
805 	if(SCp != NULL) {
806 		pun = SCp->device->id;
807 		lun = SCp->device->lun;
808 	}
809 
810 	switch(hostdata->msgin[2]) {
811 	case A_SDTR_MSG:
812 		if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
813 			struct scsi_target *starget = SCp->device->sdev_target;
814 			__u8 period = hostdata->msgin[3];
815 			__u8 offset = hostdata->msgin[4];
816 
817 			if(offset == 0 || period == 0) {
818 				offset = 0;
819 				period = 0;
820 			}
821 
822 			spi_offset(starget) = offset;
823 			spi_period(starget) = period;
824 
825 			if(NCR_700_is_flag_set(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION)) {
826 				spi_display_xfer_agreement(starget);
827 				NCR_700_clear_flag(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION);
828 			}
829 
830 			NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
831 			NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
832 
833 			NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
834 				       host, SXFER_REG);
835 
836 		} else {
837 			/* SDTR message out of the blue, reject it */
838 			shost_printk(KERN_WARNING, host,
839 				"Unexpected SDTR msg\n");
840 			hostdata->msgout[0] = A_REJECT_MSG;
841 			dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE);
842 			script_patch_16(hostdata->dev, hostdata->script,
843 			                MessageCount, 1);
844 			/* SendMsgOut returns, so set up the return
845 			 * address */
846 			resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
847 		}
848 		break;
849 
850 	case A_WDTR_MSG:
851 		printk(KERN_INFO "scsi%d: (%d:%d), Unsolicited WDTR after CMD, Rejecting\n",
852 		       host->host_no, pun, lun);
853 		hostdata->msgout[0] = A_REJECT_MSG;
854 		dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE);
855 		script_patch_16(hostdata->dev, hostdata->script, MessageCount,
856 		                1);
857 		resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
858 
859 		break;
860 
861 	default:
862 		printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
863 		       host->host_no, pun, lun,
864 		       NCR_700_phase[(dsps & 0xf00) >> 8]);
865 		spi_print_msg(hostdata->msgin);
866 		printk("\n");
867 		/* just reject it */
868 		hostdata->msgout[0] = A_REJECT_MSG;
869 		dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE);
870 		script_patch_16(hostdata->dev, hostdata->script, MessageCount,
871 		                1);
872 		/* SendMsgOut returns, so set up the return
873 		 * address */
874 		resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
875 	}
876 	NCR_700_writel(temp, host, TEMP_REG);
877 	return resume_offset;
878 }
879 
880 STATIC __u32
881 process_message(struct Scsi_Host *host,	struct NCR_700_Host_Parameters *hostdata,
882 		struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps)
883 {
884 	/* work out where to return to */
885 	__u32 temp = dsp + 8, resume_offset = dsp;
886 	__u8 pun = 0xff, lun = 0xff;
887 
888 	if(SCp != NULL) {
889 		pun = SCp->device->id;
890 		lun = SCp->device->lun;
891 	}
892 
893 #ifdef NCR_700_DEBUG
894 	printk("scsi%d (%d:%d): message %s: ", host->host_no, pun, lun,
895 	       NCR_700_phase[(dsps & 0xf00) >> 8]);
896 	spi_print_msg(hostdata->msgin);
897 	printk("\n");
898 #endif
899 
900 	switch(hostdata->msgin[0]) {
901 
902 	case A_EXTENDED_MSG:
903 		resume_offset =  process_extended_message(host, hostdata, SCp,
904 							  dsp, dsps);
905 		break;
906 
907 	case A_REJECT_MSG:
908 		if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
909 			/* Rejected our sync negotiation attempt */
910 			spi_period(SCp->device->sdev_target) =
911 				spi_offset(SCp->device->sdev_target) = 0;
912 			NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
913 			NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
914 		} else if(SCp != NULL && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION) {
915 			/* rejected our first simple tag message */
916 			scmd_printk(KERN_WARNING, SCp,
917 				"Rejected first tag queue attempt, turning off tag queueing\n");
918 			/* we're done negotiating */
919 			NCR_700_set_tag_neg_state(SCp->device, NCR_700_FINISHED_TAG_NEGOTIATION);
920 			hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
921 			SCp->device->tagged_supported = 0;
922 			scsi_deactivate_tcq(SCp->device, host->cmd_per_lun);
923 		} else {
924 			shost_printk(KERN_WARNING, host,
925 				"(%d:%d) Unexpected REJECT Message %s\n",
926 			       pun, lun,
927 			       NCR_700_phase[(dsps & 0xf00) >> 8]);
928 			/* however, just ignore it */
929 		}
930 		break;
931 
932 	case A_PARITY_ERROR_MSG:
933 		printk(KERN_ERR "scsi%d (%d:%d) Parity Error!\n", host->host_no,
934 		       pun, lun);
935 		NCR_700_internal_bus_reset(host);
936 		break;
937 	case A_SIMPLE_TAG_MSG:
938 		printk(KERN_INFO "scsi%d (%d:%d) SIMPLE TAG %d %s\n", host->host_no,
939 		       pun, lun, hostdata->msgin[1],
940 		       NCR_700_phase[(dsps & 0xf00) >> 8]);
941 		/* just ignore it */
942 		break;
943 	default:
944 		printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
945 		       host->host_no, pun, lun,
946 		       NCR_700_phase[(dsps & 0xf00) >> 8]);
947 
948 		spi_print_msg(hostdata->msgin);
949 		printk("\n");
950 		/* just reject it */
951 		hostdata->msgout[0] = A_REJECT_MSG;
952 		dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE);
953 		script_patch_16(hostdata->dev, hostdata->script, MessageCount,
954 		                1);
955 		/* SendMsgOut returns, so set up the return
956 		 * address */
957 		resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
958 
959 		break;
960 	}
961 	NCR_700_writel(temp, host, TEMP_REG);
962 	/* set us up to receive another message */
963 	dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE, DMA_FROM_DEVICE);
964 	return resume_offset;
965 }
966 
967 STATIC __u32
968 process_script_interrupt(__u32 dsps, __u32 dsp, struct scsi_cmnd *SCp,
969 			 struct Scsi_Host *host,
970 			 struct NCR_700_Host_Parameters *hostdata)
971 {
972 	__u32 resume_offset = 0;
973 	__u8 pun = 0xff, lun=0xff;
974 
975 	if(SCp != NULL) {
976 		pun = SCp->device->id;
977 		lun = SCp->device->lun;
978 	}
979 
980 	if(dsps == A_GOOD_STATUS_AFTER_STATUS) {
981 		DEBUG(("  COMMAND COMPLETE, status=%02x\n",
982 		       hostdata->status[0]));
983 		/* OK, if TCQ still under negotiation, we now know it works */
984 		if (NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION)
985 			NCR_700_set_tag_neg_state(SCp->device,
986 						  NCR_700_FINISHED_TAG_NEGOTIATION);
987 
988 		/* check for contingent allegiance contitions */
989 		if(status_byte(hostdata->status[0]) == CHECK_CONDITION ||
990 		   status_byte(hostdata->status[0]) == COMMAND_TERMINATED) {
991 			struct NCR_700_command_slot *slot =
992 				(struct NCR_700_command_slot *)SCp->host_scribble;
993 			if(slot->flags == NCR_700_FLAG_AUTOSENSE) {
994 				/* OOPS: bad device, returning another
995 				 * contingent allegiance condition */
996 				scmd_printk(KERN_ERR, SCp,
997 					"broken device is looping in contingent allegiance: ignoring\n");
998 				NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
999 			} else {
1000 				char *cmnd =
1001 					NCR_700_get_sense_cmnd(SCp->device);
1002 #ifdef NCR_DEBUG
1003 				scsi_print_command(SCp);
1004 				printk("  cmd %p has status %d, requesting sense\n",
1005 				       SCp, hostdata->status[0]);
1006 #endif
1007 				/* we can destroy the command here
1008 				 * because the contingent allegiance
1009 				 * condition will cause a retry which
1010 				 * will re-copy the command from the
1011 				 * saved data_cmnd.  We also unmap any
1012 				 * data associated with the command
1013 				 * here */
1014 				NCR_700_unmap(hostdata, SCp, slot);
1015 				dma_unmap_single(hostdata->dev, slot->pCmd,
1016 						 sizeof(SCp->cmnd),
1017 						 DMA_TO_DEVICE);
1018 
1019 				cmnd[0] = REQUEST_SENSE;
1020 				cmnd[1] = (SCp->device->lun & 0x7) << 5;
1021 				cmnd[2] = 0;
1022 				cmnd[3] = 0;
1023 				cmnd[4] = sizeof(SCp->sense_buffer);
1024 				cmnd[5] = 0;
1025 				/* Here's a quiet hack: the
1026 				 * REQUEST_SENSE command is six bytes,
1027 				 * so store a flag indicating that
1028 				 * this was an internal sense request
1029 				 * and the original status at the end
1030 				 * of the command */
1031 				cmnd[6] = NCR_700_INTERNAL_SENSE_MAGIC;
1032 				cmnd[7] = hostdata->status[0];
1033 				cmnd[8] = SCp->cmd_len;
1034 				SCp->cmd_len = 6; /* command length for
1035 						   * REQUEST_SENSE */
1036 				slot->pCmd = dma_map_single(hostdata->dev, cmnd, MAX_COMMAND_SIZE, DMA_TO_DEVICE);
1037 				slot->dma_handle = dma_map_single(hostdata->dev, SCp->sense_buffer, sizeof(SCp->sense_buffer), DMA_FROM_DEVICE);
1038 				slot->SG[0].ins = bS_to_host(SCRIPT_MOVE_DATA_IN | sizeof(SCp->sense_buffer));
1039 				slot->SG[0].pAddr = bS_to_host(slot->dma_handle);
1040 				slot->SG[1].ins = bS_to_host(SCRIPT_RETURN);
1041 				slot->SG[1].pAddr = 0;
1042 				slot->resume_offset = hostdata->pScript;
1043 				dma_cache_sync(hostdata->dev, slot->SG, sizeof(slot->SG[0])*2, DMA_TO_DEVICE);
1044 				dma_cache_sync(hostdata->dev, SCp->sense_buffer, sizeof(SCp->sense_buffer), DMA_FROM_DEVICE);
1045 
1046 				/* queue the command for reissue */
1047 				slot->state = NCR_700_SLOT_QUEUED;
1048 				slot->flags = NCR_700_FLAG_AUTOSENSE;
1049 				hostdata->state = NCR_700_HOST_FREE;
1050 				hostdata->cmd = NULL;
1051 			}
1052 		} else {
1053 			// Currently rely on the mid layer evaluation
1054 			// of the tag queuing capability
1055 			//
1056 			//if(status_byte(hostdata->status[0]) == GOOD &&
1057 			//   SCp->cmnd[0] == INQUIRY && SCp->use_sg == 0) {
1058 			//	/* Piggy back the tag queueing support
1059 			//	 * on this command */
1060 			//	dma_sync_single_for_cpu(hostdata->dev,
1061 			//			    slot->dma_handle,
1062 			//			    SCp->request_bufflen,
1063 			//			    DMA_FROM_DEVICE);
1064 			//	if(((char *)SCp->request_buffer)[7] & 0x02) {
1065 			//		scmd_printk(KERN_INFO, SCp,
1066 			//		     "Enabling Tag Command Queuing\n");
1067 			//		hostdata->tag_negotiated |= (1<<scmd_id(SCp));
1068 			//		NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
1069 			//	} else {
1070 			//		NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
1071 			//		hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
1072 			//	}
1073 			//}
1074 			NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
1075 		}
1076 	} else if((dsps & 0xfffff0f0) == A_UNEXPECTED_PHASE) {
1077 		__u8 i = (dsps & 0xf00) >> 8;
1078 
1079 		scmd_printk(KERN_ERR, SCp, "UNEXPECTED PHASE %s (%s)\n",
1080 		       NCR_700_phase[i],
1081 		       sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
1082 		scmd_printk(KERN_ERR, SCp, "         len = %d, cmd =",
1083 			SCp->cmd_len);
1084 		scsi_print_command(SCp);
1085 
1086 		NCR_700_internal_bus_reset(host);
1087 	} else if((dsps & 0xfffff000) == A_FATAL) {
1088 		int i = (dsps & 0xfff);
1089 
1090 		printk(KERN_ERR "scsi%d: (%d:%d) FATAL ERROR: %s\n",
1091 		       host->host_no, pun, lun, NCR_700_fatal_messages[i]);
1092 		if(dsps == A_FATAL_ILLEGAL_MSG_LENGTH) {
1093 			printk(KERN_ERR "     msg begins %02x %02x\n",
1094 			       hostdata->msgin[0], hostdata->msgin[1]);
1095 		}
1096 		NCR_700_internal_bus_reset(host);
1097 	} else if((dsps & 0xfffff0f0) == A_DISCONNECT) {
1098 #ifdef NCR_700_DEBUG
1099 		__u8 i = (dsps & 0xf00) >> 8;
1100 
1101 		printk("scsi%d: (%d:%d), DISCONNECTED (%d) %s\n",
1102 		       host->host_no, pun, lun,
1103 		       i, NCR_700_phase[i]);
1104 #endif
1105 		save_for_reselection(hostdata, SCp, dsp);
1106 
1107 	} else if(dsps == A_RESELECTION_IDENTIFIED) {
1108 		__u8 lun;
1109 		struct NCR_700_command_slot *slot;
1110 		__u8 reselection_id = hostdata->reselection_id;
1111 		struct scsi_device *SDp;
1112 
1113 		lun = hostdata->msgin[0] & 0x1f;
1114 
1115 		hostdata->reselection_id = 0xff;
1116 		DEBUG(("scsi%d: (%d:%d) RESELECTED!\n",
1117 		       host->host_no, reselection_id, lun));
1118 		/* clear the reselection indicator */
1119 		SDp = __scsi_device_lookup(host, 0, reselection_id, lun);
1120 		if(unlikely(SDp == NULL)) {
1121 			printk(KERN_ERR "scsi%d: (%d:%d) HAS NO device\n",
1122 			       host->host_no, reselection_id, lun);
1123 			BUG();
1124 		}
1125 		if(hostdata->msgin[1] == A_SIMPLE_TAG_MSG) {
1126 			struct scsi_cmnd *SCp = scsi_find_tag(SDp, hostdata->msgin[2]);
1127 			if(unlikely(SCp == NULL)) {
1128 				printk(KERN_ERR "scsi%d: (%d:%d) no saved request for tag %d\n",
1129 				       host->host_no, reselection_id, lun, hostdata->msgin[2]);
1130 				BUG();
1131 			}
1132 
1133 			slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1134 			DDEBUG(KERN_DEBUG, SDp,
1135 				"reselection is tag %d, slot %p(%d)\n",
1136 				hostdata->msgin[2], slot, slot->tag);
1137 		} else {
1138 			struct scsi_cmnd *SCp = scsi_find_tag(SDp, SCSI_NO_TAG);
1139 			if(unlikely(SCp == NULL)) {
1140 				sdev_printk(KERN_ERR, SDp,
1141 					"no saved request for untagged cmd\n");
1142 				BUG();
1143 			}
1144 			slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1145 		}
1146 
1147 		if(slot == NULL) {
1148 			printk(KERN_ERR "scsi%d: (%d:%d) RESELECTED but no saved command (MSG = %02x %02x %02x)!!\n",
1149 			       host->host_no, reselection_id, lun,
1150 			       hostdata->msgin[0], hostdata->msgin[1],
1151 			       hostdata->msgin[2]);
1152 		} else {
1153 			if(hostdata->state != NCR_700_HOST_BUSY)
1154 				printk(KERN_ERR "scsi%d: FATAL, host not busy during valid reselection!\n",
1155 				       host->host_no);
1156 			resume_offset = slot->resume_offset;
1157 			hostdata->cmd = slot->cmnd;
1158 
1159 			/* re-patch for this command */
1160 			script_patch_32_abs(hostdata->dev, hostdata->script,
1161 			                    CommandAddress, slot->pCmd);
1162 			script_patch_16(hostdata->dev, hostdata->script,
1163 					CommandCount, slot->cmnd->cmd_len);
1164 			script_patch_32_abs(hostdata->dev, hostdata->script,
1165 			                    SGScriptStartAddress,
1166 					    to32bit(&slot->pSG[0].ins));
1167 
1168 			/* Note: setting SXFER only works if we're
1169 			 * still in the MESSAGE phase, so it is vital
1170 			 * that ACK is still asserted when we process
1171 			 * the reselection message.  The resume offset
1172 			 * should therefore always clear ACK */
1173 			NCR_700_writeb(NCR_700_get_SXFER(hostdata->cmd->device),
1174 				       host, SXFER_REG);
1175 			dma_cache_sync(hostdata->dev, hostdata->msgin,
1176 				       MSG_ARRAY_SIZE, DMA_FROM_DEVICE);
1177 			dma_cache_sync(hostdata->dev, hostdata->msgout,
1178 				       MSG_ARRAY_SIZE, DMA_TO_DEVICE);
1179 			/* I'm just being paranoid here, the command should
1180 			 * already have been flushed from the cache */
1181 			dma_cache_sync(hostdata->dev, slot->cmnd->cmnd,
1182 				       slot->cmnd->cmd_len, DMA_TO_DEVICE);
1183 
1184 
1185 
1186 		}
1187 	} else if(dsps == A_RESELECTED_DURING_SELECTION) {
1188 
1189 		/* This section is full of debugging code because I've
1190 		 * never managed to reach it.  I think what happens is
1191 		 * that, because the 700 runs with selection
1192 		 * interrupts enabled the whole time that we take a
1193 		 * selection interrupt before we manage to get to the
1194 		 * reselected script interrupt */
1195 
1196 		__u8 reselection_id = NCR_700_readb(host, SFBR_REG);
1197 		struct NCR_700_command_slot *slot;
1198 
1199 		/* Take out our own ID */
1200 		reselection_id &= ~(1<<host->this_id);
1201 
1202 		/* I've never seen this happen, so keep this as a printk rather
1203 		 * than a debug */
1204 		printk(KERN_INFO "scsi%d: (%d:%d) RESELECTION DURING SELECTION, dsp=%08x[%04x] state=%d, count=%d\n",
1205 		       host->host_no, reselection_id, lun, dsp, dsp - hostdata->pScript, hostdata->state, hostdata->command_slot_count);
1206 
1207 		{
1208 			/* FIXME: DEBUGGING CODE */
1209 			__u32 SG = (__u32)bS_to_cpu(hostdata->script[A_SGScriptStartAddress_used[0]]);
1210 			int i;
1211 
1212 			for(i=0; i< NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
1213 				if(SG >= to32bit(&hostdata->slots[i].pSG[0])
1214 				   && SG <= to32bit(&hostdata->slots[i].pSG[NCR_700_SG_SEGMENTS]))
1215 					break;
1216 			}
1217 			printk(KERN_INFO "IDENTIFIED SG segment as being %08x in slot %p, cmd %p, slot->resume_offset=%08x\n", SG, &hostdata->slots[i], hostdata->slots[i].cmnd, hostdata->slots[i].resume_offset);
1218 			SCp =  hostdata->slots[i].cmnd;
1219 		}
1220 
1221 		if(SCp != NULL) {
1222 			slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1223 			/* change slot from busy to queued to redo command */
1224 			slot->state = NCR_700_SLOT_QUEUED;
1225 		}
1226 		hostdata->cmd = NULL;
1227 
1228 		if(reselection_id == 0) {
1229 			if(hostdata->reselection_id == 0xff) {
1230 				printk(KERN_ERR "scsi%d: Invalid reselection during selection!!\n", host->host_no);
1231 				return 0;
1232 			} else {
1233 				printk(KERN_ERR "scsi%d: script reselected and we took a selection interrupt\n",
1234 				       host->host_no);
1235 				reselection_id = hostdata->reselection_id;
1236 			}
1237 		} else {
1238 
1239 			/* convert to real ID */
1240 			reselection_id = bitmap_to_number(reselection_id);
1241 		}
1242 		hostdata->reselection_id = reselection_id;
1243 		/* just in case we have a stale simple tag message, clear it */
1244 		hostdata->msgin[1] = 0;
1245 		dma_cache_sync(hostdata->dev, hostdata->msgin,
1246 			       MSG_ARRAY_SIZE, DMA_BIDIRECTIONAL);
1247 		if(hostdata->tag_negotiated & (1<<reselection_id)) {
1248 			resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
1249 		} else {
1250 			resume_offset = hostdata->pScript + Ent_GetReselectionData;
1251 		}
1252 	} else if(dsps == A_COMPLETED_SELECTION_AS_TARGET) {
1253 		/* we've just disconnected from the bus, do nothing since
1254 		 * a return here will re-run the queued command slot
1255 		 * that may have been interrupted by the initial selection */
1256 		DEBUG((" SELECTION COMPLETED\n"));
1257 	} else if((dsps & 0xfffff0f0) == A_MSG_IN) {
1258 		resume_offset = process_message(host, hostdata, SCp,
1259 						dsp, dsps);
1260 	} else if((dsps &  0xfffff000) == 0) {
1261 		__u8 i = (dsps & 0xf0) >> 4, j = (dsps & 0xf00) >> 8;
1262 		printk(KERN_ERR "scsi%d: (%d:%d), unhandled script condition %s %s at %04x\n",
1263 		       host->host_no, pun, lun, NCR_700_condition[i],
1264 		       NCR_700_phase[j], dsp - hostdata->pScript);
1265 		if(SCp != NULL) {
1266 			scsi_print_command(SCp);
1267 
1268 			if(SCp->use_sg) {
1269 				for(i = 0; i < SCp->use_sg + 1; i++) {
1270 					printk(KERN_INFO " SG[%d].length = %d, move_insn=%08x, addr %08x\n", i, ((struct scatterlist *)SCp->request_buffer)[i].length, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].ins, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].pAddr);
1271 				}
1272 			}
1273 		}
1274 		NCR_700_internal_bus_reset(host);
1275 	} else if((dsps & 0xfffff000) == A_DEBUG_INTERRUPT) {
1276 		printk(KERN_NOTICE "scsi%d (%d:%d) DEBUG INTERRUPT %d AT %08x[%04x], continuing\n",
1277 		       host->host_no, pun, lun, dsps & 0xfff, dsp, dsp - hostdata->pScript);
1278 		resume_offset = dsp;
1279 	} else {
1280 		printk(KERN_ERR "scsi%d: (%d:%d), unidentified script interrupt 0x%x at %04x\n",
1281 		       host->host_no, pun, lun, dsps, dsp - hostdata->pScript);
1282 		NCR_700_internal_bus_reset(host);
1283 	}
1284 	return resume_offset;
1285 }
1286 
1287 /* We run the 53c700 with selection interrupts always enabled.  This
1288  * means that the chip may be selected as soon as the bus frees.  On a
1289  * busy bus, this can be before the scripts engine finishes its
1290  * processing.  Therefore, part of the selection processing has to be
1291  * to find out what the scripts engine is doing and complete the
1292  * function if necessary (i.e. process the pending disconnect or save
1293  * the interrupted initial selection */
1294 STATIC inline __u32
1295 process_selection(struct Scsi_Host *host, __u32 dsp)
1296 {
1297 	__u8 id = 0;	/* Squash compiler warning */
1298 	int count = 0;
1299 	__u32 resume_offset = 0;
1300 	struct NCR_700_Host_Parameters *hostdata =
1301 		(struct NCR_700_Host_Parameters *)host->hostdata[0];
1302 	struct scsi_cmnd *SCp = hostdata->cmd;
1303 	__u8 sbcl;
1304 
1305 	for(count = 0; count < 5; count++) {
1306 		id = NCR_700_readb(host, hostdata->chip710 ?
1307 				   CTEST9_REG : SFBR_REG);
1308 
1309 		/* Take out our own ID */
1310 		id &= ~(1<<host->this_id);
1311 		if(id != 0)
1312 			break;
1313 		udelay(5);
1314 	}
1315 	sbcl = NCR_700_readb(host, SBCL_REG);
1316 	if((sbcl & SBCL_IO) == 0) {
1317 		/* mark as having been selected rather than reselected */
1318 		id = 0xff;
1319 	} else {
1320 		/* convert to real ID */
1321 		hostdata->reselection_id = id = bitmap_to_number(id);
1322 		DEBUG(("scsi%d:  Reselected by %d\n",
1323 		       host->host_no, id));
1324 	}
1325 	if(hostdata->state == NCR_700_HOST_BUSY && SCp != NULL) {
1326 		struct NCR_700_command_slot *slot =
1327 			(struct NCR_700_command_slot *)SCp->host_scribble;
1328 		DEBUG(("  ID %d WARNING: RESELECTION OF BUSY HOST, saving cmd %p, slot %p, addr %x [%04x], resume %x!\n", id, hostdata->cmd, slot, dsp, dsp - hostdata->pScript, resume_offset));
1329 
1330 		switch(dsp - hostdata->pScript) {
1331 		case Ent_Disconnect1:
1332 		case Ent_Disconnect2:
1333 			save_for_reselection(hostdata, SCp, Ent_Disconnect2 + hostdata->pScript);
1334 			break;
1335 		case Ent_Disconnect3:
1336 		case Ent_Disconnect4:
1337 			save_for_reselection(hostdata, SCp, Ent_Disconnect4 + hostdata->pScript);
1338 			break;
1339 		case Ent_Disconnect5:
1340 		case Ent_Disconnect6:
1341 			save_for_reselection(hostdata, SCp, Ent_Disconnect6 + hostdata->pScript);
1342 			break;
1343 		case Ent_Disconnect7:
1344 		case Ent_Disconnect8:
1345 			save_for_reselection(hostdata, SCp, Ent_Disconnect8 + hostdata->pScript);
1346 			break;
1347 		case Ent_Finish1:
1348 		case Ent_Finish2:
1349 			process_script_interrupt(A_GOOD_STATUS_AFTER_STATUS, dsp, SCp, host, hostdata);
1350 			break;
1351 
1352 		default:
1353 			slot->state = NCR_700_SLOT_QUEUED;
1354 			break;
1355 			}
1356 	}
1357 	hostdata->state = NCR_700_HOST_BUSY;
1358 	hostdata->cmd = NULL;
1359 	/* clear any stale simple tag message */
1360 	hostdata->msgin[1] = 0;
1361 	dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE,
1362 		       DMA_BIDIRECTIONAL);
1363 
1364 	if(id == 0xff) {
1365 		/* Selected as target, Ignore */
1366 		resume_offset = hostdata->pScript + Ent_SelectedAsTarget;
1367 	} else if(hostdata->tag_negotiated & (1<<id)) {
1368 		resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
1369 	} else {
1370 		resume_offset = hostdata->pScript + Ent_GetReselectionData;
1371 	}
1372 	return resume_offset;
1373 }
1374 
1375 static inline void
1376 NCR_700_clear_fifo(struct Scsi_Host *host) {
1377 	const struct NCR_700_Host_Parameters *hostdata
1378 		= (struct NCR_700_Host_Parameters *)host->hostdata[0];
1379 	if(hostdata->chip710) {
1380 		NCR_700_writeb(CLR_FIFO_710, host, CTEST8_REG);
1381 	} else {
1382 		NCR_700_writeb(CLR_FIFO, host, DFIFO_REG);
1383 	}
1384 }
1385 
1386 static inline void
1387 NCR_700_flush_fifo(struct Scsi_Host *host) {
1388 	const struct NCR_700_Host_Parameters *hostdata
1389 		= (struct NCR_700_Host_Parameters *)host->hostdata[0];
1390 	if(hostdata->chip710) {
1391 		NCR_700_writeb(FLUSH_DMA_FIFO_710, host, CTEST8_REG);
1392 		udelay(10);
1393 		NCR_700_writeb(0, host, CTEST8_REG);
1394 	} else {
1395 		NCR_700_writeb(FLUSH_DMA_FIFO, host, DFIFO_REG);
1396 		udelay(10);
1397 		NCR_700_writeb(0, host, DFIFO_REG);
1398 	}
1399 }
1400 
1401 
1402 /* The queue lock with interrupts disabled must be held on entry to
1403  * this function */
1404 STATIC int
1405 NCR_700_start_command(struct scsi_cmnd *SCp)
1406 {
1407 	struct NCR_700_command_slot *slot =
1408 		(struct NCR_700_command_slot *)SCp->host_scribble;
1409 	struct NCR_700_Host_Parameters *hostdata =
1410 		(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1411 	__u16 count = 1;	/* for IDENTIFY message */
1412 
1413 	if(hostdata->state != NCR_700_HOST_FREE) {
1414 		/* keep this inside the lock to close the race window where
1415 		 * the running command finishes on another CPU while we don't
1416 		 * change the state to queued on this one */
1417 		slot->state = NCR_700_SLOT_QUEUED;
1418 
1419 		DEBUG(("scsi%d: host busy, queueing command %p, slot %p\n",
1420 		       SCp->device->host->host_no, slot->cmnd, slot));
1421 		return 0;
1422 	}
1423 	hostdata->state = NCR_700_HOST_BUSY;
1424 	hostdata->cmd = SCp;
1425 	slot->state = NCR_700_SLOT_BUSY;
1426 	/* keep interrupts disabled until we have the command correctly
1427 	 * set up so we cannot take a selection interrupt */
1428 
1429 	hostdata->msgout[0] = NCR_700_identify((SCp->cmnd[0] != REQUEST_SENSE &&
1430 						slot->flags != NCR_700_FLAG_AUTOSENSE),
1431 					       SCp->device->lun);
1432 	/* for INQUIRY or REQUEST_SENSE commands, we cannot be sure
1433 	 * if the negotiated transfer parameters still hold, so
1434 	 * always renegotiate them */
1435 	if(SCp->cmnd[0] == INQUIRY || SCp->cmnd[0] == REQUEST_SENSE ||
1436 	   slot->flags == NCR_700_FLAG_AUTOSENSE) {
1437 		NCR_700_clear_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
1438 	}
1439 
1440 	/* REQUEST_SENSE is asking for contingent I_T_L(_Q) status.
1441 	 * If a contingent allegiance condition exists, the device
1442 	 * will refuse all tags, so send the request sense as untagged
1443 	 * */
1444 	if((hostdata->tag_negotiated & (1<<scmd_id(SCp)))
1445 	   && (slot->tag != SCSI_NO_TAG && SCp->cmnd[0] != REQUEST_SENSE &&
1446 	       slot->flags != NCR_700_FLAG_AUTOSENSE)) {
1447 		count += scsi_populate_tag_msg(SCp, &hostdata->msgout[count]);
1448 	}
1449 
1450 	if(hostdata->fast &&
1451 	   NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC)) {
1452 		count += spi_populate_sync_msg(&hostdata->msgout[count],
1453 				spi_period(SCp->device->sdev_target),
1454 				spi_offset(SCp->device->sdev_target));
1455 		NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
1456 	}
1457 
1458 	script_patch_16(hostdata->dev, hostdata->script, MessageCount, count);
1459 
1460 
1461 	script_patch_ID(hostdata->dev, hostdata->script,
1462 			Device_ID, 1<<scmd_id(SCp));
1463 
1464 	script_patch_32_abs(hostdata->dev, hostdata->script, CommandAddress,
1465 			    slot->pCmd);
1466 	script_patch_16(hostdata->dev, hostdata->script, CommandCount,
1467 	                SCp->cmd_len);
1468 	/* finally plumb the beginning of the SG list into the script
1469 	 * */
1470 	script_patch_32_abs(hostdata->dev, hostdata->script,
1471 	                    SGScriptStartAddress, to32bit(&slot->pSG[0].ins));
1472 	NCR_700_clear_fifo(SCp->device->host);
1473 
1474 	if(slot->resume_offset == 0)
1475 		slot->resume_offset = hostdata->pScript;
1476 	/* now perform all the writebacks and invalidates */
1477 	dma_cache_sync(hostdata->dev, hostdata->msgout, count, DMA_TO_DEVICE);
1478 	dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE,
1479 		       DMA_FROM_DEVICE);
1480 	dma_cache_sync(hostdata->dev, SCp->cmnd, SCp->cmd_len, DMA_TO_DEVICE);
1481 	dma_cache_sync(hostdata->dev, hostdata->status, 1, DMA_FROM_DEVICE);
1482 
1483 	/* set the synchronous period/offset */
1484 	NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
1485 		       SCp->device->host, SXFER_REG);
1486 	NCR_700_writel(slot->temp, SCp->device->host, TEMP_REG);
1487 	NCR_700_writel(slot->resume_offset, SCp->device->host, DSP_REG);
1488 
1489 	return 1;
1490 }
1491 
1492 irqreturn_t
1493 NCR_700_intr(int irq, void *dev_id)
1494 {
1495 	struct Scsi_Host *host = (struct Scsi_Host *)dev_id;
1496 	struct NCR_700_Host_Parameters *hostdata =
1497 		(struct NCR_700_Host_Parameters *)host->hostdata[0];
1498 	__u8 istat;
1499 	__u32 resume_offset = 0;
1500 	__u8 pun = 0xff, lun = 0xff;
1501 	unsigned long flags;
1502 	int handled = 0;
1503 
1504 	/* Use the host lock to serialise acess to the 53c700
1505 	 * hardware.  Note: In future, we may need to take the queue
1506 	 * lock to enter the done routines.  When that happens, we
1507 	 * need to ensure that for this driver, the host lock and the
1508 	 * queue lock point to the same thing. */
1509 	spin_lock_irqsave(host->host_lock, flags);
1510 	if((istat = NCR_700_readb(host, ISTAT_REG))
1511 	      & (SCSI_INT_PENDING | DMA_INT_PENDING)) {
1512 		__u32 dsps;
1513 		__u8 sstat0 = 0, dstat = 0;
1514 		__u32 dsp;
1515 		struct scsi_cmnd *SCp = hostdata->cmd;
1516 		enum NCR_700_Host_State state;
1517 
1518 		handled = 1;
1519 		state = hostdata->state;
1520 		SCp = hostdata->cmd;
1521 
1522 		if(istat & SCSI_INT_PENDING) {
1523 			udelay(10);
1524 
1525 			sstat0 = NCR_700_readb(host, SSTAT0_REG);
1526 		}
1527 
1528 		if(istat & DMA_INT_PENDING) {
1529 			udelay(10);
1530 
1531 			dstat = NCR_700_readb(host, DSTAT_REG);
1532 		}
1533 
1534 		dsps = NCR_700_readl(host, DSPS_REG);
1535 		dsp = NCR_700_readl(host, DSP_REG);
1536 
1537 		DEBUG(("scsi%d: istat %02x sstat0 %02x dstat %02x dsp %04x[%08x] dsps 0x%x\n",
1538 		       host->host_no, istat, sstat0, dstat,
1539 		       (dsp - (__u32)(hostdata->pScript))/4,
1540 		       dsp, dsps));
1541 
1542 		if(SCp != NULL) {
1543 			pun = SCp->device->id;
1544 			lun = SCp->device->lun;
1545 		}
1546 
1547 		if(sstat0 & SCSI_RESET_DETECTED) {
1548 			struct scsi_device *SDp;
1549 			int i;
1550 
1551 			hostdata->state = NCR_700_HOST_BUSY;
1552 
1553 			printk(KERN_ERR "scsi%d: Bus Reset detected, executing command %p, slot %p, dsp %08x[%04x]\n",
1554 			       host->host_no, SCp, SCp == NULL ? NULL : SCp->host_scribble, dsp, dsp - hostdata->pScript);
1555 
1556 			scsi_report_bus_reset(host, 0);
1557 
1558 			/* clear all the negotiated parameters */
1559 			__shost_for_each_device(SDp, host)
1560 				NCR_700_clear_flag(SDp, ~0);
1561 
1562 			/* clear all the slots and their pending commands */
1563 			for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
1564 				struct scsi_cmnd *SCp;
1565 				struct NCR_700_command_slot *slot =
1566 					&hostdata->slots[i];
1567 
1568 				if(slot->state == NCR_700_SLOT_FREE)
1569 					continue;
1570 
1571 				SCp = slot->cmnd;
1572 				printk(KERN_ERR " failing command because of reset, slot %p, cmnd %p\n",
1573 				       slot, SCp);
1574 				free_slot(slot, hostdata);
1575 				SCp->host_scribble = NULL;
1576 				NCR_700_set_depth(SCp->device, 0);
1577 				/* NOTE: deadlock potential here: we
1578 				 * rely on mid-layer guarantees that
1579 				 * scsi_done won't try to issue the
1580 				 * command again otherwise we'll
1581 				 * deadlock on the
1582 				 * hostdata->state_lock */
1583 				SCp->result = DID_RESET << 16;
1584 				SCp->scsi_done(SCp);
1585 			}
1586 			mdelay(25);
1587 			NCR_700_chip_setup(host);
1588 
1589 			hostdata->state = NCR_700_HOST_FREE;
1590 			hostdata->cmd = NULL;
1591 			/* signal back if this was an eh induced reset */
1592 			if(hostdata->eh_complete != NULL)
1593 				complete(hostdata->eh_complete);
1594 			goto out_unlock;
1595 		} else if(sstat0 & SELECTION_TIMEOUT) {
1596 			DEBUG(("scsi%d: (%d:%d) selection timeout\n",
1597 			       host->host_no, pun, lun));
1598 			NCR_700_scsi_done(hostdata, SCp, DID_NO_CONNECT<<16);
1599 		} else if(sstat0 & PHASE_MISMATCH) {
1600 			struct NCR_700_command_slot *slot = (SCp == NULL) ? NULL :
1601 				(struct NCR_700_command_slot *)SCp->host_scribble;
1602 
1603 			if(dsp == Ent_SendMessage + 8 + hostdata->pScript) {
1604 				/* It wants to reply to some part of
1605 				 * our message */
1606 #ifdef NCR_700_DEBUG
1607 				__u32 temp = NCR_700_readl(host, TEMP_REG);
1608 				int count = (hostdata->script[Ent_SendMessage/4] & 0xffffff) - ((NCR_700_readl(host, DBC_REG) & 0xffffff) + NCR_700_data_residual(host));
1609 				printk("scsi%d (%d:%d) PHASE MISMATCH IN SEND MESSAGE %d remain, return %p[%04x], phase %s\n", host->host_no, pun, lun, count, (void *)temp, temp - hostdata->pScript, sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
1610 #endif
1611 				resume_offset = hostdata->pScript + Ent_SendMessagePhaseMismatch;
1612 			} else if(dsp >= to32bit(&slot->pSG[0].ins) &&
1613 				  dsp <= to32bit(&slot->pSG[NCR_700_SG_SEGMENTS].ins)) {
1614 				int data_transfer = NCR_700_readl(host, DBC_REG) & 0xffffff;
1615 				int SGcount = (dsp - to32bit(&slot->pSG[0].ins))/sizeof(struct NCR_700_SG_List);
1616 				int residual = NCR_700_data_residual(host);
1617 				int i;
1618 #ifdef NCR_700_DEBUG
1619 				__u32 naddr = NCR_700_readl(host, DNAD_REG);
1620 
1621 				printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x\n",
1622 				       host->host_no, pun, lun,
1623 				       SGcount, data_transfer);
1624 				scsi_print_command(SCp);
1625 				if(residual) {
1626 					printk("scsi%d: (%d:%d) Expected phase mismatch in slot->SG[%d], transferred 0x%x, residual %d\n",
1627 				       host->host_no, pun, lun,
1628 				       SGcount, data_transfer, residual);
1629 				}
1630 #endif
1631 				data_transfer += residual;
1632 
1633 				if(data_transfer != 0) {
1634 					int count;
1635 					__u32 pAddr;
1636 
1637 					SGcount--;
1638 
1639 					count = (bS_to_cpu(slot->SG[SGcount].ins) & 0x00ffffff);
1640 					DEBUG(("DATA TRANSFER MISMATCH, count = %d, transferred %d\n", count, count-data_transfer));
1641 					slot->SG[SGcount].ins &= bS_to_host(0xff000000);
1642 					slot->SG[SGcount].ins |= bS_to_host(data_transfer);
1643 					pAddr = bS_to_cpu(slot->SG[SGcount].pAddr);
1644 					pAddr += (count - data_transfer);
1645 #ifdef NCR_700_DEBUG
1646 					if(pAddr != naddr) {
1647 						printk("scsi%d (%d:%d) transfer mismatch pAddr=%lx, naddr=%lx, data_transfer=%d, residual=%d\n", host->host_no, pun, lun, (unsigned long)pAddr, (unsigned long)naddr, data_transfer, residual);
1648 					}
1649 #endif
1650 					slot->SG[SGcount].pAddr = bS_to_host(pAddr);
1651 				}
1652 				/* set the executed moves to nops */
1653 				for(i=0; i<SGcount; i++) {
1654 					slot->SG[i].ins = bS_to_host(SCRIPT_NOP);
1655 					slot->SG[i].pAddr = 0;
1656 				}
1657 				dma_cache_sync(hostdata->dev, slot->SG, sizeof(slot->SG), DMA_TO_DEVICE);
1658 				/* and pretend we disconnected after
1659 				 * the command phase */
1660 				resume_offset = hostdata->pScript + Ent_MsgInDuringData;
1661 				/* make sure all the data is flushed */
1662 				NCR_700_flush_fifo(host);
1663 			} else {
1664 				__u8 sbcl = NCR_700_readb(host, SBCL_REG);
1665 				printk(KERN_ERR "scsi%d: (%d:%d) phase mismatch at %04x, phase %s\n",
1666 				       host->host_no, pun, lun, dsp - hostdata->pScript, sbcl_to_string(sbcl));
1667 				NCR_700_internal_bus_reset(host);
1668 			}
1669 
1670 		} else if(sstat0 & SCSI_GROSS_ERROR) {
1671 			printk(KERN_ERR "scsi%d: (%d:%d) GROSS ERROR\n",
1672 			       host->host_no, pun, lun);
1673 			NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
1674 		} else if(sstat0 & PARITY_ERROR) {
1675 			printk(KERN_ERR "scsi%d: (%d:%d) PARITY ERROR\n",
1676 			       host->host_no, pun, lun);
1677 			NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
1678 		} else if(dstat & SCRIPT_INT_RECEIVED) {
1679 			DEBUG(("scsi%d: (%d:%d) ====>SCRIPT INTERRUPT<====\n",
1680 			       host->host_no, pun, lun));
1681 			resume_offset = process_script_interrupt(dsps, dsp, SCp, host, hostdata);
1682 		} else if(dstat & (ILGL_INST_DETECTED)) {
1683 			printk(KERN_ERR "scsi%d: (%d:%d) Illegal Instruction detected at 0x%08x[0x%x]!!!\n"
1684 			       "         Please email James.Bottomley@HansenPartnership.com with the details\n",
1685 			       host->host_no, pun, lun,
1686 			       dsp, dsp - hostdata->pScript);
1687 			NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
1688 		} else if(dstat & (WATCH_DOG_INTERRUPT|ABORTED)) {
1689 			printk(KERN_ERR "scsi%d: (%d:%d) serious DMA problem, dstat=%02x\n",
1690 			       host->host_no, pun, lun, dstat);
1691 			NCR_700_scsi_done(hostdata, SCp, DID_ERROR<<16);
1692 		}
1693 
1694 
1695 		/* NOTE: selection interrupt processing MUST occur
1696 		 * after script interrupt processing to correctly cope
1697 		 * with the case where we process a disconnect and
1698 		 * then get reselected before we process the
1699 		 * disconnection */
1700 		if(sstat0 & SELECTED) {
1701 			/* FIXME: It currently takes at least FOUR
1702 			 * interrupts to complete a command that
1703 			 * disconnects: one for the disconnect, one
1704 			 * for the reselection, one to get the
1705 			 * reselection data and one to complete the
1706 			 * command.  If we guess the reselected
1707 			 * command here and prepare it, we only need
1708 			 * to get a reselection data interrupt if we
1709 			 * guessed wrongly.  Since the interrupt
1710 			 * overhead is much greater than the command
1711 			 * setup, this would be an efficient
1712 			 * optimisation particularly as we probably
1713 			 * only have one outstanding command on a
1714 			 * target most of the time */
1715 
1716 			resume_offset = process_selection(host, dsp);
1717 
1718 		}
1719 
1720 	}
1721 
1722 	if(resume_offset) {
1723 		if(hostdata->state != NCR_700_HOST_BUSY) {
1724 			printk(KERN_ERR "scsi%d: Driver error: resume at 0x%08x [0x%04x] with non busy host!\n",
1725 			       host->host_no, resume_offset, resume_offset - hostdata->pScript);
1726 			hostdata->state = NCR_700_HOST_BUSY;
1727 		}
1728 
1729 		DEBUG(("Attempting to resume at %x\n", resume_offset));
1730 		NCR_700_clear_fifo(host);
1731 		NCR_700_writel(resume_offset, host, DSP_REG);
1732 	}
1733 	/* There is probably a technical no-no about this: If we're a
1734 	 * shared interrupt and we got this interrupt because the
1735 	 * other device needs servicing not us, we're still going to
1736 	 * check our queued commands here---of course, there shouldn't
1737 	 * be any outstanding.... */
1738 	if(hostdata->state == NCR_700_HOST_FREE) {
1739 		int i;
1740 
1741 		for(i = 0; i < NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
1742 			/* fairness: always run the queue from the last
1743 			 * position we left off */
1744 			int j = (i + hostdata->saved_slot_position)
1745 				% NCR_700_COMMAND_SLOTS_PER_HOST;
1746 
1747 			if(hostdata->slots[j].state != NCR_700_SLOT_QUEUED)
1748 				continue;
1749 			if(NCR_700_start_command(hostdata->slots[j].cmnd)) {
1750 				DEBUG(("scsi%d: Issuing saved command slot %p, cmd %p\t\n",
1751 				       host->host_no, &hostdata->slots[j],
1752 				       hostdata->slots[j].cmnd));
1753 				hostdata->saved_slot_position = j + 1;
1754 			}
1755 
1756 			break;
1757 		}
1758 	}
1759  out_unlock:
1760 	spin_unlock_irqrestore(host->host_lock, flags);
1761 	return IRQ_RETVAL(handled);
1762 }
1763 
1764 STATIC int
1765 NCR_700_queuecommand(struct scsi_cmnd *SCp, void (*done)(struct scsi_cmnd *))
1766 {
1767 	struct NCR_700_Host_Parameters *hostdata =
1768 		(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1769 	__u32 move_ins;
1770 	enum dma_data_direction direction;
1771 	struct NCR_700_command_slot *slot;
1772 
1773 	if(hostdata->command_slot_count >= NCR_700_COMMAND_SLOTS_PER_HOST) {
1774 		/* We're over our allocation, this should never happen
1775 		 * since we report the max allocation to the mid layer */
1776 		printk(KERN_WARNING "scsi%d: Command depth has gone over queue depth\n", SCp->device->host->host_no);
1777 		return 1;
1778 	}
1779 	/* check for untagged commands.  We cannot have any outstanding
1780 	 * commands if we accept them.  Commands could be untagged because:
1781 	 *
1782 	 * - The tag negotiated bitmap is clear
1783 	 * - The blk layer sent and untagged command
1784 	 */
1785 	if(NCR_700_get_depth(SCp->device) != 0
1786 	   && (!(hostdata->tag_negotiated & (1<<scmd_id(SCp)))
1787 	       || !blk_rq_tagged(SCp->request))) {
1788 		CDEBUG(KERN_ERR, SCp, "has non zero depth %d\n",
1789 		       NCR_700_get_depth(SCp->device));
1790 		return SCSI_MLQUEUE_DEVICE_BUSY;
1791 	}
1792 	if(NCR_700_get_depth(SCp->device) >= SCp->device->queue_depth) {
1793 		CDEBUG(KERN_ERR, SCp, "has max tag depth %d\n",
1794 		       NCR_700_get_depth(SCp->device));
1795 		return SCSI_MLQUEUE_DEVICE_BUSY;
1796 	}
1797 	NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) + 1);
1798 
1799 	/* begin the command here */
1800 	/* no need to check for NULL, test for command_slot_count above
1801 	 * ensures a slot is free */
1802 	slot = find_empty_slot(hostdata);
1803 
1804 	slot->cmnd = SCp;
1805 
1806 	SCp->scsi_done = done;
1807 	SCp->host_scribble = (unsigned char *)slot;
1808 	SCp->SCp.ptr = NULL;
1809 	SCp->SCp.buffer = NULL;
1810 
1811 #ifdef NCR_700_DEBUG
1812 	printk("53c700: scsi%d, command ", SCp->device->host->host_no);
1813 	scsi_print_command(SCp);
1814 #endif
1815 	if(blk_rq_tagged(SCp->request)
1816 	   && (hostdata->tag_negotiated &(1<<scmd_id(SCp))) == 0
1817 	   && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_START_TAG_NEGOTIATION) {
1818 		scmd_printk(KERN_ERR, SCp, "Enabling Tag Command Queuing\n");
1819 		hostdata->tag_negotiated |= (1<<scmd_id(SCp));
1820 		NCR_700_set_tag_neg_state(SCp->device, NCR_700_DURING_TAG_NEGOTIATION);
1821 	}
1822 
1823 	/* here we may have to process an untagged command.  The gate
1824 	 * above ensures that this will be the only one outstanding,
1825 	 * so clear the tag negotiated bit.
1826 	 *
1827 	 * FIXME: This will royally screw up on multiple LUN devices
1828 	 * */
1829 	if(!blk_rq_tagged(SCp->request)
1830 	   && (hostdata->tag_negotiated &(1<<scmd_id(SCp)))) {
1831 		scmd_printk(KERN_INFO, SCp, "Disabling Tag Command Queuing\n");
1832 		hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
1833 	}
1834 
1835 	if((hostdata->tag_negotiated &(1<<scmd_id(SCp)))
1836 	   && scsi_get_tag_type(SCp->device)) {
1837 		slot->tag = SCp->request->tag;
1838 		CDEBUG(KERN_DEBUG, SCp, "sending out tag %d, slot %p\n",
1839 		       slot->tag, slot);
1840 	} else {
1841 		slot->tag = SCSI_NO_TAG;
1842 		/* must populate current_cmnd for scsi_find_tag to work */
1843 		SCp->device->current_cmnd = SCp;
1844 	}
1845 	/* sanity check: some of the commands generated by the mid-layer
1846 	 * have an eccentric idea of their sc_data_direction */
1847 	if(!SCp->use_sg && !SCp->request_bufflen
1848 	   && SCp->sc_data_direction != DMA_NONE) {
1849 #ifdef NCR_700_DEBUG
1850 		printk("53c700: Command");
1851 		scsi_print_command(SCp);
1852 		printk("Has wrong data direction %d\n", SCp->sc_data_direction);
1853 #endif
1854 		SCp->sc_data_direction = DMA_NONE;
1855 	}
1856 
1857 	switch (SCp->cmnd[0]) {
1858 	case REQUEST_SENSE:
1859 		/* clear the internal sense magic */
1860 		SCp->cmnd[6] = 0;
1861 		/* fall through */
1862 	default:
1863 		/* OK, get it from the command */
1864 		switch(SCp->sc_data_direction) {
1865 		case DMA_BIDIRECTIONAL:
1866 		default:
1867 			printk(KERN_ERR "53c700: Unknown command for data direction ");
1868 			scsi_print_command(SCp);
1869 
1870 			move_ins = 0;
1871 			break;
1872 		case DMA_NONE:
1873 			move_ins = 0;
1874 			break;
1875 		case DMA_FROM_DEVICE:
1876 			move_ins = SCRIPT_MOVE_DATA_IN;
1877 			break;
1878 		case DMA_TO_DEVICE:
1879 			move_ins = SCRIPT_MOVE_DATA_OUT;
1880 			break;
1881 		}
1882 	}
1883 
1884 	/* now build the scatter gather list */
1885 	direction = SCp->sc_data_direction;
1886 	if(move_ins != 0) {
1887 		int i;
1888 		int sg_count;
1889 		dma_addr_t vPtr = 0;
1890 		__u32 count = 0;
1891 
1892 		if(SCp->use_sg) {
1893 			sg_count = dma_map_sg(hostdata->dev,
1894 					      SCp->request_buffer, SCp->use_sg,
1895 					      direction);
1896 		} else {
1897 			vPtr = dma_map_single(hostdata->dev,
1898 					      SCp->request_buffer,
1899 					      SCp->request_bufflen,
1900 					      direction);
1901 			count = SCp->request_bufflen;
1902 			slot->dma_handle = vPtr;
1903 			sg_count = 1;
1904 		}
1905 
1906 
1907 		for(i = 0; i < sg_count; i++) {
1908 
1909 			if(SCp->use_sg) {
1910 				struct scatterlist *sg = SCp->request_buffer;
1911 
1912 				vPtr = sg_dma_address(&sg[i]);
1913 				count = sg_dma_len(&sg[i]);
1914 			}
1915 
1916 			slot->SG[i].ins = bS_to_host(move_ins | count);
1917 			DEBUG((" scatter block %d: move %d[%08x] from 0x%lx\n",
1918 			       i, count, slot->SG[i].ins, (unsigned long)vPtr));
1919 			slot->SG[i].pAddr = bS_to_host(vPtr);
1920 		}
1921 		slot->SG[i].ins = bS_to_host(SCRIPT_RETURN);
1922 		slot->SG[i].pAddr = 0;
1923 		dma_cache_sync(hostdata->dev, slot->SG, sizeof(slot->SG), DMA_TO_DEVICE);
1924 		DEBUG((" SETTING %08lx to %x\n",
1925 		       (&slot->pSG[i].ins),
1926 		       slot->SG[i].ins));
1927 	}
1928 	slot->resume_offset = 0;
1929 	slot->pCmd = dma_map_single(hostdata->dev, SCp->cmnd,
1930 				    sizeof(SCp->cmnd), DMA_TO_DEVICE);
1931 	NCR_700_start_command(SCp);
1932 	return 0;
1933 }
1934 
1935 STATIC int
1936 NCR_700_abort(struct scsi_cmnd * SCp)
1937 {
1938 	struct NCR_700_command_slot *slot;
1939 
1940 	scmd_printk(KERN_INFO, SCp,
1941 		"New error handler wants to abort command\n\t");
1942 	scsi_print_command(SCp);
1943 
1944 	slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1945 
1946 	if(slot == NULL)
1947 		/* no outstanding command to abort */
1948 		return SUCCESS;
1949 	if(SCp->cmnd[0] == TEST_UNIT_READY) {
1950 		/* FIXME: This is because of a problem in the new
1951 		 * error handler.  When it is in error recovery, it
1952 		 * will send a TUR to a device it thinks may still be
1953 		 * showing a problem.  If the TUR isn't responded to,
1954 		 * it will abort it and mark the device off line.
1955 		 * Unfortunately, it does no other error recovery, so
1956 		 * this would leave us with an outstanding command
1957 		 * occupying a slot.  Rather than allow this to
1958 		 * happen, we issue a bus reset to force all
1959 		 * outstanding commands to terminate here. */
1960 		NCR_700_internal_bus_reset(SCp->device->host);
1961 		/* still drop through and return failed */
1962 	}
1963 	return FAILED;
1964 
1965 }
1966 
1967 STATIC int
1968 NCR_700_bus_reset(struct scsi_cmnd * SCp)
1969 {
1970 	DECLARE_COMPLETION_ONSTACK(complete);
1971 	struct NCR_700_Host_Parameters *hostdata =
1972 		(struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1973 
1974 	scmd_printk(KERN_INFO, SCp,
1975 		"New error handler wants BUS reset, cmd %p\n\t", SCp);
1976 	scsi_print_command(SCp);
1977 
1978 	/* In theory, eh_complete should always be null because the
1979 	 * eh is single threaded, but just in case we're handling a
1980 	 * reset via sg or something */
1981 	spin_lock_irq(SCp->device->host->host_lock);
1982 	while (hostdata->eh_complete != NULL) {
1983 		spin_unlock_irq(SCp->device->host->host_lock);
1984 		msleep_interruptible(100);
1985 		spin_lock_irq(SCp->device->host->host_lock);
1986 	}
1987 
1988 	hostdata->eh_complete = &complete;
1989 	NCR_700_internal_bus_reset(SCp->device->host);
1990 
1991 	spin_unlock_irq(SCp->device->host->host_lock);
1992 	wait_for_completion(&complete);
1993 	spin_lock_irq(SCp->device->host->host_lock);
1994 
1995 	hostdata->eh_complete = NULL;
1996 	/* Revalidate the transport parameters of the failing device */
1997 	if(hostdata->fast)
1998 		spi_schedule_dv_device(SCp->device);
1999 
2000 	spin_unlock_irq(SCp->device->host->host_lock);
2001 	return SUCCESS;
2002 }
2003 
2004 STATIC int
2005 NCR_700_host_reset(struct scsi_cmnd * SCp)
2006 {
2007 	scmd_printk(KERN_INFO, SCp, "New error handler wants HOST reset\n\t");
2008 	scsi_print_command(SCp);
2009 
2010 	spin_lock_irq(SCp->device->host->host_lock);
2011 
2012 	NCR_700_internal_bus_reset(SCp->device->host);
2013 	NCR_700_chip_reset(SCp->device->host);
2014 
2015 	spin_unlock_irq(SCp->device->host->host_lock);
2016 
2017 	return SUCCESS;
2018 }
2019 
2020 STATIC void
2021 NCR_700_set_period(struct scsi_target *STp, int period)
2022 {
2023 	struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent);
2024 	struct NCR_700_Host_Parameters *hostdata =
2025 		(struct NCR_700_Host_Parameters *)SHp->hostdata[0];
2026 
2027 	if(!hostdata->fast)
2028 		return;
2029 
2030 	if(period < hostdata->min_period)
2031 		period = hostdata->min_period;
2032 
2033 	spi_period(STp) = period;
2034 	spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC |
2035 			    NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
2036 	spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION;
2037 }
2038 
2039 STATIC void
2040 NCR_700_set_offset(struct scsi_target *STp, int offset)
2041 {
2042 	struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent);
2043 	struct NCR_700_Host_Parameters *hostdata =
2044 		(struct NCR_700_Host_Parameters *)SHp->hostdata[0];
2045 	int max_offset = hostdata->chip710
2046 		? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET;
2047 
2048 	if(!hostdata->fast)
2049 		return;
2050 
2051 	if(offset > max_offset)
2052 		offset = max_offset;
2053 
2054 	/* if we're currently async, make sure the period is reasonable */
2055 	if(spi_offset(STp) == 0 && (spi_period(STp) < hostdata->min_period ||
2056 				    spi_period(STp) > 0xff))
2057 		spi_period(STp) = hostdata->min_period;
2058 
2059 	spi_offset(STp) = offset;
2060 	spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC |
2061 			    NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
2062 	spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION;
2063 }
2064 
2065 STATIC int
2066 NCR_700_slave_alloc(struct scsi_device *SDp)
2067 {
2068 	SDp->hostdata = kzalloc(sizeof(struct NCR_700_Device_Parameters),
2069 				GFP_KERNEL);
2070 
2071 	if (!SDp->hostdata)
2072 		return -ENOMEM;
2073 
2074 	return 0;
2075 }
2076 
2077 STATIC int
2078 NCR_700_slave_configure(struct scsi_device *SDp)
2079 {
2080 	struct NCR_700_Host_Parameters *hostdata =
2081 		(struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
2082 
2083 	/* to do here: allocate memory; build a queue_full list */
2084 	if(SDp->tagged_supported) {
2085 		scsi_set_tag_type(SDp, MSG_ORDERED_TAG);
2086 		scsi_activate_tcq(SDp, NCR_700_DEFAULT_TAGS);
2087 		NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
2088 	} else {
2089 		/* initialise to default depth */
2090 		scsi_adjust_queue_depth(SDp, 0, SDp->host->cmd_per_lun);
2091 	}
2092 	if(hostdata->fast) {
2093 		/* Find the correct offset and period via domain validation */
2094 		if (!spi_initial_dv(SDp->sdev_target))
2095 			spi_dv_device(SDp);
2096 	} else {
2097 		spi_offset(SDp->sdev_target) = 0;
2098 		spi_period(SDp->sdev_target) = 0;
2099 	}
2100 	return 0;
2101 }
2102 
2103 STATIC void
2104 NCR_700_slave_destroy(struct scsi_device *SDp)
2105 {
2106 	kfree(SDp->hostdata);
2107 	SDp->hostdata = NULL;
2108 }
2109 
2110 static int
2111 NCR_700_change_queue_depth(struct scsi_device *SDp, int depth)
2112 {
2113 	if (depth > NCR_700_MAX_TAGS)
2114 		depth = NCR_700_MAX_TAGS;
2115 
2116 	scsi_adjust_queue_depth(SDp, scsi_get_tag_type(SDp), depth);
2117 	return depth;
2118 }
2119 
2120 static int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type)
2121 {
2122 	int change_tag = ((tag_type ==0 &&  scsi_get_tag_type(SDp) != 0)
2123 			  || (tag_type != 0 && scsi_get_tag_type(SDp) == 0));
2124 	struct NCR_700_Host_Parameters *hostdata =
2125 		(struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
2126 
2127 	scsi_set_tag_type(SDp, tag_type);
2128 
2129 	/* We have a global (per target) flag to track whether TCQ is
2130 	 * enabled, so we'll be turning it off for the entire target here.
2131 	 * our tag algorithm will fail if we mix tagged and untagged commands,
2132 	 * so quiesce the device before doing this */
2133 	if (change_tag)
2134 		scsi_target_quiesce(SDp->sdev_target);
2135 
2136 	if (!tag_type) {
2137 		/* shift back to the default unqueued number of commands
2138 		 * (the user can still raise this) */
2139 		scsi_deactivate_tcq(SDp, SDp->host->cmd_per_lun);
2140 		hostdata->tag_negotiated &= ~(1 << sdev_id(SDp));
2141 	} else {
2142 		/* Here, we cleared the negotiation flag above, so this
2143 		 * will force the driver to renegotiate */
2144 		scsi_activate_tcq(SDp, SDp->queue_depth);
2145 		if (change_tag)
2146 			NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
2147 	}
2148 	if (change_tag)
2149 		scsi_target_resume(SDp->sdev_target);
2150 
2151 	return tag_type;
2152 }
2153 
2154 static ssize_t
2155 NCR_700_show_active_tags(struct device *dev, struct device_attribute *attr, char *buf)
2156 {
2157 	struct scsi_device *SDp = to_scsi_device(dev);
2158 
2159 	return snprintf(buf, 20, "%d\n", NCR_700_get_depth(SDp));
2160 }
2161 
2162 static struct device_attribute NCR_700_active_tags_attr = {
2163 	.attr = {
2164 		.name =		"active_tags",
2165 		.mode =		S_IRUGO,
2166 	},
2167 	.show = NCR_700_show_active_tags,
2168 };
2169 
2170 STATIC struct device_attribute *NCR_700_dev_attrs[] = {
2171 	&NCR_700_active_tags_attr,
2172 	NULL,
2173 };
2174 
2175 EXPORT_SYMBOL(NCR_700_detect);
2176 EXPORT_SYMBOL(NCR_700_release);
2177 EXPORT_SYMBOL(NCR_700_intr);
2178 
2179 static struct spi_function_template NCR_700_transport_functions =  {
2180 	.set_period	= NCR_700_set_period,
2181 	.show_period	= 1,
2182 	.set_offset	= NCR_700_set_offset,
2183 	.show_offset	= 1,
2184 };
2185 
2186 static int __init NCR_700_init(void)
2187 {
2188 	NCR_700_transport_template = spi_attach_transport(&NCR_700_transport_functions);
2189 	if(!NCR_700_transport_template)
2190 		return -ENODEV;
2191 	return 0;
2192 }
2193 
2194 static void __exit NCR_700_exit(void)
2195 {
2196 	spi_release_transport(NCR_700_transport_template);
2197 }
2198 
2199 module_init(NCR_700_init);
2200 module_exit(NCR_700_exit);
2201 
2202