drivers/scsi/ncr53c8xx.c

   1 /******************************************************************************
   2 **  Device driver for the PCI-SCSI NCR538XX controller family.
   3 **
   4 **  Copyright (C) 1994  Wolfgang Stanglmeier
   5 **
   6 **  This program is free software; you can redistribute it and/or modify
   7 **  it under the terms of the GNU General Public License as published by
   8 **  the Free Software Foundation; either version 2 of the License, or
   9 **  (at your option) any later version.
  10 **
  11 **  This program is distributed in the hope that it will be useful,
  12 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 **  GNU General Public License for more details.
  15 **
  16 **  You should have received a copy of the GNU General Public License
  17 **  along with this program; if not, write to the Free Software
  18 **  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 **
  20 **-----------------------------------------------------------------------------
  21 **
  22 **  This driver has been ported to Linux from the FreeBSD NCR53C8XX driver
  23 **  and is currently maintained by
  24 **
  25 **          Gerard Roudier              <groudier@free.fr>
  26 **
  27 **  Being given that this driver originates from the FreeBSD version, and
  28 **  in order to keep synergy on both, any suggested enhancements and corrections
  29 **  received on Linux are automatically a potential candidate for the FreeBSD
  30 **  version.
  31 **
  32 **  The original driver has been written for 386bsd and FreeBSD by
  33 **          Wolfgang Stanglmeier        <wolf@cologne.de>
  34 **          Stefan Esser                <se@mi.Uni-Koeln.de>
  35 **
  36 **  And has been ported to NetBSD by
  37 **          Charles M. Hannum           <mycroft@gnu.ai.mit.edu>
  38 **
  39 **-----------------------------------------------------------------------------
  40 **
  41 **                     Brief history
  42 **
  43 **  December 10 1995 by Gerard Roudier:
  44 **     Initial port to Linux.
  45 **
  46 **  June 23 1996 by Gerard Roudier:
  47 **     Support for 64 bits architectures (Alpha).
  48 **
  49 **  November 30 1996 by Gerard Roudier:
  50 **     Support for Fast-20 scsi.
  51 **     Support for large DMA fifo and 128 dwords bursting.
  52 **
  53 **  February 27 1997 by Gerard Roudier:
  54 **     Support for Fast-40 scsi.
  55 **     Support for on-Board RAM.
  56 **
  57 **  May 3 1997 by Gerard Roudier:
  58 **     Full support for scsi scripts instructions pre-fetching.
  59 **
  60 **  May 19 1997 by Richard Waltham <dormouse@farsrobt.demon.co.uk>:
  61 **     Support for NvRAM detection and reading.
  62 **
  63 **  August 18 1997 by Cort <cort@cs.nmt.edu>:
  64 **     Support for Power/PC (Big Endian).
  65 **
  66 **  June 20 1998 by Gerard Roudier
  67 **     Support for up to 64 tags per lun.
  68 **     O(1) everywhere (C and SCRIPTS) for normal cases.
  69 **     Low PCI traffic for command handling when on-chip RAM is present.
  70 **     Aggressive SCSI SCRIPTS optimizations.
  71 **
  72 *******************************************************************************
  73 */
  74
  75 /*
  76 **      Supported SCSI-II features:
  77 **          Synchronous negotiation
  78 **          Wide negotiation        (depends on the NCR Chip)
  79 **          Enable disconnection
  80 **          Tagged command queuing
  81 **          Parity checking
  82 **          Etc...
  83 **
  84 **      Supported NCR/SYMBIOS chips:
  85 **              53C720          (Wide,   Fast SCSI-2, intfly problems)
  86 **
  87 **      Other features:
  88 **              Memory mapped IO (linux-1.3.X and above only)
  89 **              Module
  90 **              Shared IRQ (since linux-1.3.72)
  91 */
  92
  93 /* Name and version of the driver */
  94 #define SCSI_NCR_DRIVER_NAME    "ncr53c8xx-3.4.3f"
  95
  96 #define SCSI_NCR_DEBUG_FLAGS    (0)
  97
  98 /*==========================================================
  99 **
 100 **      Include files
 101 **
 102 **==========================================================
 103 */
 104
 105 #include <linux/blkdev.h>
 106 #include <linux/delay.h>
 107 #include <linux/dma-mapping.h>
 108 #include <linux/errno.h>
 109 #include <linux/init.h>
 110 #include <linux/interrupt.h>
 111 #include <linux/ioport.h>
 112 #include <linux/mm.h>
 113 #include <linux/module.h>
 114 #include <linux/sched.h>
 115 #include <linux/signal.h>
 116 #include <linux/spinlock.h>
 117 #include <linux/stat.h>
 118 #include <linux/string.h>
 119 #include <linux/time.h>
 120 #include <linux/timer.h>
 121 #include <linux/types.h>
 122
 123 #include <asm/dma.h>
 124 #include <asm/io.h>
 125 #include <asm/system.h>
 126
 127 #include "scsi.h"
 128 #include <scsi/scsi_host.h>
 129
 130 #include "ncr53c8xx.h"
 131
 132 /*
 133 **      Donnot compile integrity checking code for Linux-2.3.0
 134 **      and above since SCSI data structures are not ready yet.
 135 */
 136 /* #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0) */
 137 #if 0
 138 #define SCSI_NCR_INTEGRITY_CHECKING
 139 #endif
 140
 141 #define NAME53C                 "ncr53c"
 142 #define NAME53C8XX              "ncr53c8xx"
 143 #define DRIVER_SMP_LOCK         ncr53c8xx_lock
 144
 145 #include "sym53c8xx_comm.h"
 146
 147
 148 /*==========================================================
 149 **
 150 **      The CCB done queue uses an array of CCB virtual
 151 **      addresses. Empty entries are flagged using the bogus
 152 **      virtual address 0xffffffff.
 153 **
 154 **      Since PCI ensures that only aligned DWORDs are accessed
 155 **      atomically, 64 bit little-endian architecture requires
 156 **      to test the high order DWORD of the entry to determine
 157 **      if it is empty or valid.
 158 **
 159 **      BTW, I will make things differently as soon as I will
 160 **      have a better idea, but this is simple and should work.
 161 **
 162 **==========================================================
 163 */
 164
 165 #define SCSI_NCR_CCB_DONE_SUPPORT
 166 #ifdef  SCSI_NCR_CCB_DONE_SUPPORT
 167
 168 #define MAX_DONE 24
 169 #define CCB_DONE_EMPTY 0xffffffffUL
 170
 171 /* All 32 bit architectures */
 172 #if BITS_PER_LONG == 32
 173 #define CCB_DONE_VALID(cp)  (((u_long) cp) != CCB_DONE_EMPTY)
 174
 175 /* All > 32 bit (64 bit) architectures regardless endian-ness */
 176 #else
 177 #define CCB_DONE_VALID(cp)  \
 178         ((((u_long) cp) & 0xffffffff00000000ul) &&      \
 179          (((u_long) cp) & 0xfffffffful) != CCB_DONE_EMPTY)
 180 #endif
 181
 182 #endif /* SCSI_NCR_CCB_DONE_SUPPORT */
 183
 184 /*==========================================================
 185 **
 186 **      Configuration and Debugging
 187 **
 188 **==========================================================
 189 */
 190
 191 /*
 192 **    SCSI address of this device.
 193 **    The boot routines should have set it.
 194 **    If not, use this.
 195 */
 196
 197 #ifndef SCSI_NCR_MYADDR
 198 #define SCSI_NCR_MYADDR      (7)
 199 #endif
 200
 201 /*
 202 **    The maximum number of tags per logic unit.
 203 **    Used only for disk devices that support tags.
 204 */
 205
 206 #ifndef SCSI_NCR_MAX_TAGS
 207 #define SCSI_NCR_MAX_TAGS    (8)
 208 #endif
 209
 210 /*
 211 **    TAGS are actually limited to 64 tags/lun.
 212 **    We need to deal with power of 2, for alignment constraints.
 213 */
 214 #if     SCSI_NCR_MAX_TAGS > 64
 215 #define MAX_TAGS (64)
 216 #else
 217 #define MAX_TAGS SCSI_NCR_MAX_TAGS
 218 #endif
 219
 220 #define NO_TAG  (255)
 221
 222 /*
 223 **      Choose appropriate type for tag bitmap.
 224 */
 225 #if     MAX_TAGS > 32
 226 typedef u64 tagmap_t;
 227 #else
 228 typedef u32 tagmap_t;
 229 #endif
 230
 231 /*
 232 **    Number of targets supported by the driver.
 233 **    n permits target numbers 0..n-1.
 234 **    Default is 16, meaning targets #0..#15.
 235 **    #7 .. is myself.
 236 */
 237
 238 #ifdef SCSI_NCR_MAX_TARGET
 239 #define MAX_TARGET  (SCSI_NCR_MAX_TARGET)
 240 #else
 241 #define MAX_TARGET  (16)
 242 #endif
 243
 244 /*
 245 **    Number of logic units supported by the driver.
 246 **    n enables logic unit numbers 0..n-1.
 247 **    The common SCSI devices require only
 248 **    one lun, so take 1 as the default.
 249 */
 250
 251 #ifdef SCSI_NCR_MAX_LUN
 252 #define MAX_LUN    SCSI_NCR_MAX_LUN
 253 #else
 254 #define MAX_LUN    (1)
 255 #endif
 256
 257 /*
 258 **    Asynchronous pre-scaler (ns). Shall be 40
 259 */
 260
 261 #ifndef SCSI_NCR_MIN_ASYNC
 262 #define SCSI_NCR_MIN_ASYNC (40)
 263 #endif
 264
 265 /*
 266 **    The maximum number of jobs scheduled for starting.
 267 **    There should be one slot per target, and one slot
 268 **    for each tag of each target in use.
 269 **    The calculation below is actually quite silly ...
 270 */
 271
 272 #ifdef SCSI_NCR_CAN_QUEUE
 273 #define MAX_START   (SCSI_NCR_CAN_QUEUE + 4)
 274 #else
 275 #define MAX_START   (MAX_TARGET + 7 * MAX_TAGS)
 276 #endif
 277
 278 /*
 279 **   We limit the max number of pending IO to 250.
 280 **   since we donnot want to allocate more than 1
 281 **   PAGE for 'scripth'.
 282 */
 283 #if     MAX_START > 250
 284 #undef  MAX_START
 285 #define MAX_START 250
 286 #endif
 287
 288 /*
 289 **    The maximum number of segments a transfer is split into.
 290 **    We support up to 127 segments for both read and write.
 291 **    The data scripts are broken into 2 sub-scripts.
 292 **    80 (MAX_SCATTERL) segments are moved from a sub-script
 293 **    in on-chip RAM. This makes data transfers shorter than
 294 **    80k (assuming 1k fs) as fast as possible.
 295 */
 296
 297 #define MAX_SCATTER (SCSI_NCR_MAX_SCATTER)
 298
 299 #if (MAX_SCATTER > 80)
 300 #define MAX_SCATTERL    80
 301 #define MAX_SCATTERH    (MAX_SCATTER - MAX_SCATTERL)
 302 #else
 303 #define MAX_SCATTERL    (MAX_SCATTER-1)
 304 #define MAX_SCATTERH    1
 305 #endif
 306
 307 /*
 308 **      other
 309 */
 310
 311 #define NCR_SNOOP_TIMEOUT (1000000)
 312
 313 /*
 314 **      Other definitions
 315 */
 316
 317 #define ScsiResult(host_code, scsi_code) (((host_code) << 16) + ((scsi_code) & 0x7f))
 318
 319 static void ncr53c8xx_timeout(unsigned long np);
 320 static int ncr53c8xx_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
 321                         int length, int func);
 322
 323 #define initverbose (driver_setup.verbose)
 324 #define bootverbose (np->verbose)
 325
 326 /*==========================================================
 327 **
 328 **      Command control block states.
 329 **
 330 **==========================================================
 331 */
 332
 333 #define HS_IDLE         (0)
 334 #define HS_BUSY         (1)
 335 #define HS_NEGOTIATE    (2)     /* sync/wide data transfer*/
 336 #define HS_DISCONNECT   (3)     /* Disconnected by target */
 337
 338 #define HS_DONEMASK     (0x80)
 339 #define HS_COMPLETE     (4|HS_DONEMASK)
 340 #define HS_SEL_TIMEOUT  (5|HS_DONEMASK) /* Selection timeout      */
 341 #define HS_RESET        (6|HS_DONEMASK) /* SCSI reset             */
 342 #define HS_ABORTED      (7|HS_DONEMASK) /* Transfer aborted       */
 343 #define HS_TIMEOUT      (8|HS_DONEMASK) /* Software timeout       */
 344 #define HS_FAIL         (9|HS_DONEMASK) /* SCSI or PCI bus errors */
 345 #define HS_UNEXPECTED   (10|HS_DONEMASK)/* Unexpected disconnect  */
 346
 347 /*
 348 **      Invalid host status values used by the SCRIPTS processor
 349 **      when the nexus is not fully identified.
 350 **      Shall never appear in a CCB.
 351 */
 352
 353 #define HS_INVALMASK    (0x40)
 354 #define HS_SELECTING    (0|HS_INVALMASK)
 355 #define HS_IN_RESELECT  (1|HS_INVALMASK)
 356 #define HS_STARTING     (2|HS_INVALMASK)
 357
 358 /*
 359 **      Flags set by the SCRIPT processor for commands
 360 **      that have been skipped.
 361 */
 362 #define HS_SKIPMASK     (0x20)
 363
 364 /*==========================================================
 365 **
 366 **      Software Interrupt Codes
 367 **
 368 **==========================================================
 369 */
 370
 371 #define SIR_BAD_STATUS          (1)
 372 #define SIR_XXXXXXXXXX          (2)
 373 #define SIR_NEGO_SYNC           (3)
 374 #define SIR_NEGO_WIDE           (4)
 375 #define SIR_NEGO_FAILED         (5)
 376 #define SIR_NEGO_PROTO          (6)
 377 #define SIR_REJECT_RECEIVED     (7)
 378 #define SIR_REJECT_SENT         (8)
 379 #define SIR_IGN_RESIDUE         (9)
 380 #define SIR_MISSING_SAVE        (10)
 381 #define SIR_RESEL_NO_MSG_IN     (11)
 382 #define SIR_RESEL_NO_IDENTIFY   (12)
 383 #define SIR_RESEL_BAD_LUN       (13)
 384 #define SIR_RESEL_BAD_TARGET    (14)
 385 #define SIR_RESEL_BAD_I_T_L     (15)
 386 #define SIR_RESEL_BAD_I_T_L_Q   (16)
 387 #define SIR_DONE_OVERFLOW       (17)
 388 #define SIR_INTFLY              (18)
 389 #define SIR_MAX                 (18)
 390
 391 /*==========================================================
 392 **
 393 **      Extended error codes.
 394 **      xerr_status field of struct ccb.
 395 **
 396 **==========================================================
 397 */
 398
 399 #define XE_OK           (0)
 400 #define XE_EXTRA_DATA   (1)     /* unexpected data phase */
 401 #define XE_BAD_PHASE    (2)     /* illegal phase (4/5)   */
 402
 403 /*==========================================================
 404 **
 405 **      Negotiation status.
 406 **      nego_status field       of struct ccb.
 407 **
 408 **==========================================================
 409 */
 410
 411 #define NS_NOCHANGE     (0)
 412 #define NS_SYNC         (1)
 413 #define NS_WIDE         (2)
 414 #define NS_PPR          (4)
 415
 416 /*==========================================================
 417 **
 418 **      "Special features" of targets.
 419 **      quirks field            of struct tcb.
 420 **      actualquirks field      of struct ccb.
 421 **
 422 **==========================================================
 423 */
 424
 425 #define QUIRK_AUTOSAVE  (0x01)
 426 #define QUIRK_NOMSG     (0x02)
 427 #define QUIRK_NOSYNC    (0x10)
 428 #define QUIRK_NOWIDE16  (0x20)
 429
 430 /*==========================================================
 431 **
 432 **      Capability bits in Inquire response byte 7.
 433 **
 434 **==========================================================
 435 */
 436
 437 #define INQ7_QUEUE      (0x02)
 438 #define INQ7_SYNC       (0x10)
 439 #define INQ7_WIDE16     (0x20)
 440
 441 /*==========================================================
 442 **
 443 **      Misc.
 444 **
 445 **==========================================================
 446 */
 447
 448 #define CCB_MAGIC       (0xf2691ad2)
 449
 450 /*==========================================================
 451 **
 452 **      Declaration of structs.
 453 **
 454 **==========================================================
 455 */
 456
 457 struct tcb;
 458 struct lcb;
 459 struct ccb;
 460 struct ncb;
 461 struct script;
 462
 463 struct link {
 464         ncrcmd  l_cmd;
 465         ncrcmd  l_paddr;
 466 };
 467
 468 struct  usrcmd {
 469         u_long  target;
 470         u_long  lun;
 471         u_long  data;
 472         u_long  cmd;
 473 };
 474
 475 #define UC_SETSYNC      10
 476 #define UC_SETTAGS      11
 477 #define UC_SETDEBUG     12
 478 #define UC_SETORDER     13
 479 #define UC_SETWIDE      14
 480 #define UC_SETFLAG      15
 481 #define UC_SETVERBOSE   17
 482
 483 #define UF_TRACE        (0x01)
 484 #define UF_NODISC       (0x02)
 485 #define UF_NOSCAN       (0x04)
 486
 487 /*========================================================================
 488 **
 489 **      Declaration of structs:         target control block
 490 **
 491 **========================================================================
 492 */
 493 struct tcb {
 494         /*----------------------------------------------------------------
 495         **      During reselection the ncr jumps to this point with SFBR
 496         **      set to the encoded target number with bit 7 set.
 497         **      if it's not this target, jump to the next.
 498         **
 499         **      JUMP  IF (SFBR != #target#), @(next tcb)
 500         **----------------------------------------------------------------
 501         */
 502         struct link   jump_tcb;
 503
 504         /*----------------------------------------------------------------
 505         **      Load the actual values for the sxfer and the scntl3
 506         **      register (sync/wide mode).
 507         **
 508         **      SCR_COPY (1), @(sval field of this tcb), @(sxfer  register)
 509         **      SCR_COPY (1), @(wval field of this tcb), @(scntl3 register)
 510         **----------------------------------------------------------------
 511         */
 512         ncrcmd  getscr[6];
 513
 514         /*----------------------------------------------------------------
 515         **      Get the IDENTIFY message and load the LUN to SFBR.
 516         **
 517         **      CALL, <RESEL_LUN>
 518         **----------------------------------------------------------------
 519         */
 520         struct link   call_lun;
 521
 522         /*----------------------------------------------------------------
 523         **      Now look for the right lun.
 524         **
 525         **      For i = 0 to 3
 526         **              SCR_JUMP ^ IFTRUE(MASK(i, 3)), @(first lcb mod. i)
 527         **
 528         **      Recent chips will prefetch the 4 JUMPS using only 1 burst.
 529         **      It is kind of hashcoding.
 530         **----------------------------------------------------------------
 531         */
 532         struct link     jump_lcb[4];    /* JUMPs for reselection        */
 533         struct lcb *    lp[MAX_LUN];    /* The lcb's of this tcb        */
 534         u_char          inq_done;       /* Target capabilities received */
 535         u_char          inq_byte7;      /* Contains these capabilities  */
 536
 537         /*----------------------------------------------------------------
 538         **      Pointer to the ccb used for negotiation.
 539         **      Prevent from starting a negotiation for all queued commands
 540         **      when tagged command queuing is enabled.
 541         **----------------------------------------------------------------
 542         */
 543         struct ccb *   nego_cp;
 544
 545         /*----------------------------------------------------------------
 546         **      statistical data
 547         **----------------------------------------------------------------
 548         */
 549         u_long  transfers;
 550         u_long  bytes;
 551
 552         /*----------------------------------------------------------------
 553         **      negotiation of wide and synch transfer and device quirks.
 554         **----------------------------------------------------------------
 555         */
 556 #ifdef SCSI_NCR_BIG_ENDIAN
 557 /*0*/   u16     period;
 558 /*2*/   u_char  sval;
 559 /*3*/   u_char  minsync;
 560 /*0*/   u_char  wval;
 561 /*1*/   u_char  widedone;
 562 /*2*/   u_char  quirks;
 563 /*3*/   u_char  maxoffs;
 564 #else
 565 /*0*/   u_char  minsync;
 566 /*1*/   u_char  sval;
 567 /*2*/   u16     period;
 568 /*0*/   u_char  maxoffs;
 569 /*1*/   u_char  quirks;
 570 /*2*/   u_char  widedone;
 571 /*3*/   u_char  wval;
 572 #endif
 573
 574 #ifdef SCSI_NCR_INTEGRITY_CHECKING
 575         u_char  ic_min_sync;
 576         u_char  ic_max_width;
 577         u_char  ic_maximums_set;
 578         u_char  ic_done;
 579 #endif
 580
 581         /* User settable limits and options.  */
 582         u_char  usrsync;
 583         u_char  usrwide;
 584         u_char  usrtags;
 585         u_char  usrflag;
 586 };
 587
 588 /*========================================================================
 589 **
 590 **      Declaration of structs:         lun control block
 591 **
 592 **========================================================================
 593 */
 594 struct lcb {
 595         /*----------------------------------------------------------------
 596         **      During reselection the ncr jumps to this point
 597         **      with SFBR set to the "Identify" message.
 598         **      if it's not this lun, jump to the next.
 599         **
 600         **      JUMP  IF (SFBR != #lun#), @(next lcb of this target)
 601         **
 602         **      It is this lun. Load TEMP with the nexus jumps table
 603         **      address and jump to RESEL_TAG (or RESEL_NOTAG).
 604         **
 605         **              SCR_COPY (4), p_jump_ccb, TEMP,
 606         **              SCR_JUMP, <RESEL_TAG>
 607         **----------------------------------------------------------------
 608         */
 609         struct link     jump_lcb;
 610         ncrcmd          load_jump_ccb[3];
 611         struct link     jump_tag;
 612         ncrcmd          p_jump_ccb;     /* Jump table bus address       */
 613
 614         /*----------------------------------------------------------------
 615         **      Jump table used by the script processor to directly jump
 616         **      to the CCB corresponding to the reselected nexus.
 617         **      Address is allocated on 256 bytes boundary in order to
 618         **      allow 8 bit calculation of the tag jump entry for up to
 619         **      64 possible tags.
 620         **----------------------------------------------------------------
 621         */
 622         u32             jump_ccb_0;     /* Default table if no tags     */
 623         u32             *jump_ccb;      /* Virtual address              */
 624
 625         /*----------------------------------------------------------------
 626         **      CCB queue management.
 627         **----------------------------------------------------------------
 628         */
 629         XPT_QUEHEAD     free_ccbq;      /* Queue of available CCBs      */
 630         XPT_QUEHEAD     busy_ccbq;      /* Queue of busy CCBs           */
 631         XPT_QUEHEAD     wait_ccbq;      /* Queue of waiting for IO CCBs */
 632         XPT_QUEHEAD     skip_ccbq;      /* Queue of skipped CCBs        */
 633         u_char          actccbs;        /* Number of allocated CCBs     */
 634         u_char          busyccbs;       /* CCBs busy for this lun       */
 635         u_char          queuedccbs;     /* CCBs queued to the controller*/
 636         u_char          queuedepth;     /* Queue depth for this lun     */
 637         u_char          scdev_depth;    /* SCSI device queue depth      */
 638         u_char          maxnxs;         /* Max possible nexuses         */
 639
 640         /*----------------------------------------------------------------
 641         **      Control of tagged command queuing.
 642         **      Tags allocation is performed using a circular buffer.
 643         **      This avoids using a loop for tag allocation.
 644         **----------------------------------------------------------------
 645         */
 646         u_char          ia_tag;         /* Allocation index             */
 647         u_char          if_tag;         /* Freeing index                */
 648         u_char cb_tags[MAX_TAGS];       /* Circular tags buffer */
 649         u_char          usetags;        /* Command queuing is active    */
 650         u_char          maxtags;        /* Max nr of tags asked by user */
 651         u_char          numtags;        /* Current number of tags       */
 652         u_char          inq_byte7;      /* Store unit CmdQ capabitility */
 653
 654         /*----------------------------------------------------------------
 655         **      QUEUE FULL control and ORDERED tag control.
 656         **----------------------------------------------------------------
 657         */
 658         /*----------------------------------------------------------------
 659         **      QUEUE FULL and ORDERED tag control.
 660         **----------------------------------------------------------------
 661         */
 662         u16             num_good;       /* Nr of GOOD since QUEUE FULL  */
 663         tagmap_t        tags_umap;      /* Used tags bitmap             */
 664         tagmap_t        tags_smap;      /* Tags in use at 'tag_stime'   */
 665         u_long          tags_stime;     /* Last time we set smap=umap   */
 666         struct ccb *    held_ccb;       /* CCB held for QUEUE FULL      */
 667 };
 668
 669 /*========================================================================
 670 **
 671 **      Declaration of structs:     the launch script.
 672 **
 673 **========================================================================
 674 **
 675 **      It is part of the CCB and is called by the scripts processor to
 676 **      start or restart the data structure (nexus).
 677 **      This 6 DWORDs mini script makes use of prefetching.
 678 **
 679 **------------------------------------------------------------------------
 680 */
 681 struct launch {
 682         /*----------------------------------------------------------------
 683         **      SCR_COPY(4),    @(p_phys), @(dsa register)
 684         **      SCR_JUMP,       @(scheduler_point)
 685         **----------------------------------------------------------------
 686         */
 687         ncrcmd          setup_dsa[3];   /* Copy 'phys' address to dsa   */
 688         struct link     schedule;       /* Jump to scheduler point      */
 689         ncrcmd          p_phys;         /* 'phys' header bus address    */
 690 };
 691
 692 /*========================================================================
 693 **
 694 **      Declaration of structs:     global HEADER.
 695 **
 696 **========================================================================
 697 **
 698 **      This substructure is copied from the ccb to a global address after
 699 **      selection (or reselection) and copied back before disconnect.
 700 **
 701 **      These fields are accessible to the script processor.
 702 **
 703 **------------------------------------------------------------------------
 704 */
 705
 706 struct head {
 707         /*----------------------------------------------------------------
 708         **      Saved data pointer.
 709         **      Points to the position in the script responsible for the
 710         **      actual transfer transfer of data.
 711         **      It's written after reception of a SAVE_DATA_POINTER message.
 712         **      The goalpointer points after the last transfer command.
 713         **----------------------------------------------------------------
 714         */
 715         u32             savep;
 716         u32             lastp;
 717         u32             goalp;
 718
 719         /*----------------------------------------------------------------
 720         **      Alternate data pointer.
 721         **      They are copied back to savep/lastp/goalp by the SCRIPTS
 722         **      when the direction is unknown and the device claims data out.
 723         **----------------------------------------------------------------
 724         */
 725         u32             wlastp;
 726         u32             wgoalp;
 727
 728         /*----------------------------------------------------------------
 729         **      The virtual address of the ccb containing this header.
 730         **----------------------------------------------------------------
 731         */
 732         struct ccb *    cp;
 733
 734         /*----------------------------------------------------------------
 735         **      Status fields.
 736         **----------------------------------------------------------------
 737         */
 738         u_char          scr_st[4];      /* script status                */
 739         u_char          status[4];      /* host status. must be the     */
 740                                         /*  last DWORD of the header.   */
 741 };
 742
 743 /*
 744 **      The status bytes are used by the host and the script processor.
 745 **
 746 **      The byte corresponding to the host_status must be stored in the
 747 **      last DWORD of the CCB header since it is used for command
 748 **      completion (ncr_wakeup()). Doing so, we are sure that the header
 749 **      has been entirely copied back to the CCB when the host_status is
 750 **      seen complete by the CPU.
 751 **
 752 **      The last four bytes (status[4]) are copied to the scratchb register
 753 **      (declared as scr0..scr3 in ncr_reg.h) just after the select/reselect,
 754 **      and copied back just after disconnecting.
 755 **      Inside the script the XX_REG are used.
 756 **
 757 **      The first four bytes (scr_st[4]) are used inside the script by
 758 **      "COPY" commands.
 759 **      Because source and destination must have the same alignment
 760 **      in a DWORD, the fields HAVE to be at the choosen offsets.
 761 **              xerr_st         0       (0x34)  scratcha
 762 **              sync_st         1       (0x05)  sxfer
 763 **              wide_st         3       (0x03)  scntl3
 764 */
 765
 766 /*
 767 **      Last four bytes (script)
 768 */
 769 #define  QU_REG scr0
 770 #define  HS_REG scr1
 771 #define  HS_PRT nc_scr1
 772 #define  SS_REG scr2
 773 #define  SS_PRT nc_scr2
 774 #define  PS_REG scr3
 775
 776 /*
 777 **      Last four bytes (host)
 778 */
 779 #ifdef SCSI_NCR_BIG_ENDIAN
 780 #define  actualquirks  phys.header.status[3]
 781 #define  host_status   phys.header.status[2]
 782 #define  scsi_status   phys.header.status[1]
 783 #define  parity_status phys.header.status[0]
 784 #else
 785 #define  actualquirks  phys.header.status[0]
 786 #define  host_status   phys.header.status[1]
 787 #define  scsi_status   phys.header.status[2]
 788 #define  parity_status phys.header.status[3]
 789 #endif
 790
 791 /*
 792 **      First four bytes (script)
 793 */
 794 #define  xerr_st       header.scr_st[0]
 795 #define  sync_st       header.scr_st[1]
 796 #define  nego_st       header.scr_st[2]
 797 #define  wide_st       header.scr_st[3]
 798
 799 /*
 800 **      First four bytes (host)
 801 */
 802 #define  xerr_status   phys.xerr_st
 803 #define  nego_status   phys.nego_st
 804
 805 #if 0
 806 #define  sync_status   phys.sync_st
 807 #define  wide_status   phys.wide_st
 808 #endif
 809
 810 /*==========================================================
 811 **
 812 **      Declaration of structs:     Data structure block
 813 **
 814 **==========================================================
 815 **
 816 **      During execution of a ccb by the script processor,
 817 **      the DSA (data structure address) register points
 818 **      to this substructure of the ccb.
 819 **      This substructure contains the header with
 820 **      the script-processor-changable data and
 821 **      data blocks for the indirect move commands.
 822 **
 823 **----------------------------------------------------------
 824 */
 825
 826 struct dsb {
 827
 828         /*
 829         **      Header.
 830         */
 831
 832         struct head     header;
 833
 834         /*
 835         **      Table data for Script
 836         */
 837
 838         struct scr_tblsel  select;
 839         struct scr_tblmove smsg  ;
 840         struct scr_tblmove cmd   ;
 841         struct scr_tblmove sense ;
 842         struct scr_tblmove data[MAX_SCATTER];
 843 };
 844
 845
 846 /*========================================================================
 847 **
 848 **      Declaration of structs:     Command control block.
 849 **
 850 **========================================================================
 851 */
 852 struct ccb {
 853         /*----------------------------------------------------------------
 854         **      This is the data structure which is pointed by the DSA
 855         **      register when it is executed by the script processor.
 856         **      It must be the first entry because it contains the header
 857         **      as first entry that must be cache line aligned.
 858         **----------------------------------------------------------------
 859         */
 860         struct dsb      phys;
 861
 862         /*----------------------------------------------------------------
 863         **      Mini-script used at CCB execution start-up.
 864         **      Load the DSA with the data structure address (phys) and
 865         **      jump to SELECT. Jump to CANCEL if CCB is to be canceled.
 866         **----------------------------------------------------------------
 867         */
 868         struct launch   start;
 869
 870         /*----------------------------------------------------------------
 871         **      Mini-script used at CCB relection to restart the nexus.
 872         **      Load the DSA with the data structure address (phys) and
 873         **      jump to RESEL_DSA. Jump to ABORT if CCB is to be aborted.
 874         **----------------------------------------------------------------
 875         */
 876         struct launch   restart;
 877
 878         /*----------------------------------------------------------------
 879         **      If a data transfer phase is terminated too early
 880         **      (after reception of a message (i.e. DISCONNECT)),
 881         **      we have to prepare a mini script to transfer
 882         **      the rest of the data.
 883         **----------------------------------------------------------------
 884         */
 885         ncrcmd          patch[8];
 886
 887         /*----------------------------------------------------------------
 888         **      The general SCSI driver provides a
 889         **      pointer to a control block.
 890         **----------------------------------------------------------------
 891         */
 892         struct scsi_cmnd        *cmd;           /* SCSI command                 */
 893         u_char          cdb_buf[16];    /* Copy of CDB                  */
 894         u_char          sense_buf[64];
 895         int             data_len;       /* Total data length            */
 896
 897         /*----------------------------------------------------------------
 898         **      Message areas.
 899         **      We prepare a message to be sent after selection.
 900         **      We may use a second one if the command is rescheduled
 901         **      due to GETCC or QFULL.
 902         **      Contents are IDENTIFY and SIMPLE_TAG.
 903         **      While negotiating sync or wide transfer,
 904         **      a SDTR or WDTR message is appended.
 905         **----------------------------------------------------------------
 906         */
 907         u_char          scsi_smsg [8];
 908         u_char          scsi_smsg2[8];
 909
 910         /*----------------------------------------------------------------
 911         **      Other fields.
 912         **----------------------------------------------------------------
 913         */
 914         u_long          p_ccb;          /* BUS address of this CCB      */
 915         u_char          sensecmd[6];    /* Sense command                */
 916         u_char          tag;            /* Tag for this transfer        */
 917                                         /*  255 means no tag            */
 918         u_char          target;
 919         u_char          lun;
 920         u_char          queued;
 921         u_char          auto_sense;
 922         struct ccb *    link_ccb;       /* Host adapter CCB chain       */
 923         XPT_QUEHEAD     link_ccbq;      /* Link to unit CCB queue       */
 924         u32             startp;         /* Initial data pointer         */
 925         u_long          magic;          /* Free / busy  CCB flag        */
 926 };
 927
 928 #define CCB_PHYS(cp,lbl)        (cp->p_ccb + offsetof(struct ccb, lbl))
 929
 930
 931 /*========================================================================
 932 **
 933 **      Declaration of structs:     NCR device descriptor
 934 **
 935 **========================================================================
 936 */
 937 struct ncb {
 938         /*----------------------------------------------------------------
 939         **      The global header.
 940         **      It is accessible to both the host and the script processor.
 941         **      Must be cache line size aligned (32 for x86) in order to
 942         **      allow cache line bursting when it is copied to/from CCB.
 943         **----------------------------------------------------------------
 944         */
 945         struct head     header;
 946
 947         /*----------------------------------------------------------------
 948         **      CCBs management queues.
 949         **----------------------------------------------------------------
 950         */
 951         struct scsi_cmnd        *waiting_list;  /* Commands waiting for a CCB   */
 952                                         /*  when lcb is not allocated.  */
 953         struct scsi_cmnd        *done_list;     /* Commands waiting for done()  */
 954                                         /* callback to be invoked.      */
 955         spinlock_t      smp_lock;       /* Lock for SMP threading       */
 956
 957         /*----------------------------------------------------------------
 958         **      Chip and controller indentification.
 959         **----------------------------------------------------------------
 960         */
 961         int             unit;           /* Unit number                  */
 962         char            inst_name[16];  /* ncb instance name            */
 963
 964         /*----------------------------------------------------------------
 965         **      Initial value of some IO register bits.
 966         **      These values are assumed to have been set by BIOS, and may
 967         **      be used for probing adapter implementation differences.
 968         **----------------------------------------------------------------
 969         */
 970         u_char  sv_scntl0, sv_scntl3, sv_dmode, sv_dcntl, sv_ctest0, sv_ctest3,
 971                 sv_ctest4, sv_ctest5, sv_gpcntl, sv_stest2, sv_stest4;
 972
 973         /*----------------------------------------------------------------
 974         **      Actual initial value of IO register bits used by the
 975         **      driver. They are loaded at initialisation according to
 976         **      features that are to be enabled.
 977         **----------------------------------------------------------------
 978         */
 979         u_char  rv_scntl0, rv_scntl3, rv_dmode, rv_dcntl, rv_ctest0, rv_ctest3,
 980                 rv_ctest4, rv_ctest5, rv_stest2;
 981
 982         /*----------------------------------------------------------------
 983         **      Targets management.
 984         **      During reselection the ncr jumps to jump_tcb.
 985         **      The SFBR register is loaded with the encoded target id.
 986         **      For i = 0 to 3
 987         **              SCR_JUMP ^ IFTRUE(MASK(i, 3)), @(next tcb mod. i)
 988         **
 989         **      Recent chips will prefetch the 4 JUMPS using only 1 burst.
 990         **      It is kind of hashcoding.
 991         **----------------------------------------------------------------
 992         */
 993         struct link     jump_tcb[4];    /* JUMPs for reselection        */
 994         struct tcb  target[MAX_TARGET]; /* Target data                  */
 995
 996         /*----------------------------------------------------------------
 997         **      Virtual and physical bus addresses of the chip.
 998         **----------------------------------------------------------------
 999         */
1000         vm_offset_t     vaddr;          /* Virtual and bus address of   */
1001         vm_offset_t     paddr;          /*  chip's IO registers.        */
1002         vm_offset_t     paddr2;         /* On-chip RAM bus address.     */
1003         volatile                        /* Pointer to volatile for      */
1004         struct ncr_reg  *reg;           /*  memory mapped IO.           */
1005
1006         /*----------------------------------------------------------------
1007         **      SCRIPTS virtual and physical bus addresses.
1008         **      'script'  is loaded in the on-chip RAM if present.
1009         **      'scripth' stays in main memory.
1010         **----------------------------------------------------------------
1011         */
1012         struct script   *script0;       /* Copies of script and scripth */
1013         struct scripth  *scripth0;      /*  relocated for this ncb.     */
1014         struct scripth  *scripth;       /* Actual scripth virt. address */
1015         u_long          p_script;       /* Actual script and scripth    */
1016         u_long          p_scripth;      /*  bus addresses.              */
1017
1018         /*----------------------------------------------------------------
1019         **      General controller parameters and configuration.
1020         **----------------------------------------------------------------
1021         */
1022         struct device   *dev;
1023         u_char          revision_id;    /* PCI device revision id       */
1024         u32             irq;            /* IRQ level                    */
1025         u32             features;       /* Chip features map            */
1026         u_char          myaddr;         /* SCSI id of the adapter       */
1027         u_char          maxburst;       /* log base 2 of dwords burst   */
1028         u_char          maxwide;        /* Maximum transfer width       */
1029         u_char          minsync;        /* Minimum sync period factor   */
1030         u_char          maxsync;        /* Maximum sync period factor   */
1031         u_char          maxoffs;        /* Max scsi offset              */
1032         u_char          multiplier;     /* Clock multiplier (1,2,4)     */
1033         u_char          clock_divn;     /* Number of clock divisors     */
1034         u_long          clock_khz;      /* SCSI clock frequency in KHz  */
1035
1036         /*----------------------------------------------------------------
1037         **      Start queue management.
1038         **      It is filled up by the host processor and accessed by the
1039         **      SCRIPTS processor in order to start SCSI commands.
1040         **----------------------------------------------------------------
1041         */
1042         u16             squeueput;      /* Next free slot of the queue  */
1043         u16             actccbs;        /* Number of allocated CCBs     */
1044         u16             queuedccbs;     /* Number of CCBs in start queue*/
1045         u16             queuedepth;     /* Start queue depth            */
1046
1047         /*----------------------------------------------------------------
1048         **      Timeout handler.
1049         **----------------------------------------------------------------
1050         */
1051         struct timer_list timer;        /* Timer handler link header    */
1052         u_long          lasttime;
1053         u_long          settle_time;    /* Resetting the SCSI BUS       */
1054
1055         /*----------------------------------------------------------------
1056         **      Debugging and profiling.
1057         **----------------------------------------------------------------
1058         */
1059         struct ncr_reg  regdump;        /* Register dump                */
1060         u_long          regtime;        /* Time it has been done        */
1061
1062         /*----------------------------------------------------------------
1063         **      Miscellaneous buffers accessed by the scripts-processor.
1064         **      They shall be DWORD aligned, because they may be read or
1065         **      written with a SCR_COPY script command.
1066         **----------------------------------------------------------------
1067         */
1068         u_char          msgout[8];      /* Buffer for MESSAGE OUT       */
1069         u_char          msgin [8];      /* Buffer for MESSAGE IN        */
1070         u32             lastmsg;        /* Last SCSI message sent       */
1071         u_char          scratch;        /* Scratch for SCSI receive     */
1072
1073         /*----------------------------------------------------------------
1074         **      Miscellaneous configuration and status parameters.
1075         **----------------------------------------------------------------
1076         */
1077         u_char          disc;           /* Diconnection allowed         */
1078         u_char          scsi_mode;      /* Current SCSI BUS mode        */
1079         u_char          order;          /* Tag order to use             */
1080         u_char          verbose;        /* Verbosity for this controller*/
1081         int             ncr_cache;      /* Used for cache test at init. */
1082         u_long          p_ncb;          /* BUS address of this NCB      */
1083
1084         /*----------------------------------------------------------------
1085         **      Command completion handling.
1086         **----------------------------------------------------------------
1087         */
1088 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
1089         struct ccb      *(ccb_done[MAX_DONE]);
1090         int             ccb_done_ic;
1091 #endif
1092         /*----------------------------------------------------------------
1093         **      Fields that should be removed or changed.
1094         **----------------------------------------------------------------
1095         */
1096         struct ccb      *ccb;           /* Global CCB                   */
1097         struct usrcmd   user;           /* Command from user            */
1098         volatile u_char release_stage;  /* Synchronisation stage on release  */
1099
1100 #ifdef SCSI_NCR_INTEGRITY_CHECKING
1101         /*----------------------------------------------------------------
1102         **      Fields that are used for integrity check
1103         **----------------------------------------------------------------
1104         */
1105         unsigned char check_integrity; /* Enable midlayer integ.check on
1106                                         * bus scan. */
1107         unsigned char check_integ_par;  /* Set if par or Init. Det. error
1108                                          * used only during integ check */
1109 #endif
1110 };
1111
1112 #define NCB_SCRIPT_PHYS(np,lbl)  (np->p_script  + offsetof (struct script, lbl))
1113 #define NCB_SCRIPTH_PHYS(np,lbl) (np->p_scripth + offsetof (struct scripth,lbl))
1114
1115 /*==========================================================
1116 **
1117 **
1118 **      Script for NCR-Processor.
1119 **
1120 **      Use ncr_script_fill() to create the variable parts.
1121 **      Use ncr_script_copy_and_bind() to make a copy and
1122 **      bind to physical addresses.
1123 **
1124 **
1125 **==========================================================
1126 **
1127 **      We have to know the offsets of all labels before
1128 **      we reach them (for forward jumps).
1129 **      Therefore we declare a struct here.
1130 **      If you make changes inside the script,
1131 **      DONT FORGET TO CHANGE THE LENGTHS HERE!
1132 **
1133 **----------------------------------------------------------
1134 */
1135
1136 /*
1137 **      For HP Zalon/53c720 systems, the Zalon interface
1138 **      between CPU and 53c720 does prefetches, which causes
1139 **      problems with self modifying scripts.  The problem
1140 **      is overcome by calling a dummy subroutine after each
1141 **      modification, to force a refetch of the script on
1142 **      return from the subroutine.
1143 */
1144
1145 #ifdef CONFIG_NCR53C8XX_PREFETCH
1146 #define PREFETCH_FLUSH_CNT      2
1147 #define PREFETCH_FLUSH          SCR_CALL, PADDRH (wait_dma),
1148 #else
1149 #define PREFETCH_FLUSH_CNT      0
1150 #define PREFETCH_FLUSH
1151 #endif
1152
1153 /*
1154 **      Script fragments which are loaded into the on-chip RAM
1155 **      of 825A, 875 and 895 chips.
1156 */
1157 struct script {
1158         ncrcmd  start           [  5];
1159         ncrcmd  startpos        [  1];
1160         ncrcmd  select          [  6];
1161         ncrcmd  select2         [  9 + PREFETCH_FLUSH_CNT];
1162         ncrcmd  loadpos         [  4];
1163         ncrcmd  send_ident      [  9];
1164         ncrcmd  prepare         [  6];
1165         ncrcmd  prepare2        [  7];
1166         ncrcmd  command         [  6];
1167         ncrcmd  dispatch        [ 32];
1168         ncrcmd  clrack          [  4];
1169         ncrcmd  no_data         [ 17];
1170         ncrcmd  status          [  8];
1171         ncrcmd  msg_in          [  2];
1172         ncrcmd  msg_in2         [ 16];
1173         ncrcmd  msg_bad         [  4];
1174         ncrcmd  setmsg          [  7];
1175         ncrcmd  cleanup         [  6];
1176         ncrcmd  complete        [  9];
1177         ncrcmd  cleanup_ok      [  8 + PREFETCH_FLUSH_CNT];
1178         ncrcmd  cleanup0        [  1];
1179 #ifndef SCSI_NCR_CCB_DONE_SUPPORT
1180         ncrcmd  signal          [ 12];
1181 #else
1182         ncrcmd  signal          [  9];
1183         ncrcmd  done_pos        [  1];
1184         ncrcmd  done_plug       [  2];
1185         ncrcmd  done_end        [  7];
1186 #endif
1187         ncrcmd  save_dp         [  7];
1188         ncrcmd  restore_dp      [  5];
1189         ncrcmd  disconnect      [ 17];
1190         ncrcmd  msg_out         [  9];
1191         ncrcmd  msg_out_done    [  7];
1192         ncrcmd  idle            [  2];
1193         ncrcmd  reselect        [  8];
1194         ncrcmd  reselected      [  8];
1195         ncrcmd  resel_dsa       [  6 + PREFETCH_FLUSH_CNT];
1196         ncrcmd  loadpos1        [  4];
1197         ncrcmd  resel_lun       [  6];
1198         ncrcmd  resel_tag       [  6];
1199         ncrcmd  jump_to_nexus   [  4 + PREFETCH_FLUSH_CNT];
1200         ncrcmd  nexus_indirect  [  4];
1201         ncrcmd  resel_notag     [  4];
1202         ncrcmd  data_in         [MAX_SCATTERL * 4];
1203         ncrcmd  data_in2        [  4];
1204         ncrcmd  data_out        [MAX_SCATTERL * 4];
1205         ncrcmd  data_out2       [  4];
1206 };
1207
1208 /*
1209 **      Script fragments which stay in main memory for all chips.
1210 */
1211 struct scripth {
1212         ncrcmd  tryloop         [MAX_START*2];
1213         ncrcmd  tryloop2        [  2];
1214 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
1215         ncrcmd  done_queue      [MAX_DONE*5];
1216         ncrcmd  done_queue2     [  2];
1217 #endif
1218         ncrcmd  select_no_atn   [  8];
1219         ncrcmd  cancel          [  4];
1220         ncrcmd  skip            [  9 + PREFETCH_FLUSH_CNT];
1221         ncrcmd  skip2           [ 19];
1222         ncrcmd  par_err_data_in [  6];
1223         ncrcmd  par_err_other   [  4];
1224         ncrcmd  msg_reject      [  8];
1225         ncrcmd  msg_ign_residue [ 24];
1226         ncrcmd  msg_extended    [ 10];
1227         ncrcmd  msg_ext_2       [ 10];
1228         ncrcmd  msg_wdtr        [ 14];
1229         ncrcmd  send_wdtr       [  7];
1230         ncrcmd  msg_ext_3       [ 10];
1231         ncrcmd  msg_sdtr        [ 14];
1232         ncrcmd  send_sdtr       [  7];
1233         ncrcmd  nego_bad_phase  [  4];
1234         ncrcmd  msg_out_abort   [ 10];
1235         ncrcmd  hdata_in        [MAX_SCATTERH * 4];
1236         ncrcmd  hdata_in2       [  2];
1237         ncrcmd  hdata_out       [MAX_SCATTERH * 4];
1238         ncrcmd  hdata_out2      [  2];
1239         ncrcmd  reset           [  4];
1240         ncrcmd  aborttag        [  4];
1241         ncrcmd  abort           [  2];
1242         ncrcmd  abort_resel     [ 20];
1243         ncrcmd  resend_ident    [  4];
1244         ncrcmd  clratn_go_on    [  3];
1245         ncrcmd  nxtdsp_go_on    [  1];
1246         ncrcmd  sdata_in        [  8];
1247         ncrcmd  data_io         [ 18];
1248         ncrcmd  bad_identify    [ 12];
1249         ncrcmd  bad_i_t_l       [  4];
1250         ncrcmd  bad_i_t_l_q     [  4];
1251         ncrcmd  bad_target      [  8];
1252         ncrcmd  bad_status      [  8];
1253         ncrcmd  start_ram       [  4 + PREFETCH_FLUSH_CNT];
1254         ncrcmd  start_ram0      [  4];
1255         ncrcmd  sto_restart     [  5];
1256         ncrcmd  wait_dma        [  2];
1257         ncrcmd  snooptest       [  9];
1258         ncrcmd  snoopend        [  2];
1259 };
1260
1261 /*==========================================================
1262 **
1263 **
1264 **      Function headers.
1265 **
1266 **
1267 **==========================================================
1268 */
1269
1270 static  void    ncr_alloc_ccb   (struct ncb *np, u_char tn, u_char ln);
1271 static  void    ncr_complete    (struct ncb *np, struct ccb *cp);
1272 static  void    ncr_exception   (struct ncb *np);
1273 static  void    ncr_free_ccb    (struct ncb *np, struct ccb *cp);
1274 static  void    ncr_init_ccb    (struct ncb *np, struct ccb *cp);
1275 static  void    ncr_init_tcb    (struct ncb *np, u_char tn);
1276 static  struct lcb *    ncr_alloc_lcb   (struct ncb *np, u_char tn, u_char ln);
1277 static  struct lcb *    ncr_setup_lcb   (struct ncb *np, u_char tn, u_char ln,
1278                                  u_char *inq_data);
1279 static  void    ncr_getclock    (struct ncb *np, int mult);
1280 static  void    ncr_selectclock (struct ncb *np, u_char scntl3);
1281 static  struct ccb *ncr_get_ccb (struct ncb *np, u_char tn, u_char ln);
1282 static  void    ncr_chip_reset  (struct ncb *np, int delay);
1283 static  void    ncr_init        (struct ncb *np, int reset, char * msg, u_long code);
1284 static  int     ncr_int_sbmc    (struct ncb *np);
1285 static  int     ncr_int_par     (struct ncb *np);
1286 static  void    ncr_int_ma      (struct ncb *np);
1287 static  void    ncr_int_sir     (struct ncb *np);
1288 static  void    ncr_int_sto     (struct ncb *np);
1289 static  u_long  ncr_lookup      (char* id);
1290 static  void    ncr_negotiate   (struct ncb* np, struct tcb* tp);
1291 static  int     ncr_prepare_nego(struct ncb *np, struct ccb *cp, u_char *msgptr);
1292 #ifdef SCSI_NCR_INTEGRITY_CHECKING
1293 static  int     ncr_ic_nego(struct ncb *np, struct ccb *cp, struct scsi_cmnd *cmd, u_char *msgptr);
1294 #endif
1295
1296 static  void    ncr_script_copy_and_bind
1297                                 (struct ncb *np, ncrcmd *src, ncrcmd *dst, int len);
1298 static  void    ncr_script_fill (struct script * scr, struct scripth * scripth);
1299 static  int     ncr_scatter     (struct ncb *np, struct ccb *cp, struct scsi_cmnd *cmd);
1300 static  void    ncr_getsync     (struct ncb *np, u_char sfac, u_char *fakp, u_char *scntl3p);
1301 static  void    ncr_setsync     (struct ncb *np, struct ccb *cp, u_char scntl3, u_char sxfer);
1302 static  void    ncr_setup_tags  (struct ncb *np, u_char tn, u_char ln);
1303 static  void    ncr_setwide     (struct ncb *np, struct ccb *cp, u_char wide, u_char ack);
1304 static  int     ncr_show_msg    (u_char * msg);
1305 static  void    ncr_print_msg   (struct ccb *cp, char *label, u_char *msg);
1306 static  int     ncr_snooptest   (struct ncb *np);
1307 static  void    ncr_timeout     (struct ncb *np);
1308 static  void    ncr_wakeup      (struct ncb *np, u_long code);
1309 static  void    ncr_wakeup_done (struct ncb *np);
1310 static  void    ncr_start_next_ccb (struct ncb *np, struct lcb * lp, int maxn);
1311 static  void    ncr_put_start_queue(struct ncb *np, struct ccb *cp);
1312
1313 static void insert_into_waiting_list(struct ncb *np, struct scsi_cmnd *cmd);
1314 static struct scsi_cmnd *retrieve_from_waiting_list(int to_remove, struct ncb *np, struct scsi_cmnd *cmd);
1315 static void process_waiting_list(struct ncb *np, int sts);
1316
1317 #define remove_from_waiting_list(np, cmd) \
1318                 retrieve_from_waiting_list(1, (np), (cmd))
1319 #define requeue_waiting_list(np) process_waiting_list((np), DID_OK)
1320 #define reset_waiting_list(np) process_waiting_list((np), DID_RESET)
1321
1322 static inline char *ncr_name (struct ncb *np)
1323 {
1324         return np->inst_name;
1325 }
1326
1327
1328 /*==========================================================
1329 **
1330 **
1331 **      Scripts for NCR-Processor.
1332 **
1333 **      Use ncr_script_bind for binding to physical addresses.
1334 **
1335 **
1336 **==========================================================
1337 **
1338 **      NADDR generates a reference to a field of the controller data.
1339 **      PADDR generates a reference to another part of the script.
1340 **      RADDR generates a reference to a script processor register.
1341 **      FADDR generates a reference to a script processor register
1342 **              with offset.
1343 **
1344 **----------------------------------------------------------
1345 */
1346
1347 #define RELOC_SOFTC     0x40000000
1348 #define RELOC_LABEL     0x50000000
1349 #define RELOC_REGISTER  0x60000000
1350 #if 0
1351 #define RELOC_KVAR      0x70000000
1352 #endif
1353 #define RELOC_LABELH    0x80000000
1354 #define RELOC_MASK      0xf0000000
1355
1356 #define NADDR(label)    (RELOC_SOFTC | offsetof(struct ncb, label))
1357 #define PADDR(label)    (RELOC_LABEL | offsetof(struct script, label))
1358 #define PADDRH(label)   (RELOC_LABELH | offsetof(struct scripth, label))
1359 #define RADDR(label)    (RELOC_REGISTER | REG(label))
1360 #define FADDR(label,ofs)(RELOC_REGISTER | ((REG(label))+(ofs)))
1361 #if 0
1362 #define KVAR(which)     (RELOC_KVAR | (which))
1363 #endif
1364
1365 #if 0
1366 #define SCRIPT_KVAR_JIFFIES     (0)
1367 #define SCRIPT_KVAR_FIRST               SCRIPT_KVAR_JIFFIES
1368 #define SCRIPT_KVAR_LAST                SCRIPT_KVAR_JIFFIES
1369 /*
1370  * Kernel variables referenced in the scripts.
1371  * THESE MUST ALL BE ALIGNED TO A 4-BYTE BOUNDARY.
1372  */
1373 static void *script_kvars[] __initdata =
1374         { (void *)&jiffies };
1375 #endif
1376
1377 static  struct script script0 __initdata = {
1378 /*--------------------------< START >-----------------------*/ {
1379         /*
1380         **      This NOP will be patched with LED ON
1381         **      SCR_REG_REG (gpreg, SCR_AND, 0xfe)
1382         */
1383         SCR_NO_OP,
1384                 0,
1385         /*
1386         **      Clear SIGP.
1387         */
1388         SCR_FROM_REG (ctest2),
1389                 0,
1390         /*
1391         **      Then jump to a certain point in tryloop.
1392         **      Due to the lack of indirect addressing the code
1393         **      is self modifying here.
1394         */
1395         SCR_JUMP,
1396 }/*-------------------------< STARTPOS >--------------------*/,{
1397                 PADDRH(tryloop),
1398
1399 }/*-------------------------< SELECT >----------------------*/,{
1400         /*
1401         **      DSA     contains the address of a scheduled
1402         **              data structure.
1403         **
1404         **      SCRATCHA contains the address of the script,
1405         **              which starts the next entry.
1406         **
1407         **      Set Initiator mode.
1408         **
1409         **      (Target mode is left as an exercise for the reader)
1410         */
1411
1412         SCR_CLR (SCR_TRG),
1413                 0,
1414         SCR_LOAD_REG (HS_REG, HS_SELECTING),
1415                 0,
1416
1417         /*
1418         **      And try to select this target.
1419         */
1420         SCR_SEL_TBL_ATN ^ offsetof (struct dsb, select),
1421                 PADDR (reselect),
1422
1423 }/*-------------------------< SELECT2 >----------------------*/,{
1424         /*
1425         **      Now there are 4 possibilities:
1426         **
1427         **      (1) The ncr loses arbitration.
1428         **      This is ok, because it will try again,
1429         **      when the bus becomes idle.
1430         **      (But beware of the timeout function!)
1431         **
1432         **      (2) The ncr is reselected.
1433         **      Then the script processor takes the jump
1434         **      to the RESELECT label.
1435         **
1436         **      (3) The ncr wins arbitration.
1437         **      Then it will execute SCRIPTS instruction until
1438         **      the next instruction that checks SCSI phase.
1439         **      Then will stop and wait for selection to be
1440         **      complete or selection time-out to occur.
1441         **      As a result the SCRIPTS instructions until
1442         **      LOADPOS + 2 should be executed in parallel with
1443         **      the SCSI core performing selection.
1444         */
1445
1446         /*
1447         **      The M_REJECT problem seems to be due to a selection
1448         **      timing problem.
1449         **      Wait immediately for the selection to complete.
1450         **      (2.5x behaves so)
1451         */
1452         SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_OUT)),
1453                 0,
1454
1455         /*
1456         **      Next time use the next slot.
1457         */
1458         SCR_COPY (4),
1459                 RADDR (temp),
1460                 PADDR (startpos),
1461         /*
1462         **      The ncr doesn't have an indirect load
1463         **      or store command. So we have to
1464         **      copy part of the control block to a
1465         **      fixed place, where we can access it.
1466         **
1467         **      We patch the address part of a
1468         **      COPY command with the DSA-register.
1469         */
1470         SCR_COPY_F (4),
1471                 RADDR (dsa),
1472                 PADDR (loadpos),
1473         /*
1474         **      Flush script prefetch if required
1475         */
1476         PREFETCH_FLUSH
1477         /*
1478         **      then we do the actual copy.
1479         */
1480         SCR_COPY (sizeof (struct head)),
1481         /*
1482         **      continued after the next label ...
1483         */
1484 }/*-------------------------< LOADPOS >---------------------*/,{
1485                 0,
1486                 NADDR (header),
1487         /*
1488         **      Wait for the next phase or the selection
1489         **      to complete or time-out.
1490         */
1491         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
1492                 PADDR (prepare),
1493
1494 }/*-------------------------< SEND_IDENT >----------------------*/,{
1495         /*
1496         **      Selection complete.
1497         **      Send the IDENTIFY and SIMPLE_TAG messages
1498         **      (and the M_X_SYNC_REQ message)
1499         */
1500         SCR_MOVE_TBL ^ SCR_MSG_OUT,
1501                 offsetof (struct dsb, smsg),
1502         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)),
1503                 PADDRH (resend_ident),
1504         SCR_LOAD_REG (scratcha, 0x80),
1505                 0,
1506         SCR_COPY (1),
1507                 RADDR (scratcha),
1508                 NADDR (lastmsg),
1509 }/*-------------------------< PREPARE >----------------------*/,{
1510         /*
1511         **      load the savep (saved pointer) into
1512         **      the TEMP register (actual pointer)
1513         */
1514         SCR_COPY (4),
1515                 NADDR (header.savep),
1516                 RADDR (temp),
1517         /*
1518         **      Initialize the status registers
1519         */
1520         SCR_COPY (4),
1521                 NADDR (header.status),
1522                 RADDR (scr0),
1523 }/*-------------------------< PREPARE2 >---------------------*/,{
1524         /*
1525         **      Initialize the msgout buffer with a NOOP message.
1526         */
1527         SCR_LOAD_REG (scratcha, M_NOOP),
1528                 0,
1529         SCR_COPY (1),
1530                 RADDR (scratcha),
1531                 NADDR (msgout),
1532 #if 0
1533         SCR_COPY (1),
1534                 RADDR (scratcha),
1535                 NADDR (msgin),
1536 #endif
1537         /*
1538         **      Anticipate the COMMAND phase.
1539         **      This is the normal case for initial selection.
1540         */
1541         SCR_JUMP ^ IFFALSE (WHEN (SCR_COMMAND)),
1542                 PADDR (dispatch),
1543
1544 }/*-------------------------< COMMAND >--------------------*/,{
1545         /*
1546         **      ... and send the command
1547         */
1548         SCR_MOVE_TBL ^ SCR_COMMAND,
1549                 offsetof (struct dsb, cmd),
1550         /*
1551         **      If status is still HS_NEGOTIATE, negotiation failed.
1552         **      We check this here, since we want to do that
1553         **      only once.
1554         */
1555         SCR_FROM_REG (HS_REG),
1556                 0,
1557         SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
1558                 SIR_NEGO_FAILED,
1559
1560 }/*-----------------------< DISPATCH >----------------------*/,{
1561         /*
1562         **      MSG_IN is the only phase that shall be
1563         **      entered at least once for each (re)selection.
1564         **      So we test it first.
1565         */
1566         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_IN)),
1567                 PADDR (msg_in),
1568
1569         SCR_RETURN ^ IFTRUE (IF (SCR_DATA_OUT)),
1570                 0,
1571         /*
1572         **      DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 4.
1573         **      Possible data corruption during Memory Write and Invalidate.
1574         **      This work-around resets the addressing logic prior to the
1575         **      start of the first MOVE of a DATA IN phase.
1576         **      (See Documentation/scsi/ncr53c8xx.txt for more information)
1577         */
1578         SCR_JUMPR ^ IFFALSE (IF (SCR_DATA_IN)),
1579                 20,
1580         SCR_COPY (4),
1581                 RADDR (scratcha),
1582                 RADDR (scratcha),
1583         SCR_RETURN,
1584                 0,
1585         SCR_JUMP ^ IFTRUE (IF (SCR_STATUS)),
1586                 PADDR (status),
1587         SCR_JUMP ^ IFTRUE (IF (SCR_COMMAND)),
1588                 PADDR (command),
1589         SCR_JUMP ^ IFTRUE (IF (SCR_MSG_OUT)),
1590                 PADDR (msg_out),
1591         /*
1592         **      Discard one illegal phase byte, if required.
1593         */
1594         SCR_LOAD_REG (scratcha, XE_BAD_PHASE),
1595                 0,
1596         SCR_COPY (1),
1597                 RADDR (scratcha),
1598                 NADDR (xerr_st),
1599         SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_OUT)),
1600                 8,
1601         SCR_MOVE_ABS (1) ^ SCR_ILG_OUT,
1602                 NADDR (scratch),
1603         SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_IN)),
1604                 8,
1605         SCR_MOVE_ABS (1) ^ SCR_ILG_IN,
1606                 NADDR (scratch),
1607         SCR_JUMP,
1608                 PADDR (dispatch),
1609
1610 }/*-------------------------< CLRACK >----------------------*/,{
1611         /*
1612         **      Terminate possible pending message phase.
1613         */
1614         SCR_CLR (SCR_ACK),
1615                 0,
1616         SCR_JUMP,
1617                 PADDR (dispatch),
1618
1619 }/*-------------------------< NO_DATA >--------------------*/,{
1620         /*
1621         **      The target wants to tranfer too much data
1622         **      or in the wrong direction.
1623         **      Remember that in extended error.
1624         */
1625         SCR_LOAD_REG (scratcha, XE_EXTRA_DATA),
1626                 0,
1627         SCR_COPY (1),
1628                 RADDR (scratcha),
1629                 NADDR (xerr_st),
1630         /*
1631         **      Discard one data byte, if required.
1632         */
1633         SCR_JUMPR ^ IFFALSE (WHEN (SCR_DATA_OUT)),
1634                 8,
1635         SCR_MOVE_ABS (1) ^ SCR_DATA_OUT,
1636                 NADDR (scratch),
1637         SCR_JUMPR ^ IFFALSE (IF (SCR_DATA_IN)),
1638                 8,
1639         SCR_MOVE_ABS (1) ^ SCR_DATA_IN,
1640                 NADDR (scratch),
1641         /*
1642         **      .. and repeat as required.
1643         */
1644         SCR_CALL,
1645                 PADDR (dispatch),
1646         SCR_JUMP,
1647                 PADDR (no_data),
1648
1649 }/*-------------------------< STATUS >--------------------*/,{
1650         /*
1651         **      get the status
1652         */
1653         SCR_MOVE_ABS (1) ^ SCR_STATUS,
1654                 NADDR (scratch),
1655         /*
1656         **      save status to scsi_status.
1657         **      mark as complete.
1658         */
1659         SCR_TO_REG (SS_REG),
1660                 0,
1661         SCR_LOAD_REG (HS_REG, HS_COMPLETE),
1662                 0,
1663         SCR_JUMP,
1664                 PADDR (dispatch),
1665 }/*-------------------------< MSG_IN >--------------------*/,{
1666         /*
1667         **      Get the first byte of the message
1668         **      and save it to SCRATCHA.
1669         **
1670         **      The script processor doesn't negate the
1671         **      ACK signal after this transfer.
1672         */
1673         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
1674                 NADDR (msgin[0]),
1675 }/*-------------------------< MSG_IN2 >--------------------*/,{
1676         /*
1677         **      Handle this message.
1678         */
1679         SCR_JUMP ^ IFTRUE (DATA (M_COMPLETE)),
1680                 PADDR (complete),
1681         SCR_JUMP ^ IFTRUE (DATA (M_DISCONNECT)),
1682                 PADDR (disconnect),
1683         SCR_JUMP ^ IFTRUE (DATA (M_SAVE_DP)),
1684                 PADDR (save_dp),
1685         SCR_JUMP ^ IFTRUE (DATA (M_RESTORE_DP)),
1686                 PADDR (restore_dp),
1687         SCR_JUMP ^ IFTRUE (DATA (M_EXTENDED)),
1688                 PADDRH (msg_extended),
1689         SCR_JUMP ^ IFTRUE (DATA (M_NOOP)),
1690                 PADDR (clrack),
1691         SCR_JUMP ^ IFTRUE (DATA (M_REJECT)),
1692                 PADDRH (msg_reject),
1693         SCR_JUMP ^ IFTRUE (DATA (M_IGN_RESIDUE)),
1694                 PADDRH (msg_ign_residue),
1695         /*
1696         **      Rest of the messages left as
1697         **      an exercise ...
1698         **
1699         **      Unimplemented messages:
1700         **      fall through to MSG_BAD.
1701         */
1702 }/*-------------------------< MSG_BAD >------------------*/,{
1703         /*
1704         **      unimplemented message - reject it.
1705         */
1706         SCR_INT,
1707                 SIR_REJECT_SENT,
1708         SCR_LOAD_REG (scratcha, M_REJECT),
1709                 0,
1710 }/*-------------------------< SETMSG >----------------------*/,{
1711         SCR_COPY (1),
1712                 RADDR (scratcha),
1713                 NADDR (msgout),
1714         SCR_SET (SCR_ATN),
1715                 0,
1716         SCR_JUMP,
1717                 PADDR (clrack),
1718 }/*-------------------------< CLEANUP >-------------------*/,{
1719         /*
1720         **      dsa:    Pointer to ccb
1721         **            or xxxxxxFF (no ccb)
1722         **
1723         **      HS_REG:   Host-Status (<>0!)
1724         */
1725         SCR_FROM_REG (dsa),
1726                 0,
1727         SCR_JUMP ^ IFTRUE (DATA (0xff)),
1728                 PADDR (start),
1729         /*
1730         **      dsa is valid.
1731         **      complete the cleanup.
1732         */
1733         SCR_JUMP,
1734                 PADDR (cleanup_ok),
1735
1736 }/*-------------------------< COMPLETE >-----------------*/,{
1737         /*
1738         **      Complete message.
1739         **
1740         **      Copy TEMP register to LASTP in header.
1741         */
1742         SCR_COPY (4),
1743                 RADDR (temp),
1744                 NADDR (header.lastp),
1745         /*
1746         **      When we terminate the cycle by clearing ACK,
1747         **      the target may disconnect immediately.
1748         **
1749         **      We don't want to be told of an
1750         **      "unexpected disconnect",
1751         **      so we disable this feature.
1752         */
1753         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
1754                 0,
1755         /*
1756         **      Terminate cycle ...
1757         */
1758         SCR_CLR (SCR_ACK|SCR_ATN),
1759                 0,
1760         /*
1761         **      ... and wait for the disconnect.
1762         */
1763         SCR_WAIT_DISC,
1764                 0,
1765 }/*-------------------------< CLEANUP_OK >----------------*/,{
1766         /*
1767         **      Save host status to header.
1768         */
1769         SCR_COPY (4),
1770                 RADDR (scr0),
1771                 NADDR (header.status),
1772         /*
1773         **      and copy back the header to the ccb.
1774         */
1775         SCR_COPY_F (4),
1776                 RADDR (dsa),
1777                 PADDR (cleanup0),
1778         /*
1779         **      Flush script prefetch if required
1780         */
1781         PREFETCH_FLUSH
1782         SCR_COPY (sizeof (struct head)),
1783                 NADDR (header),
1784 }/*-------------------------< CLEANUP0 >--------------------*/,{
1785                 0,
1786 }/*-------------------------< SIGNAL >----------------------*/,{
1787         /*
1788         **      if job not completed ...
1789         */
1790         SCR_FROM_REG (HS_REG),
1791                 0,
1792         /*
1793         **      ... start the next command.
1794         */
1795         SCR_JUMP ^ IFTRUE (MASK (0, (HS_DONEMASK|HS_SKIPMASK))),
1796                 PADDR(start),
1797         /*
1798         **      If command resulted in not GOOD status,
1799         **      call the C code if needed.
1800         */
1801         SCR_FROM_REG (SS_REG),
1802                 0,
1803         SCR_CALL ^ IFFALSE (DATA (S_GOOD)),
1804                 PADDRH (bad_status),
1805
1806 #ifndef SCSI_NCR_CCB_DONE_SUPPORT
1807
1808         /*
1809         **      ... signal completion to the host
1810         */
1811         SCR_INT,
1812                 SIR_INTFLY,
1813         /*
1814         **      Auf zu neuen Schandtaten!
1815         */
1816         SCR_JUMP,
1817                 PADDR(start),
1818
1819 #else   /* defined SCSI_NCR_CCB_DONE_SUPPORT */
1820
1821         /*
1822         **      ... signal completion to the host
1823         */
1824         SCR_JUMP,
1825 }/*------------------------< DONE_POS >---------------------*/,{
1826                 PADDRH (done_queue),
1827 }/*------------------------< DONE_PLUG >--------------------*/,{
1828         SCR_INT,
1829                 SIR_DONE_OVERFLOW,
1830 }/*------------------------< DONE_END >---------------------*/,{
1831         SCR_INT,
1832                 SIR_INTFLY,
1833         SCR_COPY (4),
1834                 RADDR (temp),
1835                 PADDR (done_pos),
1836         SCR_JUMP,
1837                 PADDR (start),
1838
1839 #endif  /* SCSI_NCR_CCB_DONE_SUPPORT */
1840
1841 }/*-------------------------< SAVE_DP >------------------*/,{
1842         /*
1843         **      SAVE_DP message:
1844         **      Copy TEMP register to SAVEP in header.
1845         */
1846         SCR_COPY (4),
1847                 RADDR (temp),
1848                 NADDR (header.savep),
1849         SCR_CLR (SCR_ACK),
1850                 0,
1851         SCR_JUMP,
1852                 PADDR (dispatch),
1853 }/*-------------------------< RESTORE_DP >---------------*/,{
1854         /*
1855         **      RESTORE_DP message:
1856         **      Copy SAVEP in header to TEMP register.
1857         */
1858         SCR_COPY (4),
1859                 NADDR (header.savep),
1860                 RADDR (temp),
1861         SCR_JUMP,
1862                 PADDR (clrack),
1863
1864 }/*-------------------------< DISCONNECT >---------------*/,{
1865         /*
1866         **      DISCONNECTing  ...
1867         **
1868         **      disable the "unexpected disconnect" feature,
1869         **      and remove the ACK signal.
1870         */
1871         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
1872                 0,
1873         SCR_CLR (SCR_ACK|SCR_ATN),
1874                 0,
1875         /*
1876         **      Wait for the disconnect.
1877         */
1878         SCR_WAIT_DISC,
1879                 0,
1880         /*
1881         **      Status is: DISCONNECTED.
1882         */
1883         SCR_LOAD_REG (HS_REG, HS_DISCONNECT),
1884                 0,
1885         /*
1886         **      If QUIRK_AUTOSAVE is set,
1887         **      do an "save pointer" operation.
1888         */
1889         SCR_FROM_REG (QU_REG),
1890                 0,
1891         SCR_JUMP ^ IFFALSE (MASK (QUIRK_AUTOSAVE, QUIRK_AUTOSAVE)),
1892                 PADDR (cleanup_ok),
1893         /*
1894         **      like SAVE_DP message:
1895         **      Copy TEMP register to SAVEP in header.
1896         */
1897         SCR_COPY (4),
1898                 RADDR (temp),
1899                 NADDR (header.savep),
1900         SCR_JUMP,
1901                 PADDR (cleanup_ok),
1902
1903 }/*-------------------------< MSG_OUT >-------------------*/,{
1904         /*
1905         **      The target requests a message.
1906         */
1907         SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
1908                 NADDR (msgout),
1909         SCR_COPY (1),
1910                 NADDR (msgout),
1911                 NADDR (lastmsg),
1912         /*
1913         **      If it was no ABORT message ...
1914         */
1915         SCR_JUMP ^ IFTRUE (DATA (M_ABORT)),
1916                 PADDRH (msg_out_abort),
1917         /*
1918         **      ... wait for the next phase
1919         **      if it's a message out, send it again, ...
1920         */
1921         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)),
1922                 PADDR (msg_out),
1923 }/*-------------------------< MSG_OUT_DONE >--------------*/,{
1924         /*
1925         **      ... else clear the message ...
1926         */
1927         SCR_LOAD_REG (scratcha, M_NOOP),
1928                 0,
1929         SCR_COPY (4),
1930                 RADDR (scratcha),
1931                 NADDR (msgout),
1932         /*
1933         **      ... and process the next phase
1934         */
1935         SCR_JUMP,
1936                 PADDR (dispatch),
1937 }/*-------------------------< IDLE >------------------------*/,{
1938         /*
1939         **      Nothing to do?
1940         **      Wait for reselect.
1941         **      This NOP will be patched with LED OFF
1942         **      SCR_REG_REG (gpreg, SCR_OR, 0x01)
1943         */
1944         SCR_NO_OP,
1945                 0,
1946 }/*-------------------------< RESELECT >--------------------*/,{
1947         /*
1948         **      make the DSA invalid.
1949         */
1950         SCR_LOAD_REG (dsa, 0xff),
1951                 0,
1952         SCR_CLR (SCR_TRG),
1953                 0,
1954         SCR_LOAD_REG (HS_REG, HS_IN_RESELECT),
1955                 0,
1956         /*
1957         **      Sleep waiting for a reselection.
1958         **      If SIGP is set, special treatment.
1959         **
1960         **      Zu allem bereit ..
1961         */
1962         SCR_WAIT_RESEL,
1963                 PADDR(start),
1964 }/*-------------------------< RESELECTED >------------------*/,{
1965         /*
1966         **      This NOP will be patched with LED ON
1967         **      SCR_REG_REG (gpreg, SCR_AND, 0xfe)
1968         */
1969         SCR_NO_OP,
1970                 0,
1971         /*
1972         **      ... zu nichts zu gebrauchen ?
1973         **
1974         **      load the target id into the SFBR
1975         **      and jump to the control block.
1976         **
1977         **      Look at the declarations of
1978         **      - struct ncb
1979         **      - struct tcb
1980         **      - struct lcb
1981         **      - struct ccb
1982         **      to understand what's going on.
1983         */
1984         SCR_REG_SFBR (ssid, SCR_AND, 0x8F),
1985                 0,
1986         SCR_TO_REG (sdid),
1987                 0,
1988         SCR_JUMP,
1989                 NADDR (jump_tcb),
1990
1991 }/*-------------------------< RESEL_DSA >-------------------*/,{
1992         /*
1993         **      Ack the IDENTIFY or TAG previously received.
1994         */
1995         SCR_CLR (SCR_ACK),
1996                 0,
1997         /*
1998         **      The ncr doesn't have an indirect load
1999         **      or store command. So we have to
2000         **      copy part of the control block to a
2001         **      fixed place, where we can access it.
2002         **
2003         **      We patch the address part of a
2004         **      COPY command with the DSA-register.
2005         */
2006         SCR_COPY_F (4),
2007                 RADDR (dsa),
2008                 PADDR (loadpos1),
2009         /*
2010         **      Flush script prefetch if required
2011         */
2012         PREFETCH_FLUSH
2013         /*
2014         **      then we do the actual copy.
2015         */
2016         SCR_COPY (sizeof (struct head)),
2017         /*
2018         **      continued after the next label ...
2019         */
2020
2021 }/*-------------------------< LOADPOS1 >-------------------*/,{
2022                 0,
2023                 NADDR (header),
2024         /*
2025         **      The DSA contains the data structure address.
2026         */
2027         SCR_JUMP,
2028                 PADDR (prepare),
2029
2030 }/*-------------------------< RESEL_LUN >-------------------*/,{
2031         /*
2032         **      come back to this point
2033         **      to get an IDENTIFY message
2034         **      Wait for a msg_in phase.
2035         */
2036         SCR_INT ^ IFFALSE (WHEN (SCR_MSG_IN)),
2037                 SIR_RESEL_NO_MSG_IN,
2038         /*
2039         **      message phase.
2040         **      Read the data directly from the BUS DATA lines.
2041         **      This helps to support very old SCSI devices that
2042         **      may reselect without sending an IDENTIFY.
2043         */
2044         SCR_FROM_REG (sbdl),
2045                 0,
2046         /*
2047         **      It should be an Identify message.
2048         */
2049         SCR_RETURN,
2050                 0,
2051 }/*-------------------------< RESEL_TAG >-------------------*/,{
2052         /*
2053         **      Read IDENTIFY + SIMPLE + TAG using a single MOVE.
2054         **      Agressive optimization, is'nt it?
2055         **      No need to test the SIMPLE TAG message, since the
2056         **      driver only supports conformant devices for tags. ;-)
2057         */
2058         SCR_MOVE_ABS (3) ^ SCR_MSG_IN,
2059                 NADDR (msgin),
2060         /*
2061         **      Read the TAG from the SIDL.
2062         **      Still an aggressive optimization. ;-)
2063         **      Compute the CCB indirect jump address which
2064         **      is (#TAG*2 & 0xfc) due to tag numbering using
2065         **      1,3,5..MAXTAGS*2+1 actual values.
2066         */
2067         SCR_REG_SFBR (sidl, SCR_SHL, 0),
2068                 0,
2069         SCR_SFBR_REG (temp, SCR_AND, 0xfc),
2070                 0,
2071 }/*-------------------------< JUMP_TO_NEXUS >-------------------*/,{
2072         SCR_COPY_F (4),
2073                 RADDR (temp),
2074                 PADDR (nexus_indirect),
2075         /*
2076         **      Flush script prefetch if required
2077         */
2078         PREFETCH_FLUSH
2079         SCR_COPY (4),
2080 }/*-------------------------< NEXUS_INDIRECT >-------------------*/,{
2081                 0,
2082                 RADDR (temp),
2083         SCR_RETURN,
2084                 0,
2085 }/*-------------------------< RESEL_NOTAG >-------------------*/,{
2086         /*
2087         **      No tag expected.
2088         **      Read an throw away the IDENTIFY.
2089         */
2090         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2091                 NADDR (msgin),
2092         SCR_JUMP,
2093                 PADDR (jump_to_nexus),
2094 }/*-------------------------< DATA_IN >--------------------*/,{
2095 /*
2096 **      Because the size depends on the
2097 **      #define MAX_SCATTERL parameter,
2098 **      it is filled in at runtime.
2099 **
2100 **  ##===========< i=0; i<MAX_SCATTERL >=========
2101 **  ||  SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)),
2102 **  ||          PADDR (dispatch),
2103 **  ||  SCR_MOVE_TBL ^ SCR_DATA_IN,
2104 **  ||          offsetof (struct dsb, data[ i]),
2105 **  ##==========================================
2106 **
2107 **---------------------------------------------------------
2108 */
2109 0
2110 }/*-------------------------< DATA_IN2 >-------------------*/,{
2111         SCR_CALL,
2112                 PADDR (dispatch),
2113         SCR_JUMP,
2114                 PADDR (no_data),
2115 }/*-------------------------< DATA_OUT >--------------------*/,{
2116 /*
2117 **      Because the size depends on the
2118 **      #define MAX_SCATTERL parameter,
2119 **      it is filled in at runtime.
2120 **
2121 **  ##===========< i=0; i<MAX_SCATTERL >=========
2122 **  ||  SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT)),
2123 **  ||          PADDR (dispatch),
2124 **  ||  SCR_MOVE_TBL ^ SCR_DATA_OUT,
2125 **  ||          offsetof (struct dsb, data[ i]),
2126 **  ##==========================================
2127 **
2128 **---------------------------------------------------------
2129 */
2130 0
2131 }/*-------------------------< DATA_OUT2 >-------------------*/,{
2132         SCR_CALL,
2133                 PADDR (dispatch),
2134         SCR_JUMP,
2135                 PADDR (no_data),
2136 }/*--------------------------------------------------------*/
2137 };
2138
2139 static  struct scripth scripth0 __initdata = {
2140 /*-------------------------< TRYLOOP >---------------------*/{
2141 /*
2142 **      Start the next entry.
2143 **      Called addresses point to the launch script in the CCB.
2144 **      They are patched by the main processor.
2145 **
2146 **      Because the size depends on the
2147 **      #define MAX_START parameter, it is filled
2148 **      in at runtime.
2149 **
2150 **-----------------------------------------------------------
2151 **
2152 **  ##===========< I=0; i<MAX_START >===========
2153 **  ||  SCR_CALL,
2154 **  ||          PADDR (idle),
2155 **  ##==========================================
2156 **
2157 **-----------------------------------------------------------
2158 */
2159 0
2160 }/*------------------------< TRYLOOP2 >---------------------*/,{
2161         SCR_JUMP,
2162                 PADDRH(tryloop),
2163
2164 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
2165
2166 }/*------------------------< DONE_QUEUE >-------------------*/,{
2167 /*
2168 **      Copy the CCB address to the next done entry.
2169 **      Because the size depends on the
2170 **      #define MAX_DONE parameter, it is filled
2171 **      in at runtime.
2172 **
2173 **-----------------------------------------------------------
2174 **
2175 **  ##===========< I=0; i<MAX_DONE >===========
2176 **  ||  SCR_COPY (sizeof(struct ccb *),
2177 **  ||          NADDR (header.cp),
2178 **  ||          NADDR (ccb_done[i]),
2179 **  ||  SCR_CALL,
2180 **  ||          PADDR (done_end),
2181 **  ##==========================================
2182 **
2183 **-----------------------------------------------------------
2184 */
2185 0
2186 }/*------------------------< DONE_QUEUE2 >------------------*/,{
2187         SCR_JUMP,
2188                 PADDRH (done_queue),
2189
2190 #endif /* SCSI_NCR_CCB_DONE_SUPPORT */
2191 }/*------------------------< SELECT_NO_ATN >-----------------*/,{
2192         /*
2193         **      Set Initiator mode.
2194         **      And try to select this target without ATN.
2195         */
2196
2197         SCR_CLR (SCR_TRG),
2198                 0,
2199         SCR_LOAD_REG (HS_REG, HS_SELECTING),
2200                 0,
2201         SCR_SEL_TBL ^ offsetof (struct dsb, select),
2202                 PADDR (reselect),
2203         SCR_JUMP,
2204                 PADDR (select2),
2205
2206 }/*-------------------------< CANCEL >------------------------*/,{
2207
2208         SCR_LOAD_REG (scratcha, HS_ABORTED),
2209                 0,
2210         SCR_JUMPR,
2211                 8,
2212 }/*-------------------------< SKIP >------------------------*/,{
2213         SCR_LOAD_REG (scratcha, 0),
2214                 0,
2215         /*
2216         **      This entry has been canceled.
2217         **      Next time use the next slot.
2218         */
2219         SCR_COPY (4),
2220                 RADDR (temp),
2221                 PADDR (startpos),
2222         /*
2223         **      The ncr doesn't have an indirect load
2224         **      or store command. So we have to
2225         **      copy part of the control block to a
2226         **      fixed place, where we can access it.
2227         **
2228         **      We patch the address part of a
2229         **      COPY command with the DSA-register.
2230         */
2231         SCR_COPY_F (4),
2232                 RADDR (dsa),
2233                 PADDRH (skip2),
2234         /*
2235         **      Flush script prefetch if required
2236         */
2237         PREFETCH_FLUSH
2238         /*
2239         **      then we do the actual copy.
2240         */
2241         SCR_COPY (sizeof (struct head)),
2242         /*
2243         **      continued after the next label ...
2244         */
2245 }/*-------------------------< SKIP2 >---------------------*/,{
2246                 0,
2247                 NADDR (header),
2248         /*
2249         **      Initialize the status registers
2250         */
2251         SCR_COPY (4),
2252                 NADDR (header.status),
2253                 RADDR (scr0),
2254         /*
2255         **      Force host status.
2256         */
2257         SCR_FROM_REG (scratcha),
2258                 0,
2259         SCR_JUMPR ^ IFFALSE (MASK (0, HS_DONEMASK)),
2260                 16,
2261         SCR_REG_REG (HS_REG, SCR_OR, HS_SKIPMASK),
2262                 0,
2263         SCR_JUMPR,
2264                 8,
2265         SCR_TO_REG (HS_REG),
2266                 0,
2267         SCR_LOAD_REG (SS_REG, S_GOOD),
2268                 0,
2269         SCR_JUMP,
2270                 PADDR (cleanup_ok),
2271
2272 },/*-------------------------< PAR_ERR_DATA_IN >---------------*/{
2273         /*
2274         **      Ignore all data in byte, until next phase
2275         */
2276         SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_IN)),
2277                 PADDRH (par_err_other),
2278         SCR_MOVE_ABS (1) ^ SCR_DATA_IN,
2279                 NADDR (scratch),
2280         SCR_JUMPR,
2281                 -24,
2282 },/*-------------------------< PAR_ERR_OTHER >------------------*/{
2283         /*
2284         **      count it.
2285         */
2286         SCR_REG_REG (PS_REG, SCR_ADD, 0x01),
2287                 0,
2288         /*
2289         **      jump to dispatcher.
2290         */
2291         SCR_JUMP,
2292                 PADDR (dispatch),
2293 }/*-------------------------< MSG_REJECT >---------------*/,{
2294         /*
2295         **      If a negotiation was in progress,
2296         **      negotiation failed.
2297         **      Otherwise, let the C code print
2298         **      some message.
2299         */
2300         SCR_FROM_REG (HS_REG),
2301                 0,
2302         SCR_INT ^ IFFALSE (DATA (HS_NEGOTIATE)),
2303                 SIR_REJECT_RECEIVED,
2304         SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
2305                 SIR_NEGO_FAILED,
2306         SCR_JUMP,
2307                 PADDR (clrack),
2308
2309 }/*-------------------------< MSG_IGN_RESIDUE >----------*/,{
2310         /*
2311         **      Terminate cycle
2312         */
2313         SCR_CLR (SCR_ACK),
2314                 0,
2315         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2316                 PADDR (dispatch),
2317         /*
2318         **      get residue size.
2319         */
2320         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2321                 NADDR (msgin[1]),
2322         /*
2323         **      Size is 0 .. ignore message.
2324         */
2325         SCR_JUMP ^ IFTRUE (DATA (0)),
2326                 PADDR (clrack),
2327         /*
2328         **      Size is not 1 .. have to interrupt.
2329         */
2330         SCR_JUMPR ^ IFFALSE (DATA (1)),
2331                 40,
2332         /*
2333         **      Check for residue byte in swide register
2334         */
2335         SCR_FROM_REG (scntl2),
2336                 0,
2337         SCR_JUMPR ^ IFFALSE (MASK (WSR, WSR)),
2338                 16,
2339         /*
2340         **      There IS data in the swide register.
2341         **      Discard it.
2342         */
2343         SCR_REG_REG (scntl2, SCR_OR, WSR),
2344                 0,
2345         SCR_JUMP,
2346                 PADDR (clrack),
2347         /*
2348         **      Load again the size to the sfbr register.
2349         */
2350         SCR_FROM_REG (scratcha),
2351                 0,
2352         SCR_INT,
2353                 SIR_IGN_RESIDUE,
2354         SCR_JUMP,
2355                 PADDR (clrack),
2356
2357 }/*-------------------------< MSG_EXTENDED >-------------*/,{
2358         /*
2359         **      Terminate cycle
2360         */
2361         SCR_CLR (SCR_ACK),
2362                 0,
2363         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2364                 PADDR (dispatch),
2365         /*
2366         **      get length.
2367         */
2368         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2369                 NADDR (msgin[1]),
2370         /*
2371         */
2372         SCR_JUMP ^ IFTRUE (DATA (3)),
2373                 PADDRH (msg_ext_3),
2374         SCR_JUMP ^ IFFALSE (DATA (2)),
2375                 PADDR (msg_bad),
2376 }/*-------------------------< MSG_EXT_2 >----------------*/,{
2377         SCR_CLR (SCR_ACK),
2378                 0,
2379         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2380                 PADDR (dispatch),
2381         /*
2382         **      get extended message code.
2383         */
2384         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2385                 NADDR (msgin[2]),
2386         SCR_JUMP ^ IFTRUE (DATA (M_X_WIDE_REQ)),
2387                 PADDRH (msg_wdtr),
2388         /*
2389         **      unknown extended message
2390         */
2391         SCR_JUMP,
2392                 PADDR (msg_bad)
2393 }/*-------------------------< MSG_WDTR >-----------------*/,{
2394         SCR_CLR (SCR_ACK),
2395                 0,
2396         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2397                 PADDR (dispatch),
2398         /*
2399         **      get data bus width
2400         */
2401         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2402                 NADDR (msgin[3]),
2403         /*
2404         **      let the host do the real work.
2405         */
2406         SCR_INT,
2407                 SIR_NEGO_WIDE,
2408         /*
2409         **      let the target fetch our answer.
2410         */
2411         SCR_SET (SCR_ATN),
2412                 0,
2413         SCR_CLR (SCR_ACK),
2414                 0,
2415         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
2416                 PADDRH (nego_bad_phase),
2417
2418 }/*-------------------------< SEND_WDTR >----------------*/,{
2419         /*
2420         **      Send the M_X_WIDE_REQ
2421         */
2422         SCR_MOVE_ABS (4) ^ SCR_MSG_OUT,
2423                 NADDR (msgout),
2424         SCR_COPY (1),
2425                 NADDR (msgout),
2426                 NADDR (lastmsg),
2427         SCR_JUMP,
2428                 PADDR (msg_out_done),
2429
2430 }/*-------------------------< MSG_EXT_3 >----------------*/,{
2431         SCR_CLR (SCR_ACK),
2432                 0,
2433         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2434                 PADDR (dispatch),
2435         /*
2436         **      get extended message code.
2437         */
2438         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2439                 NADDR (msgin[2]),
2440         SCR_JUMP ^ IFTRUE (DATA (M_X_SYNC_REQ)),
2441                 PADDRH (msg_sdtr),
2442         /*
2443         **      unknown extended message
2444         */
2445         SCR_JUMP,
2446                 PADDR (msg_bad)
2447
2448 }/*-------------------------< MSG_SDTR >-----------------*/,{
2449         SCR_CLR (SCR_ACK),
2450                 0,
2451         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2452                 PADDR (dispatch),
2453         /*
2454         **      get period and offset
2455         */
2456         SCR_MOVE_ABS (2) ^ SCR_MSG_IN,
2457                 NADDR (msgin[3]),
2458         /*
2459         **      let the host do the real work.
2460         */
2461         SCR_INT,
2462                 SIR_NEGO_SYNC,
2463         /*
2464         **      let the target fetch our answer.
2465         */
2466         SCR_SET (SCR_ATN),
2467                 0,
2468         SCR_CLR (SCR_ACK),
2469                 0,
2470         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
2471                 PADDRH (nego_bad_phase),
2472
2473 }/*-------------------------< SEND_SDTR >-------------*/,{
2474         /*
2475         **      Send the M_X_SYNC_REQ
2476         */
2477         SCR_MOVE_ABS (5) ^ SCR_MSG_OUT,
2478                 NADDR (msgout),
2479         SCR_COPY (1),
2480                 NADDR (msgout),
2481                 NADDR (lastmsg),
2482         SCR_JUMP,
2483                 PADDR (msg_out_done),
2484
2485 }/*-------------------------< NEGO_BAD_PHASE >------------*/,{
2486         SCR_INT,
2487                 SIR_NEGO_PROTO,
2488         SCR_JUMP,
2489                 PADDR (dispatch),
2490
2491 }/*-------------------------< MSG_OUT_ABORT >-------------*/,{
2492         /*
2493         **      After ABORT message,
2494         **
2495         **      expect an immediate disconnect, ...
2496         */
2497         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2498                 0,
2499         SCR_CLR (SCR_ACK|SCR_ATN),
2500                 0,
2501         SCR_WAIT_DISC,
2502                 0,
2503         /*
2504         **      ... and set the status to "ABORTED"
2505         */
2506         SCR_LOAD_REG (HS_REG, HS_ABORTED),
2507                 0,
2508         SCR_JUMP,
2509                 PADDR (cleanup),
2510
2511 }/*-------------------------< HDATA_IN >-------------------*/,{
2512 /*
2513 **      Because the size depends on the
2514 **      #define MAX_SCATTERH parameter,
2515 **      it is filled in at runtime.
2516 **
2517 **  ##==< i=MAX_SCATTERL; i<MAX_SCATTERL+MAX_SCATTERH >==
2518 **  ||  SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)),
2519 **  ||          PADDR (dispatch),
2520 **  ||  SCR_MOVE_TBL ^ SCR_DATA_IN,
2521 **  ||          offsetof (struct dsb, data[ i]),
2522 **  ##===================================================
2523 **
2524 **---------------------------------------------------------
2525 */
2526 0
2527 }/*-------------------------< HDATA_IN2 >------------------*/,{
2528         SCR_JUMP,
2529                 PADDR (data_in),
2530
2531 }/*-------------------------< HDATA_OUT >-------------------*/,{
2532 /*
2533 **      Because the size depends on the
2534 **      #define MAX_SCATTERH parameter,
2535 **      it is filled in at runtime.
2536 **
2537 **  ##==< i=MAX_SCATTERL; i<MAX_SCATTERL+MAX_SCATTERH >==
2538 **  ||  SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT)),
2539 **  ||          PADDR (dispatch),
2540 **  ||  SCR_MOVE_TBL ^ SCR_DATA_OUT,
2541 **  ||          offsetof (struct dsb, data[ i]),
2542 **  ##===================================================
2543 **
2544 **---------------------------------------------------------
2545 */
2546 0
2547 }/*-------------------------< HDATA_OUT2 >------------------*/,{
2548         SCR_JUMP,
2549                 PADDR (data_out),
2550
2551 }/*-------------------------< RESET >----------------------*/,{
2552         /*
2553         **      Send a M_RESET message if bad IDENTIFY
2554         **      received on reselection.
2555         */
2556         SCR_LOAD_REG (scratcha, M_ABORT_TAG),
2557                 0,
2558         SCR_JUMP,
2559                 PADDRH (abort_resel),
2560 }/*-------------------------< ABORTTAG >-------------------*/,{
2561         /*
2562         **      Abort a wrong tag received on reselection.
2563         */
2564         SCR_LOAD_REG (scratcha, M_ABORT_TAG),
2565                 0,
2566         SCR_JUMP,
2567                 PADDRH (abort_resel),
2568 }/*-------------------------< ABORT >----------------------*/,{
2569         /*
2570         **      Abort a reselection when no active CCB.
2571         */
2572         SCR_LOAD_REG (scratcha, M_ABORT),
2573                 0,
2574 }/*-------------------------< ABORT_RESEL >----------------*/,{
2575         SCR_COPY (1),
2576                 RADDR (scratcha),
2577                 NADDR (msgout),
2578         SCR_SET (SCR_ATN),
2579                 0,
2580         SCR_CLR (SCR_ACK),
2581                 0,
2582         /*
2583         **      and send it.
2584         **      we expect an immediate disconnect
2585         */
2586         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2587                 0,
2588         SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
2589                 NADDR (msgout),
2590         SCR_COPY (1),
2591                 NADDR (msgout),
2592                 NADDR (lastmsg),
2593         SCR_CLR (SCR_ACK|SCR_ATN),
2594                 0,
2595         SCR_WAIT_DISC,
2596                 0,
2597         SCR_JUMP,
2598                 PADDR (start),
2599 }/*-------------------------< RESEND_IDENT >-------------------*/,{
2600         /*
2601         **      The target stays in MSG OUT phase after having acked
2602         **      Identify [+ Tag [+ Extended message ]]. Targets shall
2603         **      behave this way on parity error.
2604         **      We must send it again all the messages.
2605         */
2606         SCR_SET (SCR_ATN), /* Shall be asserted 2 deskew delays before the  */
2607                 0,         /* 1rst ACK = 90 ns. Hope the NCR is'nt too fast */
2608         SCR_JUMP,
2609                 PADDR (send_ident),
2610 }/*-------------------------< CLRATN_GO_ON >-------------------*/,{
2611         SCR_CLR (SCR_ATN),
2612                 0,
2613         SCR_JUMP,
2614 }/*-------------------------< NXTDSP_GO_ON >-------------------*/,{
2615                 0,
2616 }/*-------------------------< SDATA_IN >-------------------*/,{
2617         SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)),
2618                 PADDR (dispatch),
2619         SCR_MOVE_TBL ^ SCR_DATA_IN,
2620                 offsetof (struct dsb, sense),
2621         SCR_CALL,
2622                 PADDR (dispatch),
2623         SCR_JUMP,
2624                 PADDR (no_data),
2625 }/*-------------------------< DATA_IO >--------------------*/,{
2626         /*
2627         **      We jump here if the data direction was unknown at the
2628         **      time we had to queue the command to the scripts processor.
2629         **      Pointers had been set as follow in this situation:
2630         **        savep   -->   DATA_IO
2631         **        lastp   -->   start pointer when DATA_IN
2632         **        goalp   -->   goal  pointer when DATA_IN
2633         **        wlastp  -->   start pointer when DATA_OUT
2634         **        wgoalp  -->   goal  pointer when DATA_OUT
2635         **      This script sets savep/lastp/goalp according to the
2636         **      direction chosen by the target.
2637         */
2638         SCR_JUMPR ^ IFTRUE (WHEN (SCR_DATA_OUT)),
2639                 32,
2640         /*
2641         **      Direction is DATA IN.
2642         **      Warning: we jump here, even when phase is DATA OUT.
2643         */
2644         SCR_COPY (4),
2645                 NADDR (header.lastp),
2646                 NADDR (header.savep),
2647
2648         /*
2649         **      Jump to the SCRIPTS according to actual direction.
2650         */
2651         SCR_COPY (4),
2652                 NADDR (header.savep),
2653                 RADDR (temp),
2654         SCR_RETURN,
2655                 0,
2656         /*
2657         **      Direction is DATA OUT.
2658         */
2659         SCR_COPY (4),
2660                 NADDR (header.wlastp),
2661                 NADDR (header.lastp),
2662         SCR_COPY (4),
2663                 NADDR (header.wgoalp),
2664                 NADDR (header.goalp),
2665         SCR_JUMPR,
2666                 -64,
2667 }/*-------------------------< BAD_IDENTIFY >---------------*/,{
2668         /*
2669         **      If message phase but not an IDENTIFY,
2670         **      get some help from the C code.
2671         **      Old SCSI device may behave so.
2672         */
2673         SCR_JUMPR ^ IFTRUE (MASK (0x80, 0x80)),
2674                 16,
2675         SCR_INT,
2676                 SIR_RESEL_NO_IDENTIFY,
2677         SCR_JUMP,
2678                 PADDRH (reset),
2679         /*
2680         **      Message is an IDENTIFY, but lun is unknown.
2681         **      Read the message, since we got it directly
2682         **      from the SCSI BUS data lines.
2683         **      Signal problem to C code for logging the event.
2684         **      Send a M_ABORT to clear all pending tasks.
2685         */
2686         SCR_INT,
2687                 SIR_RESEL_BAD_LUN,
2688         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2689                 NADDR (msgin),
2690         SCR_JUMP,
2691                 PADDRH (abort),
2692 }/*-------------------------< BAD_I_T_L >------------------*/,{
2693         /*
2694         **      We donnot have a task for that I_T_L.
2695         **      Signal problem to C code for logging the event.
2696         **      Send a M_ABORT message.
2697         */
2698         SCR_INT,
2699                 SIR_RESEL_BAD_I_T_L,
2700         SCR_JUMP,
2701                 PADDRH (abort),
2702 }/*-------------------------< BAD_I_T_L_Q >----------------*/,{
2703         /*
2704         **      We donnot have a task that matches the tag.
2705         **      Signal problem to C code for logging the event.
2706         **      Send a M_ABORTTAG message.
2707         */
2708         SCR_INT,
2709                 SIR_RESEL_BAD_I_T_L_Q,
2710         SCR_JUMP,
2711                 PADDRH (aborttag),
2712 }/*-------------------------< BAD_TARGET >-----------------*/,{
2713         /*
2714         **      We donnot know the target that reselected us.
2715         **      Grab the first message if any (IDENTIFY).
2716         **      Signal problem to C code for logging the event.
2717         **      M_RESET message.
2718         */
2719         SCR_INT,
2720                 SIR_RESEL_BAD_TARGET,
2721         SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)),
2722                 8,
2723         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2724                 NADDR (msgin),
2725         SCR_JUMP,
2726                 PADDRH (reset),
2727 }/*-------------------------< BAD_STATUS >-----------------*/,{
2728         /*
2729         **      If command resulted in either QUEUE FULL,
2730         **      CHECK CONDITION or COMMAND TERMINATED,
2731         **      call the C code.
2732         */
2733         SCR_INT ^ IFTRUE (DATA (S_QUEUE_FULL)),
2734                 SIR_BAD_STATUS,
2735         SCR_INT ^ IFTRUE (DATA (S_CHECK_COND)),
2736                 SIR_BAD_STATUS,
2737         SCR_INT ^ IFTRUE (DATA (S_TERMINATED)),
2738                 SIR_BAD_STATUS,
2739         SCR_RETURN,
2740                 0,
2741 }/*-------------------------< START_RAM >-------------------*/,{
2742         /*
2743         **      Load the script into on-chip RAM,
2744         **      and jump to start point.
2745         */
2746         SCR_COPY_F (4),
2747                 RADDR (scratcha),
2748                 PADDRH (start_ram0),
2749         /*
2750         **      Flush script prefetch if required
2751         */
2752         PREFETCH_FLUSH
2753         SCR_COPY (sizeof (struct script)),
2754 }/*-------------------------< START_RAM0 >--------------------*/,{
2755                 0,
2756                 PADDR (start),
2757         SCR_JUMP,
2758                 PADDR (start),
2759 }/*-------------------------< STO_RESTART >-------------------*/,{
2760         /*
2761         **
2762         **      Repair start queue (e.g. next time use the next slot)
2763         **      and jump to start point.
2764         */
2765         SCR_COPY (4),
2766                 RADDR (temp),
2767                 PADDR (startpos),
2768         SCR_JUMP,
2769                 PADDR (start),
2770 }/*-------------------------< WAIT_DMA >-------------------*/,{
2771         /*
2772         **      For HP Zalon/53c720 systems, the Zalon interface
2773         **      between CPU and 53c720 does prefetches, which causes
2774         **      problems with self modifying scripts.  The problem
2775         **      is overcome by calling a dummy subroutine after each
2776         **      modification, to force a refetch of the script on
2777         **      return from the subroutine.
2778         */
2779         SCR_RETURN,
2780                 0,
2781 }/*-------------------------< SNOOPTEST >-------------------*/,{
2782         /*
2783         **      Read the variable.
2784         */
2785         SCR_COPY (4),
2786                 NADDR(ncr_cache),
2787                 RADDR (scratcha),
2788         /*
2789         **      Write the variable.
2790         */
2791         SCR_COPY (4),
2792                 RADDR (temp),
2793                 NADDR(ncr_cache),
2794         /*
2795         **      Read back the variable.
2796         */
2797         SCR_COPY (4),
2798                 NADDR(ncr_cache),
2799                 RADDR (temp),
2800 }/*-------------------------< SNOOPEND >-------------------*/,{
2801         /*
2802         **      And stop.
2803         */
2804         SCR_INT,
2805                 99,
2806 }/*--------------------------------------------------------*/
2807 };
2808
2809 /*==========================================================
2810 **
2811 **
2812 **      Fill in #define dependent parts of the script
2813 **
2814 **
2815 **==========================================================
2816 */
2817
2818 void __init ncr_script_fill (struct script * scr, struct scripth * scrh)
2819 {
2820         int     i;
2821         ncrcmd  *p;
2822
2823         p = scrh->tryloop;
2824         for (i=0; i<MAX_START; i++) {
2825                 *p++ =SCR_CALL;
2826                 *p++ =PADDR (idle);
2827         };
2828
2829         assert ((u_long)p == (u_long)&scrh->tryloop + sizeof (scrh->tryloop));
2830
2831 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
2832
2833         p = scrh->done_queue;
2834         for (i = 0; i<MAX_DONE; i++) {
2835                 *p++ =SCR_COPY (sizeof(struct ccb *));
2836                 *p++ =NADDR (header.cp);
2837                 *p++ =NADDR (ccb_done[i]);
2838                 *p++ =SCR_CALL;
2839                 *p++ =PADDR (done_end);
2840         }
2841
2842         assert ((u_long)p ==(u_long)&scrh->done_queue+sizeof(scrh->done_queue));
2843
2844 #endif /* SCSI_NCR_CCB_DONE_SUPPORT */
2845
2846         p = scrh->hdata_in;
2847         for (i=0; i<MAX_SCATTERH; i++) {
2848                 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN));
2849                 *p++ =PADDR (dispatch);
2850                 *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN;
2851                 *p++ =offsetof (struct dsb, data[i]);
2852         };
2853         assert ((u_long)p == (u_long)&scrh->hdata_in + sizeof (scrh->hdata_in));
2854
2855         p = scr->data_in;
2856         for (i=MAX_SCATTERH; i<MAX_SCATTERH+MAX_SCATTERL; i++) {
2857                 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN));
2858                 *p++ =PADDR (dispatch);
2859                 *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN;
2860                 *p++ =offsetof (struct dsb, data[i]);
2861         };
2862         assert ((u_long)p == (u_long)&scr->data_in + sizeof (scr->data_in));
2863
2864         p = scrh->hdata_out;
2865         for (i=0; i<MAX_SCATTERH; i++) {
2866                 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT));
2867                 *p++ =PADDR (dispatch);
2868                 *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT;
2869                 *p++ =offsetof (struct dsb, data[i]);
2870         };
2871         assert ((u_long)p==(u_long)&scrh->hdata_out + sizeof (scrh->hdata_out));
2872
2873         p = scr->data_out;
2874         for (i=MAX_SCATTERH; i<MAX_SCATTERH+MAX_SCATTERL; i++) {
2875                 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT));
2876                 *p++ =PADDR (dispatch);
2877                 *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT;
2878                 *p++ =offsetof (struct dsb, data[i]);
2879         };
2880
2881         assert ((u_long)p == (u_long)&scr->data_out + sizeof (scr->data_out));
2882 }
2883
2884 /*==========================================================
2885 **
2886 **
2887 **      Copy and rebind a script.
2888 **
2889 **
2890 **==========================================================
2891 */
2892
2893 static void __init
2894 ncr_script_copy_and_bind (struct ncb *np, ncrcmd *src, ncrcmd *dst, int len)
2895 {
2896         ncrcmd  opcode, new, old, tmp1, tmp2;
2897         ncrcmd  *start, *end;
2898         int relocs;
2899         int opchanged = 0;
2900
2901         start = src;
2902         end = src + len/4;
2903
2904         while (src < end) {
2905
2906                 opcode = *src++;
2907                 *dst++ = cpu_to_scr(opcode);
2908
2909                 /*
2910                 **      If we forget to change the length
2911                 **      in struct script, a field will be
2912                 **      padded with 0. This is an illegal
2913                 **      command.
2914                 */
2915
2916                 if (opcode == 0) {
2917                         printk (KERN_ERR "%s: ERROR0 IN SCRIPT at %d.\n",
2918                                 ncr_name(np), (int) (src-start-1));
2919                         MDELAY (1000);
2920                 };
2921
2922                 if (DEBUG_FLAGS & DEBUG_SCRIPT)
2923                         printk (KERN_DEBUG "%p:  <%x>\n",
2924                                 (src-1), (unsigned)opcode);
2925
2926                 /*
2927                 **      We don't have to decode ALL commands
2928                 */
2929                 switch (opcode >> 28) {
2930
2931                 case 0xc:
2932                         /*
2933                         **      COPY has TWO arguments.
2934                         */
2935                         relocs = 2;
2936                         tmp1 = src[0];
2937 #ifdef  RELOC_KVAR
2938                         if ((tmp1 & RELOC_MASK) == RELOC_KVAR)
2939                                 tmp1 = 0;
2940 #endif
2941                         tmp2 = src[1];
2942 #ifdef  RELOC_KVAR
2943                         if ((tmp2 & RELOC_MASK) == RELOC_KVAR)
2944                                 tmp2 = 0;
2945 #endif
2946                         if ((tmp1 ^ tmp2) & 3) {
2947                                 printk (KERN_ERR"%s: ERROR1 IN SCRIPT at %d.\n",
2948                                         ncr_name(np), (int) (src-start-1));
2949                                 MDELAY (1000);
2950                         }
2951                         /*
2952                         **      If PREFETCH feature not enabled, remove
2953                         **      the NO FLUSH bit if present.
2954                         */
2955                         if ((opcode & SCR_NO_FLUSH) && !(np->features & FE_PFEN)) {
2956                                 dst[-1] = cpu_to_scr(opcode & ~SCR_NO_FLUSH);
2957                                 ++opchanged;
2958                         }
2959                         break;
2960
2961                 case 0x0:
2962                         /*
2963                         **      MOVE (absolute address)
2964                         */
2965                         relocs = 1;
2966                         break;
2967
2968                 case 0x8:
2969                         /*
2970                         **      JUMP / CALL
2971                         **      don't relocate if relative :-)
2972                         */
2973                         if (opcode & 0x00800000)
2974                                 relocs = 0;
2975                         else
2976                                 relocs = 1;
2977                         break;
2978
2979                 case 0x4:
2980                 case 0x5:
2981                 case 0x6:
2982                 case 0x7:
2983                         relocs = 1;
2984                         break;
2985
2986                 default:
2987                         relocs = 0;
2988                         break;
2989                 };
2990
2991                 if (relocs) {
2992                         while (relocs--) {
2993                                 old = *src++;
2994
2995                                 switch (old & RELOC_MASK) {
2996                                 case RELOC_REGISTER:
2997                                         new = (old & ~RELOC_MASK) + np->paddr;
2998                                         break;
2999                                 case RELOC_LABEL:
3000                                         new = (old & ~RELOC_MASK) + np->p_script;
3001                                         break;
3002                                 case RELOC_LABELH:
3003                                         new = (old & ~RELOC_MASK) + np->p_scripth;
3004                                         break;
3005                                 case RELOC_SOFTC:
3006                                         new = (old & ~RELOC_MASK) + np->p_ncb;
3007                                         break;
3008 #ifdef  RELOC_KVAR
3009                                 case RELOC_KVAR:
3010                                         if (((old & ~RELOC_MASK) <
3011                                              SCRIPT_KVAR_FIRST) ||
3012                                             ((old & ~RELOC_MASK) >
3013                                              SCRIPT_KVAR_LAST))
3014                                                 panic("ncr KVAR out of range");
3015                                         new = vtophys(script_kvars[old &
3016                                             ~RELOC_MASK]);
3017                                         break;
3018 #endif
3019                                 case 0:
3020                                         /* Don't relocate a 0 address. */
3021                                         if (old == 0) {
3022                                                 new = old;
3023                                                 break;
3024                                         }
3025                                         /* fall through */
3026                                 default:
3027                                         panic("ncr_script_copy_and_bind: weird relocation %x\n", old);
3028                                         break;
3029                                 }
3030
3031                                 *dst++ = cpu_to_scr(new);
3032                         }
3033                 } else
3034                         *dst++ = cpu_to_scr(*src++);
3035
3036         };
3037 }
3038
3039 /*==========================================================
3040 **
3041 **
3042 **      Auto configuration:  attach and init a host adapter.
3043 **
3044 **
3045 **==========================================================
3046 */
3047
3048 /*
3049 **      Linux host data structure
3050 **
3051 **      The script area is allocated in the host data structure
3052 **      because kmalloc() returns NULL during scsi initialisations
3053 **      with Linux 1.2.X
3054 */
3055
3056 struct host_data {
3057      struct ncb *ncb;
3058 };
3059
3060 /*
3061 **      Print something which allows to retrieve the controller type, unit,
3062 **      target, lun concerned by a kernel message.
3063 */
3064
3065 static void PRINT_TARGET(struct ncb *np, int target)
3066 {
3067         printk(KERN_INFO "%s-<%d,*>: ", ncr_name(np), target);
3068 }
3069
3070 static void PRINT_LUN(struct ncb *np, int target, int lun)
3071 {
3072         printk(KERN_INFO "%s-<%d,%d>: ", ncr_name(np), target, lun);
3073 }
3074
3075 static void PRINT_ADDR(struct scsi_cmnd *cmd)
3076 {
3077         struct host_data *host_data = (struct host_data *) cmd->device->host->hostdata;
3078         PRINT_LUN(host_data->ncb, cmd->device->id, cmd->device->lun);
3079 }
3080
3081 /*==========================================================
3082 **
3083 **      NCR chip clock divisor table.
3084 **      Divisors are multiplied by 10,000,000 in order to make
3085 **      calculations more simple.
3086 **
3087 **==========================================================
3088 */
3089
3090 #define _5M 5000000
3091 static u_long div_10M[] =
3092         {2*_5M, 3*_5M, 4*_5M, 6*_5M, 8*_5M, 12*_5M, 16*_5M};
3093
3094
3095 /*===============================================================
3096 **
3097 **      Prepare io register values used by ncr_init() according
3098 **      to selected and supported features.
3099 **
3100 **      NCR chips allow burst lengths of 2, 4, 8, 16, 32, 64, 128
3101 **      transfers. 32,64,128 are only supported by 875 and 895 chips.
3102 **      We use log base 2 (burst length) as internal code, with
3103 **      value 0 meaning "burst disabled".
3104 **
3105 **===============================================================
3106 */
3107
3108 /*
3109  *      Burst length from burst code.
3110  */
3111 #define burst_length(bc) (!(bc))? 0 : 1 << (bc)
3112
3113 /*
3114  *      Burst code from io register bits.  Burst enable is ctest0 for c720
3115  */
3116 #define burst_code(dmode, ctest0) \
3117         (ctest0) & 0x80 ? 0 : (((dmode) & 0xc0) >> 6) + 1
3118
3119 /*
3120  *      Set initial io register bits from burst code.
3121  */
3122 static inline void ncr_init_burst(struct ncb *np, u_char bc)
3123 {
3124         u_char *be = &np->rv_ctest0;
3125         *be             &= ~0x80;
3126         np->rv_dmode    &= ~(0x3 << 6);
3127         np->rv_ctest5   &= ~0x4;
3128
3129         if (!bc) {
3130                 *be             |= 0x80;
3131         } else {
3132                 --bc;
3133                 np->rv_dmode    |= ((bc & 0x3) << 6);
3134                 np->rv_ctest5   |= (bc & 0x4);
3135         }
3136 }
3137
3138 static void __init ncr_prepare_setting(struct ncb *np)
3139 {
3140         u_char  burst_max;
3141         u_long  period;
3142         int i;
3143
3144         /*
3145         **      Save assumed BIOS setting
3146         */
3147
3148         np->sv_scntl0   = INB(nc_scntl0) & 0x0a;
3149         np->sv_scntl3   = INB(nc_scntl3) & 0x07;
3150         np->sv_dmode    = INB(nc_dmode)  & 0xce;
3151         np->sv_dcntl    = INB(nc_dcntl)  & 0xa8;
3152         np->sv_ctest0   = INB(nc_ctest0) & 0x84;
3153         np->sv_ctest3   = INB(nc_ctest3) & 0x01;
3154         np->sv_ctest4   = INB(nc_ctest4) & 0x80;
3155         np->sv_ctest5   = INB(nc_ctest5) & 0x24;
3156         np->sv_gpcntl   = INB(nc_gpcntl);
3157         np->sv_stest2   = INB(nc_stest2) & 0x20;
3158         np->sv_stest4   = INB(nc_stest4);
3159
3160         /*
3161         **      Wide ?
3162         */
3163
3164         np->maxwide     = (np->features & FE_WIDE)? 1 : 0;
3165
3166         /*
3167          *  Guess the frequency of the chip's clock.
3168          */
3169         if (np->features & FE_ULTRA)
3170                 np->clock_khz = 80000;
3171         else
3172                 np->clock_khz = 40000;
3173
3174         /*
3175          *  Get the clock multiplier factor.
3176          */
3177         if      (np->features & FE_QUAD)
3178                 np->multiplier  = 4;
3179         else if (np->features & FE_DBLR)
3180                 np->multiplier  = 2;
3181         else
3182                 np->multiplier  = 1;
3183
3184         /*
3185          *  Measure SCSI clock frequency for chips
3186          *  it may vary from assumed one.
3187          */
3188         if (np->features & FE_VARCLK)
3189                 ncr_getclock(np, np->multiplier);
3190
3191         /*
3192          * Divisor to be used for async (timer pre-scaler).
3193          */
3194         i = np->clock_divn - 1;
3195         while (--i >= 0) {
3196                 if (10ul * SCSI_NCR_MIN_ASYNC * np->clock_khz > div_10M[i]) {
3197                         ++i;
3198                         break;
3199                 }
3200         }
3201         np->rv_scntl3 = i+1;
3202
3203         /*
3204          * Minimum synchronous period factor supported by the chip.
3205          * Btw, 'period' is in tenths of nanoseconds.
3206          */
3207
3208         period = (4 * div_10M[0] + np->clock_khz - 1) / np->clock_khz;
3209         if      (period <= 250)         np->minsync = 10;
3210         else if (period <= 303)         np->minsync = 11;
3211         else if (period <= 500)         np->minsync = 12;
3212         else                            np->minsync = (period + 40 - 1) / 40;
3213
3214         /*
3215          * Check against chip SCSI standard support (SCSI-2,ULTRA,ULTRA2).
3216          */
3217
3218         if      (np->minsync < 25 && !(np->features & FE_ULTRA))
3219                 np->minsync = 25;
3220
3221         /*
3222          * Maximum synchronous period factor supported by the chip.
3223          */
3224
3225         period = (11 * div_10M[np->clock_divn - 1]) / (4 * np->clock_khz);
3226         np->maxsync = period > 2540 ? 254 : period / 10;
3227
3228         /*
3229         **      Prepare initial value of other IO registers
3230         */
3231 #if defined SCSI_NCR_TRUST_BIOS_SETTING
3232         np->rv_scntl0   = np->sv_scntl0;
3233         np->rv_dmode    = np->sv_dmode;
3234         np->rv_dcntl    = np->sv_dcntl;
3235         np->rv_ctest0   = np->sv_ctest0;
3236         np->rv_ctest3   = np->sv_ctest3;
3237         np->rv_ctest4   = np->sv_ctest4;
3238         np->rv_ctest5   = np->sv_ctest5;
3239         burst_max       = burst_code(np->sv_dmode, np->sv_ctest0);
3240 #else
3241
3242         /*
3243         **      Select burst length (dwords)
3244         */
3245         burst_max       = driver_setup.burst_max;
3246         if (burst_max == 255)
3247                 burst_max = burst_code(np->sv_dmode, np->sv_ctest0);
3248         if (burst_max > 7)
3249                 burst_max = 7;
3250         if (burst_max > np->maxburst)
3251                 burst_max = np->maxburst;
3252
3253         /*
3254         **      Select all supported special features
3255         */
3256         if (np->features & FE_ERL)
3257                 np->rv_dmode    |= ERL;         /* Enable Read Line */
3258         if (np->features & FE_BOF)
3259                 np->rv_dmode    |= BOF;         /* Burst Opcode Fetch */
3260         if (np->features & FE_ERMP)
3261                 np->rv_dmode    |= ERMP;        /* Enable Read Multiple */
3262         if (np->features & FE_PFEN)
3263                 np->rv_dcntl    |= PFEN;        /* Prefetch Enable */
3264         if (np->features & FE_CLSE)
3265                 np->rv_dcntl    |= CLSE;        /* Cache Line Size Enable */
3266         if (np->features & FE_WRIE)
3267                 np->rv_ctest3   |= WRIE;        /* Write and Invalidate */
3268         if (np->features & FE_DFS)
3269                 np->rv_ctest5   |= DFS;         /* Dma Fifo Size */
3270         if (np->features & FE_MUX)
3271                 np->rv_ctest4   |= MUX;         /* Host bus multiplex mode */
3272         if (np->features & FE_EA)
3273                 np->rv_dcntl    |= EA;          /* Enable ACK */
3274         if (np->features & FE_EHP)
3275                 np->rv_ctest0   |= EHP;         /* Even host parity */
3276
3277         /*
3278         **      Select some other
3279         */
3280         if (driver_setup.master_parity)
3281                 np->rv_ctest4   |= MPEE;        /* Master parity checking */
3282         if (driver_setup.scsi_parity)
3283                 np->rv_scntl0   |= 0x0a;        /*  full arb., ena parity, par->ATN  */
3284
3285         /*
3286         **  Get SCSI addr of host adapter (set by bios?).
3287         */
3288         if (np->myaddr == 255) {
3289                 np->myaddr = INB(nc_scid) & 0x07;
3290                 if (!np->myaddr)
3291                         np->myaddr = SCSI_NCR_MYADDR;
3292         }
3293
3294 #endif /* SCSI_NCR_TRUST_BIOS_SETTING */
3295
3296         /*
3297          *      Prepare initial io register bits for burst length
3298          */
3299         ncr_init_burst(np, burst_max);
3300
3301         /*
3302         **      Set SCSI BUS mode.
3303         **
3304         **      - ULTRA2 chips (895/895A/896) report the current
3305         **        BUS mode through the STEST4 IO register.
3306         **      - For previous generation chips (825/825A/875),
3307         **        user has to tell us how to check against HVD,
3308         **        since a 100% safe algorithm is not possible.
3309         */
3310         np->scsi_mode = SMODE_SE;
3311         if (np->features & FE_DIFF) {
3312                 switch(driver_setup.diff_support) {
3313                 case 4: /* Trust previous settings if present, then GPIO3 */
3314                         if (np->sv_scntl3) {
3315                                 if (np->sv_stest2 & 0x20)
3316                                         np->scsi_mode = SMODE_HVD;
3317                                 break;
3318                         }
3319                 case 3: /* SYMBIOS controllers report HVD through GPIO3 */
3320                         if (INB(nc_gpreg) & 0x08)
3321                                 break;
3322                 case 2: /* Set HVD unconditionally */
3323                         np->scsi_mode = SMODE_HVD;
3324                 case 1: /* Trust previous settings for HVD */
3325                         if (np->sv_stest2 & 0x20)
3326                                 np->scsi_mode = SMODE_HVD;
3327                         break;
3328                 default:/* Don't care about HVD */
3329                         break;
3330                 }
3331         }
3332         if (np->scsi_mode == SMODE_HVD)
3333                 np->rv_stest2 |= 0x20;
3334
3335         /*
3336         **      Set LED support from SCRIPTS.
3337         **      Ignore this feature for boards known to use a
3338         **      specific GPIO wiring and for the 895A or 896
3339         **      that drive the LED directly.
3340         **      Also probe initial setting of GPIO0 as output.
3341         */
3342         if ((driver_setup.led_pin) &&
3343             !(np->features & FE_LEDC) && !(np->sv_gpcntl & 0x01))
3344                 np->features |= FE_LED0;
3345
3346         /*
3347         **      Set irq mode.
3348         */
3349         switch(driver_setup.irqm & 3) {
3350         case 2:
3351                 np->rv_dcntl    |= IRQM;
3352                 break;
3353         case 1:
3354                 np->rv_dcntl    |= (np->sv_dcntl & IRQM);
3355                 break;
3356         default:
3357                 break;
3358         }
3359
3360         /*
3361         **      Configure targets according to driver setup.
3362         **      Allow to override sync, wide and NOSCAN from
3363         **      boot command line.
3364         */
3365         for (i = 0 ; i < MAX_TARGET ; i++) {
3366                 struct tcb *tp = &np->target[i];
3367
3368                 tp->usrsync = driver_setup.default_sync;
3369                 tp->usrwide = driver_setup.max_wide;
3370                 tp->usrtags = MAX_TAGS;
3371                 if (!driver_setup.disconnection)
3372                         np->target[i].usrflag = UF_NODISC;
3373         }
3374
3375         /*
3376         **      Announce all that stuff to user.
3377         */
3378
3379         printk(KERN_INFO "%s: ID %d, Fast-%d%s%s\n", ncr_name(np),
3380                 np->myaddr,
3381                 np->minsync < 12 ? 40 : (np->minsync < 25 ? 20 : 10),
3382                 (np->rv_scntl0 & 0xa)   ? ", Parity Checking"   : ", NO Parity",
3383                 (np->rv_stest2 & 0x20)  ? ", Differential"      : "");
3384
3385         if (bootverbose > 1) {
3386                 printk (KERN_INFO "%s: initial SCNTL3/DMODE/DCNTL/CTEST3/4/5 = "
3387                         "(hex) %02x/%02x/%02x/%02x/%02x/%02x\n",
3388                         ncr_name(np), np->sv_scntl3, np->sv_dmode, np->sv_dcntl,
3389                         np->sv_ctest3, np->sv_ctest4, np->sv_ctest5);
3390
3391                 printk (KERN_INFO "%s: final   SCNTL3/DMODE/DCNTL/CTEST3/4/5 = "
3392                         "(hex) %02x/%02x/%02x/%02x/%02x/%02x\n",
3393                         ncr_name(np), np->rv_scntl3, np->rv_dmode, np->rv_dcntl,
3394                         np->rv_ctest3, np->rv_ctest4, np->rv_ctest5);
3395         }
3396
3397         if (bootverbose && np->paddr2)
3398                 printk (KERN_INFO "%s: on-chip RAM at 0x%lx\n",
3399                         ncr_name(np), np->paddr2);
3400 }
3401
3402 /*==========================================================
3403 **
3404 **
3405 **      Done SCSI commands list management.
3406 **
3407 **      We donnot enter the scsi_done() callback immediately
3408 **      after a command has been seen as completed but we
3409 **      insert it into a list which is flushed outside any kind
3410 **      of driver critical section.
3411 **      This allows to do minimal stuff under interrupt and
3412 **      inside critical sections and to also avoid locking up
3413 **      on recursive calls to driver entry points under SMP.
3414 **      In fact, the only kernel point which is entered by the
3415 **      driver with a driver lock set is kmalloc(GFP_ATOMIC)
3416 **      that shall not reenter the driver under any circumstances,
3417 **      AFAIK.
3418 **
3419 **==========================================================
3420 */
3421 static inline void ncr_queue_done_cmd(struct ncb *np, struct scsi_cmnd *cmd)
3422 {
3423         unmap_scsi_data(np, cmd);
3424         cmd->host_scribble = (char *) np->done_list;
3425         np->done_list = cmd;
3426 }
3427
3428 static inline void ncr_flush_done_cmds(struct scsi_cmnd *lcmd)
3429 {
3430         struct scsi_cmnd *cmd;
3431
3432         while (lcmd) {
3433                 cmd = lcmd;
3434                 lcmd = (struct scsi_cmnd *) cmd->host_scribble;
3435                 cmd->scsi_done(cmd);
3436         }
3437 }
3438
3439 /*==========================================================
3440 **
3441 **
3442 **      Prepare the next negotiation message for integrity check,
3443 **      if needed.
3444 **
3445 **      Fill in the part of message buffer that contains the
3446 **      negotiation and the nego_status field of the CCB.
3447 **      Returns the size of the message in bytes.
3448 **
3449 **
3450 **==========================================================
3451 */
3452
3453 #ifdef SCSI_NCR_INTEGRITY_CHECKING
3454 static int ncr_ic_nego(struct ncb *np, struct ccb *cp, struct scsi_cmnd *cmd, u_char *msgptr)
3455 {
3456         struct tcb *tp = &np->target[cp->target];
3457         int msglen = 0;
3458         int nego = 0;
3459         u_char no_increase;
3460
3461         if (tp->inq_done) {
3462
3463                 if (!tp->ic_maximums_set) {
3464                         tp->ic_maximums_set = 1;
3465
3466                         /* check target and host adapter capabilities */
3467                         if ( (tp->inq_byte7 & INQ7_WIDE16) &&
3468                                         np->maxwide && tp->usrwide )
3469                                 tp->ic_max_width = 1;
3470                         else
3471                                 tp->ic_max_width = 0;
3472
3473                         if ((tp->inq_byte7 & INQ7_SYNC) && tp->maxoffs) {
3474                                 tp->ic_min_sync   = (tp->minsync < np->minsync) ?
3475                                                         np->minsync : tp->minsync;
3476                         }
3477                         else
3478                                 tp->ic_min_sync   = 255;
3479
3480                         tp->period   = 1;
3481                         tp->widedone = 1;
3482                 }
3483
3484                 if (DEBUG_FLAGS & DEBUG_IC) {
3485                         printk("%s: cmd->ic_nego %d, 1st byte 0x%2X\n",
3486                                 ncr_name(np), cmd->ic_nego, cmd->cmnd[0]);
3487                 }
3488
3489                 /* First command from integrity check routine will request
3490                  * a PPR message.  Disable.
3491                  */
3492                 if ((cmd->ic_nego & NS_PPR) == NS_PPR)
3493                         cmd->ic_nego &= ~NS_PPR;
3494                 /* Previous command recorded a parity or an initiator
3495                  * detected error condition. Force bus to narrow for this
3496                  * target. Clear flag. Negotation on request sense.
3497                  * Note: kernel forces 2 bus resets :o( but clears itself out.
3498                  * Minor bug? in scsi_obsolete.c (ugly)
3499                  */
3500                 if (np->check_integ_par) {
3501                         printk("%s: Parity Error. Target set to narrow.\n",
3502                                 ncr_name(np));
3503                         tp->ic_max_width = 0;
3504                         tp->widedone = tp->period = 0;
3505                 }
3506
3507                 /* In case of a bus reset, ncr_negotiate will reset
3508                  * the flags tp->widedone and tp->period to 0, forcing
3509                  * a new negotiation.
3510                  */
3511                 no_increase = 0;
3512                 if (tp->widedone == 0) {
3513                         cmd->ic_nego = NS_WIDE;
3514                         tp->widedone = 1;
3515                         no_increase = 1;
3516                 }
3517                 else if (tp->period == 0) {
3518                         cmd->ic_nego = NS_SYNC;
3519                         tp->period = 1;
3520                         no_increase = 1;
3521                 }
3522
3523                 switch (cmd->ic_nego) {
3524                 case NS_WIDE:
3525                         /*
3526                         **      negotiate wide transfers ?
3527                         **      Do NOT negotiate if device only supports
3528                         **      narrow.
3529                         */
3530                         if (tp->ic_max_width | np->check_integ_par) {
3531                                 nego = NS_WIDE;
3532
3533                                 msgptr[msglen++] = M_EXTENDED;
3534                                 msgptr[msglen++] = 2;
3535                                 msgptr[msglen++] = M_X_WIDE_REQ;
3536                                 msgptr[msglen++] = cmd->ic_nego_width & tp->ic_max_width;
3537                         }
3538                         else
3539                                 cmd->ic_nego_width &= tp->ic_max_width;
3540
3541                         break;
3542
3543                 case NS_SYNC:
3544                         /*
3545                         **      negotiate synchronous transfers?
3546                         **      Target must support sync transfers.
3547                         **
3548                         **      If period becomes longer than max, reset to async
3549                         */
3550
3551                         if (tp->inq_byte7 & INQ7_SYNC) {
3552
3553                                 nego = NS_SYNC;
3554
3555                                 msgptr[msglen++] = M_EXTENDED;
3556                                 msgptr[msglen++] = 3;
3557                                 msgptr[msglen++] = M_X_SYNC_REQ;
3558
3559                                 switch (cmd->ic_nego_sync) {
3560                                 case 2: /* increase the period */
3561                                         if (!no_increase) {
3562                                           if (tp->ic_min_sync <= 0x0A)
3563                                               tp->ic_min_sync = 0x0C;
3564                                           else if (tp->ic_min_sync <= 0x0C)
3565                                               tp->ic_min_sync = 0x19;
3566                                           else if (tp->ic_min_sync <= 0x19)
3567                                               tp->ic_min_sync *= 2;
3568                                           else {
3569                                                 tp->ic_min_sync = 255;
3570                                                 cmd->ic_nego_sync = 0;
3571                                                 tp->maxoffs = 0;
3572                                            }
3573                                         }
3574                                         msgptr[msglen++] = tp->maxoffs?tp->ic_min_sync:0;
3575                                         msgptr[msglen++] = tp->maxoffs;
3576                                         break;
3577
3578                                 case 1: /* nego. to maximum */
3579                                         msgptr[msglen++] = tp->maxoffs?tp->ic_min_sync:0;
3580                                         msgptr[msglen++] = tp->maxoffs;
3581                                         break;
3582
3583                                 case 0: /* nego to async */
3584                                 default:
3585                                         msgptr[msglen++] = 0;
3586                                         msgptr[msglen++] = 0;
3587                                         break;
3588                                 };
3589                         }
3590                         else
3591                                 cmd->ic_nego_sync = 0;
3592                         break;
3593
3594                 case NS_NOCHANGE:
3595                 default:
3596                         break;
3597                 };
3598         };
3599
3600         cp->nego_status = nego;
3601         np->check_integ_par = 0;
3602
3603         if (nego) {
3604                 tp->nego_cp = cp;
3605                 if (DEBUG_FLAGS & DEBUG_NEGO) {
3606                         ncr_print_msg(cp, nego == NS_WIDE ?
3607                           "wide/narrow msgout": "sync/async msgout", msgptr);
3608                 };
3609         };
3610
3611         return msglen;
3612 }
3613 #endif /* SCSI_NCR_INTEGRITY_CHECKING */
3614
3615 /*==========================================================
3616 **
3617 **
3618 **      Prepare the next negotiation message if needed.
3619 **
3620 **      Fill in the part of message buffer that contains the
3621 **      negotiation and the nego_status field of the CCB.
3622 **      Returns the size of the message in bytes.
3623 **
3624 **
3625 **==========================================================
3626 */
3627
3628
3629 static int ncr_prepare_nego(struct ncb *np, struct ccb *cp, u_char *msgptr)
3630 {
3631         struct tcb *tp = &np->target[cp->target];
3632         int msglen = 0;
3633         int nego = 0;
3634
3635         if (tp->inq_done) {
3636
3637                 /*
3638                 **      negotiate wide transfers ?
3639                 */
3640
3641                 if (!tp->widedone) {
3642                         if (tp->inq_byte7 & INQ7_WIDE16) {
3643                                 nego = NS_WIDE;
3644 #ifdef SCSI_NCR_INTEGRITY_CHECKING
3645                                 if (tp->ic_done)
3646                                          tp->usrwide &= tp->ic_max_width;
3647 #endif
3648                         } else
3649                                 tp->widedone=1;
3650
3651                 };
3652
3653                 /*
3654                 **      negotiate synchronous transfers?
3655                 */
3656
3657                 if (!nego && !tp->period) {
3658                         if (tp->inq_byte7 & INQ7_SYNC) {
3659                                 nego = NS_SYNC;
3660 #ifdef SCSI_NCR_INTEGRITY_CHECKING
3661                                 if ((tp->ic_done) &&
3662                                               (tp->minsync < tp->ic_min_sync))
3663                                          tp->minsync = tp->ic_min_sync;
3664 #endif
3665                         } else {
3666                                 tp->period  =0xffff;
3667                                 PRINT_TARGET(np, cp->target);
3668                                 printk ("target did not report SYNC.\n");
3669                         };
3670                 };
3671         };
3672
3673         switch (nego) {
3674         case NS_SYNC:
3675                 msgptr[msglen++] = M_EXTENDED;
3676                 msgptr[msglen++] = 3;
3677                 msgptr[msglen++] = M_X_SYNC_REQ;
3678                 msgptr[msglen++] = tp->maxoffs ? tp->minsync : 0;
3679                 msgptr[msglen++] = tp->maxoffs;
3680                 break;
3681         case NS_WIDE:
3682                 msgptr[msglen++] = M_EXTENDED;
3683                 msgptr[msglen++] = 2;
3684                 msgptr[msglen++] = M_X_WIDE_REQ;
3685                 msgptr[msglen++] = tp->usrwide;
3686                 break;
3687         };
3688
3689         cp->nego_status = nego;
3690
3691         if (nego) {
3692                 tp->nego_cp = cp;
3693                 if (DEBUG_FLAGS & DEBUG_NEGO) {
3694                         ncr_print_msg(cp, nego == NS_WIDE ?
3695                                           "wide msgout":"sync_msgout", msgptr);
3696                 };
3697         };
3698
3699         return msglen;
3700 }
3701
3702
3703
3704 /*==========================================================
3705 **
3706 **
3707 **      Start execution of a SCSI command.
3708 **      This is called from the generic SCSI driver.
3709 **
3710 **
3711 **==========================================================
3712 */
3713 static int ncr_queue_command (struct ncb *np, struct scsi_cmnd *cmd)
3714 {
3715 /*      struct scsi_device        *device    = cmd->device; */
3716         struct tcb *tp                      = &np->target[cmd->device->id];
3717         struct lcb *lp                = tp->lp[cmd->device->lun];
3718         struct ccb *cp;
3719
3720         int     segments;
3721         u_char  idmsg, *msgptr;
3722         u32     msglen;
3723         int     direction;
3724         u32     lastp, goalp;
3725
3726         /*---------------------------------------------
3727         **
3728         **      Some shortcuts ...
3729         **
3730         **---------------------------------------------
3731         */
3732         if ((cmd->device->id == np->myaddr        ) ||
3733                 (cmd->device->id >= MAX_TARGET) ||
3734                 (cmd->device->lun    >= MAX_LUN   )) {
3735                 return(DID_BAD_TARGET);
3736         }
3737
3738         /*---------------------------------------------
3739         **
3740         **      Complete the 1st TEST UNIT READY command
3741         **      with error condition if the device is
3742         **      flagged NOSCAN, in order to speed up
3743         **      the boot.
3744         **
3745         **---------------------------------------------
3746         */
3747         if ((cmd->cmnd[0] == 0 || cmd->cmnd[0] == 0x12) &&
3748             (tp->usrflag & UF_NOSCAN)) {
3749                 tp->usrflag &= ~UF_NOSCAN;
3750                 return DID_BAD_TARGET;
3751         }
3752
3753         if (DEBUG_FLAGS & DEBUG_TINY) {
3754                 PRINT_ADDR(cmd);
3755                 printk ("CMD=%x ", cmd->cmnd[0]);
3756         }
3757
3758         /*---------------------------------------------------
3759         **
3760         **      Assign a ccb / bind cmd.
3761         **      If resetting, shorten settle_time if necessary
3762         **      in order to avoid spurious timeouts.
3763         **      If resetting or no free ccb,
3764         **      insert cmd into the waiting list.
3765         **
3766         **----------------------------------------------------
3767         */
3768         if (np->settle_time && cmd->timeout_per_command >= HZ) {
3769                 u_long tlimit = ktime_get(cmd->timeout_per_command - HZ);
3770                 if (ktime_dif(np->settle_time, tlimit) > 0)
3771                         np->settle_time = tlimit;
3772         }
3773
3774         if (np->settle_time || !(cp=ncr_get_ccb (np, cmd->device->id, cmd->device->lun))) {
3775                 insert_into_waiting_list(np, cmd);
3776                 return(DID_OK);
3777         }
3778         cp->cmd = cmd;
3779
3780         /*----------------------------------------------------
3781         **
3782         **      Build the identify / tag / sdtr message
3783         **
3784         **----------------------------------------------------
3785         */
3786
3787         idmsg = M_IDENTIFY | cmd->device->lun;
3788
3789         if (cp ->tag != NO_TAG ||
3790                 (cp != np->ccb && np->disc && !(tp->usrflag & UF_NODISC)))
3791                 idmsg |= 0x40;
3792
3793         msgptr = cp->scsi_smsg;
3794         msglen = 0;
3795         msgptr[msglen++] = idmsg;
3796
3797         if (cp->tag != NO_TAG) {
3798                 char order = np->order;
3799
3800                 /*
3801                 **      Force ordered tag if necessary to avoid timeouts
3802                 **      and to preserve interactivity.
3803                 */
3804                 if (lp && ktime_exp(lp->tags_stime)) {
3805                         if (lp->tags_smap) {
3806                                 order = M_ORDERED_TAG;
3807                                 if ((DEBUG_FLAGS & DEBUG_TAGS)||bootverbose>2){
3808                                         PRINT_ADDR(cmd);
3809                                         printk("ordered tag forced.\n");
3810                                 }
3811                         }
3812                         lp->tags_stime = ktime_get(3*HZ);
3813                         lp->tags_smap = lp->tags_umap;
3814                 }
3815
3816                 if (order == 0) {
3817                         /*
3818                         **      Ordered write ops, unordered read ops.
3819                         */
3820                         switch (cmd->cmnd[0]) {
3821                         case 0x08:  /* READ_SMALL (6) */
3822                         case 0x28:  /* READ_BIG  (10) */
3823                         case 0xa8:  /* READ_HUGE (12) */
3824                                 order = M_SIMPLE_TAG;
3825                                 break;
3826                         default:
3827                                 order = M_ORDERED_TAG;
3828                         }
3829                 }
3830                 msgptr[msglen++] = order;
3831                 /*
3832                 **      Actual tags are numbered 1,3,5,..2*MAXTAGS+1,
3833                 **      since we may have to deal with devices that have
3834                 **      problems with #TAG 0 or too great #TAG numbers.
3835                 */
3836                 msgptr[msglen++] = (cp->tag << 1) + 1;
3837         }
3838
3839         /*----------------------------------------------------
3840         **
3841         **      Build the data descriptors
3842         **
3843         **----------------------------------------------------
3844         */
3845
3846         direction = scsi_data_direction(cmd);
3847         if (direction != SCSI_DATA_NONE) {
3848                 segments = ncr_scatter(np, cp, cp->cmd);
3849                 if (segments < 0) {
3850                         ncr_free_ccb(np, cp);
3851                         return(DID_ERROR);
3852                 }
3853         }
3854         else {
3855                 cp->data_len = 0;
3856                 segments = 0;
3857         }
3858
3859         /*---------------------------------------------------
3860         **
3861         **      negotiation required?
3862         **
3863         **      (nego_status is filled by ncr_prepare_nego())
3864         **
3865         **---------------------------------------------------
3866         */
3867
3868         cp->nego_status = 0;
3869
3870 #ifdef SCSI_NCR_INTEGRITY_CHECKING
3871         if ((np->check_integrity && tp->ic_done) || !np->check_integrity) {
3872                  if ((!tp->widedone || !tp->period) && !tp->nego_cp && lp) {
3873                         msglen += ncr_prepare_nego (np, cp, msgptr + msglen);
3874                  }
3875         }
3876         else if (np->check_integrity && (cmd->ic_in_progress)) {
3877                 msglen += ncr_ic_nego (np, cp, cmd, msgptr + msglen);
3878         }
3879         else if (np->check_integrity && cmd->ic_complete) {
3880                 /*
3881                  * Midlayer signal to the driver that all of the scsi commands
3882                  * for the integrity check have completed. Save the negotiated
3883                  * parameters (extracted from sval and wval).
3884                  */
3885
3886                 {
3887                         u_char idiv;
3888                         idiv = (tp->wval>>4) & 0x07;
3889                         if ((tp->sval&0x1f) && idiv )
3890                                 tp->period = (((tp->sval>>5)+4)
3891                                                 *div_10M[idiv-1])/np->clock_khz;
3892                         else
3893                                 tp->period = 0xffff;
3894                 }
3895                 /*
3896                  * tp->period contains 10 times the transfer period,
3897                  * which itself is 4 * the requested negotiation rate.
3898                  */
3899                 if      (tp->period <= 250)     tp->ic_min_sync = 10;
3900                 else if (tp->period <= 303)     tp->ic_min_sync = 11;
3901                 else if (tp->period <= 500)     tp->ic_min_sync = 12;
3902                 else
3903                                 tp->ic_min_sync = (tp->period + 40 - 1) / 40;
3904
3905
3906                 /*
3907                  * Negotiation for this target it complete.
3908                  */
3909                 tp->ic_max_width =  (tp->wval & EWS) ? 1: 0;
3910                 tp->ic_done = 1;
3911                 tp->widedone = 1;
3912
3913                 printk("%s: Integrity Check Complete: \n", ncr_name(np));
3914
3915                 printk("%s: %s %s SCSI", ncr_name(np),
3916                                 (tp->sval&0x1f)?"SYNC":"ASYNC",
3917                                 tp->ic_max_width?"WIDE":"NARROW");
3918
3919                 if (tp->sval&0x1f) {
3920                         u_long mbs = 10000 * (tp->ic_max_width + 1);
3921
3922                         printk(" %d.%d  MB/s", (int) (mbs / tp->period),
3923                                         (int) (mbs % tp->period));
3924
3925                         printk(" (%d ns, %d offset)\n",
3926                                   tp->period/10, tp->sval&0x1f);
3927                 } else {
3928                         printk(" %d MB/s. \n ", (tp->ic_max_width+1)*5);
3929                 }
3930         }
3931 #else
3932         if ((!tp->widedone || !tp->period) && !tp->nego_cp && lp) {
3933                 msglen += ncr_prepare_nego (np, cp, msgptr + msglen);
3934         }
3935 #endif /* SCSI_NCR_INTEGRITY_CHECKING */
3936
3937         /*----------------------------------------------------
3938         **
3939         **      Determine xfer direction.
3940         **
3941         **----------------------------------------------------
3942         */
3943         if (!cp->data_len)
3944                 direction = SCSI_DATA_NONE;
3945
3946         /*
3947         **      If data direction is UNKNOWN, speculate DATA_READ
3948         **      but prepare alternate pointers for WRITE in case
3949         **      of our speculation will be just wrong.
3950         **      SCRIPTS will swap values if needed.
3951         */
3952         switch(direction) {
3953         case SCSI_DATA_UNKNOWN:
3954         case SCSI_DATA_WRITE:
3955                 goalp = NCB_SCRIPT_PHYS (np, data_out2) + 8;
3956                 if (segments <= MAX_SCATTERL)
3957                         lastp = goalp - 8 - (segments * 16);
3958                 else {
3959                         lastp = NCB_SCRIPTH_PHYS (np, hdata_out2);
3960                         lastp -= (segments - MAX_SCATTERL) * 16;
3961                 }
3962                 if (direction != SCSI_DATA_UNKNOWN)
3963                         break;
3964                 cp->phys.header.wgoalp  = cpu_to_scr(goalp);
3965                 cp->phys.header.wlastp  = cpu_to_scr(lastp);
3966                 /* fall through */
3967         case SCSI_DATA_READ:
3968                 goalp = NCB_SCRIPT_PHYS (np, data_in2) + 8;
3969                 if (segments <= MAX_SCATTERL)
3970                         lastp = goalp - 8 - (segments * 16);
3971                 else {
3972                         lastp = NCB_SCRIPTH_PHYS (np, hdata_in2);
3973                         lastp -= (segments - MAX_SCATTERL) * 16;
3974                 }
3975                 break;
3976         default:
3977         case SCSI_DATA_NONE:
3978                 lastp = goalp = NCB_SCRIPT_PHYS (np, no_data);
3979                 break;
3980         }
3981
3982         /*
3983         **      Set all pointers values needed by SCRIPTS.
3984         **      If direction is unknown, start at data_io.
3985         */
3986         cp->phys.header.lastp = cpu_to_scr(lastp);
3987         cp->phys.header.goalp = cpu_to_scr(goalp);
3988
3989         if (direction == SCSI_DATA_UNKNOWN)
3990                 cp->phys.header.savep =
3991                         cpu_to_scr(NCB_SCRIPTH_PHYS (np, data_io));
3992         else
3993                 cp->phys.header.savep= cpu_to_scr(lastp);
3994
3995         /*
3996         **      Save the initial data pointer in order to be able
3997         **      to redo the command.
3998         */
3999         cp->startp = cp->phys.header.savep;
4000
4001         /*----------------------------------------------------
4002         **
4003         **      fill in ccb
4004         **
4005         **----------------------------------------------------
4006         **
4007         **
4008         **      physical -> virtual backlink
4009         **      Generic SCSI command
4010         */
4011
4012         /*
4013         **      Startqueue
4014         */
4015         cp->start.schedule.l_paddr   = cpu_to_scr(NCB_SCRIPT_PHYS (np, select));
4016         cp->restart.schedule.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_dsa));
4017         /*
4018         **      select
4019         */
4020         cp->phys.select.sel_id          = cmd->device->id;
4021         cp->phys.select.sel_scntl3      = tp->wval;
4022         cp->phys.select.sel_sxfer       = tp->sval;
4023         /*
4024         **      message
4025         */
4026         cp->phys.smsg.addr              = cpu_to_scr(CCB_PHYS (cp, scsi_smsg));
4027         cp->phys.smsg.size              = cpu_to_scr(msglen);
4028
4029         /*
4030         **      command
4031         */
4032         memcpy(cp->cdb_buf, cmd->cmnd, min_t(int, cmd->cmd_len, sizeof(cp->cdb_buf)));
4033         cp->phys.cmd.addr               = cpu_to_scr(CCB_PHYS (cp, cdb_buf[0]));
4034         cp->phys.cmd.size               = cpu_to_scr(cmd->cmd_len);
4035
4036         /*
4037         **      status
4038         */
4039         cp->actualquirks                = tp->quirks;
4040         cp->host_status                 = cp->nego_status ? HS_NEGOTIATE : HS_BUSY;
4041         cp->scsi_status                 = S_ILLEGAL;
4042         cp->parity_status               = 0;
4043
4044         cp->xerr_status                 = XE_OK;
4045 #if 0
4046         cp->sync_status                 = tp->sval;
4047         cp->wide_status                 = tp->wval;
4048 #endif
4049
4050         /*----------------------------------------------------
4051         **
4052         **      Critical region: start this job.
4053         **
4054         **----------------------------------------------------
4055         */
4056
4057         /*
4058         **      activate this job.
4059         */
4060         cp->magic               = CCB_MAGIC;
4061
4062         /*
4063         **      insert next CCBs into start queue.
4064         **      2 max at a time is enough to flush the CCB wait queue.
4065         */
4066         cp->auto_sense = 0;
4067         if (lp)
4068                 ncr_start_next_ccb(np, lp, 2);
4069         else
4070                 ncr_put_start_queue(np, cp);
4071
4072         /*
4073         **      Command is successfully queued.
4074         */
4075
4076         return(DID_OK);
4077 }
4078
4079
4080 /*==========================================================
4081 **
4082 **
4083 **      Insert a CCB into the start queue and wake up the
4084 **      SCRIPTS processor.
4085 **
4086 **
4087 **==========================================================
4088 */
4089
4090 static void ncr_start_next_ccb(struct ncb *np, struct lcb *lp, int maxn)
4091 {
4092         XPT_QUEHEAD *qp;
4093         struct ccb *cp;
4094
4095         if (lp->held_ccb)
4096                 return;
4097
4098         while (maxn-- && lp->queuedccbs < lp->queuedepth) {
4099                 qp = xpt_remque_head(&lp->wait_ccbq);
4100                 if (!qp)
4101                         break;
4102                 ++lp->queuedccbs;
4103                 cp = xpt_que_entry(qp, struct ccb, link_ccbq);
4104                 xpt_insque_tail(qp, &lp->busy_ccbq);
4105                 lp->jump_ccb[cp->tag == NO_TAG ? 0 : cp->tag] =
4106                         cpu_to_scr(CCB_PHYS (cp, restart));
4107                 ncr_put_start_queue(np, cp);
4108         }
4109 }
4110
4111 static void ncr_put_start_queue(struct ncb *np, struct ccb *cp)
4112 {
4113         u16     qidx;
4114
4115         /*
4116         **      insert into start queue.
4117         */
4118         if (!np->squeueput) np->squeueput = 1;
4119         qidx = np->squeueput + 2;
4120         if (qidx >= MAX_START + MAX_START) qidx = 1;
4121
4122         np->scripth->tryloop [qidx] = cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
4123         MEMORY_BARRIER();
4124         np->scripth->tryloop [np->squeueput] = cpu_to_scr(CCB_PHYS (cp, start));
4125
4126         np->squeueput = qidx;
4127         ++np->queuedccbs;
4128         cp->queued = 1;
4129
4130         if (DEBUG_FLAGS & DEBUG_QUEUE)
4131                 printk ("%s: queuepos=%d.\n", ncr_name (np), np->squeueput);
4132
4133         /*
4134         **      Script processor may be waiting for reselect.
4135         **      Wake it up.
4136         */
4137         MEMORY_BARRIER();
4138         OUTB (nc_istat, SIGP);
4139 }
4140
4141
4142 static int ncr_reset_scsi_bus(struct ncb *np, int enab_int, int settle_delay)
4143 {
4144         u32 term;
4145         int retv = 0;
4146
4147         np->settle_time = ktime_get(settle_delay * HZ);
4148
4149         if (bootverbose > 1)
4150                 printk("%s: resetting, "
4151                         "command processing suspended for %d seconds\n",
4152                         ncr_name(np), settle_delay);
4153
4154         ncr_chip_reset(np, 100);
4155         UDELAY (2000);  /* The 895 needs time for the bus mode to settle */
4156         if (enab_int)
4157                 OUTW (nc_sien, RST);
4158         /*
4159         **      Enable Tolerant, reset IRQD if present and
4160         **      properly set IRQ mode, prior to resetting the bus.
4161         */
4162         OUTB (nc_stest3, TE);
4163         OUTB (nc_scntl1, CRST);
4164         UDELAY (200);
4165
4166         if (!driver_setup.bus_check)
4167                 goto out;
4168         /*
4169         **      Check for no terminators or SCSI bus shorts to ground.
4170         **      Read SCSI data bus, data parity bits and control signals.
4171         **      We are expecting RESET to be TRUE and other signals to be
4172         **      FALSE.
4173         */
4174
4175         term =  INB(nc_sstat0);
4176         term =  ((term & 2) << 7) + ((term & 1) << 17); /* rst sdp0 */
4177         term |= ((INB(nc_sstat2) & 0x01) << 26) |       /* sdp1     */
4178                 ((INW(nc_sbdl) & 0xff)   << 9)  |       /* d7-0     */
4179                 ((INW(nc_sbdl) & 0xff00) << 10) |       /* d15-8    */
4180                 INB(nc_sbcl);   /* req ack bsy sel atn msg cd io    */
4181
4182         if (!(np->features & FE_WIDE))
4183                 term &= 0x3ffff;
4184
4185         if (term != (2<<7)) {
4186                 printk("%s: suspicious SCSI data while resetting the BUS.\n",
4187                         ncr_name(np));
4188                 printk("%s: %sdp0,d7-0,rst,req,ack,bsy,sel,atn,msg,c/d,i/o = "
4189                         "0x%lx, expecting 0x%lx\n",
4190                         ncr_name(np),
4191                         (np->features & FE_WIDE) ? "dp1,d15-8," : "",
4192                         (u_long)term, (u_long)(2<<7));
4193                 if (driver_setup.bus_check == 1)
4194                         retv = 1;
4195         }
4196 out:
4197         OUTB (nc_scntl1, 0);
4198         return retv;
4199 }
4200
4201 /*
4202  * Start reset process.
4203  * If reset in progress do nothing.
4204  * The interrupt handler will reinitialize the chip.
4205  * The timeout handler will wait for settle_time before
4206  * clearing it and so resuming command processing.
4207  */
4208 static void ncr_start_reset(struct ncb *np)
4209 {
4210         if (!np->settle_time) {
4211                 ncr_reset_scsi_bus(np, 1, driver_setup.settle_delay);
4212         }
4213 }
4214
4215 /*==========================================================
4216 **
4217 **
4218 **      Reset the SCSI BUS.
4219 **      This is called from the generic SCSI driver.
4220 **
4221 **
4222 **==========================================================
4223 */
4224 static int ncr_reset_bus (struct ncb *np, struct scsi_cmnd *cmd, int sync_reset)
4225 {
4226 /*      struct scsi_device        *device    = cmd->device; */
4227         struct ccb *cp;
4228         int found;
4229
4230 /*
4231  * Return immediately if reset is in progress.
4232  */
4233         if (np->settle_time) {
4234                 return FAILED;
4235         }
4236 /*
4237  * Start the reset process.
4238  * The script processor is then assumed to be stopped.
4239  * Commands will now be queued in the waiting list until a settle
4240  * delay of 2 seconds will be completed.
4241  */
4242         ncr_start_reset(np);
4243 /*
4244  * First, look in the wakeup list
4245  */
4246         for (found=0, cp=np->ccb; cp; cp=cp->link_ccb) {
4247                 /*
4248                 **      look for the ccb of this command.
4249                 */
4250                 if (cp->host_status == HS_IDLE) continue;
4251                 if (cp->cmd == cmd) {
4252                         found = 1;
4253                         break;
4254                 }
4255         }
4256 /*
4257  * Then, look in the waiting list
4258  */
4259         if (!found && retrieve_from_waiting_list(0, np, cmd))
4260                 found = 1;
4261 /*
4262  * Wake-up all awaiting commands with DID_RESET.
4263  */
4264         reset_waiting_list(np);
4265 /*
4266  * Wake-up all pending commands with HS_RESET -> DID_RESET.
4267  */
4268         ncr_wakeup(np, HS_RESET);
4269 /*
4270  * If the involved command was not in a driver queue, and the
4271  * scsi driver told us reset is synchronous, and the command is not
4272  * currently in the waiting list, complete it with DID_RESET status,
4273  * in order to keep it alive.
4274  */
4275         if (!found && sync_reset && !retrieve_from_waiting_list(0, np, cmd)) {
4276                 cmd->result = ScsiResult(DID_RESET, 0);
4277                 ncr_queue_done_cmd(np, cmd);
4278         }
4279
4280         return SUCCESS;
4281 }
4282
4283 /*==========================================================
4284 **
4285 **
4286 **      Abort an SCSI command.
4287 **      This is called from the generic SCSI driver.
4288 **
4289 **
4290 **==========================================================
4291 */
4292 static int ncr_abort_command (struct ncb *np, struct scsi_cmnd *cmd)
4293 {
4294 /*      struct scsi_device        *device    = cmd->device; */
4295         struct ccb *cp;
4296         int found;
4297         int retv;
4298
4299 /*
4300  * First, look for the scsi command in the waiting list
4301  */
4302         if (remove_from_waiting_list(np, cmd)) {
4303                 cmd->result = ScsiResult(DID_ABORT, 0);
4304                 ncr_queue_done_cmd(np, cmd);
4305                 return SCSI_ABORT_SUCCESS;
4306         }
4307
4308 /*
4309  * Then, look in the wakeup list
4310  */
4311         for (found=0, cp=np->ccb; cp; cp=cp->link_ccb) {
4312                 /*
4313                 **      look for the ccb of this command.
4314                 */
4315                 if (cp->host_status == HS_IDLE) continue;
4316                 if (cp->cmd == cmd) {
4317                         found = 1;
4318                         break;
4319                 }
4320         }
4321
4322         if (!found) {
4323                 return SCSI_ABORT_NOT_RUNNING;
4324         }
4325
4326         if (np->settle_time) {
4327                 return SCSI_ABORT_SNOOZE;
4328         }
4329
4330         /*
4331         **      If the CCB is active, patch schedule jumps for the
4332         **      script to abort the command.
4333         */
4334
4335         switch(cp->host_status) {
4336         case HS_BUSY:
4337         case HS_NEGOTIATE:
4338                 printk ("%s: abort ccb=%p (cancel)\n", ncr_name (np), cp);
4339                         cp->start.schedule.l_paddr =
4340                                 cpu_to_scr(NCB_SCRIPTH_PHYS (np, cancel));
4341                 retv = SCSI_ABORT_PENDING;
4342                 break;
4343         case HS_DISCONNECT:
4344                 cp->restart.schedule.l_paddr =
4345                                 cpu_to_scr(NCB_SCRIPTH_PHYS (np, abort));
4346                 retv = SCSI_ABORT_PENDING;
4347                 break;
4348         default:
4349                 retv = SCSI_ABORT_NOT_RUNNING;
4350                 break;
4351
4352         }
4353
4354         /*
4355         **      If there are no requests, the script
4356         **      processor will sleep on SEL_WAIT_RESEL.
4357         **      Let's wake it up, since it may have to work.
4358         */
4359         OUTB (nc_istat, SIGP);
4360
4361         return retv;
4362 }
4363
4364 /*==========================================================
4365 **
4366 **      Linux release module stuff.
4367 **
4368 **      Called before unloading the module
4369 **      Detach the host.
4370 **      We have to free resources and halt the NCR chip
4371 **
4372 **==========================================================
4373 */
4374
4375 static void ncr_detach(struct ncb *np)
4376 {
4377         struct ccb *cp;
4378         struct tcb *tp;
4379         struct lcb *lp;
4380         int target, lun;
4381         int i;
4382         char inst_name[16];
4383
4384         /* Local copy so we don't access np after freeing it! */
4385         strlcpy(inst_name, ncr_name(np), sizeof(inst_name));
4386
4387         printk("%s: releasing host resources\n", ncr_name(np));
4388
4389 /*
4390 **      Stop the ncr_timeout process
4391 **      Set release_stage to 1 and wait that ncr_timeout() set it to 2.
4392 */
4393
4394 #ifdef DEBUG_NCR53C8XX
4395         printk("%s: stopping the timer\n", ncr_name(np));
4396 #endif
4397         np->release_stage = 1;
4398         for (i = 50 ; i && np->release_stage != 2 ; i--) MDELAY (100);
4399         if (np->release_stage != 2)
4400                 printk("%s: the timer seems to be already stopped\n", ncr_name(np));
4401         else np->release_stage = 2;
4402
4403 /*
4404 **      Disable chip interrupts
4405 */
4406
4407 #ifdef DEBUG_NCR53C8XX
4408         printk("%s: disabling chip interrupts\n", ncr_name(np));
4409 #endif
4410         OUTW (nc_sien , 0);
4411         OUTB (nc_dien , 0);
4412
4413         /*
4414         **      Reset NCR chip
4415         **      Restore bios setting for automatic clock detection.
4416         */
4417
4418         printk("%s: resetting chip\n", ncr_name(np));
4419         ncr_chip_reset(np, 100);
4420
4421         OUTB(nc_dmode,  np->sv_dmode);
4422         OUTB(nc_dcntl,  np->sv_dcntl);
4423         OUTB(nc_ctest0, np->sv_ctest0);
4424         OUTB(nc_ctest3, np->sv_ctest3);
4425         OUTB(nc_ctest4, np->sv_ctest4);
4426         OUTB(nc_ctest5, np->sv_ctest5);
4427         OUTB(nc_gpcntl, np->sv_gpcntl);
4428         OUTB(nc_stest2, np->sv_stest2);
4429
4430         ncr_selectclock(np, np->sv_scntl3);
4431
4432         /*
4433         **      Free allocated ccb(s)
4434         */
4435
4436         while ((cp=np->ccb->link_ccb) != NULL) {
4437                 np->ccb->link_ccb = cp->link_ccb;
4438                 if (cp->host_status) {
4439                 printk("%s: shall free an active ccb (host_status=%d)\n",
4440                         ncr_name(np), cp->host_status);
4441                 }
4442 #ifdef DEBUG_NCR53C8XX
4443         printk("%s: freeing ccb (%lx)\n", ncr_name(np), (u_long) cp);
4444 #endif
4445                 m_free_dma(cp, sizeof(*cp), "CCB");
4446         }
4447
4448         /* Free allocated tp(s) */
4449
4450         for (target = 0; target < MAX_TARGET ; target++) {
4451                 tp=&np->target[target];
4452                 for (lun = 0 ; lun < MAX_LUN ; lun++) {
4453                         lp = tp->lp[lun];
4454                         if (lp) {
4455 #ifdef DEBUG_NCR53C8XX
4456         printk("%s: freeing lp (%lx)\n", ncr_name(np), (u_long) lp);
4457 #endif
4458                                 if (lp->jump_ccb != &lp->jump_ccb_0)
4459                                         m_free_dma(lp->jump_ccb,256,"JUMP_CCB");
4460                                 m_free_dma(lp, sizeof(*lp), "LCB");
4461                         }
4462                 }
4463         }
4464
4465         if (np->scripth0)
4466                 m_free_dma(np->scripth0, sizeof(struct scripth), "SCRIPTH");
4467         if (np->script0)
4468                 m_free_dma(np->script0, sizeof(struct script), "SCRIPT");
4469         if (np->ccb)
4470                 m_free_dma(np->ccb, sizeof(struct ccb), "CCB");
4471         m_free_dma(np, sizeof(struct ncb), "NCB");
4472
4473         printk("%s: host resources successfully released\n", inst_name);
4474 }
4475
4476 /*==========================================================
4477 **
4478 **
4479 **      Complete execution of a SCSI command.
4480 **      Signal completion to the generic SCSI driver.
4481 **
4482 **
4483 **==========================================================
4484 */
4485
4486 void ncr_complete (struct ncb *np, struct ccb *cp)
4487 {
4488         struct scsi_cmnd *cmd;
4489         struct tcb *tp;
4490         struct lcb *lp;
4491
4492         /*
4493         **      Sanity check
4494         */
4495
4496         if (!cp || cp->magic != CCB_MAGIC || !cp->cmd)
4497                 return;
4498
4499         /*
4500         **      Print minimal debug information.
4501         */
4502
4503         if (DEBUG_FLAGS & DEBUG_TINY)
4504                 printk ("CCB=%lx STAT=%x/%x\n", (unsigned long)cp,
4505                         cp->host_status,cp->scsi_status);
4506
4507         /*
4508         **      Get command, target and lun pointers.
4509         */
4510
4511         cmd = cp->cmd;
4512         cp->cmd = NULL;
4513         tp = &np->target[cmd->device->id];
4514         lp = tp->lp[cmd->device->lun];
4515
4516         /*
4517         **      We donnot queue more than 1 ccb per target
4518         **      with negotiation at any time. If this ccb was
4519         **      used for negotiation, clear this info in the tcb.
4520         */
4521
4522         if (cp == tp->nego_cp)
4523                 tp->nego_cp = NULL;
4524
4525         /*
4526         **      If auto-sense performed, change scsi status.
4527         */
4528         if (cp->auto_sense) {
4529                 cp->scsi_status = cp->auto_sense;
4530         }
4531
4532         /*
4533         **      If we were recovering from queue full or performing
4534         **      auto-sense, requeue skipped CCBs to the wait queue.
4535         */
4536
4537         if (lp && lp->held_ccb) {
4538                 if (cp == lp->held_ccb) {
4539                         xpt_que_splice(&lp->skip_ccbq, &lp->wait_ccbq);
4540                         xpt_que_init(&lp->skip_ccbq);
4541                         lp->held_ccb = NULL;
4542                 }
4543         }
4544
4545         /*
4546         **      Check for parity errors.
4547         */
4548
4549         if (cp->parity_status > 1) {
4550                 PRINT_ADDR(cmd);
4551                 printk ("%d parity error(s).\n",cp->parity_status);
4552         }
4553
4554         /*
4555         **      Check for extended errors.
4556         */
4557
4558         if (cp->xerr_status != XE_OK) {
4559                 PRINT_ADDR(cmd);
4560                 switch (cp->xerr_status) {
4561                 case XE_EXTRA_DATA:
4562                         printk ("extraneous data discarded.\n");
4563                         break;
4564                 case XE_BAD_PHASE:
4565                         printk ("invalid scsi phase (4/5).\n");
4566                         break;
4567                 default:
4568                         printk ("extended error %d.\n", cp->xerr_status);
4569                         break;
4570                 }
4571                 if (cp->host_status==HS_COMPLETE)
4572                         cp->host_status = HS_FAIL;
4573         }
4574
4575         /*
4576         **      Print out any error for debugging purpose.
4577         */
4578         if (DEBUG_FLAGS & (DEBUG_RESULT|DEBUG_TINY)) {
4579                 if (cp->host_status!=HS_COMPLETE || cp->scsi_status!=S_GOOD) {
4580                         PRINT_ADDR(cmd);
4581                         printk ("ERROR: cmd=%x host_status=%x scsi_status=%x\n",
4582                                 cmd->cmnd[0], cp->host_status, cp->scsi_status);
4583                 }
4584         }
4585
4586         /*
4587         **      Check the status.
4588         */
4589         if (   (cp->host_status == HS_COMPLETE)
4590                 && (cp->scsi_status == S_GOOD ||
4591                     cp->scsi_status == S_COND_MET)) {
4592                 /*
4593                  *      All went well (GOOD status).
4594                  *      CONDITION MET status is returned on
4595                  *      `Pre-Fetch' or `Search data' success.
4596                  */
4597                 cmd->result = ScsiResult(DID_OK, cp->scsi_status);
4598
4599                 /*
4600                 **      @RESID@
4601                 **      Could dig out the correct value for resid,
4602                 **      but it would be quite complicated.
4603                 */
4604                 /* if (cp->phys.header.lastp != cp->phys.header.goalp) */
4605
4606                 /*
4607                 **      Allocate the lcb if not yet.
4608                 */
4609                 if (!lp)
4610                         ncr_alloc_lcb (np, cmd->device->id, cmd->device->lun);
4611
4612                 /*
4613                 **      On standard INQUIRY response (EVPD and CmDt
4614                 **      not set), setup logical unit according to
4615                 **      announced capabilities (we need the 1rst 7 bytes).
4616                 */
4617                 if (cmd->cmnd[0] == 0x12 && !(cmd->cmnd[1] & 0x3) &&
4618                     cmd->cmnd[4] >= 7 && !cmd->use_sg) {
4619                         sync_scsi_data_for_cpu(np, cmd);        /* SYNC the data */
4620                         ncr_setup_lcb (np, cmd->device->id, cmd->device->lun,
4621                                        (char *) cmd->request_buffer);
4622                         sync_scsi_data_for_device(np, cmd);     /* SYNC the data */
4623                 }
4624
4625                 tp->bytes     += cp->data_len;
4626                 tp->transfers ++;
4627
4628                 /*
4629                 **      If tags was reduced due to queue full,
4630                 **      increase tags if 1000 good status received.
4631                 */
4632                 if (lp && lp->usetags && lp->numtags < lp->maxtags) {
4633                         ++lp->num_good;
4634                         if (lp->num_good >= 1000) {
4635                                 lp->num_good = 0;
4636                                 ++lp->numtags;
4637                                 ncr_setup_tags (np, cmd->device->id, cmd->device->lun);
4638                         }
4639                 }
4640         } else if ((cp->host_status == HS_COMPLETE)
4641                 && (cp->scsi_status == S_CHECK_COND)) {
4642                 /*
4643                 **   Check condition code
4644                 */
4645                 cmd->result = ScsiResult(DID_OK, S_CHECK_COND);
4646
4647                 /*
4648                 **      Copy back sense data to caller's buffer.
4649                 */
4650                 memcpy(cmd->sense_buffer, cp->sense_buf,
4651                        min(sizeof(cmd->sense_buffer), sizeof(cp->sense_buf)));
4652
4653                 if (DEBUG_FLAGS & (DEBUG_RESULT|DEBUG_TINY)) {
4654                         u_char * p = (u_char*) & cmd->sense_buffer;
4655                         int i;
4656                         PRINT_ADDR(cmd);
4657                         printk ("sense data:");
4658                         for (i=0; i<14; i++) printk (" %x", *p++);
4659                         printk (".\n");
4660                 }
4661         } else if ((cp->host_status == HS_COMPLETE)
4662                 && (cp->scsi_status == S_CONFLICT)) {
4663                 /*
4664                 **   Reservation Conflict condition code
4665                 */
4666                 cmd->result = ScsiResult(DID_OK, S_CONFLICT);
4667
4668         } else if ((cp->host_status == HS_COMPLETE)
4669                 && (cp->scsi_status == S_BUSY ||
4670                     cp->scsi_status == S_QUEUE_FULL)) {
4671
4672                 /*
4673                 **   Target is busy.
4674                 */
4675                 cmd->result = ScsiResult(DID_OK, cp->scsi_status);
4676
4677         } else if ((cp->host_status == HS_SEL_TIMEOUT)
4678                 || (cp->host_status == HS_TIMEOUT)) {
4679
4680                 /*
4681                 **   No response
4682                 */
4683                 cmd->result = ScsiResult(DID_TIME_OUT, cp->scsi_status);
4684
4685         } else if (cp->host_status == HS_RESET) {
4686
4687                 /*
4688                 **   SCSI bus reset
4689                 */
4690                 cmd->result = ScsiResult(DID_RESET, cp->scsi_status);
4691
4692         } else if (cp->host_status == HS_ABORTED) {
4693
4694                 /*
4695                 **   Transfer aborted
4696                 */
4697                 cmd->result = ScsiResult(DID_ABORT, cp->scsi_status);
4698
4699         } else {
4700
4701                 /*
4702                 **  Other protocol messes
4703                 */
4704                 PRINT_ADDR(cmd);
4705                 printk ("COMMAND FAILED (%x %x) @%p.\n",
4706                         cp->host_status, cp->scsi_status, cp);
4707
4708                 cmd->result = ScsiResult(DID_ERROR, cp->scsi_status);
4709         }
4710
4711         /*
4712         **      trace output
4713         */
4714
4715         if (tp->usrflag & UF_TRACE) {
4716                 u_char * p;
4717                 int i;
4718                 PRINT_ADDR(cmd);
4719                 printk (" CMD:");
4720                 p = (u_char*) &cmd->cmnd[0];
4721                 for (i=0; i<cmd->cmd_len; i++) printk (" %x", *p++);
4722
4723                 if (cp->host_status==HS_COMPLETE) {
4724                         switch (cp->scsi_status) {
4725                         case S_GOOD:
4726                                 printk ("  GOOD");
4727                                 break;
4728                         case S_CHECK_COND:
4729                                 printk ("  SENSE:");
4730                                 p = (u_char*) &cmd->sense_buffer;
4731                                 for (i=0; i<14; i++)
4732                                         printk (" %x", *p++);
4733                                 break;
4734                         default:
4735                                 printk ("  STAT: %x\n", cp->scsi_status);
4736                                 break;
4737                         }
4738                 } else printk ("  HOSTERROR: %x", cp->host_status);
4739                 printk ("\n");
4740         }
4741
4742         /*
4743         **      Free this ccb
4744         */
4745         ncr_free_ccb (np, cp);
4746
4747         /*
4748         **      requeue awaiting scsi commands for this lun.
4749         */
4750         if (lp && lp->queuedccbs < lp->queuedepth &&
4751             !xpt_que_empty(&lp->wait_ccbq))
4752                 ncr_start_next_ccb(np, lp, 2);
4753
4754         /*
4755         **      requeue awaiting scsi commands for this controller.
4756         */
4757         if (np->waiting_list)
4758                 requeue_waiting_list(np);
4759
4760         /*
4761         **      signal completion to generic driver.
4762         */
4763         ncr_queue_done_cmd(np, cmd);
4764 }
4765
4766 /*==========================================================
4767 **
4768 **
4769 **      Signal all (or one) control block done.
4770 **
4771 **
4772 **==========================================================
4773 */
4774
4775 /*
4776 **      This CCB has been skipped by the NCR.
4777 **      Queue it in the correponding unit queue.
4778 */
4779 static void ncr_ccb_skipped(struct ncb *np, struct ccb *cp)
4780 {
4781         struct tcb *tp = &np->target[cp->target];
4782         struct lcb *lp = tp->lp[cp->lun];
4783
4784         if (lp && cp != np->ccb) {
4785                 cp->host_status &= ~HS_SKIPMASK;
4786                 cp->start.schedule.l_paddr =
4787                         cpu_to_scr(NCB_SCRIPT_PHYS (np, select));
4788                 xpt_remque(&cp->link_ccbq);
4789                 xpt_insque_tail(&cp->link_ccbq, &lp->skip_ccbq);
4790                 if (cp->queued) {
4791                         --lp->queuedccbs;
4792                 }
4793         }
4794         if (cp->queued) {
4795                 --np->queuedccbs;
4796                 cp->queued = 0;
4797         }
4798 }
4799
4800 /*
4801 **      The NCR has completed CCBs.
4802 **      Look at the DONE QUEUE if enabled, otherwise scan all CCBs
4803 */
4804 void ncr_wakeup_done (struct ncb *np)
4805 {
4806         struct ccb *cp;
4807 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
4808         int i, j;
4809
4810         i = np->ccb_done_ic;
4811         while (1) {
4812                 j = i+1;
4813                 if (j >= MAX_DONE)
4814                         j = 0;
4815
4816                 cp = np->ccb_done[j];
4817                 if (!CCB_DONE_VALID(cp))
4818                         break;
4819
4820                 np->ccb_done[j] = (struct ccb *)CCB_DONE_EMPTY;
4821                 np->scripth->done_queue[5*j + 4] =
4822                                 cpu_to_scr(NCB_SCRIPT_PHYS (np, done_plug));
4823                 MEMORY_BARRIER();
4824                 np->scripth->done_queue[5*i + 4] =
4825                                 cpu_to_scr(NCB_SCRIPT_PHYS (np, done_end));
4826
4827                 if (cp->host_status & HS_DONEMASK)
4828                         ncr_complete (np, cp);
4829                 else if (cp->host_status & HS_SKIPMASK)
4830                         ncr_ccb_skipped (np, cp);
4831
4832                 i = j;
4833         }
4834         np->ccb_done_ic = i;
4835 #else
4836         cp = np->ccb;
4837         while (cp) {
4838                 if (cp->host_status & HS_DONEMASK)
4839                         ncr_complete (np, cp);
4840                 else if (cp->host_status & HS_SKIPMASK)
4841                         ncr_ccb_skipped (np, cp);
4842                 cp = cp->link_ccb;
4843         }
4844 #endif
4845 }
4846
4847 /*
4848 **      Complete all active CCBs.
4849 */
4850 void ncr_wakeup (struct ncb *np, u_long code)
4851 {
4852         struct ccb *cp = np->ccb;
4853
4854         while (cp) {
4855                 if (cp->host_status != HS_IDLE) {
4856                         cp->host_status = code;
4857                         ncr_complete (np, cp);
4858                 }
4859                 cp = cp->link_ccb;
4860         }
4861 }
4862
4863 /*
4864 ** Reset ncr chip.
4865 */
4866
4867 /* Some initialisation must be done immediately following reset, for 53c720,
4868  * at least.  EA (dcntl bit 5) isn't set here as it is set once only in
4869  * the _detect function.
4870  */
4871 static void ncr_chip_reset(struct ncb *np, int delay)
4872 {
4873         OUTB (nc_istat,  SRST);
4874         UDELAY (delay);
4875         OUTB (nc_istat,  0   );
4876
4877         if (np->features & FE_EHP)
4878                 OUTB (nc_ctest0, EHP);
4879         if (np->features & FE_MUX)
4880                 OUTB (nc_ctest4, MUX);
4881 }
4882
4883
4884 /*==========================================================
4885 **
4886 **
4887 **      Start NCR chip.
4888 **
4889 **
4890 **==========================================================
4891 */
4892
4893 void ncr_init (struct ncb *np, int reset, char * msg, u_long code)
4894 {
4895         int     i;
4896
4897         /*
4898         **      Reset chip if asked, otherwise just clear fifos.
4899         */
4900
4901         if (reset) {
4902                 OUTB (nc_istat,  SRST);
4903                 UDELAY (100);
4904         }
4905         else {
4906                 OUTB (nc_stest3, TE|CSF);
4907                 OUTONB (nc_ctest3, CLF);
4908         }
4909
4910         /*
4911         **      Message.
4912         */
4913
4914         if (msg) printk (KERN_INFO "%s: restart (%s).\n", ncr_name (np), msg);
4915
4916         /*
4917         **      Clear Start Queue
4918         */
4919         np->queuedepth = MAX_START - 1; /* 1 entry needed as end marker */
4920         for (i = 1; i < MAX_START + MAX_START; i += 2)
4921                 np->scripth0->tryloop[i] =
4922                                 cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
4923
4924         /*
4925         **      Start at first entry.
4926         */
4927         np->squeueput = 0;
4928         np->script0->startpos[0] = cpu_to_scr(NCB_SCRIPTH_PHYS (np, tryloop));
4929
4930 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
4931         /*
4932         **      Clear Done Queue
4933         */
4934         for (i = 0; i < MAX_DONE; i++) {
4935                 np->ccb_done[i] = (struct ccb *)CCB_DONE_EMPTY;
4936                 np->scripth0->done_queue[5*i + 4] =
4937                         cpu_to_scr(NCB_SCRIPT_PHYS (np, done_end));
4938         }
4939 #endif
4940
4941         /*
4942         **      Start at first entry.
4943         */
4944         np->script0->done_pos[0] = cpu_to_scr(NCB_SCRIPTH_PHYS (np,done_queue));
4945         np->ccb_done_ic = MAX_DONE-1;
4946         np->scripth0->done_queue[5*(MAX_DONE-1) + 4] =
4947                         cpu_to_scr(NCB_SCRIPT_PHYS (np, done_plug));
4948
4949         /*
4950         **      Wakeup all pending jobs.
4951         */
4952         ncr_wakeup (np, code);
4953
4954         /*
4955         **      Init chip.
4956         */
4957
4958         /*
4959         ** Remove reset; big delay because the 895 needs time for the
4960         ** bus mode to settle
4961         */
4962         ncr_chip_reset(np, 2000);
4963
4964         OUTB (nc_scntl0, np->rv_scntl0 | 0xc0);
4965                                         /*  full arb., ena parity, par->ATN  */
4966         OUTB (nc_scntl1, 0x00);         /*  odd parity, and remove CRST!! */
4967
4968         ncr_selectclock(np, np->rv_scntl3);     /* Select SCSI clock */
4969
4970         OUTB (nc_scid  , RRE|np->myaddr);       /* Adapter SCSI address */
4971         OUTW (nc_respid, 1ul<<np->myaddr);      /* Id to respond to */
4972         OUTB (nc_istat , SIGP   );              /*  Signal Process */
4973         OUTB (nc_dmode , np->rv_dmode);         /* Burst length, dma mode */
4974         OUTB (nc_ctest5, np->rv_ctest5);        /* Large fifo + large burst */
4975
4976         OUTB (nc_dcntl , NOCOM|np->rv_dcntl);   /* Protect SFBR */
4977         OUTB (nc_ctest0, np->rv_ctest0);        /* 720: CDIS and EHP */
4978         OUTB (nc_ctest3, np->rv_ctest3);        /* Write and invalidate */
4979         OUTB (nc_ctest4, np->rv_ctest4);        /* Master parity checking */
4980
4981         OUTB (nc_stest2, EXT|np->rv_stest2);    /* Extended Sreq/Sack filtering */
4982         OUTB (nc_stest3, TE);                   /* TolerANT enable */
4983         OUTB (nc_stime0, 0x0c   );              /* HTH disabled  STO 0.25 sec */
4984
4985         /*
4986         **      Disable disconnects.
4987         */
4988
4989         np->disc = 0;
4990
4991         /*
4992         **    Enable GPIO0 pin for writing if LED support.
4993         */
4994
4995         if (np->features & FE_LED0) {
4996                 OUTOFFB (nc_gpcntl, 0x01);
4997         }
4998
4999         /*
5000         **      enable ints
5001         */
5002
5003         OUTW (nc_sien , STO|HTH|MA|SGE|UDC|RST|PAR);
5004         OUTB (nc_dien , MDPE|BF|ABRT|SSI|SIR|IID);
5005
5006         /*
5007         **      Fill in target structure.
5008         **      Reinitialize usrsync.
5009         **      Reinitialize usrwide.
5010         **      Prepare sync negotiation according to actual SCSI bus mode.
5011         */
5012
5013         for (i=0;i<MAX_TARGET;i++) {
5014                 struct tcb *tp = &np->target[i];
5015
5016                 tp->sval    = 0;
5017                 tp->wval    = np->rv_scntl3;
5018
5019                 if (tp->usrsync != 255) {
5020                         if (tp->usrsync <= np->maxsync) {
5021                                 if (tp->usrsync < np->minsync) {
5022                                         tp->usrsync = np->minsync;
5023                                 }
5024                         }
5025                         else
5026                                 tp->usrsync = 255;
5027                 };
5028
5029                 if (tp->usrwide > np->maxwide)
5030                         tp->usrwide = np->maxwide;
5031
5032                 ncr_negotiate (np, tp);
5033         }
5034
5035         /*
5036         **    Start script processor.
5037         */
5038         if (np->paddr2) {
5039                 if (bootverbose)
5040                         printk ("%s: Downloading SCSI SCRIPTS.\n",
5041                                 ncr_name(np));
5042                 OUTL (nc_scratcha, vtobus(np->script0));
5043                 OUTL_DSP (NCB_SCRIPTH_PHYS (np, start_ram));
5044         }
5045         else
5046                 OUTL_DSP (NCB_SCRIPT_PHYS (np, start));
5047 }
5048
5049 /*==========================================================
5050 **
5051 **      Prepare the negotiation values for wide and
5052 **      synchronous transfers.
5053 **
5054 **==========================================================
5055 */
5056
5057 static void ncr_negotiate (struct ncb* np, struct tcb* tp)
5058 {
5059         /*
5060         **      minsync unit is 4ns !
5061         */
5062
5063         u_long minsync = tp->usrsync;
5064
5065         /*
5066         **      SCSI bus mode limit
5067         */
5068
5069         if (np->scsi_mode && np->scsi_mode == SMODE_SE) {
5070                 if (minsync < 12) minsync = 12;
5071         }
5072
5073         /*
5074         **      our limit ..
5075         */
5076
5077         if (minsync < np->minsync)
5078                 minsync = np->minsync;
5079
5080         /*
5081         **      divider limit
5082         */
5083
5084         if (minsync > np->maxsync)
5085                 minsync = 255;
5086
5087         tp->minsync = minsync;
5088         tp->maxoffs = (minsync<255 ? np->maxoffs : 0);
5089
5090         /*
5091         **      period=0: has to negotiate sync transfer
5092         */
5093
5094         tp->period=0;
5095
5096         /*
5097         **      widedone=0: has to negotiate wide transfer
5098         */
5099         tp->widedone=0;
5100 }
5101
5102 /*==========================================================
5103 **
5104 **      Get clock factor and sync divisor for a given
5105 **      synchronous factor period.
5106 **      Returns the clock factor (in sxfer) and scntl3
5107 **      synchronous divisor field.
5108 **
5109 **==========================================================
5110 */
5111
5112 static void ncr_getsync(struct ncb *np, u_char sfac, u_char *fakp, u_char *scntl3p)
5113 {
5114         u_long  clk = np->clock_khz;    /* SCSI clock frequency in kHz  */
5115         int     div = np->clock_divn;   /* Number of divisors supported */
5116         u_long  fak;                    /* Sync factor in sxfer         */
5117         u_long  per;                    /* Period in tenths of ns       */
5118         u_long  kpc;                    /* (per * clk)                  */
5119
5120         /*
5121         **      Compute the synchronous period in tenths of nano-seconds
5122         */
5123         if      (sfac <= 10)    per = 250;
5124         else if (sfac == 11)    per = 303;
5125         else if (sfac == 12)    per = 500;
5126         else                    per = 40 * sfac;
5127
5128         /*
5129         **      Look for the greatest clock divisor that allows an
5130         **      input speed faster than the period.
5131         */
5132         kpc = per * clk;
5133         while (--div >= 0)
5134                 if (kpc >= (div_10M[div] << 2)) break;
5135
5136         /*
5137         **      Calculate the lowest clock factor that allows an output
5138         **      speed not faster than the period.
5139         */
5140         fak = (kpc - 1) / div_10M[div] + 1;
5141
5142 #if 0   /* This optimization does not seem very useful */
5143
5144         per = (fak * div_10M[div]) / clk;
5145
5146         /*
5147         **      Why not to try the immediate lower divisor and to choose
5148         **      the one that allows the fastest output speed ?
5149         **      We don't want input speed too much greater than output speed.
5150         */
5151         if (div >= 1 && fak < 8) {
5152                 u_long fak2, per2;
5153                 fak2 = (kpc - 1) / div_10M[div-1] + 1;
5154                 per2 = (fak2 * div_10M[div-1]) / clk;
5155                 if (per2 < per && fak2 <= 8) {
5156                         fak = fak2;
5157                         per = per2;
5158                         --div;
5159                 }
5160         }
5161 #endif
5162
5163         if (fak < 4) fak = 4;   /* Should never happen, too bad ... */
5164
5165         /*
5166         **      Compute and return sync parameters for the ncr
5167         */
5168         *fakp           = fak - 4;
5169         *scntl3p        = ((div+1) << 4) + (sfac < 25 ? 0x80 : 0);
5170 }
5171
5172
5173 /*==========================================================
5174 **
5175 **      Set actual values, sync status and patch all ccbs of
5176 **      a target according to new sync/wide agreement.
5177 **
5178 **==========================================================
5179 */
5180
5181 static void ncr_set_sync_wide_status (struct ncb *np, u_char target)
5182 {
5183         struct ccb *cp;
5184         struct tcb *tp = &np->target[target];
5185
5186         /*
5187         **      set actual value and sync_status
5188         */
5189         OUTB (nc_sxfer, tp->sval);
5190         np->sync_st = tp->sval;
5191         OUTB (nc_scntl3, tp->wval);
5192         np->wide_st = tp->wval;
5193
5194         /*
5195         **      patch ALL ccbs of this target.
5196         */
5197         for (cp = np->ccb; cp; cp = cp->link_ccb) {
5198                 if (!cp->cmd) continue;
5199                 if (cp->cmd->device->id != target) continue;
5200 #if 0
5201                 cp->sync_status = tp->sval;
5202                 cp->wide_status = tp->wval;
5203 #endif
5204                 cp->phys.select.sel_scntl3 = tp->wval;
5205                 cp->phys.select.sel_sxfer  = tp->sval;
5206         };
5207 }
5208
5209 /*==========================================================
5210 **
5211 **      Switch sync mode for current job and it's target
5212 **
5213 **==========================================================
5214 */
5215
5216 static void ncr_setsync (struct ncb *np, struct ccb *cp, u_char scntl3, u_char sxfer)
5217 {
5218         struct scsi_cmnd *cmd;
5219         struct tcb *tp;
5220         u_char target = INB (nc_sdid) & 0x0f;
5221         u_char idiv;
5222
5223         assert (cp && cp->cmd);
5224         if (!cp) return;
5225
5226         cmd = cp->cmd;
5227         if (!cmd) return;
5228
5229         assert (target == (cmd->device->id & 0xf));
5230
5231         tp = &np->target[target];
5232
5233         if (!scntl3 || !(sxfer & 0x1f))
5234                 scntl3 = np->rv_scntl3;
5235         scntl3 = (scntl3 & 0xf0) | (tp->wval & EWS) | (np->rv_scntl3 & 0x07);
5236
5237         /*
5238         **      Deduce the value of controller sync period from scntl3.
5239         **      period is in tenths of nano-seconds.
5240         */
5241
5242         idiv = ((scntl3 >> 4) & 0x7);
5243         if ((sxfer & 0x1f) && idiv)
5244                 tp->period = (((sxfer>>5)+4)*div_10M[idiv-1])/np->clock_khz;
5245         else
5246                 tp->period = 0xffff;
5247
5248         /*
5249         **       Stop there if sync parameters are unchanged
5250         */
5251         if (tp->sval == sxfer && tp->wval == scntl3) return;
5252         tp->sval = sxfer;
5253         tp->wval = scntl3;
5254
5255         /*
5256         **      Bells and whistles   ;-)
5257         */
5258         PRINT_TARGET(np, target);
5259         if (sxfer & 0x01f) {
5260                 unsigned f10 = 100000 << (tp->widedone ? tp->widedone -1 : 0);
5261                 unsigned mb10 = (f10 + tp->period/2) / tp->period;
5262                 char *scsi;
5263
5264                 /*
5265                 **  Disable extended Sreq/Sack filtering
5266                 */
5267                 if (tp->period <= 2000) OUTOFFB (nc_stest2, EXT);
5268
5269                 /*
5270                 **      Bells and whistles   ;-)
5271                 */
5272                 if      (tp->period < 500)      scsi = "FAST-40";
5273                 else if (tp->period < 1000)     scsi = "FAST-20";
5274                 else if (tp->period < 2000)     scsi = "FAST-10";
5275                 else                            scsi = "FAST-5";
5276
5277                 printk ("%s %sSCSI %d.%d MB/s (%d ns, offset %d)\n", scsi,
5278                         tp->widedone > 1 ? "WIDE " : "",
5279                         mb10 / 10, mb10 % 10, tp->period / 10, sxfer & 0x1f);
5280         } else
5281                 printk ("%sasynchronous.\n", tp->widedone > 1 ? "wide " : "");
5282
5283         /*
5284         **      set actual value and sync_status
5285         **      patch ALL ccbs of this target.
5286         */
5287         ncr_set_sync_wide_status(np, target);
5288 }
5289
5290 /*==========================================================
5291 **
5292 **      Switch wide mode for current job and it's target
5293 **      SCSI specs say: a SCSI device that accepts a WDTR
5294 **      message shall reset the synchronous agreement to
5295 **      asynchronous mode.
5296 **
5297 **==========================================================
5298 */
5299
5300 static void ncr_setwide (struct ncb *np, struct ccb *cp, u_char wide, u_char ack)
5301 {
5302         struct scsi_cmnd *cmd;
5303         u16 target = INB (nc_sdid) & 0x0f;
5304         struct tcb *tp;
5305         u_char  scntl3;
5306         u_char  sxfer;
5307
5308         assert (cp && cp->cmd);
5309         if (!cp) return;
5310
5311         cmd = cp->cmd;
5312         if (!cmd) return;
5313
5314         assert (target == (cmd->device->id & 0xf));
5315
5316         tp = &np->target[target];
5317         tp->widedone  =  wide+1;
5318         scntl3 = (tp->wval & (~EWS)) | (wide ? EWS : 0);
5319
5320         sxfer = ack ? 0 : tp->sval;
5321
5322         /*
5323         **       Stop there if sync/wide parameters are unchanged
5324         */
5325         if (tp->sval == sxfer && tp->wval == scntl3) return;
5326         tp->sval = sxfer;
5327         tp->wval = scntl3;
5328
5329         /*
5330         **      Bells and whistles   ;-)
5331         */
5332         if (bootverbose >= 2) {
5333                 PRINT_TARGET(np, target);
5334                 if (scntl3 & EWS)
5335                         printk ("WIDE SCSI (16 bit) enabled.\n");
5336                 else
5337                         printk ("WIDE SCSI disabled.\n");
5338         }
5339
5340         /*
5341         **      set actual value and sync_status
5342         **      patch ALL ccbs of this target.
5343         */
5344         ncr_set_sync_wide_status(np, target);
5345 }
5346
5347 /*==========================================================
5348 **
5349 **      Switch tagged mode for a target.
5350 **
5351 **==========================================================
5352 */
5353
5354 static void ncr_setup_tags (struct ncb *np, u_char tn, u_char ln)
5355 {
5356         struct tcb *tp = &np->target[tn];
5357         struct lcb *lp = tp->lp[ln];
5358         u_char   reqtags, maxdepth;
5359
5360         /*
5361         **      Just in case ...
5362         */
5363         if ((!tp) || (!lp))
5364                 return;
5365
5366         /*
5367         **      If SCSI device queue depth is not yet set, leave here.
5368         */
5369         if (!lp->scdev_depth)
5370                 return;
5371
5372         /*
5373         **      Donnot allow more tags than the SCSI driver can queue
5374         **      for this device.
5375         **      Donnot allow more tags than we can handle.
5376         */
5377         maxdepth = lp->scdev_depth;
5378         if (maxdepth > lp->maxnxs)      maxdepth    = lp->maxnxs;
5379         if (lp->maxtags > maxdepth)     lp->maxtags = maxdepth;
5380         if (lp->numtags > maxdepth)     lp->numtags = maxdepth;
5381
5382         /*
5383         **      only devices conformant to ANSI Version >= 2
5384         **      only devices capable of tagged commands
5385         **      only if enabled by user ..
5386         */
5387         if ((lp->inq_byte7 & INQ7_QUEUE) && lp->numtags > 1) {
5388                 reqtags = lp->numtags;
5389         } else {
5390                 reqtags = 1;
5391         };
5392
5393         /*
5394         **      Update max number of tags
5395         */
5396         lp->numtags = reqtags;
5397         if (lp->numtags > lp->maxtags)
5398                 lp->maxtags = lp->numtags;
5399
5400         /*
5401         **      If we want to switch tag mode, we must wait
5402         **      for no CCB to be active.
5403         */
5404         if      (reqtags > 1 && lp->usetags) {   /* Stay in tagged mode    */
5405                 if (lp->queuedepth == reqtags)   /* Already announced      */
5406                         return;
5407                 lp->queuedepth  = reqtags;
5408         }
5409         else if (reqtags <= 1 && !lp->usetags) { /* Stay in untagged mode  */
5410                 lp->queuedepth  = reqtags;
5411                 return;
5412         }
5413         else {                                   /* Want to switch tag mode */
5414                 if (lp->busyccbs)                /* If not yet safe, return */
5415                         return;
5416                 lp->queuedepth  = reqtags;
5417                 lp->usetags     = reqtags > 1 ? 1 : 0;
5418         }
5419
5420         /*
5421         **      Patch the lun mini-script, according to tag mode.
5422         */
5423         lp->jump_tag.l_paddr = lp->usetags?
5424                         cpu_to_scr(NCB_SCRIPT_PHYS(np, resel_tag)) :
5425                         cpu_to_scr(NCB_SCRIPT_PHYS(np, resel_notag));
5426
5427         /*
5428         **      Announce change to user.
5429         */
5430         if (bootverbose) {
5431                 PRINT_LUN(np, tn, ln);
5432                 if (lp->usetags) {
5433                         printk("tagged command queue depth set to %d\n", reqtags);
5434                 }
5435                 else {
5436                         printk("tagged command queueing disabled\n");
5437                 }
5438         }
5439 }
5440
5441 /*----------------------------------------------------
5442 **
5443 **      handle user commands
5444 **
5445 **----------------------------------------------------
5446 */
5447
5448 #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
5449
5450 static void ncr_usercmd (struct ncb *np)
5451 {
5452         u_char t;
5453         struct tcb *tp;
5454
5455         switch (np->user.cmd) {
5456
5457         case 0: return;
5458
5459         case UC_SETSYNC:
5460                 for (t=0; t<MAX_TARGET; t++) {
5461                         if (!((np->user.target>>t)&1)) continue;
5462                         tp = &np->target[t];
5463                         tp->usrsync = np->user.data;
5464                         ncr_negotiate (np, tp);
5465                 };
5466                 break;
5467
5468         case UC_SETTAGS:
5469                 for (t=0; t<MAX_TARGET; t++) {
5470                         int ln;
5471                         if (!((np->user.target>>t)&1)) continue;
5472                         np->target[t].usrtags = np->user.data;
5473                         for (ln = 0; ln < MAX_LUN; ln++) {
5474                                 struct lcb *lp = np->target[t].lp[ln];
5475                                 if (!lp)
5476                                         continue;
5477                                 lp->maxtags = lp->numtags = np->user.data;
5478                                 ncr_setup_tags (np, t, ln);
5479                         }
5480                 };
5481                 break;
5482
5483         case UC_SETDEBUG:
5484 #ifdef SCSI_NCR_DEBUG_INFO_SUPPORT
5485                 ncr_debug = np->user.data;
5486 #endif
5487                 break;
5488
5489         case UC_SETORDER:
5490                 np->order = np->user.data;
5491                 break;
5492
5493         case UC_SETVERBOSE:
5494                 np->verbose = np->user.data;
5495                 break;
5496
5497         case UC_SETWIDE:
5498                 for (t=0; t<MAX_TARGET; t++) {
5499                         u_long size;
5500                         if (!((np->user.target>>t)&1)) continue;
5501                         tp = &np->target[t];
5502                         size = np->user.data;
5503                         if (size > np->maxwide) size=np->maxwide;
5504                         tp->usrwide = size;
5505                         ncr_negotiate (np, tp);
5506                 };
5507                 break;
5508
5509         case UC_SETFLAG:
5510                 for (t=0; t<MAX_TARGET; t++) {
5511                         if (!((np->user.target>>t)&1)) continue;
5512                         tp = &np->target[t];
5513                         tp->usrflag = np->user.data;
5514                 };
5515                 break;
5516         }
5517         np->user.cmd=0;
5518 }
5519 #endif
5520
5521 /*==========================================================
5522 **
5523 **
5524 **      ncr timeout handler.
5525 **
5526 **
5527 **==========================================================
5528 **
5529 **      Misused to keep the driver running when
5530 **      interrupts are not configured correctly.
5531 **
5532 **----------------------------------------------------------
5533 */
5534
5535 static void ncr_timeout (struct ncb *np)
5536 {
5537         u_long  thistime = ktime_get(0);
5538
5539         /*
5540         **      If release process in progress, let's go
5541         **      Set the release stage from 1 to 2 to synchronize
5542         **      with the release process.
5543         */
5544
5545         if (np->release_stage) {
5546                 if (np->release_stage == 1) np->release_stage = 2;
5547                 return;
5548         }
5549
5550         np->timer.expires = ktime_get(SCSI_NCR_TIMER_INTERVAL);
5551         add_timer(&np->timer);
5552
5553         /*
5554         **      If we are resetting the ncr, wait for settle_time before
5555         **      clearing it. Then command processing will be resumed.
5556         */
5557         if (np->settle_time) {
5558                 if (np->settle_time <= thistime) {
5559                         if (bootverbose > 1)
5560                                 printk("%s: command processing resumed\n", ncr_name(np));
5561                         np->settle_time = 0;
5562                         np->disc        = 1;
5563                         requeue_waiting_list(np);
5564                 }
5565                 return;
5566         }
5567
5568         /*
5569         **      Since the generic scsi driver only allows us 0.5 second
5570         **      to perform abort of a command, we must look at ccbs about
5571         **      every 0.25 second.
5572         */
5573         if (np->lasttime + 4*HZ < thistime) {
5574                 /*
5575                 **      block ncr interrupts
5576                 */
5577                 np->lasttime = thistime;
5578         }
5579
5580 #ifdef SCSI_NCR_BROKEN_INTR
5581         if (INB(nc_istat) & (INTF|SIP|DIP)) {
5582
5583                 /*
5584                 **      Process pending interrupts.
5585                 */
5586                 if (DEBUG_FLAGS & DEBUG_TINY) printk ("{");
5587                 ncr_exception (np);
5588                 if (DEBUG_FLAGS & DEBUG_TINY) printk ("}");
5589         }
5590 #endif /* SCSI_NCR_BROKEN_INTR */
5591 }
5592
5593 /*==========================================================
5594 **
5595 **      log message for real hard errors
5596 **
5597 **      "ncr0 targ 0?: ERROR (ds:si) (so-si-sd) (sxfer/scntl3) @ name (dsp:dbc)."
5598 **      "             reg: r0 r1 r2 r3 r4 r5 r6 ..... rf."
5599 **
5600 **      exception register:
5601 **              ds:     dstat
5602 **              si:     sist
5603 **
5604 **      SCSI bus lines:
5605 **              so:     control lines as driver by NCR.
5606 **              si:     control lines as seen by NCR.
5607 **              sd:     scsi data lines as seen by NCR.
5608 **
5609 **      wide/fastmode:
5610 **              sxfer:  (see the manual)
5611 **              scntl3: (see the manual)
5612 **
5613 **      current script command:
5614 **              dsp:    script address (relative to start of script).
5615 **              dbc:    first word of script command.
5616 **
5617 **      First 16 register of the chip:
5618 **              r0..rf
5619 **
5620 **==========================================================
5621 */
5622
5623 static void ncr_log_hard_error(struct ncb *np, u16 sist, u_char dstat)
5624 {
5625         u32     dsp;
5626         int     script_ofs;
5627         int     script_size;
5628         char    *script_name;
5629         u_char  *script_base;
5630         int     i;
5631
5632         dsp     = INL (nc_dsp);
5633
5634         if (dsp > np->p_script && dsp <= np->p_script + sizeof(struct script)) {
5635                 script_ofs      = dsp - np->p_script;
5636                 script_size     = sizeof(struct script);
5637                 script_base     = (u_char *) np->script0;
5638                 script_name     = "script";
5639         }
5640         else if (np->p_scripth < dsp &&
5641                  dsp <= np->p_scripth + sizeof(struct scripth)) {
5642                 script_ofs      = dsp - np->p_scripth;
5643                 script_size     = sizeof(struct scripth);
5644                 script_base     = (u_char *) np->scripth0;
5645                 script_name     = "scripth";
5646         } else {
5647                 script_ofs      = dsp;
5648                 script_size     = 0;
5649                 script_base     = NULL;
5650                 script_name     = "mem";
5651         }
5652
5653         printk ("%s:%d: ERROR (%x:%x) (%x-%x-%x) (%x/%x) @ (%s %x:%08x).\n",
5654                 ncr_name (np), (unsigned)INB (nc_sdid)&0x0f, dstat, sist,
5655                 (unsigned)INB (nc_socl), (unsigned)INB (nc_sbcl), (unsigned)INB (nc_sbdl),
5656                 (unsigned)INB (nc_sxfer),(unsigned)INB (nc_scntl3), script_name, script_ofs,
5657                 (unsigned)INL (nc_dbc));
5658
5659         if (((script_ofs & 3) == 0) &&
5660             (unsigned)script_ofs < script_size) {
5661                 printk ("%s: script cmd = %08x\n", ncr_name(np),
5662                         scr_to_cpu((int) *(ncrcmd *)(script_base + script_ofs)));
5663         }
5664
5665         printk ("%s: regdump:", ncr_name(np));
5666         for (i=0; i<16;i++)
5667             printk (" %02x", (unsigned)INB_OFF(i));
5668         printk (".\n");
5669 }
5670
5671 /*============================================================
5672 **
5673 **      ncr chip exception handler.
5674 **
5675 **============================================================
5676 **
5677 **      In normal cases, interrupt conditions occur one at a
5678 **      time. The ncr is able to stack in some extra registers
5679 **      other interrupts that will occurs after the first one.
5680 **      But severall interrupts may occur at the same time.
5681 **
5682 **      We probably should only try to deal with the normal
5683 **      case, but it seems that multiple interrupts occur in
5684 **      some cases that are not abnormal at all.
5685 **
5686 **      The most frequent interrupt condition is Phase Mismatch.
5687 **      We should want to service this interrupt quickly.
5688 **      A SCSI parity error may be delivered at the same time.
5689 **      The SIR interrupt is not very frequent in this driver,
5690 **      since the INTFLY is likely used for command completion
5691 **      signaling.
5692 **      The Selection Timeout interrupt may be triggered with
5693 **      IID and/or UDC.
5694 **      The SBMC interrupt (SCSI Bus Mode Change) may probably
5695 **      occur at any time.
5696 **
5697 **      This handler try to deal as cleverly as possible with all
5698 **      the above.
5699 **
5700 **============================================================
5701 */
5702
5703 void ncr_exception (struct ncb *np)
5704 {
5705         u_char  istat, dstat;
5706         u16     sist;
5707         int     i;
5708
5709         /*
5710         **      interrupt on the fly ?
5711         **      Since the global header may be copied back to a CCB
5712         **      using a posted PCI memory write, the last operation on
5713         **      the istat register is a READ in order to flush posted
5714         **      PCI write commands.
5715         */
5716         istat = INB (nc_istat);
5717         if (istat & INTF) {
5718                 OUTB (nc_istat, (istat & SIGP) | INTF);
5719                 istat = INB (nc_istat);
5720                 if (DEBUG_FLAGS & DEBUG_TINY) printk ("F ");
5721                 ncr_wakeup_done (np);
5722         };
5723
5724         if (!(istat & (SIP|DIP)))
5725                 return;
5726
5727         if (istat & CABRT)
5728                 OUTB (nc_istat, CABRT);
5729
5730         /*
5731         **      Steinbach's Guideline for Systems Programming:
5732         **      Never test for an error condition you don't know how to handle.
5733         */
5734
5735         sist  = (istat & SIP) ? INW (nc_sist)  : 0;
5736         dstat = (istat & DIP) ? INB (nc_dstat) : 0;
5737
5738         if (DEBUG_FLAGS & DEBUG_TINY)
5739                 printk ("<%d|%x:%x|%x:%x>",
5740                         (int)INB(nc_scr0),
5741                         dstat,sist,
5742                         (unsigned)INL(nc_dsp),
5743                         (unsigned)INL(nc_dbc));
5744
5745         /*========================================================
5746         **      First, interrupts we want to service cleanly.
5747         **
5748         **      Phase mismatch is the most frequent interrupt, and
5749         **      so we have to service it as quickly and as cleanly
5750         **      as possible.
5751         **      Programmed interrupts are rarely used in this driver,
5752         **      but we must handle them cleanly anyway.
5753         **      We try to deal with PAR and SBMC combined with
5754         **      some other interrupt(s).
5755         **=========================================================
5756         */
5757
5758         if (!(sist  & (STO|GEN|HTH|SGE|UDC|RST)) &&
5759             !(dstat & (MDPE|BF|ABRT|IID))) {
5760                 if ((sist & SBMC) && ncr_int_sbmc (np))
5761                         return;
5762                 if ((sist & PAR)  && ncr_int_par  (np))
5763                         return;
5764                 if (sist & MA) {
5765                         ncr_int_ma (np);
5766                         return;
5767                 }
5768                 if (dstat & SIR) {
5769                         ncr_int_sir (np);
5770                         return;
5771                 }
5772                 /*
5773                 **  DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 2.
5774                 */
5775                 if (!(sist & (SBMC|PAR)) && !(dstat & SSI)) {
5776                         printk( "%s: unknown interrupt(s) ignored, "
5777                                 "ISTAT=%x DSTAT=%x SIST=%x\n",
5778                                 ncr_name(np), istat, dstat, sist);
5779                         return;
5780                 }
5781                 OUTONB_STD ();
5782                 return;
5783         };
5784
5785         /*========================================================
5786         **      Now, interrupts that need some fixing up.
5787         **      Order and multiple interrupts is so less important.
5788         **
5789         **      If SRST has been asserted, we just reset the chip.
5790         **
5791         **      Selection is intirely handled by the chip. If the
5792         **      chip says STO, we trust it. Seems some other
5793         **      interrupts may occur at the same time (UDC, IID), so
5794         **      we ignore them. In any case we do enough fix-up
5795         **      in the service routine.
5796         **      We just exclude some fatal dma errors.
5797         **=========================================================
5798         */
5799
5800         if (sist & RST) {
5801                 ncr_init (np, 1, bootverbose ? "scsi reset" : NULL, HS_RESET);
5802                 return;
5803         };
5804
5805         if ((sist & STO) &&
5806                 !(dstat & (MDPE|BF|ABRT))) {
5807         /*
5808         **      DEL 397 - 53C875 Rev 3 - Part Number 609-0392410 - ITEM 1.
5809         */
5810                 OUTONB (nc_ctest3, CLF);
5811
5812                 ncr_int_sto (np);
5813                 return;
5814         };
5815
5816         /*=========================================================
5817         **      Now, interrupts we are not able to recover cleanly.
5818         **      (At least for the moment).
5819         **
5820         **      Do the register dump.
5821         **      Log message for real hard errors.
5822         **      Clear all fifos.
5823         **      For MDPE, BF, ABORT, IID, SGE and HTH we reset the
5824         **      BUS and the chip.
5825         **      We are more soft for UDC.
5826         **=========================================================
5827         */
5828
5829         if (ktime_exp(np->regtime)) {
5830                 np->regtime = ktime_get(10*HZ);
5831                 for (i = 0; i<sizeof(np->regdump); i++)
5832                         ((char*)&np->regdump)[i] = INB_OFF(i);
5833                 np->regdump.nc_dstat = dstat;
5834                 np->regdump.nc_sist  = sist;
5835         };
5836
5837         ncr_log_hard_error(np, sist, dstat);
5838
5839         printk ("%s: have to clear fifos.\n", ncr_name (np));
5840         OUTB (nc_stest3, TE|CSF);
5841         OUTONB (nc_ctest3, CLF);
5842
5843         if ((sist & (SGE)) ||
5844                 (dstat & (MDPE|BF|ABRT|IID))) {
5845                 ncr_start_reset(np);
5846                 return;
5847         };
5848
5849         if (sist & HTH) {
5850                 printk ("%s: handshake timeout\n", ncr_name(np));
5851                 ncr_start_reset(np);
5852                 return;
5853         };
5854
5855         if (sist & UDC) {
5856                 printk ("%s: unexpected disconnect\n", ncr_name(np));
5857                 OUTB (HS_PRT, HS_UNEXPECTED);
5858                 OUTL_DSP (NCB_SCRIPT_PHYS (np, cleanup));
5859                 return;
5860         };
5861
5862         /*=========================================================
5863         **      We just miss the cause of the interrupt. :(
5864         **      Print a message. The timeout will do the real work.
5865         **=========================================================
5866         */
5867         printk ("%s: unknown interrupt\n", ncr_name(np));
5868 }
5869
5870 /*==========================================================
5871 **
5872 **      ncr chip exception handler for selection timeout
5873 **
5874 **==========================================================
5875 **
5876 **      There seems to be a bug in the 53c810.
5877 **      Although a STO-Interrupt is pending,
5878 **      it continues executing script commands.
5879 **      But it will fail and interrupt (IID) on
5880 **      the next instruction where it's looking
5881 **      for a valid phase.
5882 **
5883 **----------------------------------------------------------
5884 */
5885
5886 void ncr_int_sto (struct ncb *np)
5887 {
5888         u_long dsa;
5889         struct ccb *cp;
5890         if (DEBUG_FLAGS & DEBUG_TINY) printk ("T");
5891
5892         /*
5893         **      look for ccb and set the status.
5894         */
5895
5896         dsa = INL (nc_dsa);
5897         cp = np->ccb;
5898         while (cp && (CCB_PHYS (cp, phys) != dsa))
5899                 cp = cp->link_ccb;
5900
5901         if (cp) {
5902                 cp-> host_status = HS_SEL_TIMEOUT;
5903                 ncr_complete (np, cp);
5904         };
5905
5906         /*
5907         **      repair start queue and jump to start point.
5908         */
5909
5910         OUTL_DSP (NCB_SCRIPTH_PHYS (np, sto_restart));
5911         return;
5912 }
5913
5914 /*==========================================================
5915 **
5916 **      ncr chip exception handler for SCSI bus mode change
5917 **
5918 **==========================================================
5919 **
5920 **      spi2-r12 11.2.3 says a transceiver mode change must
5921 **      generate a reset event and a device that detects a reset
5922 **      event shall initiate a hard reset. It says also that a
5923 **      device that detects a mode change shall set data transfer
5924 **      mode to eight bit asynchronous, etc...
5925 **      So, just resetting should be enough.
5926 **
5927 **
5928 **----------------------------------------------------------
5929 */
5930
5931 static int ncr_int_sbmc (struct ncb *np)
5932 {
5933         u_char scsi_mode = INB (nc_stest4) & SMODE;
5934
5935         if (scsi_mode != np->scsi_mode) {
5936                 printk("%s: SCSI bus mode change from %x to %x.\n",
5937                         ncr_name(np), np->scsi_mode, scsi_mode);
5938
5939                 np->scsi_mode = scsi_mode;
5940
5941
5942                 /*
5943                 **      Suspend command processing for 1 second and
5944                 **      reinitialize all except the chip.
5945                 */
5946                 np->settle_time = ktime_get(1*HZ);
5947                 ncr_init (np, 0, bootverbose ? "scsi mode change" : NULL, HS_RESET);
5948                 return 1;
5949         }
5950         return 0;
5951 }
5952
5953 /*==========================================================
5954 **
5955 **      ncr chip exception handler for SCSI parity error.
5956 **
5957 **==========================================================
5958 **
5959 **
5960 **----------------------------------------------------------
5961 */
5962
5963 static int ncr_int_par (struct ncb *np)
5964 {
5965         u_char  hsts    = INB (HS_PRT);
5966         u32     dbc     = INL (nc_dbc);
5967         u_char  sstat1  = INB (nc_sstat1);
5968         int phase       = -1;
5969         int msg         = -1;
5970         u32 jmp;
5971
5972         printk("%s: SCSI parity error detected: SCR1=%d DBC=%x SSTAT1=%x\n",
5973                 ncr_name(np), hsts, dbc, sstat1);
5974
5975         /*
5976          *      Ignore the interrupt if the NCR is not connected
5977          *      to the SCSI bus, since the right work should have
5978          *      been done on unexpected disconnection handling.
5979          */
5980         if (!(INB (nc_scntl1) & ISCON))
5981                 return 0;
5982
5983         /*
5984          *      If the nexus is not clearly identified, reset the bus.
5985          *      We will try to do better later.
5986          */
5987         if (hsts & HS_INVALMASK)
5988                 goto reset_all;
5989
5990         /*
5991          *      If the SCSI parity error occurs in MSG IN phase, prepare a
5992          *      MSG PARITY message. Otherwise, prepare a INITIATOR DETECTED
5993          *      ERROR message and let the device decide to retry the command
5994          *      or to terminate with check condition. If we were in MSG IN
5995          *      phase waiting for the response of a negotiation, we will
5996          *      get SIR_NEGO_FAILED at dispatch.
5997          */
5998         if (!(dbc & 0xc0000000))
5999                 phase = (dbc >> 24) & 7;
6000         if (phase == 7)
6001                 msg = M_PARITY;
6002         else
6003                 msg = M_ID_ERROR;
6004
6005 #ifdef SCSI_NCR_INTEGRITY_CHECKING
6006         /*
6007         **      Save error message. For integrity check use only.
6008         */
6009         if (np->check_integrity)
6010                 np->check_integ_par = msg;
6011 #endif
6012
6013         /*
6014          *      If the NCR stopped on a MOVE ^ DATA_IN, we jump to a
6015          *      script that will ignore all data in bytes until phase
6016          *      change, since we are not sure the chip will wait the phase
6017          *      change prior to delivering the interrupt.
6018          */
6019         if (phase == 1)
6020                 jmp = NCB_SCRIPTH_PHYS (np, par_err_data_in);
6021         else
6022                 jmp = NCB_SCRIPTH_PHYS (np, par_err_other);
6023
6024         OUTONB (nc_ctest3, CLF );       /* clear dma fifo  */
6025         OUTB (nc_stest3, TE|CSF);       /* clear scsi fifo */
6026
6027         np->msgout[0] = msg;
6028         OUTL_DSP (jmp);
6029         return 1;
6030
6031 reset_all:
6032         ncr_start_reset(np);
6033         return 1;
6034 }
6035
6036 /*==========================================================
6037 **
6038 **
6039 **      ncr chip exception handler for phase errors.
6040 **
6041 **
6042 **==========================================================
6043 **
6044 **      We have to construct a new transfer descriptor,
6045 **      to transfer the rest of the current block.
6046 **
6047 **----------------------------------------------------------
6048 */
6049
6050 static void ncr_int_ma (struct ncb *np)
6051 {
6052         u32     dbc;
6053         u32     rest;
6054         u32     dsp;
6055         u32     dsa;
6056         u32     nxtdsp;
6057         u32     newtmp;
6058         u32     *vdsp;
6059         u32     oadr, olen;
6060         u32     *tblp;
6061         ncrcmd *newcmd;
6062         u_char  cmd, sbcl;
6063         struct ccb *cp;
6064
6065         dsp     = INL (nc_dsp);
6066         dbc     = INL (nc_dbc);
6067         sbcl    = INB (nc_sbcl);
6068
6069         cmd     = dbc >> 24;
6070         rest    = dbc & 0xffffff;
6071
6072         /*
6073         **      Take into account dma fifo and various buffers and latches,
6074         **      only if the interrupted phase is an OUTPUT phase.
6075         */
6076
6077         if ((cmd & 1) == 0) {
6078                 u_char  ctest5, ss0, ss2;
6079                 u16     delta;
6080
6081                 ctest5 = (np->rv_ctest5 & DFS) ? INB (nc_ctest5) : 0;
6082                 if (ctest5 & DFS)
6083                         delta=(((ctest5 << 8) | (INB (nc_dfifo) & 0xff)) - rest) & 0x3ff;
6084                 else
6085                         delta=(INB (nc_dfifo) - rest) & 0x7f;
6086
6087                 /*
6088                 **      The data in the dma fifo has not been transferred to
6089                 **      the target -> add the amount to the rest
6090                 **      and clear the data.
6091                 **      Check the sstat2 register in case of wide transfer.
6092                 */
6093
6094                 rest += delta;
6095                 ss0  = INB (nc_sstat0);
6096                 if (ss0 & OLF) rest++;
6097                 if (ss0 & ORF) rest++;
6098                 if (INB(nc_scntl3) & EWS) {
6099                         ss2 = INB (nc_sstat2);
6100                         if (ss2 & OLF1) rest++;
6101                         if (ss2 & ORF1) rest++;
6102                 };
6103
6104                 if (DEBUG_FLAGS & (DEBUG_TINY|DEBUG_PHASE))
6105                         printk ("P%x%x RL=%d D=%d SS0=%x ", cmd&7, sbcl&7,
6106                                 (unsigned) rest, (unsigned) delta, ss0);
6107
6108         } else  {
6109                 if (DEBUG_FLAGS & (DEBUG_TINY|DEBUG_PHASE))
6110                         printk ("P%x%x RL=%d ", cmd&7, sbcl&7, rest);
6111         }
6112
6113         /*
6114         **      Clear fifos.
6115         */
6116         OUTONB (nc_ctest3, CLF );       /* clear dma fifo  */
6117         OUTB (nc_stest3, TE|CSF);       /* clear scsi fifo */
6118
6119         /*
6120         **      locate matching cp.
6121         **      if the interrupted phase is DATA IN or DATA OUT,
6122         **      trust the global header.
6123         */
6124         dsa = INL (nc_dsa);
6125         if (!(cmd & 6)) {
6126                 cp = np->header.cp;
6127                 if (CCB_PHYS(cp, phys) != dsa)
6128                         cp = NULL;
6129         } else {
6130                 cp  = np->ccb;
6131                 while (cp && (CCB_PHYS (cp, phys) != dsa))
6132                         cp = cp->link_ccb;
6133         }
6134
6135         /*
6136         **      try to find the interrupted script command,
6137         **      and the address at which to continue.
6138         */
6139         vdsp    = NULL;
6140         nxtdsp  = 0;
6141         if      (dsp >  np->p_script &&
6142                  dsp <= np->p_script + sizeof(struct script)) {
6143                 vdsp = (u32 *)((char*)np->script0 + (dsp-np->p_script-8));
6144                 nxtdsp = dsp;
6145         }
6146         else if (dsp >  np->p_scripth &&
6147                  dsp <= np->p_scripth + sizeof(struct scripth)) {
6148                 vdsp = (u32 *)((char*)np->scripth0 + (dsp-np->p_scripth-8));
6149                 nxtdsp = dsp;
6150         }
6151         else if (cp) {
6152                 if      (dsp == CCB_PHYS (cp, patch[2])) {
6153                         vdsp = &cp->patch[0];
6154                         nxtdsp = scr_to_cpu(vdsp[3]);
6155                 }
6156                 else if (dsp == CCB_PHYS (cp, patch[6])) {
6157                         vdsp = &cp->patch[4];
6158                         nxtdsp = scr_to_cpu(vdsp[3]);
6159                 }
6160         }
6161
6162         /*
6163         **      log the information
6164         */
6165
6166         if (DEBUG_FLAGS & DEBUG_PHASE) {
6167                 printk ("\nCP=%p CP2=%p DSP=%x NXT=%x VDSP=%p CMD=%x ",
6168                         cp, np->header.cp,
6169                         (unsigned)dsp,
6170                         (unsigned)nxtdsp, vdsp, cmd);
6171         };
6172
6173         /*
6174         **      cp=0 means that the DSA does not point to a valid control
6175         **      block. This should not happen since we donnot use multi-byte
6176         **      move while we are being reselected ot after command complete.
6177         **      We are not able to recover from such a phase error.
6178         */
6179         if (!cp) {
6180                 printk ("%s: SCSI phase error fixup: "
6181                         "CCB already dequeued (0x%08lx)\n",
6182                         ncr_name (np), (u_long) np->header.cp);
6183                 goto reset_all;
6184         }
6185
6186         /*
6187         **      get old startaddress and old length.
6188         */
6189
6190         oadr = scr_to_cpu(vdsp[1]);
6191
6192         if (cmd & 0x10) {       /* Table indirect */
6193                 tblp = (u32 *) ((char*) &cp->phys + oadr);
6194                 olen = scr_to_cpu(tblp[0]);
6195                 oadr = scr_to_cpu(tblp[1]);
6196         } else {
6197                 tblp = (u32 *) 0;
6198                 olen = scr_to_cpu(vdsp[0]) & 0xffffff;
6199         };
6200
6201         if (DEBUG_FLAGS & DEBUG_PHASE) {
6202                 printk ("OCMD=%x\nTBLP=%p OLEN=%x OADR=%x\n",
6203                         (unsigned) (scr_to_cpu(vdsp[0]) >> 24),
6204                         tblp,
6205                         (unsigned) olen,
6206                         (unsigned) oadr);
6207         };
6208
6209         /*
6210         **      check cmd against assumed interrupted script command.
6211         */
6212
6213         if (cmd != (scr_to_cpu(vdsp[0]) >> 24)) {
6214                 PRINT_ADDR(cp->cmd);
6215                 printk ("internal error: cmd=%02x != %02x=(vdsp[0] >> 24)\n",
6216                         (unsigned)cmd, (unsigned)scr_to_cpu(vdsp[0]) >> 24);
6217
6218                 goto reset_all;
6219         }
6220
6221         /*
6222         **      cp != np->header.cp means that the header of the CCB
6223         **      currently being processed has not yet been copied to
6224         **      the global header area. That may happen if the device did
6225         **      not accept all our messages after having been selected.
6226         */
6227         if (cp != np->header.cp) {
6228                 printk ("%s: SCSI phase error fixup: "
6229                         "CCB address mismatch (0x%08lx != 0x%08lx)\n",
6230                         ncr_name (np), (u_long) cp, (u_long) np->header.cp);
6231         }
6232
6233         /*
6234         **      if old phase not dataphase, leave here.
6235         */
6236
6237         if (cmd & 0x06) {
6238                 PRINT_ADDR(cp->cmd);
6239                 printk ("phase change %x-%x %d@%08x resid=%d.\n",
6240                         cmd&7, sbcl&7, (unsigned)olen,
6241                         (unsigned)oadr, (unsigned)rest);
6242                 goto unexpected_phase;
6243         };
6244
6245         /*
6246         **      choose the correct patch area.
6247         **      if savep points to one, choose the other.
6248         */
6249
6250         newcmd = cp->patch;
6251         newtmp = CCB_PHYS (cp, patch);
6252         if (newtmp == scr_to_cpu(cp->phys.header.savep)) {
6253                 newcmd = &cp->patch[4];
6254                 newtmp = CCB_PHYS (cp, patch[4]);
6255         }
6256
6257         /*
6258         **      fillin the commands
6259         */
6260
6261         newcmd[0] = cpu_to_scr(((cmd & 0x0f) << 24) | rest);
6262         newcmd[1] = cpu_to_scr(oadr + olen - rest);
6263         newcmd[2] = cpu_to_scr(SCR_JUMP);
6264         newcmd[3] = cpu_to_scr(nxtdsp);
6265
6266         if (DEBUG_FLAGS & DEBUG_PHASE) {
6267                 PRINT_ADDR(cp->cmd);
6268                 printk ("newcmd[%d] %x %x %x %x.\n",
6269                         (int) (newcmd - cp->patch),
6270                         (unsigned)scr_to_cpu(newcmd[0]),
6271                         (unsigned)scr_to_cpu(newcmd[1]),
6272                         (unsigned)scr_to_cpu(newcmd[2]),
6273                         (unsigned)scr_to_cpu(newcmd[3]));
6274         }
6275         /*
6276         **      fake the return address (to the patch).
6277         **      and restart script processor at dispatcher.
6278         */
6279         OUTL (nc_temp, newtmp);
6280         OUTL_DSP (NCB_SCRIPT_PHYS (np, dispatch));
6281         return;
6282
6283         /*
6284         **      Unexpected phase changes that occurs when the current phase
6285         **      is not a DATA IN or DATA OUT phase are due to error conditions.
6286         **      Such event may only happen when the SCRIPTS is using a
6287         **      multibyte SCSI MOVE.
6288         **
6289         **      Phase change            Some possible cause
6290         **
6291         **      COMMAND  --> MSG IN     SCSI parity error detected by target.
6292         **      COMMAND  --> STATUS     Bad command or refused by target.
6293         **      MSG OUT  --> MSG IN     Message rejected by target.
6294         **      MSG OUT  --> COMMAND    Bogus target that discards extended
6295         **                              negotiation messages.
6296         **
6297         **      The code below does not care of the new phase and so
6298         **      trusts the target. Why to annoy it ?
6299         **      If the interrupted phase is COMMAND phase, we restart at
6300         **      dispatcher.
6301         **      If a target does not get all the messages after selection,
6302         **      the code assumes blindly that the target discards extended
6303         **      messages and clears the negotiation status.
6304         **      If the target does not want all our response to negotiation,
6305         **      we force a SIR_NEGO_PROTO interrupt (it is a hack that avoids
6306         **      bloat for such a should_not_happen situation).
6307         **      In all other situation, we reset the BUS.
6308         **      Are these assumptions reasonnable ? (Wait and see ...)
6309         */
6310 unexpected_phase:
6311         dsp -= 8;
6312         nxtdsp = 0;
6313
6314         switch (cmd & 7) {
6315         case 2: /* COMMAND phase */
6316                 nxtdsp = NCB_SCRIPT_PHYS (np, dispatch);
6317                 break;
6318 #if 0
6319         case 3: /* STATUS  phase */
6320                 nxtdsp = NCB_SCRIPT_PHYS (np, dispatch);
6321                 break;
6322 #endif
6323         case 6: /* MSG OUT phase */
6324                 np->scripth->nxtdsp_go_on[0] = cpu_to_scr(dsp + 8);
6325                 if      (dsp == NCB_SCRIPT_PHYS (np, send_ident)) {
6326                         cp->host_status = HS_BUSY;
6327                         nxtdsp = NCB_SCRIPTH_PHYS (np, clratn_go_on);
6328                 }
6329                 else if (dsp == NCB_SCRIPTH_PHYS (np, send_wdtr) ||
6330                          dsp == NCB_SCRIPTH_PHYS (np, send_sdtr)) {
6331                         nxtdsp = NCB_SCRIPTH_PHYS (np, nego_bad_phase);
6332                 }
6333                 break;
6334 #if 0
6335         case 7: /* MSG IN  phase */
6336                 nxtdsp = NCB_SCRIPT_PHYS (np, clrack);
6337                 break;
6338 #endif
6339         }
6340
6341         if (nxtdsp) {
6342                 OUTL_DSP (nxtdsp);
6343                 return;
6344         }
6345
6346 reset_all:
6347         ncr_start_reset(np);
6348 }
6349
6350
6351 static void ncr_sir_to_redo(struct ncb *np, int num, struct ccb *cp)
6352 {
6353         struct scsi_cmnd *cmd   = cp->cmd;
6354         struct tcb *tp  = &np->target[cmd->device->id];
6355         struct lcb *lp  = tp->lp[cmd->device->lun];
6356         XPT_QUEHEAD     *qp;
6357         struct ccb *    cp2;
6358         int             disc_cnt = 0;
6359         int             busy_cnt = 0;
6360         u32             startp;
6361         u_char          s_status = INB (SS_PRT);
6362
6363         /*
6364         **      Let the SCRIPTS processor skip all not yet started CCBs,
6365         **      and count disconnected CCBs. Since the busy queue is in
6366         **      the same order as the chip start queue, disconnected CCBs
6367         **      are before cp and busy ones after.
6368         */
6369         if (lp) {
6370                 qp = lp->busy_ccbq.blink;
6371                 while (qp != &lp->busy_ccbq) {
6372                         cp2 = xpt_que_entry(qp, struct ccb, link_ccbq);
6373                         qp  = qp->blink;
6374                         ++busy_cnt;
6375                         if (cp2 == cp)
6376                                 break;
6377                         cp2->start.schedule.l_paddr =
6378                         cpu_to_scr(NCB_SCRIPTH_PHYS (np, skip));
6379                 }
6380                 lp->held_ccb = cp;      /* Requeue when this one completes */
6381                 disc_cnt = lp->queuedccbs - busy_cnt;
6382         }
6383
6384         switch(s_status) {
6385         default:        /* Just for safety, should never happen */
6386         case S_QUEUE_FULL:
6387                 /*
6388                 **      Decrease number of tags to the number of
6389                 **      disconnected commands.
6390                 */
6391                 if (!lp)
6392                         goto out;
6393                 if (bootverbose >= 1) {
6394                         PRINT_ADDR(cmd);
6395                         printk ("QUEUE FULL! %d busy, %d disconnected CCBs\n",
6396                                 busy_cnt, disc_cnt);
6397                 }
6398                 if (disc_cnt < lp->numtags) {
6399                         lp->numtags     = disc_cnt > 2 ? disc_cnt : 2;
6400                         lp->num_good    = 0;
6401                         ncr_setup_tags (np, cmd->device->id, cmd->device->lun);
6402                 }
6403                 /*
6404                 **      Requeue the command to the start queue.
6405                 **      If any disconnected commands,
6406                 **              Clear SIGP.
6407                 **              Jump to reselect.
6408                 */
6409                 cp->phys.header.savep = cp->startp;
6410                 cp->host_status = HS_BUSY;
6411                 cp->scsi_status = S_ILLEGAL;
6412
6413                 ncr_put_start_queue(np, cp);
6414                 if (disc_cnt)
6415                         INB (nc_ctest2);                /* Clear SIGP */
6416                 OUTL_DSP (NCB_SCRIPT_PHYS (np, reselect));
6417                 return;
6418         case S_TERMINATED:
6419         case S_CHECK_COND:
6420                 /*
6421                 **      If we were requesting sense, give up.
6422                 */
6423                 if (cp->auto_sense)
6424                         goto out;
6425
6426                 /*
6427                 **      Device returned CHECK CONDITION status.
6428                 **      Prepare all needed data strutures for getting
6429                 **      sense data.
6430                 **
6431                 **      identify message
6432                 */
6433                 cp->scsi_smsg2[0]       = M_IDENTIFY | cmd->device->lun;
6434                 cp->phys.smsg.addr      = cpu_to_scr(CCB_PHYS (cp, scsi_smsg2));
6435                 cp->phys.smsg.size      = cpu_to_scr(1);
6436
6437                 /*
6438                 **      sense command
6439                 */
6440                 cp->phys.cmd.addr       = cpu_to_scr(CCB_PHYS (cp, sensecmd));
6441                 cp->phys.cmd.size       = cpu_to_scr(6);
6442
6443                 /*
6444                 **      patch requested size into sense command
6445                 */
6446                 cp->sensecmd[0]         = 0x03;
6447                 cp->sensecmd[1]         = cmd->device->lun << 5;
6448                 cp->sensecmd[4]         = sizeof(cp->sense_buf);
6449
6450                 /*
6451                 **      sense data
6452                 */
6453                 bzero(cp->sense_buf, sizeof(cp->sense_buf));
6454                 cp->phys.sense.addr     = cpu_to_scr(CCB_PHYS(cp,sense_buf[0]));
6455                 cp->phys.sense.size     = cpu_to_scr(sizeof(cp->sense_buf));
6456
6457                 /*
6458                 **      requeue the command.
6459                 */
6460                 startp = cpu_to_scr(NCB_SCRIPTH_PHYS (np, sdata_in));
6461
6462                 cp->phys.header.savep   = startp;
6463                 cp->phys.header.goalp   = startp + 24;
6464                 cp->phys.header.lastp   = startp;
6465                 cp->phys.header.wgoalp  = startp + 24;
6466                 cp->phys.header.wlastp  = startp;
6467
6468                 cp->host_status = HS_BUSY;
6469                 cp->scsi_status = S_ILLEGAL;
6470                 cp->auto_sense  = s_status;
6471
6472                 cp->start.schedule.l_paddr =
6473                         cpu_to_scr(NCB_SCRIPT_PHYS (np, select));
6474
6475                 /*
6476                 **      Select without ATN for quirky devices.
6477                 */
6478                 if (tp->quirks & QUIRK_NOMSG)
6479                         cp->start.schedule.l_paddr =
6480                         cpu_to_scr(NCB_SCRIPTH_PHYS (np, select_no_atn));
6481
6482                 ncr_put_start_queue(np, cp);
6483
6484                 OUTL_DSP (NCB_SCRIPT_PHYS (np, start));
6485                 return;
6486         }
6487
6488 out:
6489         OUTONB_STD ();
6490         return;
6491 }
6492
6493
6494 /*==========================================================
6495 **
6496 **
6497 **      ncr chip exception handler for programmed interrupts.
6498 **
6499 **
6500 **==========================================================
6501 */
6502
6503 static int ncr_show_msg (u_char * msg)
6504 {
6505         u_char i;
6506         printk ("%x",*msg);
6507         if (*msg==M_EXTENDED) {
6508                 for (i=1;i<8;i++) {
6509                         if (i-1>msg[1]) break;
6510                         printk ("-%x",msg[i]);
6511                 };
6512                 return (i+1);
6513         } else if ((*msg & 0xf0) == 0x20) {
6514                 printk ("-%x",msg[1]);
6515                 return (2);
6516         };
6517         return (1);
6518 }
6519
6520 static void ncr_print_msg ( struct ccb *cp, char *label, u_char *msg)
6521 {
6522         if (cp)
6523                 PRINT_ADDR(cp->cmd);
6524         if (label)
6525                 printk("%s: ", label);
6526
6527         (void) ncr_show_msg (msg);
6528         printk(".\n");
6529 }
6530
6531 void ncr_int_sir (struct ncb *np)
6532 {
6533         u_char scntl3;
6534         u_char chg, ofs, per, fak, wide;
6535         u_char num = INB (nc_dsps);
6536         struct ccb *cp=NULL;
6537         u_long  dsa    = INL (nc_dsa);
6538         u_char  target = INB (nc_sdid) & 0x0f;
6539         struct tcb *tp     = &np->target[target];
6540
6541         if (DEBUG_FLAGS & DEBUG_TINY) printk ("I#%d", num);
6542
6543         switch (num) {
6544         case SIR_INTFLY:
6545                 /*
6546                 **      This is used for HP Zalon/53c720 where INTFLY
6547                 **      operation is currently broken.
6548                 */
6549                 ncr_wakeup_done(np);
6550 #ifdef SCSI_NCR_CCB_DONE_SUPPORT
6551                 OUTL(nc_dsp, NCB_SCRIPT_PHYS (np, done_end) + 8);
6552 #else
6553                 OUTL(nc_dsp, NCB_SCRIPT_PHYS (np, start));
6554 #endif
6555                 return;
6556         case SIR_RESEL_NO_MSG_IN:
6557         case SIR_RESEL_NO_IDENTIFY:
6558                 /*
6559                 **      If devices reselecting without sending an IDENTIFY
6560                 **      message still exist, this should help.
6561                 **      We just assume lun=0, 1 CCB, no tag.
6562                 */
6563                 if (tp->lp[0]) {
6564                         OUTL_DSP (scr_to_cpu(tp->lp[0]->jump_ccb[0]));
6565                         return;
6566                 }
6567         case SIR_RESEL_BAD_TARGET:      /* Will send a TARGET RESET message */
6568         case SIR_RESEL_BAD_LUN:         /* Will send a TARGET RESET message */
6569         case SIR_RESEL_BAD_I_T_L_Q:     /* Will send an ABORT TAG message   */
6570         case SIR_RESEL_BAD_I_T_L:       /* Will send an ABORT message       */
6571                 printk ("%s:%d: SIR %d, "
6572                         "incorrect nexus identification on reselection\n",
6573                         ncr_name (np), target, num);
6574                 goto out;
6575         case SIR_DONE_OVERFLOW:
6576                 printk ("%s:%d: SIR %d, "
6577                         "CCB done queue overflow\n",
6578                         ncr_name (np), target, num);
6579                 goto out;
6580         case SIR_BAD_STATUS:
6581                 cp = np->header.cp;
6582                 if (!cp || CCB_PHYS (cp, phys) != dsa)
6583                         goto out;
6584                 ncr_sir_to_redo(np, num, cp);
6585                 return;
6586         default:
6587                 /*
6588                 **      lookup the ccb
6589                 */
6590                 cp = np->ccb;
6591                 while (cp && (CCB_PHYS (cp, phys) != dsa))
6592                         cp = cp->link_ccb;
6593
6594                 assert (cp && cp == np->header.cp);
6595
6596                 if (!cp || cp != np->header.cp)
6597                         goto out;
6598         }
6599
6600         switch (num) {
6601 /*-----------------------------------------------------------------------------
6602 **
6603 **      Was Sie schon immer ueber transfermode negotiation wissen wollten ...
6604 **
6605 **      We try to negotiate sync and wide transfer only after
6606 **      a successful inquire command. We look at byte 7 of the
6607 **      inquire data to determine the capabilities of the target.
6608 **
6609 **      When we try to negotiate, we append the negotiation message
6610 **      to the identify and (maybe) simple tag message.
6611 **      The host status field is set to HS_NEGOTIATE to mark this
6612 **      situation.
6613 **
6614 **      If the target doesn't answer this message immidiately
6615 **      (as required by the standard), the SIR_NEGO_FAIL interrupt
6616 **      will be raised eventually.
6617 **      The handler removes the HS_NEGOTIATE status, and sets the
6618 **      negotiated value to the default (async / nowide).
6619 **
6620 **      If we receive a matching answer immediately, we check it
6621 **      for validity, and set the values.
6622 **
6623 **      If we receive a Reject message immediately, we assume the
6624 **      negotiation has failed, and fall back to standard values.
6625 **
6626 **      If we receive a negotiation message while not in HS_NEGOTIATE
6627 **      state, it's a target initiated negotiation. We prepare a
6628 **      (hopefully) valid answer, set our parameters, and send back
6629 **      this answer to the target.
6630 **
6631 **      If the target doesn't fetch the answer (no message out phase),
6632 **      we assume the negotiation has failed, and fall back to default
6633 **      settings.
6634 **
6635 **      When we set the values, we adjust them in all ccbs belonging
6636 **      to this target, in the controller's register, and in the "phys"
6637 **      field of the controller's struct ncb.
6638 **
6639 **      Possible cases:            hs  sir   msg_in value  send   goto
6640 **      We try to negotiate:
6641 **      -> target doesn't msgin    NEG FAIL  noop   defa.  -      dispatch
6642 **      -> target rejected our msg NEG FAIL  reject defa.  -      dispatch
6643 **      -> target answered  (ok)   NEG SYNC  sdtr   set    -      clrack
6644 **      -> target answered (!ok)   NEG SYNC  sdtr   defa.  REJ--->msg_bad
6645 **      -> target answered  (ok)   NEG WIDE  wdtr   set    -      clrack
6646 **      -> target answered (!ok)   NEG WIDE  wdtr   defa.  REJ--->msg_bad
6647 **      -> any other msgin         NEG FAIL  noop   defa.  -      dispatch
6648 **
6649 **      Target tries to negotiate:
6650 **      -> incoming message        --- SYNC  sdtr   set    SDTR   -
6651 **      -> incoming message        --- WIDE  wdtr   set    WDTR   -
6652 **      We sent our answer:
6653 **      -> target doesn't msgout   --- PROTO ?      defa.  -      dispatch
6654 **
6655 **-----------------------------------------------------------------------------
6656 */
6657
6658         case SIR_NEGO_FAILED:
6659                 /*-------------------------------------------------------
6660                 **
6661                 **      Negotiation failed.
6662                 **      Target doesn't send an answer message,
6663                 **      or target rejected our message.
6664                 **
6665                 **      Remove negotiation request.
6666                 **
6667                 **-------------------------------------------------------
6668                 */
6669                 OUTB (HS_PRT, HS_BUSY);
6670
6671                 /* fall through */
6672
6673         case SIR_NEGO_PROTO:
6674                 /*-------------------------------------------------------
6675                 **
6676                 **      Negotiation failed.
6677                 **      Target doesn't fetch the answer message.
6678                 **
6679                 **-------------------------------------------------------
6680                 */
6681
6682                 if (DEBUG_FLAGS & DEBUG_NEGO) {
6683                         PRINT_ADDR(cp->cmd);
6684                         printk ("negotiation failed sir=%x status=%x.\n",
6685                                 num, cp->nego_status);
6686                 };
6687
6688                 /*
6689                 **      any error in negotiation:
6690                 **      fall back to default mode.
6691                 */
6692                 switch (cp->nego_status) {
6693
6694                 case NS_SYNC:
6695                         ncr_setsync (np, cp, 0, 0xe0);
6696                         break;
6697
6698                 case NS_WIDE:
6699                         ncr_setwide (np, cp, 0, 0);
6700                         break;
6701
6702                 };
6703                 np->msgin [0] = M_NOOP;
6704                 np->msgout[0] = M_NOOP;
6705                 cp->nego_status = 0;
6706                 break;
6707
6708         case SIR_NEGO_SYNC:
6709                 /*
6710                 **      Synchronous request message received.
6711                 */
6712
6713                 if (DEBUG_FLAGS & DEBUG_NEGO) {
6714                         PRINT_ADDR(cp->cmd);
6715                         printk ("sync msgin: ");
6716                         (void) ncr_show_msg (np->msgin);
6717                         printk (".\n");
6718                 };
6719
6720                 /*
6721                 **      get requested values.
6722                 */
6723
6724                 chg = 0;
6725                 per = np->msgin[3];
6726                 ofs = np->msgin[4];
6727                 if (ofs==0) per=255;
6728
6729                 /*
6730                 **      if target sends SDTR message,
6731                 **            it CAN transfer synch.
6732                 */
6733
6734                 if (ofs)
6735                         tp->inq_byte7 |= INQ7_SYNC;
6736
6737                 /*
6738                 **      check values against driver limits.
6739                 */
6740
6741                 if (per < np->minsync)
6742                         {chg = 1; per = np->minsync;}
6743                 if (per < tp->minsync)
6744                         {chg = 1; per = tp->minsync;}
6745                 if (ofs > tp->maxoffs)
6746                         {chg = 1; ofs = tp->maxoffs;}
6747
6748                 /*
6749                 **      Check against controller limits.
6750                 */
6751                 fak     = 7;
6752                 scntl3  = 0;
6753                 if (ofs != 0) {
6754                         ncr_getsync(np, per, &fak, &scntl3);
6755                         if (fak > 7) {
6756                                 chg = 1;
6757                                 ofs = 0;
6758                         }
6759                 }
6760                 if (ofs == 0) {
6761                         fak     = 7;
6762                         per     = 0;
6763                         scntl3  = 0;
6764                         tp->minsync = 0;
6765                 }
6766
6767                 if (DEBUG_FLAGS & DEBUG_NEGO) {
6768                         PRINT_ADDR(cp->cmd);
6769                         printk ("sync: per=%d scntl3=0x%x ofs=%d fak=%d chg=%d.\n",
6770                                 per, scntl3, ofs, fak, chg);
6771                 }
6772
6773                 if (INB (HS_PRT) == HS_NEGOTIATE) {
6774                         OUTB (HS_PRT, HS_BUSY);
6775                         switch (cp->nego_status) {
6776
6777                         case NS_SYNC:
6778                                 /*
6779                                 **      This was an answer message
6780                                 */
6781                                 if (chg) {
6782                                         /*
6783                                         **      Answer wasn't acceptable.
6784                                         */
6785                                         ncr_setsync (np, cp, 0, 0xe0);
6786                                         OUTL_DSP (NCB_SCRIPT_PHYS (np, msg_bad));
6787                                 } else {
6788                                         /*
6789                                         **      Answer is ok.
6790                                         */
6791                                         ncr_setsync (np, cp, scntl3, (fak<<5)|ofs);
6792                                         OUTL_DSP (NCB_SCRIPT_PHYS (np, clrack));
6793                                 };
6794                                 return;
6795
6796                         case NS_WIDE:
6797                                 ncr_setwide (np, cp, 0, 0);
6798                                 break;
6799                         };
6800                 };
6801
6802                 /*
6803                 **      It was a request. Set value and
6804                 **      prepare an answer message
6805                 */
6806
6807                 ncr_setsync (np, cp, scntl3, (fak<<5)|ofs);
6808
6809                 np->msgout[0] = M_EXTENDED;
6810                 np->msgout[1] = 3;
6811                 np->msgout[2] = M_X_SYNC_REQ;
6812                 np->msgout[3] = per;
6813                 np->msgout[4] = ofs;
6814
6815                 cp->nego_status = NS_SYNC;
6816
6817                 if (DEBUG_FLAGS & DEBUG_NEGO) {
6818                         PRINT_ADDR(cp->cmd);
6819                         printk ("sync msgout: ");
6820                         (void) ncr_show_msg (np->msgout);
6821                         printk (".\n");
6822                 }
6823
6824                 if (!ofs) {
6825                         OUTL_DSP (NCB_SCRIPT_PHYS (np, msg_bad));
6826                         return;
6827                 }
6828                 np->msgin [0] = M_NOOP;
6829
6830                 break;
6831
6832         case SIR_NEGO_WIDE:
6833                 /*
6834                 **      Wide request message received.
6835                 */
6836                 if (DEBUG_FLAGS & DEBUG_NEGO) {
6837                         PRINT_ADDR(cp->cmd);
6838                         printk ("wide msgin: ");
6839                         (void) ncr_show_msg (np->msgin);
6840                         printk (".\n");
6841                 };
6842
6843                 /*
6844                 **      get requested values.
6845                 */
6846
6847                 chg  = 0;
6848                 wide = np->msgin[3];
6849
6850                 /*
6851                 **      if target sends WDTR message,
6852                 **            it CAN transfer wide.
6853                 */
6854
6855                 if (wide)
6856                         tp->inq_byte7 |= INQ7_WIDE16;
6857
6858                 /*
6859                 **      check values against driver limits.
6860                 */
6861
6862                 if (wide > tp->usrwide)
6863                         {chg = 1; wide = tp->usrwide;}
6864
6865                 if (DEBUG_FLAGS & DEBUG_NEGO) {
6866                         PRINT_ADDR(cp->cmd);
6867                         printk ("wide: wide=%d chg=%d.\n", wide, chg);
6868                 }
6869
6870                 if (INB (HS_PRT) == HS_NEGOTIATE) {
6871                         OUTB (HS_PRT, HS_BUSY);
6872                         switch (cp->nego_status) {
6873
6874                         case NS_WIDE:
6875                                 /*
6876                                 **      This was an answer message
6877                                 */
6878                                 if (chg) {
6879                                         /*
6880                                         **      Answer wasn't acceptable.
6881                                         */
6882                                         ncr_setwide (np, cp, 0, 1);
6883                                         OUTL_DSP (NCB_SCRIPT_PHYS (np, msg_bad));
6884                                 } else {
6885                                         /*
6886                                         **      Answer is ok.
6887                                         */
6888                                         ncr_setwide (np, cp, wide, 1);
6889                                         OUTL_DSP (NCB_SCRIPT_PHYS (np, clrack));
6890                                 };
6891                                 return;
6892
6893                         case NS_SYNC:
6894                                 ncr_setsync (np, cp, 0, 0xe0);
6895                                 break;
6896                         };
6897                 };
6898
6899                 /*
6900                 **      It was a request, set value and
6901                 **      prepare an answer message
6902                 */
6903
6904                 ncr_setwide (np, cp, wide, 1);
6905
6906                 np->msgout[0] = M_EXTENDED;
6907                 np->msgout[1] = 2;
6908                 np->msgout[2] = M_X_WIDE_REQ;
6909                 np->msgout[3] = wide;
6910
6911                 np->msgin [0] = M_NOOP;
6912
6913                 cp->nego_status = NS_WIDE;
6914
6915                 if (DEBUG_FLAGS & DEBUG_NEGO) {
6916                         PRINT_ADDR(cp->cmd);
6917                         printk ("wide msgout: ");
6918                         (void) ncr_show_msg (np->msgin);
6919                         printk (".\n");
6920                 }
6921                 break;
6922
6923 /*--------------------------------------------------------------------
6924 **
6925 **      Processing of special messages
6926 **
6927 **--------------------------------------------------------------------
6928 */
6929
6930         case SIR_REJECT_RECEIVED:
6931                 /*-----------------------------------------------
6932                 **
6933                 **      We received a M_REJECT message.
6934                 **
6935                 **-----------------------------------------------
6936                 */
6937
6938                 PRINT_ADDR(cp->cmd);
6939                 printk ("M_REJECT received (%x:%x).\n",
6940                         (unsigned)scr_to_cpu(np->lastmsg), np->msgout[0]);
6941                 break;
6942
6943         case SIR_REJECT_SENT:
6944                 /*-----------------------------------------------
6945                 **
6946                 **      We received an unknown message
6947                 **
6948                 **-----------------------------------------------
6949                 */
6950
6951                 PRINT_ADDR(cp->cmd);
6952                 printk ("M_REJECT sent for ");
6953                 (void) ncr_show_msg (np->msgin);
6954                 printk (".\n");
6955                 break;
6956
6957 /*--------------------------------------------------------------------
6958 **
6959 **      Processing of special messages
6960 **
6961 **--------------------------------------------------------------------
6962 */
6963
6964         case SIR_IGN_RESIDUE:
6965                 /*-----------------------------------------------
6966                 **
6967                 **      We received an IGNORE RESIDUE message,
6968                 **      which couldn't be handled by the script.
6969                 **
6970                 **-----------------------------------------------
6971                 */
6972
6973                 PRINT_ADDR(cp->cmd);
6974                 printk ("M_IGN_RESIDUE received, but not yet implemented.\n");
6975                 break;
6976 #if 0
6977         case SIR_MISSING_SAVE:
6978                 /*-----------------------------------------------
6979                 **
6980                 **      We received an DISCONNECT message,
6981                 **      but the datapointer wasn't saved before.
6982                 **
6983                 **-----------------------------------------------
6984                 */
6985
6986                 PRINT_ADDR(cp->cmd);
6987                 printk ("M_DISCONNECT received, but datapointer not saved: "
6988                         "data=%x save=%x goal=%x.\n",
6989                         (unsigned) INL (nc_temp),
6990                         (unsigned) scr_to_cpu(np->header.savep),
6991                         (unsigned) scr_to_cpu(np->header.goalp));
6992                 break;
6993 #endif
6994         };
6995
6996 out:
6997         OUTONB_STD ();
6998 }
6999
7000 /*==========================================================
7001 **
7002 **
7003 **      Acquire a control block
7004 **
7005 **
7006 **==========================================================
7007 */
7008
7009 static  struct ccb *ncr_get_ccb (struct ncb *np, u_char tn, u_char ln)
7010 {
7011         struct tcb *tp = &np->target[tn];
7012         struct lcb *lp = tp->lp[ln];
7013         u_char tag = NO_TAG;
7014         struct ccb *cp = NULL;
7015
7016         /*
7017         **      Lun structure available ?
7018         */
7019         if (lp) {
7020                 XPT_QUEHEAD *qp;
7021                 /*
7022                 **      Keep from using more tags than we can handle.
7023                 */
7024                 if (lp->usetags && lp->busyccbs >= lp->maxnxs)
7025                         return NULL;
7026
7027                 /*
7028                 **      Allocate a new CCB if needed.
7029                 */
7030                 if (xpt_que_empty(&lp->free_ccbq))
7031                         ncr_alloc_ccb(np, tn, ln);
7032
7033                 /*
7034                 **      Tune tag mode if asked by user.
7035                 */
7036                 if (lp->queuedepth != lp->numtags) {
7037                         ncr_setup_tags(np, tn, ln);
7038                 }
7039
7040                 /*
7041                 **      Look for free CCB
7042                 */
7043                 qp = xpt_remque_head(&lp->free_ccbq);
7044                 if (qp) {
7045                         cp = xpt_que_entry(qp, struct ccb, link_ccbq);
7046                         if (cp->magic) {
7047                                 PRINT_LUN(np, tn, ln);
7048                                 printk ("ccb free list corrupted (@%p)\n", cp);
7049                                 cp = NULL;
7050                         }
7051                         else {
7052                                 xpt_insque_tail(qp, &lp->wait_ccbq);
7053                                 ++lp->busyccbs;
7054                         }
7055                 }
7056
7057                 /*
7058                 **      If a CCB is available,
7059                 **      Get a tag for this nexus if required.
7060                 */
7061                 if (cp) {
7062                         if (lp->usetags)
7063                                 tag = lp->cb_tags[lp->ia_tag];
7064                 }
7065                 else if (lp->actccbs > 0)
7066                         return NULL;
7067         }
7068
7069         /*
7070         **      if nothing available, take the default.
7071         */
7072         if (!cp)
7073                 cp = np->ccb;
7074
7075         /*
7076         **      Wait until available.
7077         */
7078 #if 0
7079         while (cp->magic) {
7080                 if (flags & SCSI_NOSLEEP) break;
7081                 if (tsleep ((caddr_t)cp, PRIBIO|PCATCH, "ncr", 0))
7082                         break;
7083         };
7084 #endif
7085
7086         if (cp->magic)
7087                 return NULL;
7088
7089         cp->magic = 1;
7090
7091         /*
7092         **      Move to next available tag if tag used.
7093         */
7094         if (lp) {
7095                 if (tag != NO_TAG) {
7096                         ++lp->ia_tag;
7097                         if (lp->ia_tag == MAX_TAGS)
7098                                 lp->ia_tag = 0;
7099                         lp->tags_umap |= (((tagmap_t) 1) << tag);
7100                 }
7101         }
7102
7103         /*
7104         **      Remember all informations needed to free this CCB.
7105         */
7106         cp->tag    = tag;
7107         cp->target = tn;
7108         cp->lun    = ln;
7109
7110         if (DEBUG_FLAGS & DEBUG_TAGS) {
7111                 PRINT_LUN(np, tn, ln);
7112                 printk ("ccb @%p using tag %d.\n", cp, tag);
7113         }
7114
7115         return cp;
7116 }
7117
7118 /*==========================================================
7119 **
7120 **
7121 **      Release one control block
7122 **
7123 **
7124 **==========================================================
7125 */
7126
7127 static void ncr_free_ccb (struct ncb *np, struct ccb *cp)
7128 {
7129         struct tcb *tp = &np->target[cp->target];
7130         struct lcb *lp = tp->lp[cp->lun];
7131
7132         if (DEBUG_FLAGS & DEBUG_TAGS) {
7133                 PRINT_LUN(np, cp->target, cp->lun);
7134                 printk ("ccb @%p freeing tag %d.\n", cp, cp->tag);
7135         }
7136
7137         /*
7138         **      If lun control block available,
7139         **      decrement active commands and increment credit,
7140         **      free the tag if any and remove the JUMP for reselect.
7141         */
7142         if (lp) {
7143                 if (cp->tag != NO_TAG) {
7144                         lp->cb_tags[lp->if_tag++] = cp->tag;
7145                         if (lp->if_tag == MAX_TAGS)
7146                                 lp->if_tag = 0;
7147                         lp->tags_umap &= ~(((tagmap_t) 1) << cp->tag);
7148                         lp->tags_smap &= lp->tags_umap;
7149                         lp->jump_ccb[cp->tag] =
7150                                 cpu_to_scr(NCB_SCRIPTH_PHYS(np, bad_i_t_l_q));
7151                 } else {
7152                         lp->jump_ccb[0] =
7153                                 cpu_to_scr(NCB_SCRIPTH_PHYS(np, bad_i_t_l));
7154                 }
7155         }
7156
7157         /*
7158         **      Make this CCB available.
7159         */
7160
7161         if (lp) {
7162                 if (cp != np->ccb) {
7163                         xpt_remque(&cp->link_ccbq);
7164                         xpt_insque_head(&cp->link_ccbq, &lp->free_ccbq);
7165                 }
7166                 --lp->busyccbs;
7167                 if (cp->queued) {
7168                         --lp->queuedccbs;
7169                 }
7170         }
7171         cp -> host_status = HS_IDLE;
7172         cp -> magic = 0;
7173         if (cp->queued) {
7174                 --np->queuedccbs;
7175                 cp->queued = 0;
7176         }
7177
7178 #if 0
7179         if (cp == np->ccb)
7180                 wakeup ((caddr_t) cp);
7181 #endif
7182 }
7183
7184
7185 #define ncr_reg_bus_addr(r) (np->paddr + offsetof (struct ncr_reg, r))
7186
7187 /*------------------------------------------------------------------------
7188 **      Initialize the fixed part of a CCB structure.
7189 **------------------------------------------------------------------------
7190 **------------------------------------------------------------------------
7191 */
7192 static void ncr_init_ccb(struct ncb *np, struct ccb *cp)
7193 {
7194         ncrcmd copy_4 = np->features & FE_PFEN ? SCR_COPY(4) : SCR_COPY_F(4);
7195
7196         /*
7197         **      Remember virtual and bus address of this ccb.
7198         */
7199         cp->p_ccb          = vtobus(cp);
7200         cp->phys.header.cp = cp;
7201
7202         /*
7203         **      This allows xpt_remque to work for the default ccb.
7204         */
7205         xpt_que_init(&cp->link_ccbq);
7206
7207         /*
7208         **      Initialyze the start and restart launch script.
7209         **
7210         **      COPY(4) @(...p_phys), @(dsa)
7211         **      JUMP @(sched_point)
7212         */
7213         cp->start.setup_dsa[0]   = cpu_to_scr(copy_4);
7214         cp->start.setup_dsa[1]   = cpu_to_scr(CCB_PHYS(cp, start.p_phys));
7215         cp->start.setup_dsa[2]   = cpu_to_scr(ncr_reg_bus_addr(nc_dsa));
7216         cp->start.schedule.l_cmd = cpu_to_scr(SCR_JUMP);
7217         cp->start.p_phys         = cpu_to_scr(CCB_PHYS(cp, phys));
7218
7219         memcpy(&cp->restart, &cp->start, sizeof(cp->restart));
7220
7221         cp->start.schedule.l_paddr   = cpu_to_scr(NCB_SCRIPT_PHYS (np, idle));
7222         cp->restart.schedule.l_paddr = cpu_to_scr(NCB_SCRIPTH_PHYS (np, abort));
7223 }
7224
7225
7226 /*------------------------------------------------------------------------
7227 **      Allocate a CCB and initialize its fixed part.
7228 **------------------------------------------------------------------------
7229 **------------------------------------------------------------------------
7230 */
7231 static void ncr_alloc_ccb(struct ncb *np, u_char tn, u_char ln)
7232 {
7233         struct tcb *tp = &np->target[tn];
7234         struct lcb *lp = tp->lp[ln];
7235         struct ccb *cp = NULL;
7236
7237         /*
7238         **      Allocate memory for this CCB.
7239         */
7240         cp = m_calloc_dma(sizeof(struct ccb), "CCB");
7241         if (!cp)
7242                 return;
7243
7244         /*
7245         **      Count it and initialyze it.
7246         */
7247         lp->actccbs++;
7248         np->actccbs++;
7249         bzero (cp, sizeof (*cp));
7250         ncr_init_ccb(np, cp);
7251
7252         /*
7253         **      Chain into wakeup list and free ccb queue and take it
7254         **      into account for tagged commands.
7255         */
7256         cp->link_ccb      = np->ccb->link_ccb;
7257         np->ccb->link_ccb = cp;
7258
7259         xpt_insque_head(&cp->link_ccbq, &lp->free_ccbq);
7260         ncr_setup_tags (np, tn, ln);
7261 }
7262
7263 /*==========================================================
7264 **
7265 **
7266 **      Allocation of resources for Targets/Luns/Tags.
7267 **
7268 **
7269 **==========================================================
7270 */
7271
7272
7273 /*------------------------------------------------------------------------
7274 **      Target control block initialisation.
7275 **------------------------------------------------------------------------
7276 **      This data structure is fully initialized after a SCSI command
7277 **      has been successfully completed for this target.
7278 **      It contains a SCRIPT that is called on target reselection.
7279 **------------------------------------------------------------------------
7280 */
7281 static void ncr_init_tcb (struct ncb *np, u_char tn)
7282 {
7283         struct tcb *tp = &np->target[tn];
7284         ncrcmd copy_1 = np->features & FE_PFEN ? SCR_COPY(1) : SCR_COPY_F(1);
7285         int th = tn & 3;
7286         int i;
7287
7288         /*
7289         **      Jump to next tcb if SFBR does not match this target.
7290         **      JUMP  IF (SFBR != #target#), @(next tcb)
7291         */
7292         tp->jump_tcb.l_cmd   =
7293                 cpu_to_scr((SCR_JUMP ^ IFFALSE (DATA (0x80 + tn))));
7294         tp->jump_tcb.l_paddr = np->jump_tcb[th].l_paddr;
7295
7296         /*
7297         **      Load the synchronous transfer register.
7298         **      COPY @(tp->sval), @(sxfer)
7299         */
7300         tp->getscr[0] = cpu_to_scr(copy_1);
7301         tp->getscr[1] = cpu_to_scr(vtobus (&tp->sval));
7302 #ifdef SCSI_NCR_BIG_ENDIAN
7303         tp->getscr[2] = cpu_to_scr(ncr_reg_bus_addr(nc_sxfer) ^ 3);
7304 #else
7305         tp->getscr[2] = cpu_to_scr(ncr_reg_bus_addr(nc_sxfer));
7306 #endif
7307
7308         /*
7309         **      Load the timing register.
7310         **      COPY @(tp->wval), @(scntl3)
7311         */
7312         tp->getscr[3] = cpu_to_scr(copy_1);
7313         tp->getscr[4] = cpu_to_scr(vtobus (&tp->wval));
7314 #ifdef SCSI_NCR_BIG_ENDIAN
7315         tp->getscr[5] = cpu_to_scr(ncr_reg_bus_addr(nc_scntl3) ^ 3);
7316 #else
7317         tp->getscr[5] = cpu_to_scr(ncr_reg_bus_addr(nc_scntl3));
7318 #endif
7319
7320         /*
7321         **      Get the IDENTIFY message and the lun.
7322         **      CALL @script(resel_lun)
7323         */
7324         tp->call_lun.l_cmd   = cpu_to_scr(SCR_CALL);
7325         tp->call_lun.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_lun));
7326
7327         /*
7328         **      Look for the lun control block of this nexus.
7329         **      For i = 0 to 3
7330         **              JUMP ^ IFTRUE (MASK (i, 3)), @(next_lcb)
7331         */
7332         for (i = 0 ; i < 4 ; i++) {
7333                 tp->jump_lcb[i].l_cmd   =
7334                                 cpu_to_scr((SCR_JUMP ^ IFTRUE (MASK (i, 3))));
7335                 tp->jump_lcb[i].l_paddr =
7336                                 cpu_to_scr(NCB_SCRIPTH_PHYS (np, bad_identify));
7337         }
7338
7339         /*
7340         **      Link this target control block to the JUMP chain.
7341         */
7342         np->jump_tcb[th].l_paddr = cpu_to_scr(vtobus (&tp->jump_tcb));
7343
7344         /*
7345         **      These assert's should be moved at driver initialisations.
7346         */
7347 #ifdef SCSI_NCR_BIG_ENDIAN
7348         assert (( (offsetof(struct ncr_reg, nc_sxfer) ^
7349                 offsetof(struct tcb    , sval    )) &3) == 3);
7350         assert (( (offsetof(struct ncr_reg, nc_scntl3) ^
7351                 offsetof(struct tcb    , wval    )) &3) == 3);
7352 #else
7353         assert (( (offsetof(struct ncr_reg, nc_sxfer) ^
7354                 offsetof(struct tcb    , sval    )) &3) == 0);
7355         assert (( (offsetof(struct ncr_reg, nc_scntl3) ^
7356                 offsetof(struct tcb    , wval    )) &3) == 0);
7357 #endif
7358 }
7359
7360
7361 /*------------------------------------------------------------------------
7362 **      Lun control block allocation and initialization.
7363 **------------------------------------------------------------------------
7364 **      This data structure is allocated and initialized after a SCSI
7365 **      command has been successfully completed for this target/lun.
7366 **------------------------------------------------------------------------
7367 */
7368 static struct lcb *ncr_alloc_lcb (struct ncb *np, u_char tn, u_char ln)
7369 {
7370         struct tcb *tp = &np->target[tn];
7371         struct lcb *lp = tp->lp[ln];
7372         ncrcmd copy_4 = np->features & FE_PFEN ? SCR_COPY(4) : SCR_COPY_F(4);
7373         int lh = ln & 3;
7374
7375         /*
7376         **      Already done, return.
7377         */
7378         if (lp)
7379                 return lp;
7380
7381         /*
7382         **      Allocate the lcb.
7383         */
7384         lp = m_calloc_dma(sizeof(struct lcb), "LCB");
7385         if (!lp)
7386                 goto fail;
7387         bzero(lp, sizeof(*lp));
7388         tp->lp[ln] = lp;
7389
7390         /*
7391         **      Initialize the target control block if not yet.
7392         */
7393         if (!tp->jump_tcb.l_cmd)
7394                 ncr_init_tcb(np, tn);
7395
7396         /*
7397         **      Initialize the CCB queue headers.
7398         */
7399         xpt_que_init(&lp->free_ccbq);
7400         xpt_que_init(&lp->busy_ccbq);
7401         xpt_que_init(&lp->wait_ccbq);
7402         xpt_que_init(&lp->skip_ccbq);
7403
7404         /*
7405         **      Set max CCBs to 1 and use the default 1 entry
7406         **      jump table by default.
7407         */
7408         lp->maxnxs      = 1;
7409         lp->jump_ccb    = &lp->jump_ccb_0;
7410         lp->p_jump_ccb  = cpu_to_scr(vtobus(lp->jump_ccb));
7411
7412         /*
7413         **      Initilialyze the reselect script:
7414         **
7415         **      Jump to next lcb if SFBR does not match this lun.
7416         **      Load TEMP with the CCB direct jump table bus address.
7417         **      Get the SIMPLE TAG message and the tag.
7418         **
7419         **      JUMP  IF (SFBR != #lun#), @(next lcb)
7420         **      COPY @(lp->p_jump_ccb),   @(temp)
7421         **      JUMP @script(resel_notag)
7422         */
7423         lp->jump_lcb.l_cmd   =
7424                 cpu_to_scr((SCR_JUMP ^ IFFALSE (MASK (0x80+ln, 0xff))));
7425         lp->jump_lcb.l_paddr = tp->jump_lcb[lh].l_paddr;
7426
7427         lp->load_jump_ccb[0] = cpu_to_scr(copy_4);
7428         lp->load_jump_ccb[1] = cpu_to_scr(vtobus (&lp->p_jump_ccb));
7429         lp->load_jump_ccb[2] = cpu_to_scr(ncr_reg_bus_addr(nc_temp));
7430
7431         lp->jump_tag.l_cmd   = cpu_to_scr(SCR_JUMP);
7432         lp->jump_tag.l_paddr = cpu_to_scr(NCB_SCRIPT_PHYS (np, resel_notag));
7433
7434         /*
7435         **      Link this lun control block to the JUMP chain.
7436         */
7437         tp->jump_lcb[lh].l_paddr = cpu_to_scr(vtobus (&lp->jump_lcb));
7438
7439         /*
7440         **      Initialize command queuing control.
7441         */
7442         lp->busyccbs    = 1;
7443         lp->queuedccbs  = 1;
7444         lp->queuedepth  = 1;
7445 fail:
7446         return lp;
7447 }
7448
7449
7450 /*------------------------------------------------------------------------
7451 **      Lun control block setup on INQUIRY data received.
7452 **------------------------------------------------------------------------
7453 **      We only support WIDE, SYNC for targets and CMDQ for logical units.
7454 **      This setup is done on each INQUIRY since we are expecting user
7455 **      will play with CHANGE DEFINITION commands. :-)
7456 **------------------------------------------------------------------------
7457 */
7458 static struct lcb *ncr_setup_lcb (struct ncb *np, u_char tn, u_char ln, u_char *inq_data)
7459 {
7460         struct tcb *tp = &np->target[tn];
7461         struct lcb *lp = tp->lp[ln];
7462         u_char inq_byte7;
7463
7464         /*
7465         **      If no lcb, try to allocate it.
7466         */
7467         if (!lp && !(lp = ncr_alloc_lcb(np, tn, ln)))
7468                 goto fail;
7469
7470         /*
7471         **      Get device quirks from a speciality table.
7472         */
7473         tp->quirks = ncr_lookup (inq_data);
7474         if (tp->quirks && bootverbose) {
7475                 PRINT_LUN(np, tn, ln);
7476                 printk ("quirks=%x.\n", tp->quirks);
7477         }
7478
7479         /*
7480         **      Evaluate trustable target/unit capabilities.
7481         **      We only believe device version >= SCSI-2 that
7482         **      use appropriate response data format (2).
7483         **      But it seems that some CCS devices also
7484         **      support SYNC and I donnot want to frustrate
7485         **      anybody. ;-)
7486         */
7487         inq_byte7 = 0;
7488         if      ((inq_data[2] & 0x7) >= 2 && (inq_data[3] & 0xf) == 2)
7489                 inq_byte7 = inq_data[7];
7490         else if ((inq_data[2] & 0x7) == 1 && (inq_data[3] & 0xf) == 1)
7491                 inq_byte7 = INQ7_SYNC;
7492
7493         /*
7494         **      Throw away announced LUN capabilities if we are told
7495         **      that there is no real device supported by the logical unit.
7496         */
7497         if ((inq_data[0] & 0xe0) > 0x20 || (inq_data[0] & 0x1f) == 0x1f)
7498                 inq_byte7 &= (INQ7_SYNC | INQ7_WIDE16);
7499
7500         /*
7501         **      If user is wanting SYNC, force this feature.
7502         */
7503         if (driver_setup.force_sync_nego)
7504                 inq_byte7 |= INQ7_SYNC;
7505
7506         /*
7507         **      Prepare negotiation if SIP capabilities have changed.
7508         */
7509         tp->inq_done = 1;
7510         if ((inq_byte7 ^ tp->inq_byte7) & (INQ7_SYNC | INQ7_WIDE16)) {
7511                 tp->inq_byte7 = inq_byte7;
7512                 ncr_negotiate(np, tp);
7513         }
7514
7515         /*
7516         **      If unit supports tagged commands, allocate the
7517         **      CCB JUMP table if not yet.
7518         */
7519         if ((inq_byte7 & INQ7_QUEUE) && lp->jump_ccb == &lp->jump_ccb_0) {
7520                 int i;
7521                 lp->jump_ccb = m_calloc_dma(256, "JUMP_CCB");
7522                 if (!lp->jump_ccb) {
7523                         lp->jump_ccb = &lp->jump_ccb_0;
7524                         goto fail;
7525                 }
7526                 lp->p_jump_ccb = cpu_to_scr(vtobus(lp->jump_ccb));
7527                 for (i = 0 ; i < 64 ; i++)
7528                         lp->jump_ccb[i] =
7529                                 cpu_to_scr(NCB_SCRIPTH_PHYS (np, bad_i_t_l_q));
7530                 for (i = 0 ; i < MAX_TAGS ; i++)
7531                         lp->cb_tags[i] = i;
7532                 lp->maxnxs = MAX_TAGS;
7533                 lp->tags_stime = ktime_get(3*HZ);
7534         }
7535
7536         /*
7537         **      Adjust tagged queueing status if needed.
7538         */
7539         if ((inq_byte7 ^ lp->inq_byte7) & INQ7_QUEUE) {
7540                 lp->inq_byte7 = inq_byte7;
7541                 lp->numtags   = lp->maxtags;
7542                 ncr_setup_tags (np, tn, ln);
7543         }
7544
7545 fail:
7546         return lp;
7547 }
7548
7549 /*==========================================================
7550 **
7551 **
7552 **      Build Scatter Gather Block
7553 **
7554 **
7555 **==========================================================
7556 **
7557 **      The transfer area may be scattered among
7558 **      several non adjacent physical pages.
7559 **
7560 **      We may use MAX_SCATTER blocks.
7561 **
7562 **----------------------------------------------------------
7563 */
7564
7565 /*
7566 **      We try to reduce the number of interrupts caused
7567 **      by unexpected phase changes due to disconnects.
7568 **      A typical harddisk may disconnect before ANY block.
7569 **      If we wanted to avoid unexpected phase changes at all
7570 **      we had to use a break point every 512 bytes.
7571 **      Of course the number of scatter/gather blocks is
7572 **      limited.
7573 **      Under Linux, the scatter/gatter blocks are provided by
7574 **      the generic driver. We just have to copy addresses and
7575 **      sizes to the data segment array.
7576 */
7577
7578 static int ncr_scatter_no_sglist(struct ncb *np, struct ccb *cp, struct scsi_cmnd *cmd)
7579 {
7580         struct scr_tblmove *data = &cp->phys.data[MAX_SCATTER - 1];
7581         int segment;
7582
7583         cp->data_len = cmd->request_bufflen;
7584
7585         if (cmd->request_bufflen) {
7586                 dma_addr_t baddr = map_scsi_single_data(np, cmd);
7587                 if (baddr) {
7588                         ncr_build_sge(np, data, baddr, cmd->request_bufflen);
7589                         segment = 1;
7590                 } else {
7591                         segment = -2;
7592                 }
7593         } else {
7594                 segment = 0;
7595         }
7596
7597         return segment;
7598 }
7599
7600 static int ncr_scatter(struct ncb *np, struct ccb *cp, struct scsi_cmnd *cmd)
7601 {
7602         int segment     = 0;
7603         int use_sg      = (int) cmd->use_sg;
7604
7605         cp->data_len    = 0;
7606
7607         if (!use_sg)
7608                 segment = ncr_scatter_no_sglist(np, cp, cmd);
7609         else if ((use_sg = map_scsi_sg_data(np, cmd)) > 0) {
7610                 struct scatterlist *scatter = (struct scatterlist *)cmd->buffer;
7611                 struct scr_tblmove *data;
7612
7613                 if (use_sg > MAX_SCATTER) {
7614                         unmap_scsi_data(np, cmd);
7615                         return -1;
7616                 }
7617
7618                 data = &cp->phys.data[MAX_SCATTER - use_sg];
7619
7620                 for (segment = 0; segment < use_sg; segment++) {
7621                         dma_addr_t baddr = sg_dma_address(&scatter[segment]);
7622                         unsigned int len = sg_dma_len(&scatter[segment]);
7623
7624                         ncr_build_sge(np, &data[segment], baddr, len);
7625                         cp->data_len += len;
7626                 }
7627         } else {
7628                 segment = -2;
7629         }
7630
7631         return segment;
7632 }
7633
7634 /*==========================================================
7635 **
7636 **
7637 **      Test the bus snoop logic :-(
7638 **
7639 **      Has to be called with interrupts disabled.
7640 **
7641 **
7642 **==========================================================
7643 */
7644
7645 static int __init ncr_regtest (struct ncb* np)
7646 {
7647         register volatile u32 data;
7648         /*
7649         **      ncr registers may NOT be cached.
7650         **      write 0xffffffff to a read only register area,
7651         **      and try to read it back.
7652         */
7653         data = 0xffffffff;
7654         OUTL_OFF(offsetof(struct ncr_reg, nc_dstat), data);
7655         data = INL_OFF(offsetof(struct ncr_reg, nc_dstat));
7656 #if 1
7657         if (data == 0xffffffff) {
7658 #else
7659         if ((data & 0xe2f0fffd) != 0x02000080) {
7660 #endif
7661                 printk ("CACHE TEST FAILED: reg dstat-sstat2 readback %x.\n",
7662                         (unsigned) data);
7663                 return (0x10);
7664         };
7665         return (0);
7666 }
7667
7668 static int __init ncr_snooptest (struct ncb* np)
7669 {
7670         u32     ncr_rd, ncr_wr, ncr_bk, host_rd, host_wr, pc;
7671         int     i, err=0;
7672         if (np->reg) {
7673                 err |= ncr_regtest (np);
7674                 if (err)
7675                         return (err);
7676         }
7677
7678         /* init */
7679         pc  = NCB_SCRIPTH_PHYS (np, snooptest);
7680         host_wr = 1;
7681         ncr_wr  = 2;
7682         /*
7683         **      Set memory and register.
7684         */
7685         np->ncr_cache = cpu_to_scr(host_wr);
7686         OUTL (nc_temp, ncr_wr);
7687         /*
7688         **      Start script (exchange values)
7689         */
7690         OUTL_DSP (pc);
7691         /*
7692         **      Wait 'til done (with timeout)
7693         */
7694         for (i=0; i<NCR_SNOOP_TIMEOUT; i++)
7695                 if (INB(nc_istat) & (INTF|SIP|DIP))
7696                         break;
7697         /*
7698         **      Save termination position.
7699         */
7700         pc = INL (nc_dsp);
7701         /*
7702         **      Read memory and register.
7703         */
7704         host_rd = scr_to_cpu(np->ncr_cache);
7705         ncr_rd  = INL (nc_scratcha);
7706         ncr_bk  = INL (nc_temp);
7707         /*
7708         **      Reset ncr chip
7709         */
7710         ncr_chip_reset(np, 100);
7711         /*
7712         **      check for timeout
7713         */
7714         if (i>=NCR_SNOOP_TIMEOUT) {
7715                 printk ("CACHE TEST FAILED: timeout.\n");
7716                 return (0x20);
7717         };
7718         /*
7719         **      Check termination position.
7720         */
7721         if (pc != NCB_SCRIPTH_PHYS (np, snoopend)+8) {
7722                 printk ("CACHE TEST FAILED: script execution failed.\n");
7723                 printk ("start=%08lx, pc=%08lx, end=%08lx\n",
7724                         (u_long) NCB_SCRIPTH_PHYS (np, snooptest), (u_long) pc,
7725                         (u_long) NCB_SCRIPTH_PHYS (np, snoopend) +8);
7726                 return (0x40);
7727         };
7728         /*
7729         **      Show results.
7730         */
7731         if (host_wr != ncr_rd) {
7732                 printk ("CACHE TEST FAILED: host wrote %d, ncr read %d.\n",
7733                         (int) host_wr, (int) ncr_rd);
7734                 err |= 1;
7735         };
7736         if (host_rd != ncr_wr) {
7737                 printk ("CACHE TEST FAILED: ncr wrote %d, host read %d.\n",
7738                         (int) ncr_wr, (int) host_rd);
7739                 err |= 2;
7740         };
7741         if (ncr_bk != ncr_wr) {
7742                 printk ("CACHE TEST FAILED: ncr wrote %d, read back %d.\n",
7743                         (int) ncr_wr, (int) ncr_bk);
7744                 err |= 4;
7745         };
7746         return (err);
7747 }
7748
7749 /*==========================================================
7750 **
7751 **
7752 **      Device lookup.
7753 **
7754 **      @GENSCSI@ should be integrated to scsiconf.c
7755 **
7756 **
7757 **==========================================================
7758 */
7759
7760 struct table_entry {
7761         char *  manufacturer;
7762         char *  model;
7763         char *  version;
7764         u_long  info;
7765 };
7766
7767 static struct table_entry device_tab[] =
7768 {
7769 #if 0
7770         {"", "", "", QUIRK_NOMSG},
7771 #endif
7772         {"SONY", "SDT-5000", "3.17", QUIRK_NOMSG},
7773         {"WangDAT", "Model 2600", "01.7", QUIRK_NOMSG},
7774         {"WangDAT", "Model 3200", "02.2", QUIRK_NOMSG},
7775         {"WangDAT", "Model 1300", "02.4", QUIRK_NOMSG},
7776         {"", "", "", 0} /* catch all: must be last entry. */
7777 };
7778
7779 static u_long ncr_lookup(char * id)
7780 {
7781         struct table_entry * p = device_tab;
7782         char *d, *r, c;
7783
7784         for (;;p++) {
7785
7786                 d = id+8;
7787                 r = p->manufacturer;
7788                 while ((c=*r++)) if (c!=*d++) break;
7789                 if (c) continue;
7790
7791                 d = id+16;
7792                 r = p->model;
7793                 while ((c=*r++)) if (c!=*d++) break;
7794                 if (c) continue;
7795
7796                 d = id+32;
7797                 r = p->version;
7798                 while ((c=*r++)) if (c!=*d++) break;
7799                 if (c) continue;
7800
7801                 return (p->info);
7802         }
7803 }
7804
7805 /*==========================================================
7806 **
7807 **      Determine the ncr's clock frequency.
7808 **      This is essential for the negotiation
7809 **      of the synchronous transfer rate.
7810 **
7811 **==========================================================
7812 **
7813 **      Note: we have to return the correct value.
7814 **      THERE IS NO SAVE DEFAULT VALUE.
7815 **
7816 **      Most NCR/SYMBIOS boards are delivered with a 40 Mhz clock.
7817 **      53C860 and 53C875 rev. 1 support fast20 transfers but
7818 **      do not have a clock doubler and so are provided with a
7819 **      80 MHz clock. All other fast20 boards incorporate a doubler
7820 **      and so should be delivered with a 40 MHz clock.
7821 **      The future fast40 chips (895/895) use a 40 Mhz base clock
7822 **      and provide a clock quadrupler (160 Mhz). The code below
7823 **      tries to deal as cleverly as possible with all this stuff.
7824 **
7825 **----------------------------------------------------------
7826 */
7827
7828 /*
7829  *      Select NCR SCSI clock frequency
7830  */
7831 static void ncr_selectclock(struct ncb *np, u_char scntl3)
7832 {
7833         if (np->multiplier < 2) {
7834                 OUTB(nc_scntl3, scntl3);
7835                 return;
7836         }
7837
7838         if (bootverbose >= 2)
7839                 printk ("%s: enabling clock multiplier\n", ncr_name(np));
7840
7841         OUTB(nc_stest1, DBLEN);    /* Enable clock multiplier             */
7842         if (np->multiplier > 2) {  /* Poll bit 5 of stest4 for quadrupler */
7843                 int i = 20;
7844                 while (!(INB(nc_stest4) & LCKFRQ) && --i > 0)
7845                         UDELAY (20);
7846                 if (!i)
7847                         printk("%s: the chip cannot lock the frequency\n", ncr_name(np));
7848         } else                  /* Wait 20 micro-seconds for doubler    */
7849                 UDELAY (20);
7850         OUTB(nc_stest3, HSC);           /* Halt the scsi clock          */
7851         OUTB(nc_scntl3, scntl3);
7852         OUTB(nc_stest1, (DBLEN|DBLSEL));/* Select clock multiplier      */
7853         OUTB(nc_stest3, 0x00);          /* Restart scsi clock           */
7854 }
7855
7856
7857 /*
7858  *      calculate NCR SCSI clock frequency (in KHz)
7859  */
7860 static unsigned __init ncrgetfreq (struct ncb *np, int gen)
7861 {
7862         unsigned ms = 0;
7863         char count = 0;
7864
7865         /*
7866          * Measure GEN timer delay in order
7867          * to calculate SCSI clock frequency
7868          *
7869          * This code will never execute too
7870          * many loop iterations (if DELAY is
7871          * reasonably correct). It could get
7872          * too low a delay (too high a freq.)
7873          * if the CPU is slow executing the
7874          * loop for some reason (an NMI, for
7875          * example). For this reason we will
7876          * if multiple measurements are to be
7877          * performed trust the higher delay
7878          * (lower frequency returned).
7879          */
7880         OUTB (nc_stest1, 0);    /* make sure clock doubler is OFF */
7881         OUTW (nc_sien , 0);     /* mask all scsi interrupts */
7882         (void) INW (nc_sist);   /* clear pending scsi interrupt */
7883         OUTB (nc_dien , 0);     /* mask all dma interrupts */
7884         (void) INW (nc_sist);   /* another one, just to be sure :) */
7885         OUTB (nc_scntl3, 4);    /* set pre-scaler to divide by 3 */
7886         OUTB (nc_stime1, 0);    /* disable general purpose timer */
7887         OUTB (nc_stime1, gen);  /* set to nominal delay of 1<<gen * 125us */
7888         while (!(INW(nc_sist) & GEN) && ms++ < 100000) {
7889                 for (count = 0; count < 10; count ++)
7890                         UDELAY (100);   /* count ms */
7891         }
7892         OUTB (nc_stime1, 0);    /* disable general purpose timer */
7893         /*
7894          * set prescaler to divide by whatever 0 means
7895          * 0 ought to choose divide by 2, but appears
7896          * to set divide by 3.5 mode in my 53c810 ...
7897          */
7898         OUTB (nc_scntl3, 0);
7899
7900         if (bootverbose >= 2)
7901                 printk ("%s: Delay (GEN=%d): %u msec\n", ncr_name(np), gen, ms);
7902         /*
7903          * adjust for prescaler, and convert into KHz
7904          */
7905         return ms ? ((1 << gen) * 4340) / ms : 0;
7906 }
7907
7908 /*
7909  *      Get/probe NCR SCSI clock frequency
7910  */
7911 static void __init ncr_getclock (struct ncb *np, int mult)
7912 {
7913         unsigned char scntl3 = INB(nc_scntl3);
7914         unsigned char stest1 = INB(nc_stest1);
7915         unsigned f1;
7916
7917         np->multiplier = 1;
7918         f1 = 40000;
7919
7920         /*
7921         **      True with 875 or 895 with clock multiplier selected
7922         */
7923         if (mult > 1 && (stest1 & (DBLEN+DBLSEL)) == DBLEN+DBLSEL) {
7924                 if (bootverbose >= 2)
7925                         printk ("%s: clock multiplier found\n", ncr_name(np));
7926                 np->multiplier = mult;
7927         }
7928
7929         /*
7930         **      If multiplier not found or scntl3 not 7,5,3,
7931         **      reset chip and get frequency from general purpose timer.
7932         **      Otherwise trust scntl3 BIOS setting.
7933         */
7934         if (np->multiplier != mult || (scntl3 & 7) < 3 || !(scntl3 & 1)) {
7935                 unsigned f2;
7936
7937                 ncr_chip_reset(np, 5);
7938
7939                 (void) ncrgetfreq (np, 11);     /* throw away first result */
7940                 f1 = ncrgetfreq (np, 11);
7941                 f2 = ncrgetfreq (np, 11);
7942
7943                 if(bootverbose)
7944                         printk ("%s: NCR clock is %uKHz, %uKHz\n", ncr_name(np), f1, f2);
7945
7946                 if (f1 > f2) f1 = f2;           /* trust lower result   */
7947
7948                 if      (f1 <   45000)          f1 =  40000;
7949                 else if (f1 <   55000)          f1 =  50000;
7950                 else                            f1 =  80000;
7951
7952                 if (f1 < 80000 && mult > 1) {
7953                         if (bootverbose >= 2)
7954                                 printk ("%s: clock multiplier assumed\n", ncr_name(np));
7955                         np->multiplier  = mult;
7956                 }
7957         } else {
7958                 if      ((scntl3 & 7) == 3)     f1 =  40000;
7959                 else if ((scntl3 & 7) == 5)     f1 =  80000;
7960                 else                            f1 = 160000;
7961
7962                 f1 /= np->multiplier;
7963         }
7964
7965         /*
7966         **      Compute controller synchronous parameters.
7967         */
7968         f1              *= np->multiplier;
7969         np->clock_khz   = f1;
7970 }
7971
7972 /*===================== LINUX ENTRY POINTS SECTION ==========================*/
7973
7974 /*
7975 **   Linux select queue depths function
7976 */
7977
7978 int ncr53c8xx_slave_configure(struct scsi_device *device)
7979 {
7980         struct Scsi_Host *host = device->host;
7981         struct ncb *np;
7982         struct tcb *tp;
7983         struct lcb *lp;
7984         int numtags, depth_to_use;
7985
7986         np = ((struct host_data *) host->hostdata)->ncb;
7987         tp = &np->target[device->id];
7988         lp = tp->lp[device->lun];
7989
7990         /*
7991         **      Select queue depth from driver setup.
7992         **      Donnot use more than configured by user.
7993         **      Use at least 2.
7994         **      Donnot use more than our maximum.
7995         */
7996         numtags = device_queue_depth(np->unit, device->id, device->lun);
7997         if (numtags > tp->usrtags)
7998                 numtags = tp->usrtags;
7999         if (!device->tagged_supported)
8000                 numtags = 1;
8001         depth_to_use = numtags;
8002         if (depth_to_use < 2)
8003                 depth_to_use = 2;
8004         if (depth_to_use > MAX_TAGS)
8005                 depth_to_use = MAX_TAGS;
8006
8007         scsi_adjust_queue_depth(device,
8008                                 (device->tagged_supported ?
8009                                  MSG_SIMPLE_TAG : 0),
8010                                 depth_to_use);
8011
8012         /*
8013         **      Since the queue depth is not tunable under Linux,
8014         **      we need to know this value in order not to
8015         **      announce stupid things to user.
8016         */
8017         if (lp) {
8018                 lp->numtags = lp->maxtags = numtags;
8019                 lp->scdev_depth = depth_to_use;
8020         }
8021         ncr_setup_tags (np, device->id, device->lun);
8022
8023 #ifdef DEBUG_NCR53C8XX
8024         printk("ncr53c8xx_select_queue_depth: host=%d, id=%d, lun=%d, depth=%d\n",
8025                np->unit, device->id, device->lun, depth_to_use);
8026 #endif
8027
8028         return 0;
8029 }
8030
8031 /*
8032 **   Linux entry point of queuecommand() function
8033 */
8034
8035 int ncr53c8xx_queue_command (struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
8036 {
8037      struct ncb *np = ((struct host_data *) cmd->device->host->hostdata)->ncb;
8038      unsigned long flags;
8039      int sts;
8040
8041 #ifdef DEBUG_NCR53C8XX
8042 printk("ncr53c8xx_queue_command\n");
8043 #endif
8044
8045      cmd->scsi_done     = done;
8046      cmd->host_scribble = NULL;
8047      cmd->__data_mapped = 0;
8048      cmd->__data_mapping = 0;
8049
8050      NCR_LOCK_NCB(np, flags);
8051
8052      if ((sts = ncr_queue_command(np, cmd)) != DID_OK) {
8053           cmd->result = ScsiResult(sts, 0);
8054 #ifdef DEBUG_NCR53C8XX
8055 printk("ncr53c8xx : command not queued - result=%d\n", sts);
8056 #endif
8057      }
8058 #ifdef DEBUG_NCR53C8XX
8059      else
8060 printk("ncr53c8xx : command successfully queued\n");
8061 #endif
8062
8063      NCR_UNLOCK_NCB(np, flags);
8064
8065      if (sts != DID_OK) {
8066           unmap_scsi_data(np, cmd);
8067           done(cmd);
8068      }
8069
8070      return sts;
8071 }
8072
8073 /*
8074 **   Linux entry point of the interrupt handler.
8075 **   Since linux versions > 1.3.70, we trust the kernel for
8076 **   passing the internal host descriptor as 'dev_id'.
8077 **   Otherwise, we scan the host list and call the interrupt
8078 **   routine for each host that uses this IRQ.
8079 */
8080
8081 irqreturn_t ncr53c8xx_intr(int irq, void *dev_id, struct pt_regs * regs)
8082 {
8083      unsigned long flags;
8084      struct Scsi_Host *shost = (struct Scsi_Host *)dev_id;
8085      struct host_data *host_data = (struct host_data *)shost->hostdata;
8086      struct ncb *np = host_data->ncb;
8087      struct scsi_cmnd *done_list;
8088
8089 #ifdef DEBUG_NCR53C8XX
8090      printk("ncr53c8xx : interrupt received\n");
8091 #endif
8092
8093      if (DEBUG_FLAGS & DEBUG_TINY) printk ("[");
8094
8095      NCR_LOCK_NCB(np, flags);
8096      ncr_exception(np);
8097      done_list     = np->done_list;
8098      np->done_list = NULL;
8099      NCR_UNLOCK_NCB(np, flags);
8100
8101      if (DEBUG_FLAGS & DEBUG_TINY) printk ("]\n");
8102
8103      if (done_list) {
8104           NCR_LOCK_SCSI_DONE(done_list->device->host, flags);
8105           ncr_flush_done_cmds(done_list);
8106           NCR_UNLOCK_SCSI_DONE(done_list->device->host, flags);
8107      }
8108      return IRQ_HANDLED;
8109 }
8110
8111 /*
8112 **   Linux entry point of the timer handler
8113 */
8114
8115 static void ncr53c8xx_timeout(unsigned long npref)
8116 {
8117      struct ncb *np = (struct ncb *) npref;
8118      unsigned long flags;
8119      struct scsi_cmnd *done_list;
8120
8121      NCR_LOCK_NCB(np, flags);
8122      ncr_timeout(np);
8123      done_list     = np->done_list;
8124      np->done_list = NULL;
8125      NCR_UNLOCK_NCB(np, flags);
8126
8127      if (done_list) {
8128           NCR_LOCK_SCSI_DONE(done_list->device->host, flags);
8129           ncr_flush_done_cmds(done_list);
8130           NCR_UNLOCK_SCSI_DONE(done_list->device->host, flags);
8131      }
8132 }
8133
8134 /*
8135 **   Linux entry point of reset() function
8136 */
8137
8138 int ncr53c8xx_bus_reset(struct scsi_cmnd *cmd)
8139 {
8140         struct ncb *np = ((struct host_data *) cmd->device->host->hostdata)->ncb;
8141         int sts;
8142         unsigned long flags;
8143         struct scsi_cmnd *done_list;
8144
8145         NCR_LOCK_NCB(np, flags);
8146
8147         /*
8148          * If the mid-level driver told us reset is synchronous, it seems
8149          * that we must call the done() callback for the involved command,
8150          * even if this command was not queued to the low-level driver,
8151          * before returning SUCCESS.
8152          */
8153
8154         sts = ncr_reset_bus(np, cmd, 1);
8155
8156         done_list     = np->done_list;
8157         np->done_list = NULL;
8158         NCR_UNLOCK_NCB(np, flags);
8159
8160         ncr_flush_done_cmds(done_list);
8161
8162         return sts;
8163 }
8164
8165 /*
8166 **   Linux entry point of abort() function
8167 */
8168
8169 int ncr53c8xx_abort(struct scsi_cmnd *cmd)
8170 {
8171         struct ncb *np = ((struct host_data *) cmd->device->host->hostdata)->ncb;
8172         int sts;
8173         unsigned long flags;
8174         struct scsi_cmnd *done_list;
8175
8176 #if defined SCSI_RESET_SYNCHRONOUS && defined SCSI_RESET_ASYNCHRONOUS
8177         printk("ncr53c8xx_abort: pid=%lu serial_number=%ld serial_number_at_timeout=%ld\n",
8178                 cmd->pid, cmd->serial_number, cmd->serial_number_at_timeout);
8179 #else
8180         printk("ncr53c8xx_abort: command pid %lu\n", cmd->pid);
8181 #endif
8182
8183         NCR_LOCK_NCB(np, flags);
8184
8185 #if defined SCSI_RESET_SYNCHRONOUS && defined SCSI_RESET_ASYNCHRONOUS
8186         /*
8187          * We have to just ignore abort requests in some situations.
8188          */
8189         if (cmd->serial_number != cmd->serial_number_at_timeout) {
8190                 sts = SCSI_ABORT_NOT_RUNNING;
8191                 goto out;
8192         }
8193 #endif
8194
8195         sts = ncr_abort_command(np, cmd);
8196 out:
8197         done_list     = np->done_list;
8198         np->done_list = NULL;
8199         NCR_UNLOCK_NCB(np, flags);
8200
8201         ncr_flush_done_cmds(done_list);
8202
8203         return sts;
8204 }
8205
8206
8207 /*
8208 **      Scsi command waiting list management.
8209 **
8210 **      It may happen that we cannot insert a scsi command into the start queue,
8211 **      in the following circumstances.
8212 **              Too few preallocated ccb(s),
8213 **              maxtags < cmd_per_lun of the Linux host control block,
8214 **              etc...
8215 **      Such scsi commands are inserted into a waiting list.
8216 **      When a scsi command complete, we try to requeue the commands of the
8217 **      waiting list.
8218 */
8219
8220 #define next_wcmd host_scribble
8221
8222 static void insert_into_waiting_list(struct ncb *np, struct scsi_cmnd *cmd)
8223 {
8224         struct scsi_cmnd *wcmd;
8225
8226 #ifdef DEBUG_WAITING_LIST
8227         printk("%s: cmd %lx inserted into waiting list\n", ncr_name(np), (u_long) cmd);
8228 #endif
8229         cmd->next_wcmd = NULL;
8230         if (!(wcmd = np->waiting_list)) np->waiting_list = cmd;
8231         else {
8232                 while ((wcmd->next_wcmd) != 0)
8233                         wcmd = (struct scsi_cmnd *) wcmd->next_wcmd;
8234                 wcmd->next_wcmd = (char *) cmd;
8235         }
8236 }
8237
8238 static struct scsi_cmnd *retrieve_from_waiting_list(int to_remove, struct ncb *np, struct scsi_cmnd *cmd)
8239 {
8240         struct scsi_cmnd **pcmd = &np->waiting_list;
8241
8242         while (*pcmd) {
8243                 if (cmd == *pcmd) {
8244                         if (to_remove) {
8245                                 *pcmd = (struct scsi_cmnd *) cmd->next_wcmd;
8246                                 cmd->next_wcmd = NULL;
8247                         }
8248 #ifdef DEBUG_WAITING_LIST
8249         printk("%s: cmd %lx retrieved from waiting list\n", ncr_name(np), (u_long) cmd);
8250 #endif
8251                         return cmd;
8252                 }
8253                 pcmd = (struct scsi_cmnd **) &(*pcmd)->next_wcmd;
8254         }
8255         return NULL;
8256 }
8257
8258 static void process_waiting_list(struct ncb *np, int sts)
8259 {
8260         struct scsi_cmnd *waiting_list, *wcmd;
8261
8262         waiting_list = np->waiting_list;
8263         np->waiting_list = NULL;
8264
8265 #ifdef DEBUG_WAITING_LIST
8266         if (waiting_list) printk("%s: waiting_list=%lx processing sts=%d\n", ncr_name(np), (u_long) waiting_list, sts);
8267 #endif
8268         while ((wcmd = waiting_list) != 0) {
8269                 waiting_list = (struct scsi_cmnd *) wcmd->next_wcmd;
8270                 wcmd->next_wcmd = NULL;
8271                 if (sts == DID_OK) {
8272 #ifdef DEBUG_WAITING_LIST
8273         printk("%s: cmd %lx trying to requeue\n", ncr_name(np), (u_long) wcmd);
8274 #endif
8275                         sts = ncr_queue_command(np, wcmd);
8276                 }
8277                 if (sts != DID_OK) {
8278 #ifdef DEBUG_WAITING_LIST
8279         printk("%s: cmd %lx done forced sts=%d\n", ncr_name(np), (u_long) wcmd, sts);
8280 #endif
8281                         wcmd->result = ScsiResult(sts, 0);
8282                         ncr_queue_done_cmd(np, wcmd);
8283                 }
8284         }
8285 }
8286
8287 #undef next_wcmd
8288
8289 #ifdef SCSI_NCR_PROC_INFO_SUPPORT
8290
8291 /*=========================================================================
8292 **      Proc file system stuff
8293 **
8294 **      A read operation returns profile information.
8295 **      A write operation is a control command.
8296 **      The string is parsed in the driver code and the command is passed
8297 **      to the ncr_usercmd() function.
8298 **=========================================================================
8299 */
8300
8301 #ifdef SCSI_NCR_USER_COMMAND_SUPPORT
8302
8303 #define is_digit(c)     ((c) >= '0' && (c) <= '9')
8304 #define digit_to_bin(c) ((c) - '0')
8305 #define is_space(c)     ((c) == ' ' || (c) == '\t')
8306
8307 static int skip_spaces(char *ptr, int len)
8308 {
8309         int cnt, c;
8310
8311         for (cnt = len; cnt > 0 && (c = *ptr++) && is_space(c); cnt--);
8312
8313         return (len - cnt);
8314 }
8315
8316 static int get_int_arg(char *ptr, int len, u_long *pv)
8317 {
8318         int     cnt, c;
8319         u_long  v;
8320
8321         for (v = 0, cnt = len; cnt > 0 && (c = *ptr++) && is_digit(c); cnt--) {
8322                 v = (v * 10) + digit_to_bin(c);
8323         }
8324
8325         if (pv)
8326                 *pv = v;
8327
8328         return (len - cnt);
8329 }
8330
8331 static int is_keyword(char *ptr, int len, char *verb)
8332 {
8333         int verb_len = strlen(verb);
8334
8335         if (len >= strlen(verb) && !memcmp(verb, ptr, verb_len))
8336                 return verb_len;
8337         else
8338                 return 0;
8339
8340 }
8341
8342 #define SKIP_SPACES(min_spaces)                                         \
8343         if ((arg_len = skip_spaces(ptr, len)) < (min_spaces))           \
8344                 return -EINVAL;                                         \
8345         ptr += arg_len; len -= arg_len;
8346
8347 #define GET_INT_ARG(v)                                                  \
8348         if (!(arg_len = get_int_arg(ptr, len, &(v))))                   \
8349                 return -EINVAL;                                         \
8350         ptr += arg_len; len -= arg_len;
8351
8352
8353 /*
8354 **      Parse a control command
8355 */
8356
8357 static int ncr_user_command(struct ncb *np, char *buffer, int length)
8358 {
8359         char *ptr       = buffer;
8360         int len         = length;
8361         struct usrcmd    *uc = &np->user;
8362         int             arg_len;
8363         u_long          target;
8364
8365         bzero(uc, sizeof(*uc));
8366
8367         if (len > 0 && ptr[len-1] == '\n')
8368                 --len;
8369
8370         if      ((arg_len = is_keyword(ptr, len, "setsync")) != 0)
8371                 uc->cmd = UC_SETSYNC;
8372         else if ((arg_len = is_keyword(ptr, len, "settags")) != 0)
8373                 uc->cmd = UC_SETTAGS;
8374         else if ((arg_len = is_keyword(ptr, len, "setorder")) != 0)
8375                 uc->cmd = UC_SETORDER;
8376         else if ((arg_len = is_keyword(ptr, len, "setverbose")) != 0)
8377                 uc->cmd = UC_SETVERBOSE;
8378         else if ((arg_len = is_keyword(ptr, len, "setwide")) != 0)
8379                 uc->cmd = UC_SETWIDE;
8380         else if ((arg_len = is_keyword(ptr, len, "setdebug")) != 0)
8381                 uc->cmd = UC_SETDEBUG;
8382         else if ((arg_len = is_keyword(ptr, len, "setflag")) != 0)
8383                 uc->cmd = UC_SETFLAG;
8384         else
8385                 arg_len = 0;
8386
8387 #ifdef DEBUG_PROC_INFO
8388 printk("ncr_user_command: arg_len=%d, cmd=%ld\n", arg_len, uc->cmd);
8389 #endif
8390
8391         if (!arg_len)
8392                 return -EINVAL;
8393         ptr += arg_len; len -= arg_len;
8394
8395         switch(uc->cmd) {
8396         case UC_SETSYNC:
8397         case UC_SETTAGS:
8398         case UC_SETWIDE:
8399         case UC_SETFLAG:
8400                 SKIP_SPACES(1);
8401                 if ((arg_len = is_keyword(ptr, len, "all")) != 0) {
8402                         ptr += arg_len; len -= arg_len;
8403                         uc->target = ~0;
8404                 } else {
8405                         GET_INT_ARG(target);
8406                         uc->target = (1<<target);
8407 #ifdef DEBUG_PROC_INFO
8408 printk("ncr_user_command: target=%ld\n", target);
8409 #endif
8410                 }
8411                 break;
8412         }
8413
8414         switch(uc->cmd) {
8415         case UC_SETVERBOSE:
8416         case UC_SETSYNC:
8417         case UC_SETTAGS:
8418         case UC_SETWIDE:
8419                 SKIP_SPACES(1);
8420                 GET_INT_ARG(uc->data);
8421 #ifdef DEBUG_PROC_INFO
8422 printk("ncr_user_command: data=%ld\n", uc->data);
8423 #endif
8424                 break;
8425         case UC_SETORDER:
8426                 SKIP_SPACES(1);
8427                 if      ((arg_len = is_keyword(ptr, len, "simple")))
8428                         uc->data = M_SIMPLE_TAG;
8429                 else if ((arg_len = is_keyword(ptr, len, "ordered")))
8430                         uc->data = M_ORDERED_TAG;
8431                 else if ((arg_len = is_keyword(ptr, len, "default")))
8432                         uc->data = 0;
8433                 else
8434                         return -EINVAL;
8435                 break;
8436         case UC_SETDEBUG:
8437                 while (len > 0) {
8438                         SKIP_SPACES(1);
8439                         if      ((arg_len = is_keyword(ptr, len, "alloc")))
8440                                 uc->data |= DEBUG_ALLOC;
8441                         else if ((arg_len = is_keyword(ptr, len, "phase")))
8442                                 uc->data |= DEBUG_PHASE;
8443                         else if ((arg_len = is_keyword(ptr, len, "queue")))
8444                                 uc->data |= DEBUG_QUEUE;
8445                         else if ((arg_len = is_keyword(ptr, len, "result")))
8446                                 uc->data |= DEBUG_RESULT;
8447                         else if ((arg_len = is_keyword(ptr, len, "scatter")))
8448                                 uc->data |= DEBUG_SCATTER;
8449                         else if ((arg_len = is_keyword(ptr, len, "script")))
8450                                 uc->data |= DEBUG_SCRIPT;
8451                         else if ((arg_len = is_keyword(ptr, len, "tiny")))
8452                                 uc->data |= DEBUG_TINY;
8453                         else if ((arg_len = is_keyword(ptr, len, "timing")))
8454                                 uc->data |= DEBUG_TIMING;
8455                         else if ((arg_len = is_keyword(ptr, len, "nego")))
8456                                 uc->data |= DEBUG_NEGO;
8457                         else if ((arg_len = is_keyword(ptr, len, "tags")))
8458                                 uc->data |= DEBUG_TAGS;
8459                         else
8460                                 return -EINVAL;
8461                         ptr += arg_len; len -= arg_len;
8462                 }
8463 #ifdef DEBUG_PROC_INFO
8464 printk("ncr_user_command: data=%ld\n", uc->data);
8465 #endif
8466                 break;
8467         case UC_SETFLAG:
8468                 while (len > 0) {
8469                         SKIP_SPACES(1);
8470                         if      ((arg_len = is_keyword(ptr, len, "trace")))
8471                                 uc->data |= UF_TRACE;
8472                         else if ((arg_len = is_keyword(ptr, len, "no_disc")))
8473                                 uc->data |= UF_NODISC;
8474                         else
8475                                 return -EINVAL;
8476                         ptr += arg_len; len -= arg_len;
8477                 }
8478                 break;
8479         default:
8480                 break;
8481         }
8482
8483         if (len)
8484                 return -EINVAL;
8485         else {
8486                 unsigned long flags;
8487
8488                 NCR_LOCK_NCB(np, flags);
8489                 ncr_usercmd (np);
8490                 NCR_UNLOCK_NCB(np, flags);
8491         }
8492         return length;
8493 }
8494
8495 #endif  /* SCSI_NCR_USER_COMMAND_SUPPORT */
8496
8497
8498 #ifdef SCSI_NCR_USER_INFO_SUPPORT
8499 /*
8500 **      Copy formatted information into the input buffer.
8501 */
8502
8503 static int ncr_host_info(struct ncb *np, char *ptr, off_t offset, int len)
8504 {
8505         struct info_str info;
8506
8507         info.buffer     = ptr;
8508         info.length     = len;
8509         info.offset     = offset;
8510         info.pos        = 0;
8511
8512         copy_info(&info, "  Chip NCR53C720, revision id 0x%x, IRQ %d\n",
8513                          np->revision_id, (int) np->irq);
8514         copy_info(&info, "  Synchronous period factor %d, "
8515                          "max commands per lun %d\n",
8516                          (int) np->minsync, MAX_TAGS);
8517
8518         if (driver_setup.debug || driver_setup.verbose > 1) {
8519                 copy_info(&info, "  Debug flags 0x%x, verbosity level %d\n",
8520                           driver_setup.debug, driver_setup.verbose);
8521         }
8522
8523         return info.pos > info.offset? info.pos - info.offset : 0;
8524 }
8525
8526 #endif /* SCSI_NCR_USER_INFO_SUPPORT */
8527
8528 /*
8529 **      Entry point of the scsi proc fs of the driver.
8530 **      - func = 0 means read  (returns profile data)
8531 **      - func = 1 means write (parse user control command)
8532 */
8533
8534 static int ncr53c8xx_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
8535                         int length, int func)
8536 {
8537         struct host_data *host_data;
8538         struct ncb *ncb = NULL;
8539         int retv;
8540
8541 #ifdef DEBUG_PROC_INFO
8542 printk("ncr53c8xx_proc_info: hostno=%d, func=%d\n", host->host_no, func);
8543 #endif
8544
8545         host_data = (struct host_data *) host->hostdata;
8546         ncb = host_data->ncb;
8547
8548         if (func) {
8549 #ifdef  SCSI_NCR_USER_COMMAND_SUPPORT
8550                 retv = ncr_user_command(ncb, buffer, length);
8551 #else
8552                 retv = -EINVAL;
8553 #endif
8554         }
8555         else {
8556                 if (start)
8557                         *start = buffer;
8558 #ifdef SCSI_NCR_USER_INFO_SUPPORT
8559                 retv = ncr_host_info(ncb, buffer, offset, length);
8560 #else
8561                 retv = -EINVAL;
8562 #endif
8563         }
8564
8565         return retv;
8566 }
8567
8568 /*=========================================================================
8569 **      End of proc file system stuff
8570 **=========================================================================
8571 */
8572 #endif
8573
8574
8575 /*==========================================================
8576 **
8577 **      Boot command line.
8578 **
8579 **==========================================================
8580 */
8581 #ifdef  MODULE
8582 char *ncr53c8xx;        /* command line passed by insmod */
8583 MODULE_PARM(ncr53c8xx, "s");
8584 #endif
8585
8586 int __init ncr53c8xx_setup(char *str)
8587 {
8588         return sym53c8xx__setup(str);
8589 }
8590
8591 #ifndef MODULE
8592 __setup("ncr53c8xx=", ncr53c8xx_setup);
8593 #endif
8594
8595 /*==========================================================
8596 **
8597 **   Entry point for info() function
8598 **
8599 **==========================================================
8600 */
8601 const char *ncr53c8xx_info (struct Scsi_Host *host)
8602 {
8603         return SCSI_NCR_DRIVER_NAME;
8604 }
8605
8606
8607 /*
8608  *      Host attach and initialisations.
8609  *
8610  *      Allocate host data and ncb structure.
8611  *      Request IO region and remap MMIO region.
8612  *      Do chip initialization.
8613  *      If all is OK, install interrupt handling and
8614  *      start the timer daemon.
8615  */
8616 struct Scsi_Host * __init ncr_attach(struct scsi_host_template *tpnt,
8617                                         int unit, struct ncr_device *device)
8618 {
8619         struct host_data *host_data;
8620         struct ncb *np = NULL;
8621         struct Scsi_Host *instance = NULL;
8622         u_long flags = 0;
8623         int i;
8624
8625 #ifdef SCSI_NCR_PROC_INFO_SUPPORT
8626         tpnt->proc_info         = ncr53c8xx_proc_info,
8627 #endif
8628         tpnt->info              = ncr53c8xx_info;
8629         tpnt->queuecommand      = ncr53c8xx_queue_command;
8630         tpnt->slave_configure   = ncr53c8xx_slave_configure;
8631         tpnt->eh_bus_reset_handler      = ncr53c8xx_bus_reset;
8632         tpnt->can_queue         = SCSI_NCR_CAN_QUEUE;
8633         tpnt->this_id           = 7;
8634         tpnt->sg_tablesize      = SCSI_NCR_SG_TABLESIZE;
8635         tpnt->cmd_per_lun       = SCSI_NCR_CMD_PER_LUN;
8636         tpnt->use_clustering    = ENABLE_CLUSTERING;
8637
8638         if (device->differential)
8639                 driver_setup.diff_support = device->differential;
8640
8641         printk(KERN_INFO "ncr53c720-%d: rev 0x%x irq %d\n",
8642                 unit, device->chip.revision_id, device->slot.irq);
8643
8644         instance = scsi_host_alloc(tpnt, sizeof(*host_data));
8645         if (!instance)
8646                 goto attach_error;
8647         host_data = (struct host_data *) instance->hostdata;
8648
8649         np = __m_calloc_dma(device->dev, sizeof(struct ncb), "NCB");
8650         if (!np)
8651                 goto attach_error;
8652         NCR_INIT_LOCK_NCB(np);
8653         np->dev = device->dev;
8654         np->p_ncb = vtobus(np);
8655         host_data->ncb = np;
8656
8657         np->ccb = m_calloc_dma(sizeof(struct ccb), "CCB");
8658         if (!np->ccb)
8659                 goto attach_error;
8660
8661         /* Store input information in the host data structure.  */
8662         np->unit        = unit;
8663         np->verbose     = driver_setup.verbose;
8664         sprintf(np->inst_name, "ncr53c720-%d", np->unit);
8665         np->revision_id = device->chip.revision_id;
8666         np->features    = device->chip.features;
8667         np->clock_divn  = device->chip.nr_divisor;
8668         np->maxoffs     = device->chip.offset_max;
8669         np->maxburst    = device->chip.burst_max;
8670         np->myaddr      = device->host_id;
8671
8672         /* Allocate SCRIPTS areas.  */
8673         np->script0 = m_calloc_dma(sizeof(struct script), "SCRIPT");
8674         if (!np->script0)
8675                 goto attach_error;
8676         np->scripth0 = m_calloc_dma(sizeof(struct scripth), "SCRIPTH");
8677         if (!np->scripth0)
8678                 goto attach_error;
8679
8680         init_timer(&np->timer);
8681         np->timer.data     = (unsigned long) np;
8682         np->timer.function = ncr53c8xx_timeout;
8683
8684         /* Try to map the controller chip to virtual and physical memory. */
8685
8686         np->paddr       = device->slot.base;
8687         np->paddr2      = (np->features & FE_RAM) ? device->slot.base_2 : 0;
8688
8689         if (device->slot.base_v)
8690                 np->vaddr = device->slot.base_v;
8691         else
8692                 np->vaddr = (unsigned long)ioremap(device->slot.base_c, 128);
8693
8694         if (!np->vaddr) {
8695                 printk(KERN_ERR
8696                         "%s: can't map memory mapped IO region\n",ncr_name(np));
8697                 goto attach_error;
8698         } else {
8699                 if (bootverbose > 1)
8700                         printk(KERN_INFO
8701                                 "%s: using memory mapped IO at virtual address 0x%lx\n", ncr_name(np), (u_long) np->vaddr);
8702         }
8703
8704         /* Make the controller's registers available.  Now the INB INW INL
8705          * OUTB OUTW OUTL macros can be used safely.
8706          */
8707
8708         np->reg = (struct ncr_reg*) np->vaddr;
8709
8710         /* Do chip dependent initialization.  */
8711         ncr_prepare_setting(np);
8712
8713         if (np->paddr2 && sizeof(struct script) > 4096) {
8714                 np->paddr2 = 0;
8715                 printk(KERN_WARNING "%s: script too large, NOT using on chip RAM.\n",
8716                         ncr_name(np));
8717         }
8718
8719         /* Fill Linux host instance structure */
8720         instance->max_channel   = 0;
8721         instance->this_id       = np->myaddr;
8722         instance->max_id        = np->maxwide ? 16 : 8;
8723         instance->max_lun       = SCSI_NCR_MAX_LUN;
8724         instance->base          = (unsigned long) np->reg;
8725         instance->irq           = device->slot.irq;
8726         instance->unique_id     = device->slot.base;
8727         instance->dma_channel   = 0;
8728         instance->cmd_per_lun   = MAX_TAGS;
8729         instance->can_queue     = (MAX_START-4);
8730         scsi_set_device(instance, device->dev);
8731
8732 #ifdef SCSI_NCR_INTEGRITY_CHECKING
8733         np->check_integrity       = 0;
8734         instance->check_integrity = 0;
8735
8736 #ifdef SCSI_NCR_ENABLE_INTEGRITY_CHECK
8737         if ( !(driver_setup.bus_check & 0x04) ) {
8738                 np->check_integrity       = 1;
8739                 instance->check_integrity = 1;
8740         }
8741 #endif
8742 #endif
8743         /* Patch script to physical addresses */
8744         ncr_script_fill(&script0, &scripth0);
8745
8746         np->scripth     = np->scripth0;
8747         np->p_scripth   = vtobus(np->scripth);
8748         np->p_script    = (np->paddr2) ?  np->paddr2 : vtobus(np->script0);
8749
8750         ncr_script_copy_and_bind(np, (ncrcmd *) &script0,
8751                         (ncrcmd *) np->script0, sizeof(struct script));
8752         ncr_script_copy_and_bind(np, (ncrcmd *) &scripth0,
8753                         (ncrcmd *) np->scripth0, sizeof(struct scripth));
8754         np->ccb->p_ccb  = vtobus (np->ccb);
8755
8756         /* Patch the script for LED support.  */
8757
8758         if (np->features & FE_LED0) {
8759                 np->script0->idle[0]  =
8760                                 cpu_to_scr(SCR_REG_REG(gpreg, SCR_OR,  0x01));
8761                 np->script0->reselected[0] =
8762                                 cpu_to_scr(SCR_REG_REG(gpreg, SCR_AND, 0xfe));
8763                 np->script0->start[0] =
8764                                 cpu_to_scr(SCR_REG_REG(gpreg, SCR_AND, 0xfe));
8765         }
8766
8767         /*
8768          * Look for the target control block of this nexus.
8769          * For i = 0 to 3
8770          *   JUMP ^ IFTRUE (MASK (i, 3)), @(next_lcb)
8771          */
8772         for (i = 0 ; i < 4 ; i++) {
8773                 np->jump_tcb[i].l_cmd   =
8774                                 cpu_to_scr((SCR_JUMP ^ IFTRUE (MASK (i, 3))));
8775                 np->jump_tcb[i].l_paddr =
8776                                 cpu_to_scr(NCB_SCRIPTH_PHYS (np, bad_target));
8777         }
8778
8779         ncr_chip_reset(np, 100);
8780
8781         /* Now check the cache handling of the chipset.  */
8782
8783         if (ncr_snooptest(np)) {
8784                 printk(KERN_ERR "CACHE INCORRECTLY CONFIGURED.\n");
8785                 goto attach_error;
8786         };
8787
8788         /* Install the interrupt handler.  */
8789         np->irq = device->slot.irq;
8790
8791         /* Initialize the fixed part of the default ccb.  */
8792         ncr_init_ccb(np, np->ccb);
8793
8794         /*
8795          * After SCSI devices have been opened, we cannot reset the bus
8796          * safely, so we do it here.  Interrupt handler does the real work.
8797          * Process the reset exception if interrupts are not enabled yet.
8798          * Then enable disconnects.
8799          */
8800         NCR_LOCK_NCB(np, flags);
8801         if (ncr_reset_scsi_bus(np, 0, driver_setup.settle_delay) != 0) {
8802                 printk(KERN_ERR "%s: FATAL ERROR: CHECK SCSI BUS - CABLES, TERMINATION, DEVICE POWER etc.!\n", ncr_name(np));
8803
8804                 NCR_UNLOCK_NCB(np, flags);
8805                 goto attach_error;
8806         }
8807         ncr_exception(np);
8808
8809         np->disc = 1;
8810
8811         /*
8812          * The middle-level SCSI driver does not wait for devices to settle.
8813          * Wait synchronously if more than 2 seconds.
8814          */
8815         if (driver_setup.settle_delay > 2) {
8816                 printk(KERN_INFO "%s: waiting %d seconds for scsi devices to settle...\n",
8817                         ncr_name(np), driver_setup.settle_delay);
8818                 MDELAY (1000 * driver_setup.settle_delay);
8819         }
8820
8821         /* start the timeout daemon */
8822         np->lasttime=0;
8823         ncr_timeout (np);
8824
8825         /* use SIMPLE TAG messages by default */
8826 #ifdef SCSI_NCR_ALWAYS_SIMPLE_TAG
8827         np->order = M_SIMPLE_TAG;
8828 #endif
8829
8830         NCR_UNLOCK_NCB(np, flags);
8831
8832         return instance;
8833
8834  attach_error:
8835         if (!instance)
8836                 return NULL;
8837         printk(KERN_INFO "%s: detaching...\n", ncr_name(np));
8838         if (!np)
8839                 goto unregister;
8840         if (np->scripth0)
8841                 m_free_dma(np->scripth0, sizeof(struct scripth), "SCRIPTH");
8842         if (np->script0)
8843                 m_free_dma(np->script0, sizeof(struct script), "SCRIPT");
8844         if (np->ccb)
8845                 m_free_dma(np->ccb, sizeof(struct ccb), "CCB");
8846         m_free_dma(np, sizeof(struct ncb), "NCB");
8847         host_data->ncb = NULL;
8848
8849  unregister:
8850         scsi_host_put(instance);
8851
8852         return NULL;
8853 }
8854
8855
8856 int ncr53c8xx_release(struct Scsi_Host *host)
8857 {
8858         struct host_data *host_data;
8859 #ifdef DEBUG_NCR53C8XX
8860         printk("ncr53c8xx: release\n");
8861 #endif
8862         if (!host)
8863                 return 1;
8864         host_data = (struct host_data *)host->hostdata;
8865         if (host_data && host_data->ncb)
8866                 ncr_detach(host_data->ncb);
8867         return 1;
8868 }