drivers/scsi/53c700.c

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

DEFINITIONS
