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