drivers/scsi/53c700.c

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