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