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