drivers/scsi/53c700.c

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