err.no Git - linux-2.6/blob - drivers/scsi/53c700.c

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