drivers/scsi/53c700.c

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