drivers/scsi/53c700.c

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