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