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