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/kernel.h>
 118 #include <linux/types.h>
 119 #include <linux/string.h>
 120 #include <linux/slab.h>
 121 #include <linux/ioport.h>
 122 #include <linux/delay.h>
 123 #include <linux/spinlock.h>
 124 #include <linux/completion.h>
 125 #include <linux/init.h>
 126 #include <linux/proc_fs.h>
 127 #include <linux/blkdev.h>
 128 #include <linux/module.h>
 129 #include <linux/interrupt.h>
 130 #include <linux/device.h>
 131 #include <asm/dma.h>
 132 #include <asm/io.h>
 133 #include <asm/pgtable.h>
 134 #include <asm/byteorder.h>
 135
 136 #include <scsi/scsi.h>
 137 #include <scsi/scsi_cmnd.h>
 138 #include <scsi/scsi_dbg.h>
 139 #include <scsi/scsi_eh.h>
 140 #include <scsi/scsi_host.h>
 141 #include <scsi/scsi_tcq.h>
 142 #include <scsi/scsi_transport.h>
 143 #include <scsi/scsi_transport_spi.h>
 144
 145 #include "53c700.h"
 146
 147 /* NOTE: For 64 bit drivers there are points in the code where we use
 148  * a non dereferenceable pointer to point to a structure in dma-able
 149  * memory (which is 32 bits) so that we can use all of the structure
 150  * operations but take the address at the end.  This macro allows us
 151  * to truncate the 64 bit pointer down to 32 bits without the compiler
 152  * complaining */
 153 #define to32bit(x)      ((__u32)((unsigned long)(x)))
 154
 155 #ifdef NCR_700_DEBUG
 156 #define STATIC
 157 #else
 158 #define STATIC static
 159 #endif
 160
 161 MODULE_AUTHOR("James Bottomley");
 162 MODULE_DESCRIPTION("53c700 and 53c700-66 Driver");
 163 MODULE_LICENSE("GPL");
 164
 165 /* This is the script */
 166 #include "53c700_d.h"
 167
 168
 169 STATIC int NCR_700_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *);
 170 STATIC int NCR_700_abort(struct scsi_cmnd * SCpnt);
 171 STATIC int NCR_700_bus_reset(struct scsi_cmnd * SCpnt);
 172 STATIC int NCR_700_host_reset(struct scsi_cmnd * SCpnt);
 173 STATIC void NCR_700_chip_setup(struct Scsi_Host *host);
 174 STATIC void NCR_700_chip_reset(struct Scsi_Host *host);
 175 STATIC int NCR_700_slave_alloc(struct scsi_device *SDpnt);
 176 STATIC int NCR_700_slave_configure(struct scsi_device *SDpnt);
 177 STATIC void NCR_700_slave_destroy(struct scsi_device *SDpnt);
 178 static int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth, int reason);
 179 static int NCR_700_change_queue_type(struct scsi_device *SDpnt, int depth);
 180
 181 STATIC struct device_attribute *NCR_700_dev_attrs[];
 182
 183 STATIC struct scsi_transport_template *NCR_700_transport_template = NULL;
 184
 185 static char *NCR_700_phase[] = {
 186         "",
 187         "after selection",
 188         "before command phase",
 189         "after command phase",
 190         "after status phase",
 191         "after data in phase",
 192         "after data out phase",
 193         "during data phase",
 194 };
 195
 196 static char *NCR_700_condition[] = {
 197         "",
 198         "NOT MSG_OUT",
 199         "UNEXPECTED PHASE",
 200         "NOT MSG_IN",
 201         "UNEXPECTED MSG",
 202         "MSG_IN",
 203         "SDTR_MSG RECEIVED",
 204         "REJECT_MSG RECEIVED",
 205         "DISCONNECT_MSG RECEIVED",
 206         "MSG_OUT",
 207         "DATA_IN",
 208
 209 };
 210
 211 static char *NCR_700_fatal_messages[] = {
 212         "unexpected message after reselection",
 213         "still MSG_OUT after message injection",
 214         "not MSG_IN after selection",
 215         "Illegal message length received",
 216 };
 217
 218 static char *NCR_700_SBCL_bits[] = {
 219         "IO ",
 220         "CD ",
 221         "MSG ",
 222         "ATN ",
 223         "SEL ",
 224         "BSY ",
 225         "ACK ",
 226         "REQ ",
 227 };
 228
 229 static char *NCR_700_SBCL_to_phase[] = {
 230         "DATA_OUT",
 231         "DATA_IN",
 232         "CMD_OUT",
 233         "STATE",
 234         "ILLEGAL PHASE",
 235         "ILLEGAL PHASE",
 236         "MSG OUT",
 237         "MSG IN",
 238 };
 239
 240 /* This translates the SDTR message offset and period to a value
 241  * which can be loaded into the SXFER_REG.
 242  *
 243  * NOTE: According to SCSI-2, the true transfer period (in ns) is
 244  *       actually four times this period value */
 245 static inline __u8
 246 NCR_700_offset_period_to_sxfer(struct NCR_700_Host_Parameters *hostdata,
 247                                __u8 offset, __u8 period)
 248 {
 249         int XFERP;
 250
 251         __u8 min_xferp = (hostdata->chip710
 252                           ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
 253         __u8 max_offset = (hostdata->chip710
 254                            ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET);
 255
 256         if(offset == 0)
 257                 return 0;
 258
 259         if(period < hostdata->min_period) {
 260                 printk(KERN_WARNING "53c700: Period %dns is less than this chip's minimum, setting to %d\n", period*4, NCR_700_MIN_PERIOD*4);
 261                 period = hostdata->min_period;
 262         }
 263         XFERP = (period*4 * hostdata->sync_clock)/1000 - 4;
 264         if(offset > max_offset) {
 265                 printk(KERN_WARNING "53c700: Offset %d exceeds chip maximum, setting to %d\n",
 266                        offset, max_offset);
 267                 offset = max_offset;
 268         }
 269         if(XFERP < min_xferp) {
 270                 XFERP =  min_xferp;
 271         }
 272         return (offset & 0x0f) | (XFERP & 0x07)<<4;
 273 }
 274
 275 static inline __u8
 276 NCR_700_get_SXFER(struct scsi_device *SDp)
 277 {
 278         struct NCR_700_Host_Parameters *hostdata =
 279                 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
 280
 281         return NCR_700_offset_period_to_sxfer(hostdata,
 282                                               spi_offset(SDp->sdev_target),
 283                                               spi_period(SDp->sdev_target));
 284 }
 285
 286 struct Scsi_Host *
 287 NCR_700_detect(struct scsi_host_template *tpnt,
 288                struct NCR_700_Host_Parameters *hostdata, struct device *dev)
 289 {
 290         dma_addr_t pScript, pSlots;
 291         __u8 *memory;
 292         __u32 *script;
 293         struct Scsi_Host *host;
 294         static int banner = 0;
 295         int j;
 296
 297         if(tpnt->sdev_attrs == NULL)
 298                 tpnt->sdev_attrs = NCR_700_dev_attrs;
 299
 300         memory = dma_alloc_noncoherent(hostdata->dev, TOTAL_MEM_SIZE,
 301                                        &pScript, GFP_KERNEL);
 302         if(memory == NULL) {
 303                 printk(KERN_ERR "53c700: Failed to allocate memory for driver, detatching\n");
 304                 return NULL;
 305         }
 306
 307         script = (__u32 *)memory;
 308         hostdata->msgin = memory + MSGIN_OFFSET;
 309         hostdata->msgout = memory + MSGOUT_OFFSET;
 310         hostdata->status = memory + STATUS_OFFSET;
 311         hostdata->slots = (struct NCR_700_command_slot *)(memory + SLOTS_OFFSET);
 312         hostdata->dev = dev;
 313
 314         pSlots = pScript + SLOTS_OFFSET;
 315
 316         /* Fill in the missing routines from the host template */
 317         tpnt->queuecommand = NCR_700_queuecommand;
 318         tpnt->eh_abort_handler = NCR_700_abort;
 319         tpnt->eh_bus_reset_handler = NCR_700_bus_reset;
 320         tpnt->eh_host_reset_handler = NCR_700_host_reset;
 321         tpnt->can_queue = NCR_700_COMMAND_SLOTS_PER_HOST;
 322         tpnt->sg_tablesize = NCR_700_SG_SEGMENTS;
 323         tpnt->cmd_per_lun = NCR_700_CMD_PER_LUN;
 324         tpnt->use_clustering = ENABLE_CLUSTERING;
 325         tpnt->slave_configure = NCR_700_slave_configure;
 326         tpnt->slave_destroy = NCR_700_slave_destroy;
 327         tpnt->slave_alloc = NCR_700_slave_alloc;
 328         tpnt->change_queue_depth = NCR_700_change_queue_depth;
 329         tpnt->change_queue_type = NCR_700_change_queue_type;
 330
 331         if(tpnt->name == NULL)
 332                 tpnt->name = "53c700";
 333         if(tpnt->proc_name == NULL)
 334                 tpnt->proc_name = "53c700";
 335
 336         host = scsi_host_alloc(tpnt, 4);
 337         if (!host)
 338                 return NULL;
 339         memset(hostdata->slots, 0, sizeof(struct NCR_700_command_slot)
 340                * NCR_700_COMMAND_SLOTS_PER_HOST);
 341         for (j = 0; j < NCR_700_COMMAND_SLOTS_PER_HOST; j++) {
 342                 dma_addr_t offset = (dma_addr_t)((unsigned long)&hostdata->slots[j].SG[0]
 343                                           - (unsigned long)&hostdata->slots[0].SG[0]);
 344                 hostdata->slots[j].pSG = (struct NCR_700_SG_List *)((unsigned long)(pSlots + offset));
 345                 if(j == 0)
 346                         hostdata->free_list = &hostdata->slots[j];
 347                 else
 348                         hostdata->slots[j-1].ITL_forw = &hostdata->slots[j];
 349                 hostdata->slots[j].state = NCR_700_SLOT_FREE;
 350         }
 351
 352         for (j = 0; j < ARRAY_SIZE(SCRIPT); j++)
 353                 script[j] = bS_to_host(SCRIPT[j]);
 354
 355         /* adjust all labels to be bus physical */
 356         for (j = 0; j < PATCHES; j++)
 357                 script[LABELPATCHES[j]] = bS_to_host(pScript + SCRIPT[LABELPATCHES[j]]);
 358         /* now patch up fixed addresses. */
 359         script_patch_32(hostdata->dev, script, MessageLocation,
 360                         pScript + MSGOUT_OFFSET);
 361         script_patch_32(hostdata->dev, script, StatusAddress,
 362                         pScript + STATUS_OFFSET);
 363         script_patch_32(hostdata->dev, script, ReceiveMsgAddress,
 364                         pScript + MSGIN_OFFSET);
 365
 366         hostdata->script = script;
 367         hostdata->pScript = pScript;
 368         dma_sync_single_for_device(hostdata->dev, pScript, sizeof(SCRIPT), DMA_TO_DEVICE);
 369         hostdata->state = NCR_700_HOST_FREE;
 370         hostdata->cmd = NULL;
 371         host->max_id = 8;
 372         host->max_lun = NCR_700_MAX_LUNS;
 373         BUG_ON(NCR_700_transport_template == NULL);
 374         host->transportt = NCR_700_transport_template;
 375         host->unique_id = (unsigned long)hostdata->base;
 376         hostdata->eh_complete = NULL;
 377         host->hostdata[0] = (unsigned long)hostdata;
 378         /* kick the chip */
 379         NCR_700_writeb(0xff, host, CTEST9_REG);
 380         if (hostdata->chip710)
 381                 hostdata->rev = (NCR_700_readb(host, CTEST8_REG)>>4) & 0x0f;
 382         else
 383                 hostdata->rev = (NCR_700_readb(host, CTEST7_REG)>>4) & 0x0f;
 384         hostdata->fast = (NCR_700_readb(host, CTEST9_REG) == 0);
 385         if (banner == 0) {
 386                 printk(KERN_NOTICE "53c700: Version " NCR_700_VERSION " By James.Bottomley@HansenPartnership.com\n");
 387                 banner = 1;
 388         }
 389         printk(KERN_NOTICE "scsi%d: %s rev %d %s\n", host->host_no,
 390                hostdata->chip710 ? "53c710" :
 391                (hostdata->fast ? "53c700-66" : "53c700"),
 392                hostdata->rev, hostdata->differential ?
 393                "(Differential)" : "");
 394         /* reset the chip */
 395         NCR_700_chip_reset(host);
 396
 397         if (scsi_add_host(host, dev)) {
 398                 dev_printk(KERN_ERR, dev, "53c700: scsi_add_host failed\n");
 399                 scsi_host_put(host);
 400                 return NULL;
 401         }
 402
 403         spi_signalling(host) = hostdata->differential ? SPI_SIGNAL_HVD :
 404                 SPI_SIGNAL_SE;
 405
 406         return host;
 407 }
 408
 409 int
 410 NCR_700_release(struct Scsi_Host *host)
 411 {
 412         struct NCR_700_Host_Parameters *hostdata =
 413                 (struct NCR_700_Host_Parameters *)host->hostdata[0];
 414
 415         dma_free_noncoherent(hostdata->dev, TOTAL_MEM_SIZE,
 416                                hostdata->script, hostdata->pScript);
 417         return 1;
 418 }
 419
 420 static inline __u8
 421 NCR_700_identify(int can_disconnect, __u8 lun)
 422 {
 423         return IDENTIFY_BASE |
 424                 ((can_disconnect) ? 0x40 : 0) |
 425                 (lun & NCR_700_LUN_MASK);
 426 }
 427
 428 /*
 429  * Function : static int data_residual (Scsi_Host *host)
 430  *
 431  * Purpose : return residual data count of what's in the chip.  If you
 432  * really want to know what this function is doing, it's almost a
 433  * direct transcription of the algorithm described in the 53c710
 434  * guide, except that the DBC and DFIFO registers are only 6 bits
 435  * wide on a 53c700.
 436  *
 437  * Inputs : host - SCSI host */
 438 static inline int
 439 NCR_700_data_residual (struct Scsi_Host *host) {
 440         struct NCR_700_Host_Parameters *hostdata =
 441                 (struct NCR_700_Host_Parameters *)host->hostdata[0];
 442         int count, synchronous = 0;
 443         unsigned int ddir;
 444
 445         if(hostdata->chip710) {
 446                 count = ((NCR_700_readb(host, DFIFO_REG) & 0x7f) -
 447                          (NCR_700_readl(host, DBC_REG) & 0x7f)) & 0x7f;
 448         } else {
 449                 count = ((NCR_700_readb(host, DFIFO_REG) & 0x3f) -
 450                          (NCR_700_readl(host, DBC_REG) & 0x3f)) & 0x3f;
 451         }
 452
 453         if(hostdata->fast)
 454                 synchronous = NCR_700_readb(host, SXFER_REG) & 0x0f;
 455
 456         /* get the data direction */
 457         ddir = NCR_700_readb(host, CTEST0_REG) & 0x01;
 458
 459         if (ddir) {
 460                 /* Receive */
 461                 if (synchronous)
 462                         count += (NCR_700_readb(host, SSTAT2_REG) & 0xf0) >> 4;
 463                 else
 464                         if (NCR_700_readb(host, SSTAT1_REG) & SIDL_REG_FULL)
 465                                 ++count;
 466         } else {
 467                 /* Send */
 468                 __u8 sstat = NCR_700_readb(host, SSTAT1_REG);
 469                 if (sstat & SODL_REG_FULL)
 470                         ++count;
 471                 if (synchronous && (sstat & SODR_REG_FULL))
 472                         ++count;
 473         }
 474 #ifdef NCR_700_DEBUG
 475         if(count)
 476                 printk("RESIDUAL IS %d (ddir %d)\n", count, ddir);
 477 #endif
 478         return count;
 479 }
 480
 481 /* print out the SCSI wires and corresponding phase from the SBCL register
 482  * in the chip */
 483 static inline char *
 484 sbcl_to_string(__u8 sbcl)
 485 {
 486         int i;
 487         static char ret[256];
 488
 489         ret[0]='\0';
 490         for(i=0; i<8; i++) {
 491                 if((1<<i) & sbcl)
 492                         strcat(ret, NCR_700_SBCL_bits[i]);
 493         }
 494         strcat(ret, NCR_700_SBCL_to_phase[sbcl & 0x07]);
 495         return ret;
 496 }
 497
 498 static inline __u8
 499 bitmap_to_number(__u8 bitmap)
 500 {
 501         __u8 i;
 502
 503         for(i=0; i<8 && !(bitmap &(1<<i)); i++)
 504                 ;
 505         return i;
 506 }
 507
 508 /* Pull a slot off the free list */
 509 STATIC struct NCR_700_command_slot *
 510 find_empty_slot(struct NCR_700_Host_Parameters *hostdata)
 511 {
 512         struct NCR_700_command_slot *slot = hostdata->free_list;
 513
 514         if(slot == NULL) {
 515                 /* sanity check */
 516                 if(hostdata->command_slot_count != NCR_700_COMMAND_SLOTS_PER_HOST)
 517                         printk(KERN_ERR "SLOTS FULL, but count is %d, should be %d\n", hostdata->command_slot_count, NCR_700_COMMAND_SLOTS_PER_HOST);
 518                 return NULL;
 519         }
 520
 521         if(slot->state != NCR_700_SLOT_FREE)
 522                 /* should panic! */
 523                 printk(KERN_ERR "BUSY SLOT ON FREE LIST!!!\n");
 524
 525
 526         hostdata->free_list = slot->ITL_forw;
 527         slot->ITL_forw = NULL;
 528
 529
 530         /* NOTE: set the state to busy here, not queued, since this
 531          * indicates the slot is in use and cannot be run by the IRQ
 532          * finish routine.  If we cannot queue the command when it
 533          * is properly build, we then change to NCR_700_SLOT_QUEUED */
 534         slot->state = NCR_700_SLOT_BUSY;
 535         slot->flags = 0;
 536         hostdata->command_slot_count++;
 537
 538         return slot;
 539 }
 540
 541 STATIC void
 542 free_slot(struct NCR_700_command_slot *slot,
 543           struct NCR_700_Host_Parameters *hostdata)
 544 {
 545         if((slot->state & NCR_700_SLOT_MASK) != NCR_700_SLOT_MAGIC) {
 546                 printk(KERN_ERR "53c700: SLOT %p is not MAGIC!!!\n", slot);
 547         }
 548         if(slot->state == NCR_700_SLOT_FREE) {
 549                 printk(KERN_ERR "53c700: SLOT %p is FREE!!!\n", slot);
 550         }
 551
 552         slot->resume_offset = 0;
 553         slot->cmnd = NULL;
 554         slot->state = NCR_700_SLOT_FREE;
 555         slot->ITL_forw = hostdata->free_list;
 556         hostdata->free_list = slot;
 557         hostdata->command_slot_count--;
 558 }
 559
 560
 561 /* This routine really does very little.  The command is indexed on
 562    the ITL and (if tagged) the ITLQ lists in _queuecommand */
 563 STATIC void
 564 save_for_reselection(struct NCR_700_Host_Parameters *hostdata,
 565                      struct scsi_cmnd *SCp, __u32 dsp)
 566 {
 567         /* Its just possible that this gets executed twice */
 568         if(SCp != NULL) {
 569                 struct NCR_700_command_slot *slot =
 570                         (struct NCR_700_command_slot *)SCp->host_scribble;
 571
 572                 slot->resume_offset = dsp;
 573         }
 574         hostdata->state = NCR_700_HOST_FREE;
 575         hostdata->cmd = NULL;
 576 }
 577
 578 STATIC inline void
 579 NCR_700_unmap(struct NCR_700_Host_Parameters *hostdata, struct scsi_cmnd *SCp,
 580               struct NCR_700_command_slot *slot)
 581 {
 582         if(SCp->sc_data_direction != DMA_NONE &&
 583            SCp->sc_data_direction != DMA_BIDIRECTIONAL)
 584                 scsi_dma_unmap(SCp);
 585 }
 586
 587 STATIC inline void
 588 NCR_700_scsi_done(struct NCR_700_Host_Parameters *hostdata,
 589                struct scsi_cmnd *SCp, int result)
 590 {
 591         hostdata->state = NCR_700_HOST_FREE;
 592         hostdata->cmd = NULL;
 593
 594         if(SCp != NULL) {
 595                 struct NCR_700_command_slot *slot =
 596                         (struct NCR_700_command_slot *)SCp->host_scribble;
 597
 598                 dma_unmap_single(hostdata->dev, slot->pCmd,
 599                                  MAX_COMMAND_SIZE, DMA_TO_DEVICE);
 600                 if (slot->flags == NCR_700_FLAG_AUTOSENSE) {
 601                         char *cmnd = NCR_700_get_sense_cmnd(SCp->device);
 602
 603                         dma_unmap_single(hostdata->dev, slot->dma_handle,
 604                                          SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
 605                         /* restore the old result if the request sense was
 606                          * successful */
 607                         if (result == 0)
 608                                 result = cmnd[7];
 609                         /* restore the original length */
 610                         SCp->cmd_len = cmnd[8];
 611                 } else
 612                         NCR_700_unmap(hostdata, SCp, slot);
 613
 614                 free_slot(slot, hostdata);
 615 #ifdef NCR_700_DEBUG
 616                 if(NCR_700_get_depth(SCp->device) == 0 ||
 617                    NCR_700_get_depth(SCp->device) > SCp->device->queue_depth)
 618                         printk(KERN_ERR "Invalid depth in NCR_700_scsi_done(): %d\n",
 619                                NCR_700_get_depth(SCp->device));
 620 #endif /* NCR_700_DEBUG */
 621                 NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) - 1);
 622
 623                 SCp->host_scribble = NULL;
 624                 SCp->result = result;
 625                 SCp->scsi_done(SCp);
 626         } else {
 627                 printk(KERN_ERR "53c700: SCSI DONE HAS NULL SCp\n");
 628         }
 629 }
 630
 631
 632 STATIC void
 633 NCR_700_internal_bus_reset(struct Scsi_Host *host)
 634 {
 635         /* Bus reset */
 636         NCR_700_writeb(ASSERT_RST, host, SCNTL1_REG);
 637         udelay(50);
 638         NCR_700_writeb(0, host, SCNTL1_REG);
 639
 640 }
 641
 642 STATIC void
 643 NCR_700_chip_setup(struct Scsi_Host *host)
 644 {
 645         struct NCR_700_Host_Parameters *hostdata =
 646                 (struct NCR_700_Host_Parameters *)host->hostdata[0];
 647         __u8 min_period;
 648         __u8 min_xferp = (hostdata->chip710 ? NCR_710_MIN_XFERP : NCR_700_MIN_XFERP);
 649
 650         if(hostdata->chip710) {
 651                 __u8 burst_disable = 0;
 652                 __u8 burst_length = 0;
 653
 654                 switch (hostdata->burst_length) {
 655                         case 1:
 656                                 burst_length = BURST_LENGTH_1;
 657                                 break;
 658                         case 2:
 659                                 burst_length = BURST_LENGTH_2;
 660                                 break;
 661                         case 4:
 662                                 burst_length = BURST_LENGTH_4;
 663                                 break;
 664                         case 8:
 665                                 burst_length = BURST_LENGTH_8;
 666                                 break;
 667                         default:
 668                                 burst_disable = BURST_DISABLE;
 669                                 break;
 670                 }
 671                 hostdata->dcntl_extra |= COMPAT_700_MODE;
 672
 673                 NCR_700_writeb(hostdata->dcntl_extra, host, DCNTL_REG);
 674                 NCR_700_writeb(burst_length | hostdata->dmode_extra,
 675                                host, DMODE_710_REG);
 676                 NCR_700_writeb(burst_disable | hostdata->ctest7_extra |
 677                                (hostdata->differential ? DIFF : 0),
 678                                host, CTEST7_REG);
 679                 NCR_700_writeb(BTB_TIMER_DISABLE, host, CTEST0_REG);
 680                 NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY | PARITY
 681                                | AUTO_ATN, host, SCNTL0_REG);
 682         } else {
 683                 NCR_700_writeb(BURST_LENGTH_8 | hostdata->dmode_extra,
 684                                host, DMODE_700_REG);
 685                 NCR_700_writeb(hostdata->differential ?
 686                                DIFF : 0, host, CTEST7_REG);
 687                 if(hostdata->fast) {
 688                         /* this is for 700-66, does nothing on 700 */
 689                         NCR_700_writeb(LAST_DIS_ENBL | ENABLE_ACTIVE_NEGATION
 690                                        | GENERATE_RECEIVE_PARITY, host,
 691                                        CTEST8_REG);
 692                 } else {
 693                         NCR_700_writeb(FULL_ARBITRATION | ENABLE_PARITY
 694                                        | PARITY | AUTO_ATN, host, SCNTL0_REG);
 695                 }
 696         }
 697
 698         NCR_700_writeb(1 << host->this_id, host, SCID_REG);
 699         NCR_700_writeb(0, host, SBCL_REG);
 700         NCR_700_writeb(ASYNC_OPERATION, host, SXFER_REG);
 701
 702         NCR_700_writeb(PHASE_MM_INT | SEL_TIMEOUT_INT | GROSS_ERR_INT | UX_DISC_INT
 703              | RST_INT | PAR_ERR_INT | SELECT_INT, host, SIEN_REG);
 704
 705         NCR_700_writeb(ABORT_INT | INT_INST_INT | ILGL_INST_INT, host, DIEN_REG);
 706         NCR_700_writeb(ENABLE_SELECT, host, SCNTL1_REG);
 707         if(hostdata->clock > 75) {
 708                 printk(KERN_ERR "53c700: Clock speed %dMHz is too high: 75Mhz is the maximum this chip can be driven at\n", hostdata->clock);
 709                 /* do the best we can, but the async clock will be out
 710                  * of spec: sync divider 2, async divider 3 */
 711                 DEBUG(("53c700: sync 2 async 3\n"));
 712                 NCR_700_writeb(SYNC_DIV_2_0, host, SBCL_REG);
 713                 NCR_700_writeb(ASYNC_DIV_3_0 | hostdata->dcntl_extra, host, DCNTL_REG);
 714                 hostdata->sync_clock = hostdata->clock/2;
 715         } else  if(hostdata->clock > 50  && hostdata->clock <= 75) {
 716                 /* sync divider 1.5, async divider 3 */
 717                 DEBUG(("53c700: sync 1.5 async 3\n"));
 718                 NCR_700_writeb(SYNC_DIV_1_5, host, SBCL_REG);
 719                 NCR_700_writeb(ASYNC_DIV_3_0 | hostdata->dcntl_extra, host, DCNTL_REG);
 720                 hostdata->sync_clock = hostdata->clock*2;
 721                 hostdata->sync_clock /= 3;
 722
 723         } else if(hostdata->clock > 37 && hostdata->clock <= 50) {
 724                 /* sync divider 1, async divider 2 */
 725                 DEBUG(("53c700: sync 1 async 2\n"));
 726                 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
 727                 NCR_700_writeb(ASYNC_DIV_2_0 | hostdata->dcntl_extra, host, DCNTL_REG);
 728                 hostdata->sync_clock = hostdata->clock;
 729         } else if(hostdata->clock > 25 && hostdata->clock <=37) {
 730                 /* sync divider 1, async divider 1.5 */
 731                 DEBUG(("53c700: sync 1 async 1.5\n"));
 732                 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
 733                 NCR_700_writeb(ASYNC_DIV_1_5 | hostdata->dcntl_extra, host, DCNTL_REG);
 734                 hostdata->sync_clock = hostdata->clock;
 735         } else {
 736                 DEBUG(("53c700: sync 1 async 1\n"));
 737                 NCR_700_writeb(SYNC_DIV_1_0, host, SBCL_REG);
 738                 NCR_700_writeb(ASYNC_DIV_1_0 | hostdata->dcntl_extra, host, DCNTL_REG);
 739                 /* sync divider 1, async divider 1 */
 740                 hostdata->sync_clock = hostdata->clock;
 741         }
 742         /* Calculate the actual minimum period that can be supported
 743          * by our synchronous clock speed.  See the 710 manual for
 744          * exact details of this calculation which is based on a
 745          * setting of the SXFER register */
 746         min_period = 1000*(4+min_xferp)/(4*hostdata->sync_clock);
 747         hostdata->min_period = NCR_700_MIN_PERIOD;
 748         if(min_period > NCR_700_MIN_PERIOD)
 749                 hostdata->min_period = min_period;
 750 }
 751
 752 STATIC void
 753 NCR_700_chip_reset(struct Scsi_Host *host)
 754 {
 755         struct NCR_700_Host_Parameters *hostdata =
 756                 (struct NCR_700_Host_Parameters *)host->hostdata[0];
 757         if(hostdata->chip710) {
 758                 NCR_700_writeb(SOFTWARE_RESET_710, host, ISTAT_REG);
 759                 udelay(100);
 760
 761                 NCR_700_writeb(0, host, ISTAT_REG);
 762         } else {
 763                 NCR_700_writeb(SOFTWARE_RESET, host, DCNTL_REG);
 764                 udelay(100);
 765
 766                 NCR_700_writeb(0, host, DCNTL_REG);
 767         }
 768
 769         mdelay(1000);
 770
 771         NCR_700_chip_setup(host);
 772 }
 773
 774 /* The heart of the message processing engine is that the instruction
 775  * immediately after the INT is the normal case (and so must be CLEAR
 776  * ACK).  If we want to do something else, we call that routine in
 777  * scripts and set temp to be the normal case + 8 (skipping the CLEAR
 778  * ACK) so that the routine returns correctly to resume its activity
 779  * */
 780 STATIC __u32
 781 process_extended_message(struct Scsi_Host *host,
 782                          struct NCR_700_Host_Parameters *hostdata,
 783                          struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps)
 784 {
 785         __u32 resume_offset = dsp, temp = dsp + 8;
 786         __u8 pun = 0xff, lun = 0xff;
 787
 788         if(SCp != NULL) {
 789                 pun = SCp->device->id;
 790                 lun = SCp->device->lun;
 791         }
 792
 793         switch(hostdata->msgin[2]) {
 794         case A_SDTR_MSG:
 795                 if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
 796                         struct scsi_target *starget = SCp->device->sdev_target;
 797                         __u8 period = hostdata->msgin[3];
 798                         __u8 offset = hostdata->msgin[4];
 799
 800                         if(offset == 0 || period == 0) {
 801                                 offset = 0;
 802                                 period = 0;
 803                         }
 804
 805                         spi_offset(starget) = offset;
 806                         spi_period(starget) = period;
 807
 808                         if(NCR_700_is_flag_set(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION)) {
 809                                 spi_display_xfer_agreement(starget);
 810                                 NCR_700_clear_flag(SCp->device, NCR_700_DEV_PRINT_SYNC_NEGOTIATION);
 811                         }
 812
 813                         NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
 814                         NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
 815
 816                         NCR_700_writeb(NCR_700_get_SXFER(SCp->device),
 817                                        host, SXFER_REG);
 818
 819                 } else {
 820                         /* SDTR message out of the blue, reject it */
 821                         shost_printk(KERN_WARNING, host,
 822                                 "Unexpected SDTR msg\n");
 823                         hostdata->msgout[0] = A_REJECT_MSG;
 824                         dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE);
 825                         script_patch_16(hostdata->dev, hostdata->script,
 826                                         MessageCount, 1);
 827                         /* SendMsgOut returns, so set up the return
 828                          * address */
 829                         resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
 830                 }
 831                 break;
 832
 833         case A_WDTR_MSG:
 834                 printk(KERN_INFO "scsi%d: (%d:%d), Unsolicited WDTR after CMD, Rejecting\n",
 835                        host->host_no, pun, lun);
 836                 hostdata->msgout[0] = A_REJECT_MSG;
 837                 dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE);
 838                 script_patch_16(hostdata->dev, hostdata->script, MessageCount,
 839                                 1);
 840                 resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
 841
 842                 break;
 843
 844         default:
 845                 printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
 846                        host->host_no, pun, lun,
 847                        NCR_700_phase[(dsps & 0xf00) >> 8]);
 848                 spi_print_msg(hostdata->msgin);
 849                 printk("\n");
 850                 /* just reject it */
 851                 hostdata->msgout[0] = A_REJECT_MSG;
 852                 dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE);
 853                 script_patch_16(hostdata->dev, hostdata->script, MessageCount,
 854                                 1);
 855                 /* SendMsgOut returns, so set up the return
 856                  * address */
 857                 resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
 858         }
 859         NCR_700_writel(temp, host, TEMP_REG);
 860         return resume_offset;
 861 }
 862
 863 STATIC __u32
 864 process_message(struct Scsi_Host *host, struct NCR_700_Host_Parameters *hostdata,
 865                 struct scsi_cmnd *SCp, __u32 dsp, __u32 dsps)
 866 {
 867         /* work out where to return to */
 868         __u32 temp = dsp + 8, resume_offset = dsp;
 869         __u8 pun = 0xff, lun = 0xff;
 870
 871         if(SCp != NULL) {
 872                 pun = SCp->device->id;
 873                 lun = SCp->device->lun;
 874         }
 875
 876 #ifdef NCR_700_DEBUG
 877         printk("scsi%d (%d:%d): message %s: ", host->host_no, pun, lun,
 878                NCR_700_phase[(dsps & 0xf00) >> 8]);
 879         spi_print_msg(hostdata->msgin);
 880         printk("\n");
 881 #endif
 882
 883         switch(hostdata->msgin[0]) {
 884
 885         case A_EXTENDED_MSG:
 886                 resume_offset =  process_extended_message(host, hostdata, SCp,
 887                                                           dsp, dsps);
 888                 break;
 889
 890         case A_REJECT_MSG:
 891                 if(SCp != NULL && NCR_700_is_flag_set(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION)) {
 892                         /* Rejected our sync negotiation attempt */
 893                         spi_period(SCp->device->sdev_target) =
 894                                 spi_offset(SCp->device->sdev_target) = 0;
 895                         NCR_700_set_flag(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC);
 896                         NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
 897                 } else if(SCp != NULL && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION) {
 898                         /* rejected our first simple tag message */
 899                         scmd_printk(KERN_WARNING, SCp,
 900                                 "Rejected first tag queue attempt, turning off tag queueing\n");
 901                         /* we're done negotiating */
 902                         NCR_700_set_tag_neg_state(SCp->device, NCR_700_FINISHED_TAG_NEGOTIATION);
 903                         hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
 904                         SCp->device->tagged_supported = 0;
 905                         scsi_deactivate_tcq(SCp->device, host->cmd_per_lun);
 906                 } else {
 907                         shost_printk(KERN_WARNING, host,
 908                                 "(%d:%d) Unexpected REJECT Message %s\n",
 909                                pun, lun,
 910                                NCR_700_phase[(dsps & 0xf00) >> 8]);
 911                         /* however, just ignore it */
 912                 }
 913                 break;
 914
 915         case A_PARITY_ERROR_MSG:
 916                 printk(KERN_ERR "scsi%d (%d:%d) Parity Error!\n", host->host_no,
 917                        pun, lun);
 918                 NCR_700_internal_bus_reset(host);
 919                 break;
 920         case A_SIMPLE_TAG_MSG:
 921                 printk(KERN_INFO "scsi%d (%d:%d) SIMPLE TAG %d %s\n", host->host_no,
 922                        pun, lun, hostdata->msgin[1],
 923                        NCR_700_phase[(dsps & 0xf00) >> 8]);
 924                 /* just ignore it */
 925                 break;
 926         default:
 927                 printk(KERN_INFO "scsi%d (%d:%d): Unexpected message %s: ",
 928                        host->host_no, pun, lun,
 929                        NCR_700_phase[(dsps & 0xf00) >> 8]);
 930
 931                 spi_print_msg(hostdata->msgin);
 932                 printk("\n");
 933                 /* just reject it */
 934                 hostdata->msgout[0] = A_REJECT_MSG;
 935                 dma_cache_sync(hostdata->dev, hostdata->msgout, 1, DMA_TO_DEVICE);
 936                 script_patch_16(hostdata->dev, hostdata->script, MessageCount,
 937                                 1);
 938                 /* SendMsgOut returns, so set up the return
 939                  * address */
 940                 resume_offset = hostdata->pScript + Ent_SendMessageWithATN;
 941
 942                 break;
 943         }
 944         NCR_700_writel(temp, host, TEMP_REG);
 945         /* set us up to receive another message */
 946         dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE, DMA_FROM_DEVICE);
 947         return resume_offset;
 948 }
 949
 950 STATIC __u32
 951 process_script_interrupt(__u32 dsps, __u32 dsp, struct scsi_cmnd *SCp,
 952                          struct Scsi_Host *host,
 953                          struct NCR_700_Host_Parameters *hostdata)
 954 {
 955         __u32 resume_offset = 0;
 956         __u8 pun = 0xff, lun=0xff;
 957
 958         if(SCp != NULL) {
 959                 pun = SCp->device->id;
 960                 lun = SCp->device->lun;
 961         }
 962
 963         if(dsps == A_GOOD_STATUS_AFTER_STATUS) {
 964                 DEBUG(("  COMMAND COMPLETE, status=%02x\n",
 965                        hostdata->status[0]));
 966                 /* OK, if TCQ still under negotiation, we now know it works */
 967                 if (NCR_700_get_tag_neg_state(SCp->device) == NCR_700_DURING_TAG_NEGOTIATION)
 968                         NCR_700_set_tag_neg_state(SCp->device,
 969                                                   NCR_700_FINISHED_TAG_NEGOTIATION);
 970
 971                 /* check for contingent allegiance contitions */
 972                 if(status_byte(hostdata->status[0]) == CHECK_CONDITION ||
 973                    status_byte(hostdata->status[0]) == COMMAND_TERMINATED) {
 974                         struct NCR_700_command_slot *slot =
 975                                 (struct NCR_700_command_slot *)SCp->host_scribble;
 976                         if(slot->flags == NCR_700_FLAG_AUTOSENSE) {
 977                                 /* OOPS: bad device, returning another
 978                                  * contingent allegiance condition */
 979                                 scmd_printk(KERN_ERR, SCp,
 980                                         "broken device is looping in contingent allegiance: ignoring\n");
 981                                 NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
 982                         } else {
 983                                 char *cmnd =
 984                                         NCR_700_get_sense_cmnd(SCp->device);
 985 #ifdef NCR_DEBUG
 986                                 scsi_print_command(SCp);
 987                                 printk("  cmd %p has status %d, requesting sense\n",
 988                                        SCp, hostdata->status[0]);
 989 #endif
 990                                 /* we can destroy the command here
 991                                  * because the contingent allegiance
 992                                  * condition will cause a retry which
 993                                  * will re-copy the command from the
 994                                  * saved data_cmnd.  We also unmap any
 995                                  * data associated with the command
 996                                  * here */
 997                                 NCR_700_unmap(hostdata, SCp, slot);
 998                                 dma_unmap_single(hostdata->dev, slot->pCmd,
 999                                                  MAX_COMMAND_SIZE,
1000                                                  DMA_TO_DEVICE);
1001
1002                                 cmnd[0] = REQUEST_SENSE;
1003                                 cmnd[1] = (lun & 0x7) << 5;
1004                                 cmnd[2] = 0;
1005                                 cmnd[3] = 0;
1006                                 cmnd[4] = SCSI_SENSE_BUFFERSIZE;
1007                                 cmnd[5] = 0;
1008                                 /* Here's a quiet hack: the
1009                                  * REQUEST_SENSE command is six bytes,
1010                                  * so store a flag indicating that
1011                                  * this was an internal sense request
1012                                  * and the original status at the end
1013                                  * of the command */
1014                                 cmnd[6] = NCR_700_INTERNAL_SENSE_MAGIC;
1015                                 cmnd[7] = hostdata->status[0];
1016                                 cmnd[8] = SCp->cmd_len;
1017                                 SCp->cmd_len = 6; /* command length for
1018                                                    * REQUEST_SENSE */
1019                                 slot->pCmd = dma_map_single(hostdata->dev, cmnd, MAX_COMMAND_SIZE, DMA_TO_DEVICE);
1020                                 slot->dma_handle = dma_map_single(hostdata->dev, SCp->sense_buffer, SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
1021                                 slot->SG[0].ins = bS_to_host(SCRIPT_MOVE_DATA_IN | SCSI_SENSE_BUFFERSIZE);
1022                                 slot->SG[0].pAddr = bS_to_host(slot->dma_handle);
1023                                 slot->SG[1].ins = bS_to_host(SCRIPT_RETURN);
1024                                 slot->SG[1].pAddr = 0;
1025                                 slot->resume_offset = hostdata->pScript;
1026                                 dma_cache_sync(hostdata->dev, slot->SG, sizeof(slot->SG[0])*2, DMA_TO_DEVICE);
1027                                 dma_cache_sync(hostdata->dev, SCp->sense_buffer, SCSI_SENSE_BUFFERSIZE, DMA_FROM_DEVICE);
1028
1029                                 /* queue the command for reissue */
1030                                 slot->state = NCR_700_SLOT_QUEUED;
1031                                 slot->flags = NCR_700_FLAG_AUTOSENSE;
1032                                 hostdata->state = NCR_700_HOST_FREE;
1033                                 hostdata->cmd = NULL;
1034                         }
1035                 } else {
1036                         // Currently rely on the mid layer evaluation
1037                         // of the tag queuing capability
1038                         //
1039                         //if(status_byte(hostdata->status[0]) == GOOD &&
1040                         //   SCp->cmnd[0] == INQUIRY && SCp->use_sg == 0) {
1041                         //      /* Piggy back the tag queueing support
1042                         //       * on this command */
1043                         //      dma_sync_single_for_cpu(hostdata->dev,
1044                         //                          slot->dma_handle,
1045                         //                          SCp->request_bufflen,
1046                         //                          DMA_FROM_DEVICE);
1047                         //      if(((char *)SCp->request_buffer)[7] & 0x02) {
1048                         //              scmd_printk(KERN_INFO, SCp,
1049                         //                   "Enabling Tag Command Queuing\n");
1050                         //              hostdata->tag_negotiated |= (1<<scmd_id(SCp));
1051                         //              NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
1052                         //      } else {
1053                         //              NCR_700_clear_flag(SCp->device, NCR_700_DEV_BEGIN_TAG_QUEUEING);
1054                         //              hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
1055                         //      }
1056                         //}
1057                         NCR_700_scsi_done(hostdata, SCp, hostdata->status[0]);
1058                 }
1059         } else if((dsps & 0xfffff0f0) == A_UNEXPECTED_PHASE) {
1060                 __u8 i = (dsps & 0xf00) >> 8;
1061
1062                 scmd_printk(KERN_ERR, SCp, "UNEXPECTED PHASE %s (%s)\n",
1063                        NCR_700_phase[i],
1064                        sbcl_to_string(NCR_700_readb(host, SBCL_REG)));
1065                 scmd_printk(KERN_ERR, SCp, "         len = %d, cmd =",
1066                         SCp->cmd_len);
1067                 scsi_print_command(SCp);
1068
1069                 NCR_700_internal_bus_reset(host);
1070         } else if((dsps & 0xfffff000) == A_FATAL) {
1071                 int i = (dsps & 0xfff);
1072
1073                 printk(KERN_ERR "scsi%d: (%d:%d) FATAL ERROR: %s\n",
1074                        host->host_no, pun, lun, NCR_700_fatal_messages[i]);
1075                 if(dsps == A_FATAL_ILLEGAL_MSG_LENGTH) {
1076                         printk(KERN_ERR "     msg begins %02x %02x\n",
1077                                hostdata->msgin[0], hostdata->msgin[1]);
1078                 }
1079                 NCR_700_internal_bus_reset(host);
1080         } else if((dsps & 0xfffff0f0) == A_DISCONNECT) {
1081 #ifdef NCR_700_DEBUG
1082                 __u8 i = (dsps & 0xf00) >> 8;
1083
1084                 printk("scsi%d: (%d:%d), DISCONNECTED (%d) %s\n",
1085                        host->host_no, pun, lun,
1086                        i, NCR_700_phase[i]);
1087 #endif
1088                 save_for_reselection(hostdata, SCp, dsp);
1089
1090         } else if(dsps == A_RESELECTION_IDENTIFIED) {
1091                 __u8 lun;
1092                 struct NCR_700_command_slot *slot;
1093                 __u8 reselection_id = hostdata->reselection_id;
1094                 struct scsi_device *SDp;
1095
1096                 lun = hostdata->msgin[0] & 0x1f;
1097
1098                 hostdata->reselection_id = 0xff;
1099                 DEBUG(("scsi%d: (%d:%d) RESELECTED!\n",
1100                        host->host_no, reselection_id, lun));
1101                 /* clear the reselection indicator */
1102                 SDp = __scsi_device_lookup(host, 0, reselection_id, lun);
1103                 if(unlikely(SDp == NULL)) {
1104                         printk(KERN_ERR "scsi%d: (%d:%d) HAS NO device\n",
1105                                host->host_no, reselection_id, lun);
1106                         BUG();
1107                 }
1108                 if(hostdata->msgin[1] == A_SIMPLE_TAG_MSG) {
1109                         struct scsi_cmnd *SCp = scsi_find_tag(SDp, hostdata->msgin[2]);
1110                         if(unlikely(SCp == NULL)) {
1111                                 printk(KERN_ERR "scsi%d: (%d:%d) no saved request for tag %d\n",
1112                                        host->host_no, reselection_id, lun, hostdata->msgin[2]);
1113                                 BUG();
1114                         }
1115
1116                         slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1117                         DDEBUG(KERN_DEBUG, SDp,
1118                                 "reselection is tag %d, slot %p(%d)\n",
1119                                 hostdata->msgin[2], slot, slot->tag);
1120                 } else {
1121                         struct scsi_cmnd *SCp = scsi_find_tag(SDp, SCSI_NO_TAG);
1122                         if(unlikely(SCp == NULL)) {
1123                                 sdev_printk(KERN_ERR, SDp,
1124                                         "no saved request for untagged cmd\n");
1125                                 BUG();
1126                         }
1127                         slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1128                 }
1129
1130                 if(slot == NULL) {
1131                         printk(KERN_ERR "scsi%d: (%d:%d) RESELECTED but no saved command (MSG = %02x %02x %02x)!!\n",
1132                                host->host_no, reselection_id, lun,
1133                                hostdata->msgin[0], hostdata->msgin[1],
1134                                hostdata->msgin[2]);
1135                 } else {
1136                         if(hostdata->state != NCR_700_HOST_BUSY)
1137                                 printk(KERN_ERR "scsi%d: FATAL, host not busy during valid reselection!\n",
1138                                        host->host_no);
1139                         resume_offset = slot->resume_offset;
1140                         hostdata->cmd = slot->cmnd;
1141
1142                         /* re-patch for this command */
1143                         script_patch_32_abs(hostdata->dev, hostdata->script,
1144                                             CommandAddress, slot->pCmd);
1145                         script_patch_16(hostdata->dev, hostdata->script,
1146                                         CommandCount, slot->cmnd->cmd_len);
1147                         script_patch_32_abs(hostdata->dev, hostdata->script,
1148                                             SGScriptStartAddress,
1149                                             to32bit(&slot->pSG[0].ins));
1150
1151                         /* Note: setting SXFER only works if we're
1152                          * still in the MESSAGE phase, so it is vital
1153                          * that ACK is still asserted when we process
1154                          * the reselection message.  The resume offset
1155                          * should therefore always clear ACK */
1156                         NCR_700_writeb(NCR_700_get_SXFER(hostdata->cmd->device),
1157                                        host, SXFER_REG);
1158                         dma_cache_sync(hostdata->dev, hostdata->msgin,
1159                                        MSG_ARRAY_SIZE, DMA_FROM_DEVICE);
1160                         dma_cache_sync(hostdata->dev, hostdata->msgout,
1161                                        MSG_ARRAY_SIZE, DMA_TO_DEVICE);
1162                         /* I'm just being paranoid here, the command should
1163                          * already have been flushed from the cache */
1164                         dma_cache_sync(hostdata->dev, slot->cmnd->cmnd,
1165                                        slot->cmnd->cmd_len, DMA_TO_DEVICE);
1166
1167
1168
1169                 }
1170         } else if(dsps == A_RESELECTED_DURING_SELECTION) {
1171
1172                 /* This section is full of debugging code because I've
1173                  * never managed to reach it.  I think what happens is
1174                  * that, because the 700 runs with selection
1175                  * interrupts enabled the whole time that we take a
1176                  * selection interrupt before we manage to get to the
1177                  * reselected script interrupt */
1178
1179                 __u8 reselection_id = NCR_700_readb(host, SFBR_REG);
1180                 struct NCR_700_command_slot *slot;
1181
1182                 /* Take out our own ID */
1183                 reselection_id &= ~(1<<host->this_id);
1184
1185                 /* I've never seen this happen, so keep this as a printk rather
1186                  * than a debug */
1187                 printk(KERN_INFO "scsi%d: (%d:%d) RESELECTION DURING SELECTION, dsp=%08x[%04x] state=%d, count=%d\n",
1188                        host->host_no, reselection_id, lun, dsp, dsp - hostdata->pScript, hostdata->state, hostdata->command_slot_count);
1189
1190                 {
1191                         /* FIXME: DEBUGGING CODE */
1192                         __u32 SG = (__u32)bS_to_cpu(hostdata->script[A_SGScriptStartAddress_used[0]]);
1193                         int i;
1194
1195                         for(i=0; i< NCR_700_COMMAND_SLOTS_PER_HOST; i++) {
1196                                 if(SG >= to32bit(&hostdata->slots[i].pSG[0])
1197                                    && SG <= to32bit(&hostdata->slots[i].pSG[NCR_700_SG_SEGMENTS]))
1198                                         break;
1199                         }
1200                         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);
1201                         SCp =  hostdata->slots[i].cmnd;
1202                 }
1203
1204                 if(SCp != NULL) {
1205                         slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1206                         /* change slot from busy to queued to redo command */
1207                         slot->state = NCR_700_SLOT_QUEUED;
1208                 }
1209                 hostdata->cmd = NULL;
1210
1211                 if(reselection_id == 0) {
1212                         if(hostdata->reselection_id == 0xff) {
1213                                 printk(KERN_ERR "scsi%d: Invalid reselection during selection!!\n", host->host_no);
1214                                 return 0;
1215                         } else {
1216                                 printk(KERN_ERR "scsi%d: script reselected and we took a selection interrupt\n",
1217                                        host->host_no);
1218                                 reselection_id = hostdata->reselection_id;
1219                         }
1220                 } else {
1221
1222                         /* convert to real ID */
1223                         reselection_id = bitmap_to_number(reselection_id);
1224                 }
1225                 hostdata->reselection_id = reselection_id;
1226                 /* just in case we have a stale simple tag message, clear it */
1227                 hostdata->msgin[1] = 0;
1228                 dma_cache_sync(hostdata->dev, hostdata->msgin,
1229                                MSG_ARRAY_SIZE, DMA_BIDIRECTIONAL);
1230                 if(hostdata->tag_negotiated & (1<<reselection_id)) {
1231                         resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
1232                 } else {
1233                         resume_offset = hostdata->pScript + Ent_GetReselectionData;
1234                 }
1235         } else if(dsps == A_COMPLETED_SELECTION_AS_TARGET) {
1236                 /* we've just disconnected from the bus, do nothing since
1237                  * a return here will re-run the queued command slot
1238                  * that may have been interrupted by the initial selection */
1239                 DEBUG((" SELECTION COMPLETED\n"));
1240         } else if((dsps & 0xfffff0f0) == A_MSG_IN) {
1241                 resume_offset = process_message(host, hostdata, SCp,
1242                                                 dsp, dsps);
1243         } else if((dsps &  0xfffff000) == 0) {
1244                 __u8 i = (dsps & 0xf0) >> 4, j = (dsps & 0xf00) >> 8;
1245                 printk(KERN_ERR "scsi%d: (%d:%d), unhandled script condition %s %s at %04x\n",
1246                        host->host_no, pun, lun, NCR_700_condition[i],
1247                        NCR_700_phase[j], dsp - hostdata->pScript);
1248                 if(SCp != NULL) {
1249                         struct scatterlist *sg;
1250
1251                         scsi_print_command(SCp);
1252                         scsi_for_each_sg(SCp, sg, scsi_sg_count(SCp) + 1, i) {
1253                                 printk(KERN_INFO " SG[%d].length = %d, move_insn=%08x, addr %08x\n", i, sg->length, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].ins, ((struct NCR_700_command_slot *)SCp->host_scribble)->SG[i].pAddr);
1254                         }
1255                 }
1256                 NCR_700_internal_bus_reset(host);
1257         } else if((dsps & 0xfffff000) == A_DEBUG_INTERRUPT) {
1258                 printk(KERN_NOTICE "scsi%d (%d:%d) DEBUG INTERRUPT %d AT %08x[%04x], continuing\n",
1259                        host->host_no, pun, lun, dsps & 0xfff, dsp, dsp - hostdata->pScript);
1260                 resume_offset = dsp;
1261         } else {
1262                 printk(KERN_ERR "scsi%d: (%d:%d), unidentified script interrupt 0x%x at %04x\n",
1263                        host->host_no, pun, lun, dsps, dsp - hostdata->pScript);
1264                 NCR_700_internal_bus_reset(host);
1265         }
1266         return resume_offset;
1267 }
1268
1269 /* We run the 53c700 with selection interrupts always enabled.  This
1270  * means that the chip may be selected as soon as the bus frees.  On a
1271  * busy bus, this can be before the scripts engine finishes its
1272  * processing.  Therefore, part of the selection processing has to be
1273  * to find out what the scripts engine is doing and complete the
1274  * function if necessary (i.e. process the pending disconnect or save
1275  * the interrupted initial selection */
1276 STATIC inline __u32
1277 process_selection(struct Scsi_Host *host, __u32 dsp)
1278 {
1279         __u8 id = 0;    /* Squash compiler warning */
1280         int count = 0;
1281         __u32 resume_offset = 0;
1282         struct NCR_700_Host_Parameters *hostdata =
1283                 (struct NCR_700_Host_Parameters *)host->hostdata[0];
1284         struct scsi_cmnd *SCp = hostdata->cmd;
1285         __u8 sbcl;
1286
1287         for(count = 0; count < 5; count++) {
1288                 id = NCR_700_readb(host, hostdata->chip710 ?
1289                                    CTEST9_REG : SFBR_REG);
1290
1291                 /* Take out our own ID */
1292                 id &= ~(1<<host->this_id);
1293                 if(id != 0)
1294                         break;
1295                 udelay(5);
1296         }
1297         sbcl = NCR_700_readb(host, SBCL_REG);
1298         if((sbcl & SBCL_IO) == 0) {
1299                 /* mark as having been selected rather than reselected */
1300                 id = 0xff;
1301         } else {
1302                 /* convert to real ID */
1303                 hostdata->reselection_id = id = bitmap_to_number(id);
1304                 DEBUG(("scsi%d:  Reselected by %d\n",
1305                        host->host_no, id));
1306         }
1307         if(hostdata->state == NCR_700_HOST_BUSY && SCp != NULL) {
1308                 struct NCR_700_command_slot *slot =
1309                         (struct NCR_700_command_slot *)SCp->host_scribble;
1310                 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));
1311
1312                 switch(dsp - hostdata->pScript) {
1313                 case Ent_Disconnect1:
1314                 case Ent_Disconnect2:
1315                         save_for_reselection(hostdata, SCp, Ent_Disconnect2 + hostdata->pScript);
1316                         break;
1317                 case Ent_Disconnect3:
1318                 case Ent_Disconnect4:
1319                         save_for_reselection(hostdata, SCp, Ent_Disconnect4 + hostdata->pScript);
1320                         break;
1321                 case Ent_Disconnect5:
1322                 case Ent_Disconnect6:
1323                         save_for_reselection(hostdata, SCp, Ent_Disconnect6 + hostdata->pScript);
1324                         break;
1325                 case Ent_Disconnect7:
1326                 case Ent_Disconnect8:
1327                         save_for_reselection(hostdata, SCp, Ent_Disconnect8 + hostdata->pScript);
1328                         break;
1329                 case Ent_Finish1:
1330                 case Ent_Finish2:
1331                         process_script_interrupt(A_GOOD_STATUS_AFTER_STATUS, dsp, SCp, host, hostdata);
1332                         break;
1333
1334                 default:
1335                         slot->state = NCR_700_SLOT_QUEUED;
1336                         break;
1337                         }
1338         }
1339         hostdata->state = NCR_700_HOST_BUSY;
1340         hostdata->cmd = NULL;
1341         /* clear any stale simple tag message */
1342         hostdata->msgin[1] = 0;
1343         dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE,
1344                        DMA_BIDIRECTIONAL);
1345
1346         if(id == 0xff) {
1347                 /* Selected as target, Ignore */
1348                 resume_offset = hostdata->pScript + Ent_SelectedAsTarget;
1349         } else if(hostdata->tag_negotiated & (1<<id)) {
1350                 resume_offset = hostdata->pScript + Ent_GetReselectionWithTag;
1351         } else {
1352                 resume_offset = hostdata->pScript + Ent_GetReselectionData;
1353         }
1354         return resume_offset;
1355 }
1356
1357 static inline void
1358 NCR_700_clear_fifo(struct Scsi_Host *host) {
1359         const struct NCR_700_Host_Parameters *hostdata
1360                 = (struct NCR_700_Host_Parameters *)host->hostdata[0];
1361         if(hostdata->chip710) {
1362                 NCR_700_writeb(CLR_FIFO_710, host, CTEST8_REG);
1363         } else {
1364                 NCR_700_writeb(CLR_FIFO, host, DFIFO_REG);
1365         }
1366 }
1367
1368 static inline void
1369 NCR_700_flush_fifo(struct Scsi_Host *host) {
1370         const struct NCR_700_Host_Parameters *hostdata
1371                 = (struct NCR_700_Host_Parameters *)host->hostdata[0];
1372         if(hostdata->chip710) {
1373                 NCR_700_writeb(FLUSH_DMA_FIFO_710, host, CTEST8_REG);
1374                 udelay(10);
1375                 NCR_700_writeb(0, host, CTEST8_REG);
1376         } else {
1377                 NCR_700_writeb(FLUSH_DMA_FIFO, host, DFIFO_REG);
1378                 udelay(10);
1379                 NCR_700_writeb(0, host, DFIFO_REG);
1380         }
1381 }
1382
1383
1384 /* The queue lock with interrupts disabled must be held on entry to
1385  * this function */
1386 STATIC int
1387 NCR_700_start_command(struct scsi_cmnd *SCp)
1388 {
1389         struct NCR_700_command_slot *slot =
1390                 (struct NCR_700_command_slot *)SCp->host_scribble;
1391         struct NCR_700_Host_Parameters *hostdata =
1392                 (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1393         __u16 count = 1;        /* for IDENTIFY message */
1394         u8 lun = SCp->device->lun;
1395
1396         if(hostdata->state != NCR_700_HOST_FREE) {
1397                 /* keep this inside the lock to close the race window where
1398                  * the running command finishes on another CPU while we don't
1399                  * change the state to queued on this one */
1400                 slot->state = NCR_700_SLOT_QUEUED;
1401
1402                 DEBUG(("scsi%d: host busy, queueing command %p, slot %p\n",
1403                        SCp->device->host->host_no, slot->cmnd, slot));
1404                 return 0;
1405         }
1406         hostdata->state = NCR_700_HOST_BUSY;
1407         hostdata->cmd = SCp;
1408         slot->state = NCR_700_SLOT_BUSY;
1409         /* keep interrupts disabled until we have the command correctly
1410          * set up so we cannot take a selection interrupt */
1411
1412         hostdata->msgout[0] = NCR_700_identify((SCp->cmnd[0] != REQUEST_SENSE &&
1413                                                 slot->flags != NCR_700_FLAG_AUTOSENSE),
1414                                                lun);
1415         /* for INQUIRY or REQUEST_SENSE commands, we cannot be sure
1416          * if the negotiated transfer parameters still hold, so
1417          * always renegotiate them */
1418         if(SCp->cmnd[0] == INQUIRY || SCp->cmnd[0] == REQUEST_SENSE ||
1419            slot->flags == NCR_700_FLAG_AUTOSENSE) {
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<<scmd_id(SCp)))
1428            && (slot->tag != SCSI_NO_TAG && SCp->cmnd[0] != REQUEST_SENSE &&
1429                slot->flags != NCR_700_FLAG_AUTOSENSE)) {
1430                 count += scsi_populate_tag_msg(SCp, &hostdata->msgout[count]);
1431         }
1432
1433         if(hostdata->fast &&
1434            NCR_700_is_flag_clear(SCp->device, NCR_700_DEV_NEGOTIATED_SYNC)) {
1435                 count += spi_populate_sync_msg(&hostdata->msgout[count],
1436                                 spi_period(SCp->device->sdev_target),
1437                                 spi_offset(SCp->device->sdev_target));
1438                 NCR_700_set_flag(SCp->device, NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
1439         }
1440
1441         script_patch_16(hostdata->dev, hostdata->script, MessageCount, count);
1442
1443
1444         script_patch_ID(hostdata->dev, hostdata->script,
1445                         Device_ID, 1<<scmd_id(SCp));
1446
1447         script_patch_32_abs(hostdata->dev, hostdata->script, CommandAddress,
1448                             slot->pCmd);
1449         script_patch_16(hostdata->dev, hostdata->script, CommandCount,
1450                         SCp->cmd_len);
1451         /* finally plumb the beginning of the SG list into the script
1452          * */
1453         script_patch_32_abs(hostdata->dev, hostdata->script,
1454                             SGScriptStartAddress, 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->dev, hostdata->msgout, count, DMA_TO_DEVICE);
1461         dma_cache_sync(hostdata->dev, hostdata->msgin, MSG_ARRAY_SIZE,
1462                        DMA_FROM_DEVICE);
1463         dma_cache_sync(hostdata->dev, SCp->cmnd, SCp->cmd_len, DMA_TO_DEVICE);
1464         dma_cache_sync(hostdata->dev, 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)
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 access 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                                 NCR_700_clear_flag(SDp, ~0);
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(hostdata->dev, 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_lck(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<<scmd_id(SCp)))
1770                || !(SCp->flags & SCMD_TAGGED))) {
1771                 CDEBUG(KERN_ERR, SCp, "has non zero depth %d\n",
1772                        NCR_700_get_depth(SCp->device));
1773                 return SCSI_MLQUEUE_DEVICE_BUSY;
1774         }
1775         if(NCR_700_get_depth(SCp->device) >= SCp->device->queue_depth) {
1776                 CDEBUG(KERN_ERR, SCp, "has max tag depth %d\n",
1777                        NCR_700_get_depth(SCp->device));
1778                 return SCSI_MLQUEUE_DEVICE_BUSY;
1779         }
1780         NCR_700_set_depth(SCp->device, NCR_700_get_depth(SCp->device) + 1);
1781
1782         /* begin the command here */
1783         /* no need to check for NULL, test for command_slot_count above
1784          * ensures a slot is free */
1785         slot = find_empty_slot(hostdata);
1786
1787         slot->cmnd = SCp;
1788
1789         SCp->scsi_done = done;
1790         SCp->host_scribble = (unsigned char *)slot;
1791         SCp->SCp.ptr = NULL;
1792         SCp->SCp.buffer = NULL;
1793
1794 #ifdef NCR_700_DEBUG
1795         printk("53c700: scsi%d, command ", SCp->device->host->host_no);
1796         scsi_print_command(SCp);
1797 #endif
1798         if ((SCp->flags & SCMD_TAGGED)
1799            && (hostdata->tag_negotiated &(1<<scmd_id(SCp))) == 0
1800            && NCR_700_get_tag_neg_state(SCp->device) == NCR_700_START_TAG_NEGOTIATION) {
1801                 scmd_printk(KERN_ERR, SCp, "Enabling Tag Command Queuing\n");
1802                 hostdata->tag_negotiated |= (1<<scmd_id(SCp));
1803                 NCR_700_set_tag_neg_state(SCp->device, NCR_700_DURING_TAG_NEGOTIATION);
1804         }
1805
1806         /* here we may have to process an untagged command.  The gate
1807          * above ensures that this will be the only one outstanding,
1808          * so clear the tag negotiated bit.
1809          *
1810          * FIXME: This will royally screw up on multiple LUN devices
1811          * */
1812         if (!(SCp->flags & SCMD_TAGGED)
1813            && (hostdata->tag_negotiated &(1<<scmd_id(SCp)))) {
1814                 scmd_printk(KERN_INFO, SCp, "Disabling Tag Command Queuing\n");
1815                 hostdata->tag_negotiated &= ~(1<<scmd_id(SCp));
1816         }
1817
1818         if((hostdata->tag_negotiated &(1<<scmd_id(SCp)))
1819            && scsi_get_tag_type(SCp->device)) {
1820                 slot->tag = SCp->request->tag;
1821                 CDEBUG(KERN_DEBUG, SCp, "sending out tag %d, slot %p\n",
1822                        slot->tag, slot);
1823         } else {
1824                 slot->tag = SCSI_NO_TAG;
1825                 /* must populate current_cmnd for scsi_find_tag to work */
1826                 SCp->device->current_cmnd = SCp;
1827         }
1828         /* sanity check: some of the commands generated by the mid-layer
1829          * have an eccentric idea of their sc_data_direction */
1830         if(!scsi_sg_count(SCp) && !scsi_bufflen(SCp) &&
1831            SCp->sc_data_direction != DMA_NONE) {
1832 #ifdef NCR_700_DEBUG
1833                 printk("53c700: Command");
1834                 scsi_print_command(SCp);
1835                 printk("Has wrong data direction %d\n", SCp->sc_data_direction);
1836 #endif
1837                 SCp->sc_data_direction = DMA_NONE;
1838         }
1839
1840         switch (SCp->cmnd[0]) {
1841         case REQUEST_SENSE:
1842                 /* clear the internal sense magic */
1843                 SCp->cmnd[6] = 0;
1844                 /* fall through */
1845         default:
1846                 /* OK, get it from the command */
1847                 switch(SCp->sc_data_direction) {
1848                 case DMA_BIDIRECTIONAL:
1849                 default:
1850                         printk(KERN_ERR "53c700: Unknown command for data direction ");
1851                         scsi_print_command(SCp);
1852
1853                         move_ins = 0;
1854                         break;
1855                 case DMA_NONE:
1856                         move_ins = 0;
1857                         break;
1858                 case DMA_FROM_DEVICE:
1859                         move_ins = SCRIPT_MOVE_DATA_IN;
1860                         break;
1861                 case DMA_TO_DEVICE:
1862                         move_ins = SCRIPT_MOVE_DATA_OUT;
1863                         break;
1864                 }
1865         }
1866
1867         /* now build the scatter gather list */
1868         direction = SCp->sc_data_direction;
1869         if(move_ins != 0) {
1870                 int i;
1871                 int sg_count;
1872                 dma_addr_t vPtr = 0;
1873                 struct scatterlist *sg;
1874                 __u32 count = 0;
1875
1876                 sg_count = scsi_dma_map(SCp);
1877                 BUG_ON(sg_count < 0);
1878
1879                 scsi_for_each_sg(SCp, sg, sg_count, i) {
1880                         vPtr = sg_dma_address(sg);
1881                         count = sg_dma_len(sg);
1882
1883                         slot->SG[i].ins = bS_to_host(move_ins | count);
1884                         DEBUG((" scatter block %d: move %d[%08x] from 0x%lx\n",
1885                                i, count, slot->SG[i].ins, (unsigned long)vPtr));
1886                         slot->SG[i].pAddr = bS_to_host(vPtr);
1887                 }
1888                 slot->SG[i].ins = bS_to_host(SCRIPT_RETURN);
1889                 slot->SG[i].pAddr = 0;
1890                 dma_cache_sync(hostdata->dev, slot->SG, sizeof(slot->SG), DMA_TO_DEVICE);
1891                 DEBUG((" SETTING %08lx to %x\n",
1892                        (&slot->pSG[i].ins),
1893                        slot->SG[i].ins));
1894         }
1895         slot->resume_offset = 0;
1896         slot->pCmd = dma_map_single(hostdata->dev, SCp->cmnd,
1897                                     MAX_COMMAND_SIZE, DMA_TO_DEVICE);
1898         NCR_700_start_command(SCp);
1899         return 0;
1900 }
1901
1902 STATIC DEF_SCSI_QCMD(NCR_700_queuecommand)
1903
1904 STATIC int
1905 NCR_700_abort(struct scsi_cmnd * SCp)
1906 {
1907         struct NCR_700_command_slot *slot;
1908
1909         scmd_printk(KERN_INFO, SCp, "abort command\n");
1910
1911         slot = (struct NCR_700_command_slot *)SCp->host_scribble;
1912
1913         if(slot == NULL)
1914                 /* no outstanding command to abort */
1915                 return SUCCESS;
1916         if(SCp->cmnd[0] == TEST_UNIT_READY) {
1917                 /* FIXME: This is because of a problem in the new
1918                  * error handler.  When it is in error recovery, it
1919                  * will send a TUR to a device it thinks may still be
1920                  * showing a problem.  If the TUR isn't responded to,
1921                  * it will abort it and mark the device off line.
1922                  * Unfortunately, it does no other error recovery, so
1923                  * this would leave us with an outstanding command
1924                  * occupying a slot.  Rather than allow this to
1925                  * happen, we issue a bus reset to force all
1926                  * outstanding commands to terminate here. */
1927                 NCR_700_internal_bus_reset(SCp->device->host);
1928                 /* still drop through and return failed */
1929         }
1930         return FAILED;
1931
1932 }
1933
1934 STATIC int
1935 NCR_700_bus_reset(struct scsi_cmnd * SCp)
1936 {
1937         DECLARE_COMPLETION_ONSTACK(complete);
1938         struct NCR_700_Host_Parameters *hostdata =
1939                 (struct NCR_700_Host_Parameters *)SCp->device->host->hostdata[0];
1940
1941         scmd_printk(KERN_INFO, SCp,
1942                 "New error handler wants BUS reset, cmd %p\n\t", SCp);
1943         scsi_print_command(SCp);
1944
1945         /* In theory, eh_complete should always be null because the
1946          * eh is single threaded, but just in case we're handling a
1947          * reset via sg or something */
1948         spin_lock_irq(SCp->device->host->host_lock);
1949         while (hostdata->eh_complete != NULL) {
1950                 spin_unlock_irq(SCp->device->host->host_lock);
1951                 msleep_interruptible(100);
1952                 spin_lock_irq(SCp->device->host->host_lock);
1953         }
1954
1955         hostdata->eh_complete = &complete;
1956         NCR_700_internal_bus_reset(SCp->device->host);
1957
1958         spin_unlock_irq(SCp->device->host->host_lock);
1959         wait_for_completion(&complete);
1960         spin_lock_irq(SCp->device->host->host_lock);
1961
1962         hostdata->eh_complete = NULL;
1963         /* Revalidate the transport parameters of the failing device */
1964         if(hostdata->fast)
1965                 spi_schedule_dv_device(SCp->device);
1966
1967         spin_unlock_irq(SCp->device->host->host_lock);
1968         return SUCCESS;
1969 }
1970
1971 STATIC int
1972 NCR_700_host_reset(struct scsi_cmnd * SCp)
1973 {
1974         scmd_printk(KERN_INFO, SCp, "New error handler wants HOST reset\n\t");
1975         scsi_print_command(SCp);
1976
1977         spin_lock_irq(SCp->device->host->host_lock);
1978
1979         NCR_700_internal_bus_reset(SCp->device->host);
1980         NCR_700_chip_reset(SCp->device->host);
1981
1982         spin_unlock_irq(SCp->device->host->host_lock);
1983
1984         return SUCCESS;
1985 }
1986
1987 STATIC void
1988 NCR_700_set_period(struct scsi_target *STp, int period)
1989 {
1990         struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent);
1991         struct NCR_700_Host_Parameters *hostdata =
1992                 (struct NCR_700_Host_Parameters *)SHp->hostdata[0];
1993
1994         if(!hostdata->fast)
1995                 return;
1996
1997         if(period < hostdata->min_period)
1998                 period = hostdata->min_period;
1999
2000         spi_period(STp) = period;
2001         spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC |
2002                             NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
2003         spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION;
2004 }
2005
2006 STATIC void
2007 NCR_700_set_offset(struct scsi_target *STp, int offset)
2008 {
2009         struct Scsi_Host *SHp = dev_to_shost(STp->dev.parent);
2010         struct NCR_700_Host_Parameters *hostdata =
2011                 (struct NCR_700_Host_Parameters *)SHp->hostdata[0];
2012         int max_offset = hostdata->chip710
2013                 ? NCR_710_MAX_OFFSET : NCR_700_MAX_OFFSET;
2014
2015         if(!hostdata->fast)
2016                 return;
2017
2018         if(offset > max_offset)
2019                 offset = max_offset;
2020
2021         /* if we're currently async, make sure the period is reasonable */
2022         if(spi_offset(STp) == 0 && (spi_period(STp) < hostdata->min_period ||
2023                                     spi_period(STp) > 0xff))
2024                 spi_period(STp) = hostdata->min_period;
2025
2026         spi_offset(STp) = offset;
2027         spi_flags(STp) &= ~(NCR_700_DEV_NEGOTIATED_SYNC |
2028                             NCR_700_DEV_BEGIN_SYNC_NEGOTIATION);
2029         spi_flags(STp) |= NCR_700_DEV_PRINT_SYNC_NEGOTIATION;
2030 }
2031
2032 STATIC int
2033 NCR_700_slave_alloc(struct scsi_device *SDp)
2034 {
2035         SDp->hostdata = kzalloc(sizeof(struct NCR_700_Device_Parameters),
2036                                 GFP_KERNEL);
2037
2038         if (!SDp->hostdata)
2039                 return -ENOMEM;
2040
2041         return 0;
2042 }
2043
2044 STATIC int
2045 NCR_700_slave_configure(struct scsi_device *SDp)
2046 {
2047         struct NCR_700_Host_Parameters *hostdata =
2048                 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
2049
2050         /* to do here: allocate memory; build a queue_full list */
2051         if(SDp->tagged_supported) {
2052                 scsi_set_tag_type(SDp, MSG_ORDERED_TAG);
2053                 scsi_activate_tcq(SDp, NCR_700_DEFAULT_TAGS);
2054                 NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
2055         } else {
2056                 /* initialise to default depth */
2057                 scsi_adjust_queue_depth(SDp, 0, SDp->host->cmd_per_lun);
2058         }
2059         if(hostdata->fast) {
2060                 /* Find the correct offset and period via domain validation */
2061                 if (!spi_initial_dv(SDp->sdev_target))
2062                         spi_dv_device(SDp);
2063         } else {
2064                 spi_offset(SDp->sdev_target) = 0;
2065                 spi_period(SDp->sdev_target) = 0;
2066         }
2067         return 0;
2068 }
2069
2070 STATIC void
2071 NCR_700_slave_destroy(struct scsi_device *SDp)
2072 {
2073         kfree(SDp->hostdata);
2074         SDp->hostdata = NULL;
2075 }
2076
2077 static int
2078 NCR_700_change_queue_depth(struct scsi_device *SDp, int depth, int reason)
2079 {
2080         if (reason != SCSI_QDEPTH_DEFAULT)
2081                 return -EOPNOTSUPP;
2082
2083         if (depth > NCR_700_MAX_TAGS)
2084                 depth = NCR_700_MAX_TAGS;
2085
2086         scsi_adjust_queue_depth(SDp, scsi_get_tag_type(SDp), depth);
2087         return depth;
2088 }
2089
2090 static int NCR_700_change_queue_type(struct scsi_device *SDp, int tag_type)
2091 {
2092         int change_tag = ((tag_type ==0 &&  scsi_get_tag_type(SDp) != 0)
2093                           || (tag_type != 0 && scsi_get_tag_type(SDp) == 0));
2094         struct NCR_700_Host_Parameters *hostdata =
2095                 (struct NCR_700_Host_Parameters *)SDp->host->hostdata[0];
2096
2097         scsi_set_tag_type(SDp, tag_type);
2098
2099         /* We have a global (per target) flag to track whether TCQ is
2100          * enabled, so we'll be turning it off for the entire target here.
2101          * our tag algorithm will fail if we mix tagged and untagged commands,
2102          * so quiesce the device before doing this */
2103         if (change_tag)
2104                 scsi_target_quiesce(SDp->sdev_target);
2105
2106         if (!tag_type) {
2107                 /* shift back to the default unqueued number of commands
2108                  * (the user can still raise this) */
2109                 scsi_deactivate_tcq(SDp, SDp->host->cmd_per_lun);
2110                 hostdata->tag_negotiated &= ~(1 << sdev_id(SDp));
2111         } else {
2112                 /* Here, we cleared the negotiation flag above, so this
2113                  * will force the driver to renegotiate */
2114                 scsi_activate_tcq(SDp, SDp->queue_depth);
2115                 if (change_tag)
2116                         NCR_700_set_tag_neg_state(SDp, NCR_700_START_TAG_NEGOTIATION);
2117         }
2118         if (change_tag)
2119                 scsi_target_resume(SDp->sdev_target);
2120
2121         return tag_type;
2122 }
2123
2124 static ssize_t
2125 NCR_700_show_active_tags(struct device *dev, struct device_attribute *attr, char *buf)
2126 {
2127         struct scsi_device *SDp = to_scsi_device(dev);
2128
2129         return snprintf(buf, 20, "%d\n", NCR_700_get_depth(SDp));
2130 }
2131
2132 static struct device_attribute NCR_700_active_tags_attr = {
2133         .attr = {
2134                 .name =         "active_tags",
2135                 .mode =         S_IRUGO,
2136         },
2137         .show = NCR_700_show_active_tags,
2138 };
2139
2140 STATIC struct device_attribute *NCR_700_dev_attrs[] = {
2141         &NCR_700_active_tags_attr,
2142         NULL,
2143 };
2144
2145 EXPORT_SYMBOL(NCR_700_detect);
2146 EXPORT_SYMBOL(NCR_700_release);
2147 EXPORT_SYMBOL(NCR_700_intr);
2148
2149 static struct spi_function_template NCR_700_transport_functions =  {
2150         .set_period     = NCR_700_set_period,
2151         .show_period    = 1,
2152         .set_offset     = NCR_700_set_offset,
2153         .show_offset    = 1,
2154 };
2155
2156 static int __init NCR_700_init(void)
2157 {
2158         NCR_700_transport_template = spi_attach_transport(&NCR_700_transport_functions);
2159         if(!NCR_700_transport_template)
2160                 return -ENODEV;
2161         return 0;
2162 }
2163
2164 static void __exit NCR_700_exit(void)
2165 {
2166         spi_release_transport(NCR_700_transport_template);
2167 }
2168
2169 module_init(NCR_700_init);
2170 module_exit(NCR_700_exit);
2171