sys/dev/disk/ncr/ncr.c

   1 /**************************************************************************
   2 **
   3 ** $FreeBSD: src/sys/pci/ncr.c,v 1.155.2.3 2001/03/05 13:09:10 obrien Exp $
   4 ** $DragonFly: src/sys/dev/disk/ncr/ncr.c,v 1.7 2004/03/15 01:10:44 dillon Exp $
   5 **
   6 **  Device driver for the   NCR 53C8XX   PCI-SCSI-Controller Family.
   7 **
   8 **-------------------------------------------------------------------------
   9 **
  10 **  Written for 386bsd and FreeBSD by
  11 **      Wolfgang Stanglmeier    <wolf@cologne.de>
  12 **      Stefan Esser            <se@mi.Uni-Koeln.de>
  13 **
  14 **-------------------------------------------------------------------------
  15 **
  16 ** Copyright (c) 1994 Wolfgang Stanglmeier.  All rights reserved.
  17 **
  18 ** Redistribution and use in source and binary forms, with or without
  19 ** modification, are permitted provided that the following conditions
  20 ** are met:
  21 ** 1. Redistributions of source code must retain the above copyright
  22 **    notice, this list of conditions and the following disclaimer.
  23 ** 2. Redistributions in binary form must reproduce the above copyright
  24 **    notice, this list of conditions and the following disclaimer in the
  25 **    documentation and/or other materials provided with the distribution.
  26 ** 3. The name of the author may not be used to endorse or promote products
  27 **    derived from this software without specific prior written permission.
  28 **
  29 ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  30 ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  31 ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  32 ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  33 ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  34 ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  35 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  36 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  37 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  38 ** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  39 **
  40 ***************************************************************************
  41 */
  42
  43 #define NCR_DATE "pl30 98/1/1"
  44
  45 #define NCR_VERSION     (2)
  46 #define MAX_UNITS       (16)
  47
  48 #define NCR_GETCC_WITHMSG
  49
  50 #if (defined(__DragonFly__) || defined (__FreeBSD__)) && defined(_KERNEL)
  51 #include "opt_ncr.h"
  52 #endif
  53
  54 /*==========================================================
  55 **
  56 **      Configuration and Debugging
  57 **
  58 **      May be overwritten in <arch/conf/xxxx>
  59 **
  60 **==========================================================
  61 */
  62
  63 /*
  64 **    SCSI address of this device.
  65 **    The boot routines should have set it.
  66 **    If not, use this.
  67 */
  68
  69 #ifndef SCSI_NCR_MYADDR
  70 #define SCSI_NCR_MYADDR      (7)
  71 #endif /* SCSI_NCR_MYADDR */
  72
  73 /*
  74 **    The default synchronous period factor
  75 **    (0=asynchronous)
  76 **    If maximum synchronous frequency is defined, use it instead.
  77 */
  78
  79 #ifndef SCSI_NCR_MAX_SYNC
  80
  81 #ifndef SCSI_NCR_DFLT_SYNC
  82 #define SCSI_NCR_DFLT_SYNC   (12)
  83 #endif /* SCSI_NCR_DFLT_SYNC */
  84
  85 #else
  86
  87 #if     SCSI_NCR_MAX_SYNC == 0
  88 #define SCSI_NCR_DFLT_SYNC 0
  89 #else
  90 #define SCSI_NCR_DFLT_SYNC (250000 / SCSI_NCR_MAX_SYNC)
  91 #endif
  92
  93 #endif
  94
  95 /*
  96 **    The minimal asynchronous pre-scaler period (ns)
  97 **    Shall be 40.
  98 */
  99
 100 #ifndef SCSI_NCR_MIN_ASYNC
 101 #define SCSI_NCR_MIN_ASYNC   (40)
 102 #endif /* SCSI_NCR_MIN_ASYNC */
 103
 104 /*
 105 **    The maximal bus with (in log2 byte)
 106 **    (0=8 bit, 1=16 bit)
 107 */
 108
 109 #ifndef SCSI_NCR_MAX_WIDE
 110 #define SCSI_NCR_MAX_WIDE   (1)
 111 #endif /* SCSI_NCR_MAX_WIDE */
 112
 113 /*==========================================================
 114 **
 115 **      Configuration and Debugging
 116 **
 117 **==========================================================
 118 */
 119
 120 /*
 121 **    Number of targets supported by the driver.
 122 **    n permits target numbers 0..n-1.
 123 **    Default is 7, meaning targets #0..#6.
 124 **    #7 .. is myself.
 125 */
 126
 127 #define MAX_TARGET  (16)
 128
 129 /*
 130 **    Number of logic units supported by the driver.
 131 **    n enables logic unit numbers 0..n-1.
 132 **    The common SCSI devices require only
 133 **    one lun, so take 1 as the default.
 134 */
 135
 136 #ifndef MAX_LUN
 137 #define MAX_LUN     (8)
 138 #endif  /* MAX_LUN */
 139
 140 /*
 141 **    The maximum number of jobs scheduled for starting.
 142 **    There should be one slot per target, and one slot
 143 **    for each tag of each target in use.
 144 */
 145
 146 #define MAX_START   (256)
 147
 148 /*
 149 **    The maximum number of segments a transfer is split into.
 150 */
 151
 152 #define MAX_SCATTER (33)
 153
 154 /*
 155 **    The maximum transfer length (should be >= 64k).
 156 **    MUST NOT be greater than (MAX_SCATTER-1) * PAGE_SIZE.
 157 */
 158
 159 #define MAX_SIZE  ((MAX_SCATTER-1) * (long) PAGE_SIZE)
 160
 161 /*
 162 **      other
 163 */
 164
 165 #define NCR_SNOOP_TIMEOUT (1000000)
 166
 167 /*==========================================================
 168 **
 169 **      Include files
 170 **
 171 **==========================================================
 172 */
 173
 174 #include <sys/param.h>
 175 #include <sys/time.h>
 176
 177 #ifdef _KERNEL
 178 #include <sys/systm.h>
 179 #include <sys/malloc.h>
 180 #include <sys/buf.h>
 181 #include <sys/kernel.h>
 182 #include <sys/sysctl.h>
 183 #include <sys/bus.h>
 184 #include <machine/clock.h>
 185 #include <machine/md_var.h>
 186 #include <machine/bus.h>
 187 #include <machine/resource.h>
 188 #include <sys/rman.h>
 189 #include <vm/vm.h>
 190 #include <vm/pmap.h>
 191 #include <vm/vm_extern.h>
 192 #endif
 193
 194 #include <bus/pci/pcivar.h>
 195 #include <bus/pci/pcireg.h>
 196 #include "ncrreg.h"
 197
 198 #include <bus/cam/cam.h>
 199 #include <bus/cam/cam_ccb.h>
 200 #include <bus/cam/cam_sim.h>
 201 #include <bus/cam/cam_xpt_sim.h>
 202 #include <bus/cam/cam_debug.h>
 203
 204 #include <bus/cam/scsi/scsi_all.h>
 205 #include <bus/cam/scsi/scsi_message.h>
 206
 207 /*==========================================================
 208 **
 209 **      Debugging tags
 210 **
 211 **==========================================================
 212 */
 213
 214 #define DEBUG_ALLOC    (0x0001)
 215 #define DEBUG_PHASE    (0x0002)
 216 #define DEBUG_POLL     (0x0004)
 217 #define DEBUG_QUEUE    (0x0008)
 218 #define DEBUG_RESULT   (0x0010)
 219 #define DEBUG_SCATTER  (0x0020)
 220 #define DEBUG_SCRIPT   (0x0040)
 221 #define DEBUG_TINY     (0x0080)
 222 #define DEBUG_TIMING   (0x0100)
 223 #define DEBUG_NEGO     (0x0200)
 224 #define DEBUG_TAGS     (0x0400)
 225 #define DEBUG_FREEZE   (0x0800)
 226 #define DEBUG_RESTART  (0x1000)
 227
 228 /*
 229 **    Enable/Disable debug messages.
 230 **    Can be changed at runtime too.
 231 */
 232 #ifdef SCSI_NCR_DEBUG
 233         #define DEBUG_FLAGS ncr_debug
 234 #else /* SCSI_NCR_DEBUG */
 235         #define SCSI_NCR_DEBUG  0
 236         #define DEBUG_FLAGS     0
 237 #endif /* SCSI_NCR_DEBUG */
 238
 239
 240
 241 /*==========================================================
 242 **
 243 **      assert ()
 244 **
 245 **==========================================================
 246 **
 247 **      modified copy from 386bsd:/usr/include/sys/assert.h
 248 **
 249 **----------------------------------------------------------
 250 */
 251
 252 #ifdef DIAGNOSTIC
 253 #define assert(expression) {                                    \
 254         if (!(expression)) {                                    \
 255                 (void)printf("assertion \"%s\" failed: "        \
 256                              "file \"%s\", line %d\n",          \
 257                              #expression, __FILE__, __LINE__);  \
 258              Debugger("");                                      \
 259         }                                                       \
 260 }
 261 #else
 262 #define assert(expression) {                                    \
 263         if (!(expression)) {                                    \
 264                 (void)printf("assertion \"%s\" failed: "        \
 265                              "file \"%s\", line %d\n",          \
 266                              #expression, __FILE__, __LINE__);  \
 267         }                                                       \
 268 }
 269 #endif
 270
 271 /*==========================================================
 272 **
 273 **      Access to the controller chip.
 274 **
 275 **==========================================================
 276 */
 277
 278 #ifdef __alpha__
 279 /* XXX */
 280 #undef vtophys
 281 #define vtophys(va)     alpha_XXX_dmamap((vm_offset_t)va)
 282 #endif
 283
 284 #define INB(r) bus_space_read_1(np->bst, np->bsh, offsetof(struct ncr_reg, r))
 285 #define INW(r) bus_space_read_2(np->bst, np->bsh, offsetof(struct ncr_reg, r))
 286 #define INL(r) bus_space_read_4(np->bst, np->bsh, offsetof(struct ncr_reg, r))
 287
 288 #define OUTB(r, val) bus_space_write_1(np->bst, np->bsh, \
 289                                        offsetof(struct ncr_reg, r), val)
 290 #define OUTW(r, val) bus_space_write_2(np->bst, np->bsh, \
 291                                        offsetof(struct ncr_reg, r), val)
 292 #define OUTL(r, val) bus_space_write_4(np->bst, np->bsh, \
 293                                        offsetof(struct ncr_reg, r), val)
 294 #define OUTL_OFF(o, val) bus_space_write_4(np->bst, np->bsh, o, val)
 295
 296 #define INB_OFF(o) bus_space_read_1(np->bst, np->bsh, o)
 297 #define INW_OFF(o) bus_space_read_2(np->bst, np->bsh, o)
 298 #define INL_OFF(o) bus_space_read_4(np->bst, np->bsh, o)
 299
 300 #define READSCRIPT_OFF(base, off)                                       \
 301     (base ? *((volatile u_int32_t *)((volatile char *)base + (off))) :  \
 302     bus_space_read_4(np->bst2, np->bsh2, off))
 303
 304 #define WRITESCRIPT_OFF(base, off, val)                                 \
 305     do {                                                                \
 306         if (base)                                                       \
 307                 *((volatile u_int32_t *)                                \
 308                         ((volatile char *)base + (off))) = (val);       \
 309         else                                                            \
 310                 bus_space_write_4(np->bst2, np->bsh2, off, val);        \
 311     } while (0)
 312
 313 #define READSCRIPT(r) \
 314     READSCRIPT_OFF(np->script, offsetof(struct script, r))
 315
 316 #define WRITESCRIPT(r, val) \
 317     WRITESCRIPT_OFF(np->script, offsetof(struct script, r), val)
 318
 319 /*
 320 **      Set bit field ON, OFF
 321 */
 322
 323 #define OUTONB(r, m)    OUTB(r, INB(r) | (m))
 324 #define OUTOFFB(r, m)   OUTB(r, INB(r) & ~(m))
 325 #define OUTONW(r, m)    OUTW(r, INW(r) | (m))
 326 #define OUTOFFW(r, m)   OUTW(r, INW(r) & ~(m))
 327 #define OUTONL(r, m)    OUTL(r, INL(r) | (m))
 328 #define OUTOFFL(r, m)   OUTL(r, INL(r) & ~(m))
 329
 330 /*==========================================================
 331 **
 332 **      Command control block states.
 333 **
 334 **==========================================================
 335 */
 336
 337 #define HS_IDLE         (0)
 338 #define HS_BUSY         (1)
 339 #define HS_NEGOTIATE    (2)     /* sync/wide data transfer*/
 340 #define HS_DISCONNECT   (3)     /* Disconnected by target */
 341
 342 #define HS_COMPLETE     (4)
 343 #define HS_SEL_TIMEOUT  (5)     /* Selection timeout      */
 344 #define HS_RESET        (6)     /* SCSI reset        */
 345 #define HS_ABORTED      (7)     /* Transfer aborted       */
 346 #define HS_TIMEOUT      (8)     /* Software timeout       */
 347 #define HS_FAIL         (9)     /* SCSI or PCI bus errors */
 348 #define HS_UNEXPECTED   (10)    /* Unexpected disconnect  */
 349 #define HS_STALL        (11)    /* QUEUE FULL or BUSY     */
 350
 351 #define HS_DONEMASK     (0xfc)
 352
 353 /*==========================================================
 354 **
 355 **      Software Interrupt Codes
 356 **
 357 **==========================================================
 358 */
 359
 360 #define SIR_SENSE_RESTART       (1)
 361 #define SIR_SENSE_FAILED        (2)
 362 #define SIR_STALL_RESTART       (3)
 363 #define SIR_STALL_QUEUE         (4)
 364 #define SIR_NEGO_SYNC           (5)
 365 #define SIR_NEGO_WIDE           (6)
 366 #define SIR_NEGO_FAILED         (7)
 367 #define SIR_NEGO_PROTO          (8)
 368 #define SIR_REJECT_RECEIVED     (9)
 369 #define SIR_REJECT_SENT         (10)
 370 #define SIR_IGN_RESIDUE         (11)
 371 #define SIR_MISSING_SAVE        (12)
 372 #define SIR_MAX                 (12)
 373
 374 /*==========================================================
 375 **
 376 **      Extended error codes.
 377 **      xerr_status field of struct nccb.
 378 **
 379 **==========================================================
 380 */
 381
 382 #define XE_OK           (0)
 383 #define XE_EXTRA_DATA   (1)     /* unexpected data phase */
 384 #define XE_BAD_PHASE    (2)     /* illegal phase (4/5)   */
 385
 386 /*==========================================================
 387 **
 388 **      Negotiation status.
 389 **      nego_status field       of struct nccb.
 390 **
 391 **==========================================================
 392 */
 393
 394 #define NS_SYNC         (1)
 395 #define NS_WIDE         (2)
 396
 397 /*==========================================================
 398 **
 399 **      XXX These are no longer used.  Remove once the
 400 **          script is updated.
 401 **      "Special features" of targets.
 402 **      quirks field of struct tcb.
 403 **      actualquirks field of struct nccb.
 404 **
 405 **==========================================================
 406 */
 407
 408 #define QUIRK_AUTOSAVE  (0x01)
 409 #define QUIRK_NOMSG     (0x02)
 410 #define QUIRK_NOSYNC    (0x10)
 411 #define QUIRK_NOWIDE16  (0x20)
 412 #define QUIRK_NOTAGS    (0x40)
 413 #define QUIRK_UPDATE    (0x80)
 414
 415 /*==========================================================
 416 **
 417 **      Misc.
 418 **
 419 **==========================================================
 420 */
 421
 422 #define CCB_MAGIC       (0xf2691ad2)
 423 #define MAX_TAGS        (32)            /* hard limit */
 424
 425 /*==========================================================
 426 **
 427 **      OS dependencies.
 428 **
 429 **==========================================================
 430 */
 431
 432 #define PRINT_ADDR(ccb) xpt_print_path((ccb)->ccb_h.path)
 433
 434 /*==========================================================
 435 **
 436 **      Declaration of structs.
 437 **
 438 **==========================================================
 439 */
 440
 441 struct tcb;
 442 struct lcb;
 443 struct nccb;
 444 struct ncb;
 445 struct script;
 446
 447 typedef struct ncb * ncb_p;
 448 typedef struct tcb * tcb_p;
 449 typedef struct lcb * lcb_p;
 450 typedef struct nccb * nccb_p;
 451
 452 struct link {
 453         ncrcmd  l_cmd;
 454         ncrcmd  l_paddr;
 455 };
 456
 457 struct  usrcmd {
 458         u_long  target;
 459         u_long  lun;
 460         u_long  data;
 461         u_long  cmd;
 462 };
 463
 464 #define UC_SETSYNC      10
 465 #define UC_SETTAGS      11
 466 #define UC_SETDEBUG     12
 467 #define UC_SETORDER     13
 468 #define UC_SETWIDE      14
 469 #define UC_SETFLAG      15
 470
 471 #define UF_TRACE        (0x01)
 472
 473 /*---------------------------------------
 474 **
 475 **      Timestamps for profiling
 476 **
 477 **---------------------------------------
 478 */
 479
 480 /* Type of the kernel variable `ticks'.  XXX should be declared with the var. */
 481 typedef int ticks_t;
 482
 483 struct tstamp {
 484         ticks_t start;
 485         ticks_t end;
 486         ticks_t select;
 487         ticks_t command;
 488         ticks_t data;
 489         ticks_t status;
 490         ticks_t disconnect;
 491 };
 492
 493 /*
 494 **      profiling data (per device)
 495 */
 496
 497 struct profile {
 498         u_long  num_trans;
 499         u_long  num_bytes;
 500         u_long  num_disc;
 501         u_long  num_break;
 502         u_long  num_int;
 503         u_long  num_fly;
 504         u_long  ms_setup;
 505         u_long  ms_data;
 506         u_long  ms_disc;
 507         u_long  ms_post;
 508 };
 509
 510 /*==========================================================
 511 **
 512 **      Declaration of structs:         target control block
 513 **
 514 **==========================================================
 515 */
 516
 517 #define NCR_TRANS_CUR           0x01    /* Modify current neogtiation status */
 518 #define NCR_TRANS_ACTIVE        0x03    /* Assume this is the active target */
 519 #define NCR_TRANS_GOAL          0x04    /* Modify negotiation goal */
 520 #define NCR_TRANS_USER          0x08    /* Modify user negotiation settings */
 521
 522 struct ncr_transinfo {
 523         u_int8_t width;
 524         u_int8_t period;
 525         u_int8_t offset;
 526 };
 527
 528 struct ncr_target_tinfo {
 529         /* Hardware version of our sync settings */
 530         u_int8_t disc_tag;
 531 #define         NCR_CUR_DISCENB 0x01
 532 #define         NCR_CUR_TAGENB  0x02
 533 #define         NCR_USR_DISCENB 0x04
 534 #define         NCR_USR_TAGENB  0x08
 535         u_int8_t sval;
 536         struct   ncr_transinfo current;
 537         struct   ncr_transinfo goal;
 538         struct   ncr_transinfo user;
 539         /* Hardware version of our wide settings */
 540         u_int8_t wval;
 541 };
 542
 543 struct tcb {
 544         /*
 545         **      during reselection the ncr jumps to this point
 546         **      with SFBR set to the encoded target number
 547         **      with bit 7 set.
 548         **      if it's not this target, jump to the next.
 549         **
 550         **      JUMP  IF (SFBR != #target#)
 551         **      @(next tcb)
 552         */
 553
 554         struct link   jump_tcb;
 555
 556         /*
 557         **      load the actual values for the sxfer and the scntl3
 558         **      register (sync/wide mode).
 559         **
 560         **      SCR_COPY (1);
 561         **      @(sval field of this tcb)
 562         **      @(sxfer register)
 563         **      SCR_COPY (1);
 564         **      @(wval field of this tcb)
 565         **      @(scntl3 register)
 566         */
 567
 568         ncrcmd  getscr[6];
 569
 570         /*
 571         **      if next message is "identify"
 572         **      then load the message to SFBR,
 573         **      else load 0 to SFBR.
 574         **
 575         **      CALL
 576         **      <RESEL_LUN>
 577         */
 578
 579         struct link   call_lun;
 580
 581         /*
 582         **      now look for the right lun.
 583         **
 584         **      JUMP
 585         **      @(first nccb of this lun)
 586         */
 587
 588         struct link   jump_lcb;
 589
 590         /*
 591         **      pointer to interrupted getcc nccb
 592         */
 593
 594         nccb_p   hold_cp;
 595
 596         /*
 597         **      pointer to nccb used for negotiating.
 598         **      Avoid to start a nego for all queued commands
 599         **      when tagged command queuing is enabled.
 600         */
 601
 602         nccb_p   nego_cp;
 603
 604         /*
 605         **      statistical data
 606         */
 607
 608         u_long  transfers;
 609         u_long  bytes;
 610
 611         /*
 612         **      user settable limits for sync transfer
 613         **      and tagged commands.
 614         */
 615
 616         struct   ncr_target_tinfo tinfo;
 617
 618         /*
 619         **      the lcb's of this tcb
 620         */
 621
 622         lcb_p   lp[MAX_LUN];
 623 };
 624
 625 /*==========================================================
 626 **
 627 **      Declaration of structs:         lun control block
 628 **
 629 **==========================================================
 630 */
 631
 632 struct lcb {
 633         /*
 634         **      during reselection the ncr jumps to this point
 635         **      with SFBR set to the "Identify" message.
 636         **      if it's not this lun, jump to the next.
 637         **
 638         **      JUMP  IF (SFBR != #lun#)
 639         **      @(next lcb of this target)
 640         */
 641
 642         struct link     jump_lcb;
 643
 644         /*
 645         **      if next message is "simple tag",
 646         **      then load the tag to SFBR,
 647         **      else load 0 to SFBR.
 648         **
 649         **      CALL
 650         **      <RESEL_TAG>
 651         */
 652
 653         struct link     call_tag;
 654
 655         /*
 656         **      now look for the right nccb.
 657         **
 658         **      JUMP
 659         **      @(first nccb of this lun)
 660         */
 661
 662         struct link     jump_nccb;
 663
 664         /*
 665         **      start of the nccb chain
 666         */
 667
 668         nccb_p  next_nccb;
 669
 670         /*
 671         **      Control of tagged queueing
 672         */
 673
 674         u_char          reqnccbs;
 675         u_char          reqlink;
 676         u_char          actlink;
 677         u_char          usetags;
 678         u_char          lasttag;
 679 };
 680
 681 /*==========================================================
 682 **
 683 **      Declaration of structs:     COMMAND control block
 684 **
 685 **==========================================================
 686 **
 687 **      This substructure is copied from the nccb to a
 688 **      global address after selection (or reselection)
 689 **      and copied back before disconnect.
 690 **
 691 **      These fields are accessible to the script processor.
 692 **
 693 **----------------------------------------------------------
 694 */
 695
 696 struct head {
 697         /*
 698         **      Execution of a nccb starts at this point.
 699         **      It's a jump to the "SELECT" label
 700         **      of the script.
 701         **
 702         **      After successful selection the script
 703         **      processor overwrites it with a jump to
 704         **      the IDLE label of the script.
 705         */
 706
 707         struct link     launch;
 708
 709         /*
 710         **      Saved data pointer.
 711         **      Points to the position in the script
 712         **      responsible for the actual transfer
 713         **      of data.
 714         **      It's written after reception of a
 715         **      "SAVE_DATA_POINTER" message.
 716         **      The goalpointer points after
 717         **      the last transfer command.
 718         */
 719
 720         u_int32_t       savep;
 721         u_int32_t       lastp;
 722         u_int32_t       goalp;
 723
 724         /*
 725         **      The virtual address of the nccb
 726         **      containing this header.
 727         */
 728
 729         nccb_p  cp;
 730
 731         /*
 732         **      space for some timestamps to gather
 733         **      profiling data about devices and this driver.
 734         */
 735
 736         struct tstamp   stamp;
 737
 738         /*
 739         **      status fields.
 740         */
 741
 742         u_char          status[8];
 743 };
 744
 745 /*
 746 **      The status bytes are used by the host and the script processor.
 747 **
 748 **      The first four byte are copied to the scratchb register
 749 **      (declared as scr0..scr3 in ncr_reg.h) just after the select/reselect,
 750 **      and copied back just after disconnecting.
 751 **      Inside the script the XX_REG are used.
 752 **
 753 **      The last four bytes are used inside the script by "COPY" commands.
 754 **      Because source and destination must have the same alignment
 755 **      in a longword, the fields HAVE to be at the choosen offsets.
 756 **              xerr_st (4)     0       (0x34)  scratcha
 757 **              sync_st (5)     1       (0x05)  sxfer
 758 **              wide_st (7)     3       (0x03)  scntl3
 759 */
 760
 761 /*
 762 **      First four bytes (script)
 763 */
 764 #define  QU_REG scr0
 765 #define  HS_REG scr1
 766 #define  HS_PRT nc_scr1
 767 #define  SS_REG scr2
 768 #define  PS_REG scr3
 769
 770 /*
 771 **      First four bytes (host)
 772 */
 773 #define  actualquirks  phys.header.status[0]
 774 #define  host_status   phys.header.status[1]
 775 #define  s_status      phys.header.status[2]
 776 #define  parity_status phys.header.status[3]
 777
 778 /*
 779 **      Last four bytes (script)
 780 */
 781 #define  xerr_st       header.status[4] /* MUST be ==0 mod 4 */
 782 #define  sync_st       header.status[5] /* MUST be ==1 mod 4 */
 783 #define  nego_st       header.status[6]
 784 #define  wide_st       header.status[7] /* MUST be ==3 mod 4 */
 785
 786 /*
 787 **      Last four bytes (host)
 788 */
 789 #define  xerr_status   phys.xerr_st
 790 #define  sync_status   phys.sync_st
 791 #define  nego_status   phys.nego_st
 792 #define  wide_status   phys.wide_st
 793
 794 /*==========================================================
 795 **
 796 **      Declaration of structs:     Data structure block
 797 **
 798 **==========================================================
 799 **
 800 **      During execution of a nccb by the script processor,
 801 **      the DSA (data structure address) register points
 802 **      to this substructure of the nccb.
 803 **      This substructure contains the header with
 804 **      the script-processor-changable data and
 805 **      data blocks for the indirect move commands.
 806 **
 807 **----------------------------------------------------------
 808 */
 809
 810 struct dsb {
 811
 812         /*
 813         **      Header.
 814         **      Has to be the first entry,
 815         **      because it's jumped to by the
 816         **      script processor
 817         */
 818
 819         struct head     header;
 820
 821         /*
 822         **      Table data for Script
 823         */
 824
 825         struct scr_tblsel  select;
 826         struct scr_tblmove smsg  ;
 827         struct scr_tblmove smsg2 ;
 828         struct scr_tblmove cmd   ;
 829         struct scr_tblmove scmd  ;
 830         struct scr_tblmove sense ;
 831         struct scr_tblmove data [MAX_SCATTER];
 832 };
 833
 834 /*==========================================================
 835 **
 836 **      Declaration of structs:     Command control block.
 837 **
 838 **==========================================================
 839 **
 840 **      During execution of a nccb by the script processor,
 841 **      the DSA (data structure address) register points
 842 **      to this substructure of the nccb.
 843 **      This substructure contains the header with
 844 **      the script-processor-changable data and then
 845 **      data blocks for the indirect move commands.
 846 **
 847 **----------------------------------------------------------
 848 */
 849
 850
 851 struct nccb {
 852         /*
 853         **      This filler ensures that the global header is
 854         **      cache line size aligned.
 855         */
 856         ncrcmd  filler[4];
 857
 858         /*
 859         **      during reselection the ncr jumps to this point.
 860         **      If a "SIMPLE_TAG" message was received,
 861         **      then SFBR is set to the tag.
 862         **      else SFBR is set to 0
 863         **      If looking for another tag, jump to the next nccb.
 864         **
 865         **      JUMP  IF (SFBR != #TAG#)
 866         **      @(next nccb of this lun)
 867         */
 868
 869         struct link             jump_nccb;
 870
 871         /*
 872         **      After execution of this call, the return address
 873         **      (in  the TEMP register) points to the following
 874         **      data structure block.
 875         **      So copy it to the DSA register, and start
 876         **      processing of this data structure.
 877         **
 878         **      CALL
 879         **      <RESEL_TMP>
 880         */
 881
 882         struct link             call_tmp;
 883
 884         /*
 885         **      This is the data structure which is
 886         **      to be executed by the script processor.
 887         */
 888
 889         struct dsb              phys;
 890
 891         /*
 892         **      If a data transfer phase is terminated too early
 893         **      (after reception of a message (i.e. DISCONNECT)),
 894         **      we have to prepare a mini script to transfer
 895         **      the rest of the data.
 896         */
 897
 898         ncrcmd                  patch[8];
 899
 900         /*
 901         **      The general SCSI driver provides a
 902         **      pointer to a control block.
 903         */
 904
 905         union   ccb *ccb;
 906
 907         /*
 908         **      We prepare a message to be sent after selection,
 909         **      and a second one to be sent after getcc selection.
 910         **      Contents are IDENTIFY and SIMPLE_TAG.
 911         **      While negotiating sync or wide transfer,
 912         **      a SDTM or WDTM message is appended.
 913         */
 914
 915         u_char                  scsi_smsg [8];
 916         u_char                  scsi_smsg2[8];
 917
 918         /*
 919         **      Lock this nccb.
 920         **      Flag is used while looking for a free nccb.
 921         */
 922
 923         u_long          magic;
 924
 925         /*
 926         **      Physical address of this instance of nccb
 927         */
 928
 929         u_long          p_nccb;
 930
 931         /*
 932         **      Completion time out for this job.
 933         **      It's set to time of start + allowed number of seconds.
 934         */
 935
 936         time_t          tlimit;
 937
 938         /*
 939         **      All nccbs of one hostadapter are chained.
 940         */
 941
 942         nccb_p          link_nccb;
 943
 944         /*
 945         **      All nccbs of one target/lun are chained.
 946         */
 947
 948         nccb_p          next_nccb;
 949
 950         /*
 951         **      Sense command
 952         */
 953
 954         u_char          sensecmd[6];
 955
 956         /*
 957         **      Tag for this transfer.
 958         **      It's patched into jump_nccb.
 959         **      If it's not zero, a SIMPLE_TAG
 960         **      message is included in smsg.
 961         */
 962
 963         u_char                  tag;
 964 };
 965
 966 #define CCB_PHYS(cp,lbl)        (cp->p_nccb + offsetof(struct nccb, lbl))
 967
 968 /*==========================================================
 969 **
 970 **      Declaration of structs:     NCR device descriptor
 971 **
 972 **==========================================================
 973 */
 974
 975 struct ncb {
 976         /*
 977         **      The global header.
 978         **      Accessible to both the host and the
 979         **      script-processor.
 980         **      We assume it is cache line size aligned.
 981         */
 982         struct head     header;
 983
 984         int     unit;
 985
 986         /*-----------------------------------------------
 987         **      Scripts ..
 988         **-----------------------------------------------
 989         **
 990         **      During reselection the ncr jumps to this point.
 991         **      The SFBR register is loaded with the encoded target id.
 992         **
 993         **      Jump to the first target.
 994         **
 995         **      JUMP
 996         **      @(next tcb)
 997         */
 998         struct link     jump_tcb;
 999
1000         /*-----------------------------------------------
1001         **      Configuration ..
1002         **-----------------------------------------------
1003         **
1004         **      virtual and physical addresses
1005         **      of the 53c810 chip.
1006         */
1007         int             reg_rid;
1008         struct resource *reg_res;
1009         bus_space_tag_t bst;
1010         bus_space_handle_t bsh;
1011
1012         int             sram_rid;
1013         struct resource *sram_res;
1014         bus_space_tag_t bst2;
1015         bus_space_handle_t bsh2;
1016
1017         struct resource *irq_res;
1018         void            *irq_handle;
1019
1020         /*
1021         **      Scripts instance virtual address.
1022         */
1023         struct script   *script;
1024         struct scripth  *scripth;
1025
1026         /*
1027         **      Scripts instance physical address.
1028         */
1029         u_long          p_script;
1030         u_long          p_scripth;
1031
1032         /*
1033         **      The SCSI address of the host adapter.
1034         */
1035         u_char          myaddr;
1036
1037         /*
1038         **      timing parameters
1039         */
1040         u_char          minsync;        /* Minimum sync period factor   */
1041         u_char          maxsync;        /* Maximum sync period factor   */
1042         u_char          maxoffs;        /* Max scsi offset              */
1043         u_char          clock_divn;     /* Number of clock divisors     */
1044         u_long          clock_khz;      /* SCSI clock frequency in KHz  */
1045         u_long          features;       /* Chip features map            */
1046         u_char          multiplier;     /* Clock multiplier (1,2,4)     */
1047
1048         u_char          maxburst;       /* log base 2 of dwords burst   */
1049
1050         /*
1051         **      BIOS supplied PCI bus options
1052         */
1053         u_char          rv_scntl3;
1054         u_char          rv_dcntl;
1055         u_char          rv_dmode;
1056         u_char          rv_ctest3;
1057         u_char          rv_ctest4;
1058         u_char          rv_ctest5;
1059         u_char          rv_gpcntl;
1060         u_char          rv_stest2;
1061
1062         /*-----------------------------------------------
1063         **      CAM SIM information for this instance
1064         **-----------------------------------------------
1065         */
1066
1067         struct          cam_sim  *sim;
1068         struct          cam_path *path;
1069
1070         /*-----------------------------------------------
1071         **      Job control
1072         **-----------------------------------------------
1073         **
1074         **      Commands from user
1075         */
1076         struct usrcmd   user;
1077
1078         /*
1079         **      Target data
1080         */
1081         struct tcb      target[MAX_TARGET];
1082
1083         /*
1084         **      Start queue.
1085         */
1086         u_int32_t       squeue [MAX_START];
1087         u_short         squeueput;
1088
1089         /*
1090         **      Timeout handler
1091         */
1092         time_t          heartbeat;
1093         u_short         ticks;
1094         u_short         latetime;
1095         time_t          lasttime;
1096         struct          callout_handle timeout_ch;
1097
1098         /*-----------------------------------------------
1099         **      Debug and profiling
1100         **-----------------------------------------------
1101         **
1102         **      register dump
1103         */
1104         struct ncr_reg  regdump;
1105         time_t          regtime;
1106
1107         /*
1108         **      Profiling data
1109         */
1110         struct profile  profile;
1111         u_long          disc_phys;
1112         u_long          disc_ref;
1113
1114         /*
1115         **      Head of list of all nccbs for this controller.
1116         */
1117         nccb_p          link_nccb;
1118
1119         /*
1120         **      message buffers.
1121         **      Should be longword aligned,
1122         **      because they're written with a
1123         **      COPY script command.
1124         */
1125         u_char          msgout[8];
1126         u_char          msgin [8];
1127         u_int32_t       lastmsg;
1128
1129         /*
1130         **      Buffer for STATUS_IN phase.
1131         */
1132         u_char          scratch;
1133
1134         /*
1135         **      controller chip dependent maximal transfer width.
1136         */
1137         u_char          maxwide;
1138
1139 #ifdef NCR_IOMAPPED
1140         /*
1141         **      address of the ncr control registers in io space
1142         */
1143         pci_port_t      port;
1144 #endif
1145 };
1146
1147 #define NCB_SCRIPT_PHYS(np,lbl) (np->p_script + offsetof (struct script, lbl))
1148 #define NCB_SCRIPTH_PHYS(np,lbl) (np->p_scripth + offsetof (struct scripth,lbl))
1149
1150 /*==========================================================
1151 **
1152 **
1153 **      Script for NCR-Processor.
1154 **
1155 **      Use ncr_script_fill() to create the variable parts.
1156 **      Use ncr_script_copy_and_bind() to make a copy and
1157 **      bind to physical addresses.
1158 **
1159 **
1160 **==========================================================
1161 **
1162 **      We have to know the offsets of all labels before
1163 **      we reach them (for forward jumps).
1164 **      Therefore we declare a struct here.
1165 **      If you make changes inside the script,
1166 **      DONT FORGET TO CHANGE THE LENGTHS HERE!
1167 **
1168 **----------------------------------------------------------
1169 */
1170
1171 /*
1172 **      Script fragments which are loaded into the on-board RAM
1173 **      of 825A, 875 and 895 chips.
1174 */
1175 struct script {
1176         ncrcmd  start           [  7];
1177         ncrcmd  start0          [  2];
1178         ncrcmd  start1          [  3];
1179         ncrcmd  startpos        [  1];
1180         ncrcmd  trysel          [  8];
1181         ncrcmd  skip            [  8];
1182         ncrcmd  skip2           [  3];
1183         ncrcmd  idle            [  2];
1184         ncrcmd  select          [ 18];
1185         ncrcmd  prepare         [  4];
1186         ncrcmd  loadpos         [ 14];
1187         ncrcmd  prepare2        [ 24];
1188         ncrcmd  setmsg          [  5];
1189         ncrcmd  clrack          [  2];
1190         ncrcmd  dispatch        [ 33];
1191         ncrcmd  no_data         [ 17];
1192         ncrcmd  checkatn        [ 10];
1193         ncrcmd  command         [ 15];
1194         ncrcmd  status          [ 27];
1195         ncrcmd  msg_in          [ 26];
1196         ncrcmd  msg_bad         [  6];
1197         ncrcmd  complete        [ 13];
1198         ncrcmd  cleanup         [ 12];
1199         ncrcmd  cleanup0        [  9];
1200         ncrcmd  signal          [ 12];
1201         ncrcmd  save_dp         [  5];
1202         ncrcmd  restore_dp      [  5];
1203         ncrcmd  disconnect      [ 12];
1204         ncrcmd  disconnect0     [  5];
1205         ncrcmd  disconnect1     [ 23];
1206         ncrcmd  msg_out         [  9];
1207         ncrcmd  msg_out_done    [  7];
1208         ncrcmd  badgetcc        [  6];
1209         ncrcmd  reselect        [  8];
1210         ncrcmd  reselect1       [  8];
1211         ncrcmd  reselect2       [  8];
1212         ncrcmd  resel_tmp       [  5];
1213         ncrcmd  resel_lun       [ 18];
1214         ncrcmd  resel_tag       [ 24];
1215         ncrcmd  data_in         [MAX_SCATTER * 4 + 7];
1216         ncrcmd  data_out        [MAX_SCATTER * 4 + 7];
1217 };
1218
1219 /*
1220 **      Script fragments which stay in main memory for all chips.
1221 */
1222 struct scripth {
1223         ncrcmd  tryloop         [MAX_START*5+2];
1224         ncrcmd  msg_parity      [  6];
1225         ncrcmd  msg_reject      [  8];
1226         ncrcmd  msg_ign_residue [ 32];
1227         ncrcmd  msg_extended    [ 18];
1228         ncrcmd  msg_ext_2       [ 18];
1229         ncrcmd  msg_wdtr        [ 27];
1230         ncrcmd  msg_ext_3       [ 18];
1231         ncrcmd  msg_sdtr        [ 27];
1232         ncrcmd  msg_out_abort   [ 10];
1233         ncrcmd  getcc           [  4];
1234         ncrcmd  getcc1          [  5];
1235 #ifdef NCR_GETCC_WITHMSG
1236         ncrcmd  getcc2          [ 29];
1237 #else
1238         ncrcmd  getcc2          [ 14];
1239 #endif
1240         ncrcmd  getcc3          [  6];
1241         ncrcmd  aborttag        [  4];
1242         ncrcmd  abort           [ 22];
1243         ncrcmd  snooptest       [  9];
1244         ncrcmd  snoopend        [  2];
1245 };
1246
1247 /*==========================================================
1248 **
1249 **
1250 **      Function headers.
1251 **
1252 **
1253 **==========================================================
1254 */
1255
1256 #ifdef _KERNEL
1257 static  nccb_p  ncr_alloc_nccb  (ncb_p np, u_long target, u_long lun);
1258 static  void    ncr_complete    (ncb_p np, nccb_p cp);
1259 static  int     ncr_delta       (int * from, int * to);
1260 static  void    ncr_exception   (ncb_p np);
1261 static  void    ncr_free_nccb   (ncb_p np, nccb_p cp);
1262 static  void    ncr_freeze_devq (ncb_p np, struct cam_path *path);
1263 static  void    ncr_selectclock (ncb_p np, u_char scntl3);
1264 static  void    ncr_getclock    (ncb_p np, u_char multiplier);
1265 static  nccb_p  ncr_get_nccb    (ncb_p np, u_long t,u_long l);
1266 #if 0
1267 static  u_int32_t ncr_info      (int unit);
1268 #endif
1269 static  void    ncr_init        (ncb_p np, char * msg, u_long code);
1270 static  void    ncr_intr        (void *vnp);
1271 static  void    ncr_int_ma      (ncb_p np, u_char dstat);
1272 static  void    ncr_int_sir     (ncb_p np);
1273 static  void    ncr_int_sto     (ncb_p np);
1274 #if 0
1275 static  void    ncr_min_phys    (struct buf *bp);
1276 #endif
1277 static  void    ncr_poll        (struct cam_sim *sim);
1278 static  void    ncb_profile     (ncb_p np, nccb_p cp);
1279 static  void    ncr_script_copy_and_bind
1280                                 (ncb_p np, ncrcmd *src, ncrcmd *dst, int len);
1281 static  void    ncr_script_fill (struct script * scr, struct scripth *scrh);
1282 static  int     ncr_scatter     (struct dsb* phys, vm_offset_t vaddr,
1283                                  vm_size_t datalen);
1284 static  void    ncr_getsync     (ncb_p np, u_char sfac, u_char *fakp,
1285                                  u_char *scntl3p);
1286 static  void    ncr_setsync     (ncb_p np, nccb_p cp,u_char scntl3,u_char sxfer,
1287                                  u_char period);
1288 static  void    ncr_setwide     (ncb_p np, nccb_p cp, u_char wide, u_char ack);
1289 static  int     ncr_show_msg    (u_char * msg);
1290 static  int     ncr_snooptest   (ncb_p np);
1291 static  void    ncr_action      (struct cam_sim *sim, union ccb *ccb);
1292 static  void    ncr_timeout     (void *arg);
1293 static  void    ncr_wakeup      (ncb_p np, u_long code);
1294
1295 static  int     ncr_probe       (device_t dev);
1296 static  int     ncr_attach      (device_t dev);
1297
1298 #endif /* _KERNEL */
1299
1300 /*==========================================================
1301 **
1302 **
1303 **      Global static data.
1304 **
1305 **
1306 **==========================================================
1307 */
1308
1309
1310 /*
1311  * $FreeBSD: src/sys/pci/ncr.c,v 1.155.2.3 2001/03/05 13:09:10 obrien Exp $
1312  */
1313 static const u_long     ncr_version = NCR_VERSION       * 11
1314         + (u_long) sizeof (struct ncb)  *  7
1315         + (u_long) sizeof (struct nccb) *  5
1316         + (u_long) sizeof (struct lcb)  *  3
1317         + (u_long) sizeof (struct tcb)  *  2;
1318
1319 #ifdef _KERNEL
1320
1321 static int ncr_debug = SCSI_NCR_DEBUG;
1322 SYSCTL_INT(_debug, OID_AUTO, ncr_debug, CTLFLAG_RW, &ncr_debug, 0, "");
1323
1324 static int ncr_cache; /* to be aligned _NOT_ static */
1325
1326 /*==========================================================
1327 **
1328 **
1329 **      Global static data:     auto configure
1330 **
1331 **
1332 **==========================================================
1333 */
1334
1335 #define NCR_810_ID      (0x00011000ul)
1336 #define NCR_815_ID      (0x00041000ul)
1337 #define NCR_820_ID      (0x00021000ul)
1338 #define NCR_825_ID      (0x00031000ul)
1339 #define NCR_860_ID      (0x00061000ul)
1340 #define NCR_875_ID      (0x000f1000ul)
1341 #define NCR_875_ID2     (0x008f1000ul)
1342 #define NCR_885_ID      (0x000d1000ul)
1343 #define NCR_895_ID      (0x000c1000ul)
1344 #define NCR_896_ID      (0x000b1000ul)
1345 #define NCR_895A_ID     (0x00121000ul)
1346 #define NCR_1510D_ID    (0x000a1000ul)
1347
1348
1349 static char *ncr_name (ncb_p np)
1350 {
1351         static char name[10];
1352         snprintf(name, sizeof(name), "ncr%d", np->unit);
1353         return (name);
1354 }
1355
1356 /*==========================================================
1357 **
1358 **
1359 **      Scripts for NCR-Processor.
1360 **
1361 **      Use ncr_script_bind for binding to physical addresses.
1362 **
1363 **
1364 **==========================================================
1365 **
1366 **      NADDR generates a reference to a field of the controller data.
1367 **      PADDR generates a reference to another part of the script.
1368 **      RADDR generates a reference to a script processor register.
1369 **      FADDR generates a reference to a script processor register
1370 **              with offset.
1371 **
1372 **----------------------------------------------------------
1373 */
1374
1375 #define RELOC_SOFTC     0x40000000
1376 #define RELOC_LABEL     0x50000000
1377 #define RELOC_REGISTER  0x60000000
1378 #define RELOC_KVAR      0x70000000
1379 #define RELOC_LABELH    0x80000000
1380 #define RELOC_MASK      0xf0000000
1381
1382 #define NADDR(label)    (RELOC_SOFTC | offsetof(struct ncb, label))
1383 #define PADDR(label)    (RELOC_LABEL | offsetof(struct script, label))
1384 #define PADDRH(label)   (RELOC_LABELH | offsetof(struct scripth, label))
1385 #define RADDR(label)    (RELOC_REGISTER | REG(label))
1386 #define FADDR(label,ofs)(RELOC_REGISTER | ((REG(label))+(ofs)))
1387 #define KVAR(which)     (RELOC_KVAR | (which))
1388
1389 #define KVAR_SECOND                     (0)
1390 #define KVAR_TICKS                      (1)
1391 #define KVAR_NCR_CACHE                  (2)
1392
1393 #define SCRIPT_KVAR_FIRST               (0)
1394 #define SCRIPT_KVAR_LAST                (3)
1395
1396 /*
1397  * Kernel variables referenced in the scripts.
1398  * THESE MUST ALL BE ALIGNED TO A 4-BYTE BOUNDARY.
1399  */
1400 static void *script_kvars[] =
1401         { &time_second, &ticks, &ncr_cache };
1402
1403 static  struct script script0 = {
1404 /*--------------------------< START >-----------------------*/ {
1405         /*
1406         **      Claim to be still alive ...
1407         */
1408         SCR_COPY (sizeof (((struct ncb *)0)->heartbeat)),
1409                 KVAR (KVAR_SECOND),
1410                 NADDR (heartbeat),
1411         /*
1412         **      Make data structure address invalid.
1413         **      clear SIGP.
1414         */
1415         SCR_LOAD_REG (dsa, 0xff),
1416                 0,
1417         SCR_FROM_REG (ctest2),
1418                 0,
1419 }/*-------------------------< START0 >----------------------*/,{
1420         /*
1421         **      Hook for interrupted GetConditionCode.
1422         **      Will be patched to ... IFTRUE by
1423         **      the interrupt handler.
1424         */
1425         SCR_INT ^ IFFALSE (0),
1426                 SIR_SENSE_RESTART,
1427
1428 }/*-------------------------< START1 >----------------------*/,{
1429         /*
1430         **      Hook for stalled start queue.
1431         **      Will be patched to IFTRUE by the interrupt handler.
1432         */
1433         SCR_INT ^ IFFALSE (0),
1434                 SIR_STALL_RESTART,
1435         /*
1436         **      Then jump to a certain point in tryloop.
1437         **      Due to the lack of indirect addressing the code
1438         **      is self modifying here.
1439         */
1440         SCR_JUMP,
1441 }/*-------------------------< STARTPOS >--------------------*/,{
1442                 PADDRH(tryloop),
1443
1444 }/*-------------------------< TRYSEL >----------------------*/,{
1445         /*
1446         **      Now:
1447         **      DSA: Address of a Data Structure
1448         **      or   Address of the IDLE-Label.
1449         **
1450         **      TEMP:   Address of a script, which tries to
1451         **              start the NEXT entry.
1452         **
1453         **      Save the TEMP register into the SCRATCHA register.
1454         **      Then copy the DSA to TEMP and RETURN.
1455         **      This is kind of an indirect jump.
1456         **      (The script processor has NO stack, so the
1457         **      CALL is actually a jump and link, and the
1458         **      RETURN is an indirect jump.)
1459         **
1460         **      If the slot was empty, DSA contains the address
1461         **      of the IDLE part of this script. The processor
1462         **      jumps to IDLE and waits for a reselect.
1463         **      It will wake up and try the same slot again
1464         **      after the SIGP bit becomes set by the host.
1465         **
1466         **      If the slot was not empty, DSA contains
1467         **      the address of the phys-part of a nccb.
1468         **      The processor jumps to this address.
1469         **      phys starts with head,
1470         **      head starts with launch,
1471         **      so actually the processor jumps to
1472         **      the lauch part.
1473         **      If the entry is scheduled for execution,
1474         **      then launch contains a jump to SELECT.
1475         **      If it's not scheduled, it contains a jump to IDLE.
1476         */
1477         SCR_COPY (4),
1478                 RADDR (temp),
1479                 RADDR (scratcha),
1480         SCR_COPY (4),
1481                 RADDR (dsa),
1482                 RADDR (temp),
1483         SCR_RETURN,
1484                 0
1485
1486 }/*-------------------------< SKIP >------------------------*/,{
1487         /*
1488         **      This entry has been canceled.
1489         **      Next time use the next slot.
1490         */
1491         SCR_COPY (4),
1492                 RADDR (scratcha),
1493                 PADDR (startpos),
1494         /*
1495         **      patch the launch field.
1496         **      should look like an idle process.
1497         */
1498         SCR_COPY_F (4),
1499                 RADDR (dsa),
1500                 PADDR (skip2),
1501         SCR_COPY (8),
1502                 PADDR (idle),
1503 }/*-------------------------< SKIP2 >-----------------------*/,{
1504                 0,
1505         SCR_JUMP,
1506                 PADDR(start),
1507 }/*-------------------------< IDLE >------------------------*/,{
1508         /*
1509         **      Nothing to do?
1510         **      Wait for reselect.
1511         */
1512         SCR_JUMP,
1513                 PADDR(reselect),
1514
1515 }/*-------------------------< SELECT >----------------------*/,{
1516         /*
1517         **      DSA     contains the address of a scheduled
1518         **              data structure.
1519         **
1520         **      SCRATCHA contains the address of the script,
1521         **              which starts the next entry.
1522         **
1523         **      Set Initiator mode.
1524         **
1525         **      (Target mode is left as an exercise for the reader)
1526         */
1527
1528         SCR_CLR (SCR_TRG),
1529                 0,
1530         SCR_LOAD_REG (HS_REG, 0xff),
1531                 0,
1532
1533         /*
1534         **      And try to select this target.
1535         */
1536         SCR_SEL_TBL_ATN ^ offsetof (struct dsb, select),
1537                 PADDR (reselect),
1538
1539         /*
1540         **      Now there are 4 possibilities:
1541         **
1542         **      (1) The ncr looses arbitration.
1543         **      This is ok, because it will try again,
1544         **      when the bus becomes idle.
1545         **      (But beware of the timeout function!)
1546         **
1547         **      (2) The ncr is reselected.
1548         **      Then the script processor takes the jump
1549         **      to the RESELECT label.
1550         **
1551         **      (3) The ncr completes the selection.
1552         **      Then it will execute the next statement.
1553         **
1554         **      (4) There is a selection timeout.
1555         **      Then the ncr should interrupt the host and stop.
1556         **      Unfortunately, it seems to continue execution
1557         **      of the script. But it will fail with an
1558         **      IID-interrupt on the next WHEN.
1559         */
1560
1561         SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_IN)),
1562                 0,
1563
1564         /*
1565         **      Send the IDENTIFY and SIMPLE_TAG messages
1566         **      (and the MSG_EXT_SDTR message)
1567         */
1568         SCR_MOVE_TBL ^ SCR_MSG_OUT,
1569                 offsetof (struct dsb, smsg),
1570 #ifdef undef /* XXX better fail than try to deal with this ... */
1571         SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_OUT)),
1572                 -16,
1573 #endif
1574         SCR_CLR (SCR_ATN),
1575                 0,
1576         SCR_COPY (1),
1577                 RADDR (sfbr),
1578                 NADDR (lastmsg),
1579         /*
1580         **      Selection complete.
1581         **      Next time use the next slot.
1582         */
1583         SCR_COPY (4),
1584                 RADDR (scratcha),
1585                 PADDR (startpos),
1586 }/*-------------------------< PREPARE >----------------------*/,{
1587         /*
1588         **      The ncr doesn't have an indirect load
1589         **      or store command. So we have to
1590         **      copy part of the control block to a
1591         **      fixed place, where we can access it.
1592         **
1593         **      We patch the address part of a
1594         **      COPY command with the DSA-register.
1595         */
1596         SCR_COPY_F (4),
1597                 RADDR (dsa),
1598                 PADDR (loadpos),
1599         /*
1600         **      then we do the actual copy.
1601         */
1602         SCR_COPY (sizeof (struct head)),
1603         /*
1604         **      continued after the next label ...
1605         */
1606
1607 }/*-------------------------< LOADPOS >---------------------*/,{
1608                 0,
1609                 NADDR (header),
1610         /*
1611         **      Mark this nccb as not scheduled.
1612         */
1613         SCR_COPY (8),
1614                 PADDR (idle),
1615                 NADDR (header.launch),
1616         /*
1617         **      Set a time stamp for this selection
1618         */
1619         SCR_COPY (sizeof (ticks)),
1620                 KVAR (KVAR_TICKS),
1621                 NADDR (header.stamp.select),
1622         /*
1623         **      load the savep (saved pointer) into
1624         **      the TEMP register (actual pointer)
1625         */
1626         SCR_COPY (4),
1627                 NADDR (header.savep),
1628                 RADDR (temp),
1629         /*
1630         **      Initialize the status registers
1631         */
1632         SCR_COPY (4),
1633                 NADDR (header.status),
1634                 RADDR (scr0),
1635
1636 }/*-------------------------< PREPARE2 >---------------------*/,{
1637         /*
1638         **      Load the synchronous mode register
1639         */
1640         SCR_COPY (1),
1641                 NADDR (sync_st),
1642                 RADDR (sxfer),
1643         /*
1644         **      Load the wide mode and timing register
1645         */
1646         SCR_COPY (1),
1647                 NADDR (wide_st),
1648                 RADDR (scntl3),
1649         /*
1650         **      Initialize the msgout buffer with a NOOP message.
1651         */
1652         SCR_LOAD_REG (scratcha, MSG_NOOP),
1653                 0,
1654         SCR_COPY (1),
1655                 RADDR (scratcha),
1656                 NADDR (msgout),
1657         SCR_COPY (1),
1658                 RADDR (scratcha),
1659                 NADDR (msgin),
1660         /*
1661         **      Message in phase ?
1662         */
1663         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
1664                 PADDR (dispatch),
1665         /*
1666         **      Extended or reject message ?
1667         */
1668         SCR_FROM_REG (sbdl),
1669                 0,
1670         SCR_JUMP ^ IFTRUE (DATA (MSG_EXTENDED)),
1671                 PADDR (msg_in),
1672         SCR_JUMP ^ IFTRUE (DATA (MSG_MESSAGE_REJECT)),
1673                 PADDRH (msg_reject),
1674         /*
1675         **      normal processing
1676         */
1677         SCR_JUMP,
1678                 PADDR (dispatch),
1679 }/*-------------------------< SETMSG >----------------------*/,{
1680         SCR_COPY (1),
1681                 RADDR (scratcha),
1682                 NADDR (msgout),
1683         SCR_SET (SCR_ATN),
1684                 0,
1685 }/*-------------------------< CLRACK >----------------------*/,{
1686         /*
1687         **      Terminate possible pending message phase.
1688         */
1689         SCR_CLR (SCR_ACK),
1690                 0,
1691
1692 }/*-----------------------< DISPATCH >----------------------*/,{
1693         SCR_FROM_REG (HS_REG),
1694                 0,
1695         SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
1696                 SIR_NEGO_FAILED,
1697         /*
1698         **      remove bogus output signals
1699         */
1700         SCR_REG_REG (socl, SCR_AND, CACK|CATN),
1701                 0,
1702         SCR_RETURN ^ IFTRUE (WHEN (SCR_DATA_OUT)),
1703                 0,
1704         SCR_RETURN ^ IFTRUE (IF (SCR_DATA_IN)),
1705                 0,
1706         SCR_JUMP ^ IFTRUE (IF (SCR_MSG_OUT)),
1707                 PADDR (msg_out),
1708         SCR_JUMP ^ IFTRUE (IF (SCR_MSG_IN)),
1709                 PADDR (msg_in),
1710         SCR_JUMP ^ IFTRUE (IF (SCR_COMMAND)),
1711                 PADDR (command),
1712         SCR_JUMP ^ IFTRUE (IF (SCR_STATUS)),
1713                 PADDR (status),
1714         /*
1715         **      Discard one illegal phase byte, if required.
1716         */
1717         SCR_LOAD_REG (scratcha, XE_BAD_PHASE),
1718                 0,
1719         SCR_COPY (1),
1720                 RADDR (scratcha),
1721                 NADDR (xerr_st),
1722         SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_OUT)),
1723                 8,
1724         SCR_MOVE_ABS (1) ^ SCR_ILG_OUT,
1725                 NADDR (scratch),
1726         SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_IN)),
1727                 8,
1728         SCR_MOVE_ABS (1) ^ SCR_ILG_IN,
1729                 NADDR (scratch),
1730         SCR_JUMP,
1731                 PADDR (dispatch),
1732
1733 }/*-------------------------< NO_DATA >--------------------*/,{
1734         /*
1735         **      The target wants to tranfer too much data
1736         **      or in the wrong direction.
1737         **      Remember that in extended error.
1738         */
1739         SCR_LOAD_REG (scratcha, XE_EXTRA_DATA),
1740                 0,
1741         SCR_COPY (1),
1742                 RADDR (scratcha),
1743                 NADDR (xerr_st),
1744         /*
1745         **      Discard one data byte, if required.
1746         */
1747         SCR_JUMPR ^ IFFALSE (WHEN (SCR_DATA_OUT)),
1748                 8,
1749         SCR_MOVE_ABS (1) ^ SCR_DATA_OUT,
1750                 NADDR (scratch),
1751         SCR_JUMPR ^ IFFALSE (IF (SCR_DATA_IN)),
1752                 8,
1753         SCR_MOVE_ABS (1) ^ SCR_DATA_IN,
1754                 NADDR (scratch),
1755         /*
1756         **      .. and repeat as required.
1757         */
1758         SCR_CALL,
1759                 PADDR (dispatch),
1760         SCR_JUMP,
1761                 PADDR (no_data),
1762 }/*-------------------------< CHECKATN >--------------------*/,{
1763         /*
1764         **      If AAP (bit 1 of scntl0 register) is set
1765         **      and a parity error is detected,
1766         **      the script processor asserts ATN.
1767         **
1768         **      The target should switch to a MSG_OUT phase
1769         **      to get the message.
1770         */
1771         SCR_FROM_REG (socl),
1772                 0,
1773         SCR_JUMP ^ IFFALSE (MASK (CATN, CATN)),
1774                 PADDR (dispatch),
1775         /*
1776         **      count it
1777         */
1778         SCR_REG_REG (PS_REG, SCR_ADD, 1),
1779                 0,
1780         /*
1781         **      Prepare a MSG_INITIATOR_DET_ERR message
1782         **      (initiator detected error).
1783         **      The target should retry the transfer.
1784         */
1785         SCR_LOAD_REG (scratcha, MSG_INITIATOR_DET_ERR),
1786                 0,
1787         SCR_JUMP,
1788                 PADDR (setmsg),
1789
1790 }/*-------------------------< COMMAND >--------------------*/,{
1791         /*
1792         **      If this is not a GETCC transfer ...
1793         */
1794         SCR_FROM_REG (SS_REG),
1795                 0,
1796 /*<<<*/ SCR_JUMPR ^ IFTRUE (DATA (SCSI_STATUS_CHECK_COND)),
1797                 28,
1798         /*
1799         **      ... set a timestamp ...
1800         */
1801         SCR_COPY (sizeof (ticks)),
1802                 KVAR (KVAR_TICKS),
1803                 NADDR (header.stamp.command),
1804         /*
1805         **      ... and send the command
1806         */
1807         SCR_MOVE_TBL ^ SCR_COMMAND,
1808                 offsetof (struct dsb, cmd),
1809         SCR_JUMP,
1810                 PADDR (dispatch),
1811         /*
1812         **      Send the GETCC command
1813         */
1814 /*>>>*/ SCR_MOVE_TBL ^ SCR_COMMAND,
1815                 offsetof (struct dsb, scmd),
1816         SCR_JUMP,
1817                 PADDR (dispatch),
1818
1819 }/*-------------------------< STATUS >--------------------*/,{
1820         /*
1821         **      set the timestamp.
1822         */
1823         SCR_COPY (sizeof (ticks)),
1824                 KVAR (KVAR_TICKS),
1825                 NADDR (header.stamp.status),
1826         /*
1827         **      If this is a GETCC transfer,
1828         */
1829         SCR_FROM_REG (SS_REG),
1830                 0,
1831 /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (SCSI_STATUS_CHECK_COND)),
1832                 40,
1833         /*
1834         **      get the status
1835         */
1836         SCR_MOVE_ABS (1) ^ SCR_STATUS,
1837                 NADDR (scratch),
1838         /*
1839         **      Save status to scsi_status.
1840         **      Mark as complete.
1841         **      And wait for disconnect.
1842         */
1843         SCR_TO_REG (SS_REG),
1844                 0,
1845         SCR_REG_REG (SS_REG, SCR_OR, SCSI_STATUS_SENSE),
1846                 0,
1847         SCR_LOAD_REG (HS_REG, HS_COMPLETE),
1848                 0,
1849         SCR_JUMP,
1850                 PADDR (checkatn),
1851         /*
1852         **      If it was no GETCC transfer,
1853         **      save the status to scsi_status.
1854         */
1855 /*>>>*/ SCR_MOVE_ABS (1) ^ SCR_STATUS,
1856                 NADDR (scratch),
1857         SCR_TO_REG (SS_REG),
1858                 0,
1859         /*
1860         **      if it was no check condition ...
1861         */
1862         SCR_JUMP ^ IFTRUE (DATA (SCSI_STATUS_CHECK_COND)),
1863                 PADDR (checkatn),
1864         /*
1865         **      ... mark as complete.
1866         */
1867         SCR_LOAD_REG (HS_REG, HS_COMPLETE),
1868                 0,
1869         SCR_JUMP,
1870                 PADDR (checkatn),
1871
1872 }/*-------------------------< MSG_IN >--------------------*/,{
1873         /*
1874         **      Get the first byte of the message
1875         **      and save it to SCRATCHA.
1876         **
1877         **      The script processor doesn't negate the
1878         **      ACK signal after this transfer.
1879         */
1880         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
1881                 NADDR (msgin[0]),
1882         /*
1883         **      Check for message parity error.
1884         */
1885         SCR_TO_REG (scratcha),
1886                 0,
1887         SCR_FROM_REG (socl),
1888                 0,
1889         SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
1890                 PADDRH (msg_parity),
1891         SCR_FROM_REG (scratcha),
1892                 0,
1893         /*
1894         **      Parity was ok, handle this message.
1895         */
1896         SCR_JUMP ^ IFTRUE (DATA (MSG_CMDCOMPLETE)),
1897                 PADDR (complete),
1898         SCR_JUMP ^ IFTRUE (DATA (MSG_SAVEDATAPOINTER)),
1899                 PADDR (save_dp),
1900         SCR_JUMP ^ IFTRUE (DATA (MSG_RESTOREPOINTERS)),
1901                 PADDR (restore_dp),
1902         SCR_JUMP ^ IFTRUE (DATA (MSG_DISCONNECT)),
1903                 PADDR (disconnect),
1904         SCR_JUMP ^ IFTRUE (DATA (MSG_EXTENDED)),
1905                 PADDRH (msg_extended),
1906         SCR_JUMP ^ IFTRUE (DATA (MSG_NOOP)),
1907                 PADDR (clrack),
1908         SCR_JUMP ^ IFTRUE (DATA (MSG_MESSAGE_REJECT)),
1909                 PADDRH (msg_reject),
1910         SCR_JUMP ^ IFTRUE (DATA (MSG_IGN_WIDE_RESIDUE)),
1911                 PADDRH (msg_ign_residue),
1912         /*
1913         **      Rest of the messages left as
1914         **      an exercise ...
1915         **
1916         **      Unimplemented messages:
1917         **      fall through to MSG_BAD.
1918         */
1919 }/*-------------------------< MSG_BAD >------------------*/,{
1920         /*
1921         **      unimplemented message - reject it.
1922         */
1923         SCR_INT,
1924                 SIR_REJECT_SENT,
1925         SCR_LOAD_REG (scratcha, MSG_MESSAGE_REJECT),
1926                 0,
1927         SCR_JUMP,
1928                 PADDR (setmsg),
1929
1930 }/*-------------------------< COMPLETE >-----------------*/,{
1931         /*
1932         **      Complete message.
1933         **
1934         **      If it's not the get condition code,
1935         **      copy TEMP register to LASTP in header.
1936         */
1937         SCR_FROM_REG (SS_REG),
1938                 0,
1939 /*<<<*/ SCR_JUMPR ^ IFTRUE (MASK (SCSI_STATUS_SENSE, SCSI_STATUS_SENSE)),
1940                 12,
1941         SCR_COPY (4),
1942                 RADDR (temp),
1943                 NADDR (header.lastp),
1944 /*>>>*/ /*
1945         **      When we terminate the cycle by clearing ACK,
1946         **      the target may disconnect immediately.
1947         **
1948         **      We don't want to be told of an
1949         **      "unexpected disconnect",
1950         **      so we disable this feature.
1951         */
1952         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
1953                 0,
1954         /*
1955         **      Terminate cycle ...
1956         */
1957         SCR_CLR (SCR_ACK|SCR_ATN),
1958                 0,
1959         /*
1960         **      ... and wait for the disconnect.
1961         */
1962         SCR_WAIT_DISC,
1963                 0,
1964 }/*-------------------------< CLEANUP >-------------------*/,{
1965         /*
1966         **      dsa:    Pointer to nccb
1967         **            or xxxxxxFF (no nccb)
1968         **
1969         **      HS_REG:   Host-Status (<>0!)
1970         */
1971         SCR_FROM_REG (dsa),
1972                 0,
1973         SCR_JUMP ^ IFTRUE (DATA (0xff)),
1974                 PADDR (signal),
1975         /*
1976         **      dsa is valid.
1977         **      save the status registers
1978         */
1979         SCR_COPY (4),
1980                 RADDR (scr0),
1981                 NADDR (header.status),
1982         /*
1983         **      and copy back the header to the nccb.
1984         */
1985         SCR_COPY_F (4),
1986                 RADDR (dsa),
1987                 PADDR (cleanup0),
1988         SCR_COPY (sizeof (struct head)),
1989                 NADDR (header),
1990 }/*-------------------------< CLEANUP0 >--------------------*/,{
1991                 0,
1992
1993         /*
1994         **      If command resulted in "check condition"
1995         **      status and is not yet completed,
1996         **      try to get the condition code.
1997         */
1998         SCR_FROM_REG (HS_REG),
1999                 0,
2000 /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (0, HS_DONEMASK)),
2001                 16,
2002         SCR_FROM_REG (SS_REG),
2003                 0,
2004         SCR_JUMP ^ IFTRUE (DATA (SCSI_STATUS_CHECK_COND)),
2005                 PADDRH(getcc2),
2006 }/*-------------------------< SIGNAL >----------------------*/,{
2007         /*
2008         **      if status = queue full,
2009         **      reinsert in startqueue and stall queue.
2010         */
2011 /*>>>*/ SCR_FROM_REG (SS_REG),
2012                 0,
2013         SCR_INT ^ IFTRUE (DATA (SCSI_STATUS_QUEUE_FULL)),
2014                 SIR_STALL_QUEUE,
2015         /*
2016         **      And make the DSA register invalid.
2017         */
2018         SCR_LOAD_REG (dsa, 0xff), /* invalid */
2019                 0,
2020         /*
2021         **      if job completed ...
2022         */
2023         SCR_FROM_REG (HS_REG),
2024                 0,
2025         /*
2026         **      ... signal completion to the host
2027         */
2028         SCR_INT_FLY ^ IFFALSE (MASK (0, HS_DONEMASK)),
2029                 0,
2030         /*
2031         **      Auf zu neuen Schandtaten!
2032         */
2033         SCR_JUMP,
2034                 PADDR(start),
2035
2036 }/*-------------------------< SAVE_DP >------------------*/,{
2037         /*
2038         **      SAVE_DP message:
2039         **      Copy TEMP register to SAVEP in header.
2040         */
2041         SCR_COPY (4),
2042                 RADDR (temp),
2043                 NADDR (header.savep),
2044         SCR_JUMP,
2045                 PADDR (clrack),
2046 }/*-------------------------< RESTORE_DP >---------------*/,{
2047         /*
2048         **      RESTORE_DP message:
2049         **      Copy SAVEP in header to TEMP register.
2050         */
2051         SCR_COPY (4),
2052                 NADDR (header.savep),
2053                 RADDR (temp),
2054         SCR_JUMP,
2055                 PADDR (clrack),
2056
2057 }/*-------------------------< DISCONNECT >---------------*/,{
2058         /*
2059         **      If QUIRK_AUTOSAVE is set,
2060         **      do an "save pointer" operation.
2061         */
2062         SCR_FROM_REG (QU_REG),
2063                 0,
2064 /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (QUIRK_AUTOSAVE, QUIRK_AUTOSAVE)),
2065                 12,
2066         /*
2067         **      like SAVE_DP message:
2068         **      Copy TEMP register to SAVEP in header.
2069         */
2070         SCR_COPY (4),
2071                 RADDR (temp),
2072                 NADDR (header.savep),
2073 /*>>>*/ /*
2074         **      Check if temp==savep or temp==goalp:
2075         **      if not, log a missing save pointer message.
2076         **      In fact, it's a comparison mod 256.
2077         **
2078         **      Hmmm, I hadn't thought that I would be urged to
2079         **      write this kind of ugly self modifying code.
2080         **
2081         **      It's unbelievable, but the ncr53c8xx isn't able
2082         **      to subtract one register from another.
2083         */
2084         SCR_FROM_REG (temp),
2085                 0,
2086         /*
2087         **      You are not expected to understand this ..
2088         **
2089         **      CAUTION: only little endian architectures supported! XXX
2090         */
2091         SCR_COPY_F (1),
2092                 NADDR (header.savep),
2093                 PADDR (disconnect0),
2094 }/*-------------------------< DISCONNECT0 >--------------*/,{
2095 /*<<<*/ SCR_JUMPR ^ IFTRUE (DATA (1)),
2096                 20,
2097         /*
2098         **      neither this
2099         */
2100         SCR_COPY_F (1),
2101                 NADDR (header.goalp),
2102                 PADDR (disconnect1),
2103 }/*-------------------------< DISCONNECT1 >--------------*/,{
2104         SCR_INT ^ IFFALSE (DATA (1)),
2105                 SIR_MISSING_SAVE,
2106 /*>>>*/
2107
2108         /*
2109         **      DISCONNECTing  ...
2110         **
2111         **      disable the "unexpected disconnect" feature,
2112         **      and remove the ACK signal.
2113         */
2114         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2115                 0,
2116         SCR_CLR (SCR_ACK|SCR_ATN),
2117                 0,
2118         /*
2119         **      Wait for the disconnect.
2120         */
2121         SCR_WAIT_DISC,
2122                 0,
2123         /*
2124         **      Profiling:
2125         **      Set a time stamp,
2126         **      and count the disconnects.
2127         */
2128         SCR_COPY (sizeof (ticks)),
2129                 KVAR (KVAR_TICKS),
2130                 NADDR (header.stamp.disconnect),
2131         SCR_COPY (4),
2132                 NADDR (disc_phys),
2133                 RADDR (temp),
2134         SCR_REG_REG (temp, SCR_ADD, 0x01),
2135                 0,
2136         SCR_COPY (4),
2137                 RADDR (temp),
2138                 NADDR (disc_phys),
2139         /*
2140         **      Status is: DISCONNECTED.
2141         */
2142         SCR_LOAD_REG (HS_REG, HS_DISCONNECT),
2143                 0,
2144         SCR_JUMP,
2145                 PADDR (cleanup),
2146
2147 }/*-------------------------< MSG_OUT >-------------------*/,{
2148         /*
2149         **      The target requests a message.
2150         */
2151         SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
2152                 NADDR (msgout),
2153         SCR_COPY (1),
2154                 RADDR (sfbr),
2155                 NADDR (lastmsg),
2156         /*
2157         **      If it was no ABORT message ...
2158         */
2159         SCR_JUMP ^ IFTRUE (DATA (MSG_ABORT)),
2160                 PADDRH (msg_out_abort),
2161         /*
2162         **      ... wait for the next phase
2163         **      if it's a message out, send it again, ...
2164         */
2165         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)),
2166                 PADDR (msg_out),
2167 }/*-------------------------< MSG_OUT_DONE >--------------*/,{
2168         /*
2169         **      ... else clear the message ...
2170         */
2171         SCR_LOAD_REG (scratcha, MSG_NOOP),
2172                 0,
2173         SCR_COPY (4),
2174                 RADDR (scratcha),
2175                 NADDR (msgout),
2176         /*
2177         **      ... and process the next phase
2178         */
2179         SCR_JUMP,
2180                 PADDR (dispatch),
2181
2182 }/*------------------------< BADGETCC >---------------------*/,{
2183         /*
2184         **      If SIGP was set, clear it and try again.
2185         */
2186         SCR_FROM_REG (ctest2),
2187                 0,
2188         SCR_JUMP ^ IFTRUE (MASK (CSIGP,CSIGP)),
2189                 PADDRH (getcc2),
2190         SCR_INT,
2191                 SIR_SENSE_FAILED,
2192 }/*-------------------------< RESELECT >--------------------*/,{
2193         /*
2194         **      This NOP will be patched with LED OFF
2195         **      SCR_REG_REG (gpreg, SCR_OR, 0x01)
2196         */
2197         SCR_NO_OP,
2198                 0,
2199
2200         /*
2201         **      make the DSA invalid.
2202         */
2203         SCR_LOAD_REG (dsa, 0xff),
2204                 0,
2205         SCR_CLR (SCR_TRG),
2206                 0,
2207         /*
2208         **      Sleep waiting for a reselection.
2209         **      If SIGP is set, special treatment.
2210         **
2211         **      Zu allem bereit ..
2212         */
2213         SCR_WAIT_RESEL,
2214                 PADDR(reselect2),
2215 }/*-------------------------< RESELECT1 >--------------------*/,{
2216         /*
2217         **      This NOP will be patched with LED ON
2218         **      SCR_REG_REG (gpreg, SCR_AND, 0xfe)
2219         */
2220         SCR_NO_OP,
2221                 0,
2222         /*
2223         **      ... zu nichts zu gebrauchen ?
2224         **
2225         **      load the target id into the SFBR
2226         **      and jump to the control block.
2227         **
2228         **      Look at the declarations of
2229         **      - struct ncb
2230         **      - struct tcb
2231         **      - struct lcb
2232         **      - struct nccb
2233         **      to understand what's going on.
2234         */
2235         SCR_REG_SFBR (ssid, SCR_AND, 0x8F),
2236                 0,
2237         SCR_TO_REG (sdid),
2238                 0,
2239         SCR_JUMP,
2240                 NADDR (jump_tcb),
2241 }/*-------------------------< RESELECT2 >-------------------*/,{
2242         /*
2243         **      This NOP will be patched with LED ON
2244         **      SCR_REG_REG (gpreg, SCR_AND, 0xfe)
2245         */
2246         SCR_NO_OP,
2247                 0,
2248         /*
2249         **      If it's not connected :(
2250         **      -> interrupted by SIGP bit.
2251         **      Jump to start.
2252         */
2253         SCR_FROM_REG (ctest2),
2254                 0,
2255         SCR_JUMP ^ IFTRUE (MASK (CSIGP,CSIGP)),
2256                 PADDR (start),
2257         SCR_JUMP,
2258                 PADDR (reselect),
2259
2260 }/*-------------------------< RESEL_TMP >-------------------*/,{
2261         /*
2262         **      The return address in TEMP
2263         **      is in fact the data structure address,
2264         **      so copy it to the DSA register.
2265         */
2266         SCR_COPY (4),
2267                 RADDR (temp),
2268                 RADDR (dsa),
2269         SCR_JUMP,
2270                 PADDR (prepare),
2271
2272 }/*-------------------------< RESEL_LUN >-------------------*/,{
2273         /*
2274         **      come back to this point
2275         **      to get an IDENTIFY message
2276         **      Wait for a msg_in phase.
2277         */
2278 /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)),
2279                 48,
2280         /*
2281         **      message phase
2282         **      It's not a sony, it's a trick:
2283         **      read the data without acknowledging it.
2284         */
2285         SCR_FROM_REG (sbdl),
2286                 0,
2287 /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (MSG_IDENTIFYFLAG, 0x98)),
2288                 32,
2289         /*
2290         **      It WAS an Identify message.
2291         **      get it and ack it!
2292         */
2293         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2294                 NADDR (msgin),
2295         SCR_CLR (SCR_ACK),
2296                 0,
2297         /*
2298         **      Mask out the lun.
2299         */
2300         SCR_REG_REG (sfbr, SCR_AND, 0x07),
2301                 0,
2302         SCR_RETURN,
2303                 0,
2304         /*
2305         **      No message phase or no IDENTIFY message:
2306         **      return 0.
2307         */
2308 /*>>>*/ SCR_LOAD_SFBR (0),
2309                 0,
2310         SCR_RETURN,
2311                 0,
2312
2313 }/*-------------------------< RESEL_TAG >-------------------*/,{
2314         /*
2315         **      come back to this point
2316         **      to get a SIMPLE_TAG message
2317         **      Wait for a MSG_IN phase.
2318         */
2319 /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)),
2320                 64,
2321         /*
2322         **      message phase
2323         **      It's a trick - read the data
2324         **      without acknowledging it.
2325         */
2326         SCR_FROM_REG (sbdl),
2327                 0,
2328 /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (MSG_SIMPLE_Q_TAG)),
2329                 48,
2330         /*
2331         **      It WAS a SIMPLE_TAG message.
2332         **      get it and ack it!
2333         */
2334         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2335                 NADDR (msgin),
2336         SCR_CLR (SCR_ACK),
2337                 0,
2338         /*
2339         **      Wait for the second byte (the tag)
2340         */
2341 /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)),
2342                 24,
2343         /*
2344         **      Get it and ack it!
2345         */
2346         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2347                 NADDR (msgin),
2348         SCR_CLR (SCR_ACK|SCR_CARRY),
2349                 0,
2350         SCR_RETURN,
2351                 0,
2352         /*
2353         **      No message phase or no SIMPLE_TAG message
2354         **      or no second byte: return 0.
2355         */
2356 /*>>>*/ SCR_LOAD_SFBR (0),
2357                 0,
2358         SCR_SET (SCR_CARRY),
2359                 0,
2360         SCR_RETURN,
2361                 0,
2362
2363 }/*-------------------------< DATA_IN >--------------------*/,{
2364 /*
2365 **      Because the size depends on the
2366 **      #define MAX_SCATTER parameter,
2367 **      it is filled in at runtime.
2368 **
2369 **      SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_IN)),
2370 **              PADDR (no_data),
2371 **      SCR_COPY (sizeof (ticks)),
2372 **              KVAR (KVAR_TICKS),
2373 **              NADDR (header.stamp.data),
2374 **      SCR_MOVE_TBL ^ SCR_DATA_IN,
2375 **              offsetof (struct dsb, data[ 0]),
2376 **
2377 **  ##===========< i=1; i<MAX_SCATTER >=========
2378 **  ||  SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)),
2379 **  ||          PADDR (checkatn),
2380 **  ||  SCR_MOVE_TBL ^ SCR_DATA_IN,
2381 **  ||          offsetof (struct dsb, data[ i]),
2382 **  ##==========================================
2383 **
2384 **      SCR_CALL,
2385 **              PADDR (checkatn),
2386 **      SCR_JUMP,
2387 **              PADDR (no_data),
2388 */
2389 0
2390 }/*-------------------------< DATA_OUT >-------------------*/,{
2391 /*
2392 **      Because the size depends on the
2393 **      #define MAX_SCATTER parameter,
2394 **      it is filled in at runtime.
2395 **
2396 **      SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_OUT)),
2397 **              PADDR (no_data),
2398 **      SCR_COPY (sizeof (ticks)),
2399 **              KVAR (KVAR_TICKS),
2400 **              NADDR (header.stamp.data),
2401 **      SCR_MOVE_TBL ^ SCR_DATA_OUT,
2402 **              offsetof (struct dsb, data[ 0]),
2403 **
2404 **  ##===========< i=1; i<MAX_SCATTER >=========
2405 **  ||  SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT)),
2406 **  ||          PADDR (dispatch),
2407 **  ||  SCR_MOVE_TBL ^ SCR_DATA_OUT,
2408 **  ||          offsetof (struct dsb, data[ i]),
2409 **  ##==========================================
2410 **
2411 **      SCR_CALL,
2412 **              PADDR (dispatch),
2413 **      SCR_JUMP,
2414 **              PADDR (no_data),
2415 **
2416 **---------------------------------------------------------
2417 */
2418 (u_long)0
2419
2420 }/*--------------------------------------------------------*/
2421 };
2422
2423
2424 static  struct scripth scripth0 = {
2425 /*-------------------------< TRYLOOP >---------------------*/{
2426 /*
2427 **      Load an entry of the start queue into dsa
2428 **      and try to start it by jumping to TRYSEL.
2429 **
2430 **      Because the size depends on the
2431 **      #define MAX_START parameter, it is filled
2432 **      in at runtime.
2433 **
2434 **-----------------------------------------------------------
2435 **
2436 **  ##===========< I=0; i<MAX_START >===========
2437 **  ||  SCR_COPY (4),
2438 **  ||          NADDR (squeue[i]),
2439 **  ||          RADDR (dsa),
2440 **  ||  SCR_CALL,
2441 **  ||          PADDR (trysel),
2442 **  ##==========================================
2443 **
2444 **      SCR_JUMP,
2445 **              PADDRH(tryloop),
2446 **
2447 **-----------------------------------------------------------
2448 */
2449 0
2450 }/*-------------------------< MSG_PARITY >---------------*/,{
2451         /*
2452         **      count it
2453         */
2454         SCR_REG_REG (PS_REG, SCR_ADD, 0x01),
2455                 0,
2456         /*
2457         **      send a "message parity error" message.
2458         */
2459         SCR_LOAD_REG (scratcha, MSG_PARITY_ERROR),
2460                 0,
2461         SCR_JUMP,
2462                 PADDR (setmsg),
2463 }/*-------------------------< MSG_MESSAGE_REJECT >---------------*/,{
2464         /*
2465         **      If a negotiation was in progress,
2466         **      negotiation failed.
2467         */
2468         SCR_FROM_REG (HS_REG),
2469                 0,
2470         SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
2471                 SIR_NEGO_FAILED,
2472         /*
2473         **      else make host log this message
2474         */
2475         SCR_INT ^ IFFALSE (DATA (HS_NEGOTIATE)),
2476                 SIR_REJECT_RECEIVED,
2477         SCR_JUMP,
2478                 PADDR (clrack),
2479
2480 }/*-------------------------< MSG_IGN_RESIDUE >----------*/,{
2481         /*
2482         **      Terminate cycle
2483         */
2484         SCR_CLR (SCR_ACK),
2485                 0,
2486         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2487                 PADDR (dispatch),
2488         /*
2489         **      get residue size.
2490         */
2491         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2492                 NADDR (msgin[1]),
2493         /*
2494         **      Check for message parity error.
2495         */
2496         SCR_TO_REG (scratcha),
2497                 0,
2498         SCR_FROM_REG (socl),
2499                 0,
2500         SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
2501                 PADDRH (msg_parity),
2502         SCR_FROM_REG (scratcha),
2503                 0,
2504         /*
2505         **      Size is 0 .. ignore message.
2506         */
2507         SCR_JUMP ^ IFTRUE (DATA (0)),
2508                 PADDR (clrack),
2509         /*
2510         **      Size is not 1 .. have to interrupt.
2511         */
2512 /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (1)),
2513                 40,
2514         /*
2515         **      Check for residue byte in swide register
2516         */
2517         SCR_FROM_REG (scntl2),
2518                 0,
2519 /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (WSR, WSR)),
2520                 16,
2521         /*
2522         **      There IS data in the swide register.
2523         **      Discard it.
2524         */
2525         SCR_REG_REG (scntl2, SCR_OR, WSR),
2526                 0,
2527         SCR_JUMP,
2528                 PADDR (clrack),
2529         /*
2530         **      Load again the size to the sfbr register.
2531         */
2532 /*>>>*/ SCR_FROM_REG (scratcha),
2533                 0,
2534 /*>>>*/ SCR_INT,
2535                 SIR_IGN_RESIDUE,
2536         SCR_JUMP,
2537                 PADDR (clrack),
2538
2539 }/*-------------------------< MSG_EXTENDED >-------------*/,{
2540         /*
2541         **      Terminate cycle
2542         */
2543         SCR_CLR (SCR_ACK),
2544                 0,
2545         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2546                 PADDR (dispatch),
2547         /*
2548         **      get length.
2549         */
2550         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2551                 NADDR (msgin[1]),
2552         /*
2553         **      Check for message parity error.
2554         */
2555         SCR_TO_REG (scratcha),
2556                 0,
2557         SCR_FROM_REG (socl),
2558                 0,
2559         SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
2560                 PADDRH (msg_parity),
2561         SCR_FROM_REG (scratcha),
2562                 0,
2563         /*
2564         */
2565         SCR_JUMP ^ IFTRUE (DATA (3)),
2566                 PADDRH (msg_ext_3),
2567         SCR_JUMP ^ IFFALSE (DATA (2)),
2568                 PADDR (msg_bad),
2569 }/*-------------------------< MSG_EXT_2 >----------------*/,{
2570         SCR_CLR (SCR_ACK),
2571                 0,
2572         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2573                 PADDR (dispatch),
2574         /*
2575         **      get extended message code.
2576         */
2577         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2578                 NADDR (msgin[2]),
2579         /*
2580         **      Check for message parity error.
2581         */
2582         SCR_TO_REG (scratcha),
2583                 0,
2584         SCR_FROM_REG (socl),
2585                 0,
2586         SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
2587                 PADDRH (msg_parity),
2588         SCR_FROM_REG (scratcha),
2589                 0,
2590         SCR_JUMP ^ IFTRUE (DATA (MSG_EXT_WDTR)),
2591                 PADDRH (msg_wdtr),
2592         /*
2593         **      unknown extended message
2594         */
2595         SCR_JUMP,
2596                 PADDR (msg_bad)
2597 }/*-------------------------< MSG_WDTR >-----------------*/,{
2598         SCR_CLR (SCR_ACK),
2599                 0,
2600         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2601                 PADDR (dispatch),
2602         /*
2603         **      get data bus width
2604         */
2605         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2606                 NADDR (msgin[3]),
2607         SCR_FROM_REG (socl),
2608                 0,
2609         SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
2610                 PADDRH (msg_parity),
2611         /*
2612         **      let the host do the real work.
2613         */
2614         SCR_INT,
2615                 SIR_NEGO_WIDE,
2616         /*
2617         **      let the target fetch our answer.
2618         */
2619         SCR_SET (SCR_ATN),
2620                 0,
2621         SCR_CLR (SCR_ACK),
2622                 0,
2623
2624         SCR_INT ^ IFFALSE (WHEN (SCR_MSG_OUT)),
2625                 SIR_NEGO_PROTO,
2626         /*
2627         **      Send the MSG_EXT_WDTR
2628         */
2629         SCR_MOVE_ABS (4) ^ SCR_MSG_OUT,
2630                 NADDR (msgout),
2631         SCR_CLR (SCR_ATN),
2632                 0,
2633         SCR_COPY (1),
2634                 RADDR (sfbr),
2635                 NADDR (lastmsg),
2636         SCR_JUMP,
2637                 PADDR (msg_out_done),
2638
2639 }/*-------------------------< MSG_EXT_3 >----------------*/,{
2640         SCR_CLR (SCR_ACK),
2641                 0,
2642         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2643                 PADDR (dispatch),
2644         /*
2645         **      get extended message code.
2646         */
2647         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
2648                 NADDR (msgin[2]),
2649         /*
2650         **      Check for message parity error.
2651         */
2652         SCR_TO_REG (scratcha),
2653                 0,
2654         SCR_FROM_REG (socl),
2655                 0,
2656         SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
2657                 PADDRH (msg_parity),
2658         SCR_FROM_REG (scratcha),
2659                 0,
2660         SCR_JUMP ^ IFTRUE (DATA (MSG_EXT_SDTR)),
2661                 PADDRH (msg_sdtr),
2662         /*
2663         **      unknown extended message
2664         */
2665         SCR_JUMP,
2666                 PADDR (msg_bad)
2667
2668 }/*-------------------------< MSG_SDTR >-----------------*/,{
2669         SCR_CLR (SCR_ACK),
2670                 0,
2671         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
2672                 PADDR (dispatch),
2673         /*
2674         **      get period and offset
2675         */
2676         SCR_MOVE_ABS (2) ^ SCR_MSG_IN,
2677                 NADDR (msgin[3]),
2678         SCR_FROM_REG (socl),
2679                 0,
2680         SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)),
2681                 PADDRH (msg_parity),
2682         /*
2683         **      let the host do the real work.
2684         */
2685         SCR_INT,
2686                 SIR_NEGO_SYNC,
2687         /*
2688         **      let the target fetch our answer.
2689         */
2690         SCR_SET (SCR_ATN),
2691                 0,
2692         SCR_CLR (SCR_ACK),
2693                 0,
2694
2695         SCR_INT ^ IFFALSE (WHEN (SCR_MSG_OUT)),
2696                 SIR_NEGO_PROTO,
2697         /*
2698         **      Send the MSG_EXT_SDTR
2699         */
2700         SCR_MOVE_ABS (5) ^ SCR_MSG_OUT,
2701                 NADDR (msgout),
2702         SCR_CLR (SCR_ATN),
2703                 0,
2704         SCR_COPY (1),
2705                 RADDR (sfbr),
2706                 NADDR (lastmsg),
2707         SCR_JUMP,
2708                 PADDR (msg_out_done),
2709
2710 }/*-------------------------< MSG_OUT_ABORT >-------------*/,{
2711         /*
2712         **      After ABORT message,
2713         **
2714         **      expect an immediate disconnect, ...
2715         */
2716         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2717                 0,
2718         SCR_CLR (SCR_ACK|SCR_ATN),
2719                 0,
2720         SCR_WAIT_DISC,
2721                 0,
2722         /*
2723         **      ... and set the status to "ABORTED"
2724         */
2725         SCR_LOAD_REG (HS_REG, HS_ABORTED),
2726                 0,
2727         SCR_JUMP,
2728                 PADDR (cleanup),
2729
2730 }/*-------------------------< GETCC >-----------------------*/,{
2731         /*
2732         **      The ncr doesn't have an indirect load
2733         **      or store command. So we have to
2734         **      copy part of the control block to a
2735         **      fixed place, where we can modify it.
2736         **
2737         **      We patch the address part of a COPY command
2738         **      with the address of the dsa register ...
2739         */
2740         SCR_COPY_F (4),
2741                 RADDR (dsa),
2742                 PADDRH (getcc1),
2743         /*
2744         **      ... then we do the actual copy.
2745         */
2746         SCR_COPY (sizeof (struct head)),
2747 }/*-------------------------< GETCC1 >----------------------*/,{
2748                 0,
2749                 NADDR (header),
2750         /*
2751         **      Initialize the status registers
2752         */
2753         SCR_COPY (4),
2754                 NADDR (header.status),
2755                 RADDR (scr0),
2756 }/*-------------------------< GETCC2 >----------------------*/,{
2757         /*
2758         **      Get the condition code from a target.
2759         **
2760         **      DSA points to a data structure.
2761         **      Set TEMP to the script location
2762         **      that receives the condition code.
2763         **
2764         **      Because there is no script command
2765         **      to load a longword into a register,
2766         **      we use a CALL command.
2767         */
2768 /*<<<*/ SCR_CALLR,
2769                 24,
2770         /*
2771         **      Get the condition code.
2772         */
2773         SCR_MOVE_TBL ^ SCR_DATA_IN,
2774                 offsetof (struct dsb, sense),
2775         /*
2776         **      No data phase may follow!
2777         */
2778         SCR_CALL,
2779                 PADDR (checkatn),
2780         SCR_JUMP,
2781                 PADDR (no_data),
2782 /*>>>*/
2783
2784         /*
2785         **      The CALL jumps to this point.
2786         **      Prepare for a RESTORE_POINTER message.
2787         **      Save the TEMP register into the saved pointer.
2788         */
2789         SCR_COPY (4),
2790                 RADDR (temp),
2791                 NADDR (header.savep),
2792         /*
2793         **      Load scratcha, because in case of a selection timeout,
2794         **      the host will expect a new value for startpos in
2795         **      the scratcha register.
2796         */
2797         SCR_COPY (4),
2798                 PADDR (startpos),
2799                 RADDR (scratcha),
2800 #ifdef NCR_GETCC_WITHMSG
2801         /*
2802         **      If QUIRK_NOMSG is set, select without ATN.
2803         **      and don't send a message.
2804         */
2805         SCR_FROM_REG (QU_REG),
2806                 0,
2807         SCR_JUMP ^ IFTRUE (MASK (QUIRK_NOMSG, QUIRK_NOMSG)),
2808                 PADDRH(getcc3),
2809         /*
2810         **      Then try to connect to the target.
2811         **      If we are reselected, special treatment
2812         **      of the current job is required before
2813         **      accepting the reselection.
2814         */
2815         SCR_SEL_TBL_ATN ^ offsetof (struct dsb, select),
2816                 PADDR(badgetcc),
2817         /*
2818         **      Send the IDENTIFY message.
2819         **      In case of short transfer, remove ATN.
2820         */
2821         SCR_MOVE_TBL ^ SCR_MSG_OUT,
2822                 offsetof (struct dsb, smsg2),
2823         SCR_CLR (SCR_ATN),
2824                 0,
2825         /*
2826         **      save the first byte of the message.
2827         */
2828         SCR_COPY (1),
2829                 RADDR (sfbr),
2830                 NADDR (lastmsg),
2831         SCR_JUMP,
2832                 PADDR (prepare2),
2833
2834 #endif
2835 }/*-------------------------< GETCC3 >----------------------*/,{
2836         /*
2837         **      Try to connect to the target.
2838         **      If we are reselected, special treatment
2839         **      of the current job is required before
2840         **      accepting the reselection.
2841         **
2842         **      Silly target won't accept a message.
2843         **      Select without ATN.
2844         */
2845         SCR_SEL_TBL ^ offsetof (struct dsb, select),
2846                 PADDR(badgetcc),
2847         /*
2848         **      Force error if selection timeout
2849         */
2850         SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_IN)),
2851                 0,
2852         /*
2853         **      don't negotiate.
2854         */
2855         SCR_JUMP,
2856                 PADDR (prepare2),
2857 }/*-------------------------< ABORTTAG >-------------------*/,{
2858         /*
2859         **      Abort a bad reselection.
2860         **      Set the message to ABORT vs. ABORT_TAG
2861         */
2862         SCR_LOAD_REG (scratcha, MSG_ABORT_TAG),
2863                 0,
2864         SCR_JUMPR ^ IFFALSE (CARRYSET),
2865                 8,
2866 }/*-------------------------< ABORT >----------------------*/,{
2867         SCR_LOAD_REG (scratcha, MSG_ABORT),
2868                 0,
2869         SCR_COPY (1),
2870                 RADDR (scratcha),
2871                 NADDR (msgout),
2872         SCR_SET (SCR_ATN),
2873                 0,
2874         SCR_CLR (SCR_ACK),
2875                 0,
2876         /*
2877         **      and send it.
2878         **      we expect an immediate disconnect
2879         */
2880         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
2881                 0,
2882         SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
2883                 NADDR (msgout),
2884         SCR_COPY (1),
2885                 RADDR (sfbr),
2886                 NADDR (lastmsg),
2887         SCR_CLR (SCR_ACK|SCR_ATN),
2888                 0,
2889         SCR_WAIT_DISC,
2890                 0,
2891         SCR_JUMP,
2892                 PADDR (start),
2893 }/*-------------------------< SNOOPTEST >-------------------*/,{
2894         /*
2895         **      Read the variable.
2896         */
2897         SCR_COPY (4),
2898                 KVAR (KVAR_NCR_CACHE),
2899                 RADDR (scratcha),
2900         /*
2901         **      Write the variable.
2902         */
2903         SCR_COPY (4),
2904                 RADDR (temp),
2905                 KVAR (KVAR_NCR_CACHE),
2906         /*
2907         **      Read back the variable.
2908         */
2909         SCR_COPY (4),
2910                 KVAR (KVAR_NCR_CACHE),
2911                 RADDR (temp),
2912 }/*-------------------------< SNOOPEND >-------------------*/,{
2913         /*
2914         **      And stop.
2915         */
2916         SCR_INT,
2917                 99,
2918 }/*--------------------------------------------------------*/
2919 };
2920
2921
2922 /*==========================================================
2923 **
2924 **
2925 **      Fill in #define dependent parts of the script
2926 **
2927 **
2928 **==========================================================
2929 */
2930
2931 void ncr_script_fill (struct script * scr, struct scripth * scrh)
2932 {
2933         int     i;
2934         ncrcmd  *p;
2935
2936         p = scrh->tryloop;
2937         for (i=0; i<MAX_START; i++) {
2938                 *p++ =SCR_COPY (4);
2939                 *p++ =NADDR (squeue[i]);
2940                 *p++ =RADDR (dsa);
2941                 *p++ =SCR_CALL;
2942                 *p++ =PADDR (trysel);
2943         };
2944         *p++ =SCR_JUMP;
2945         *p++ =PADDRH(tryloop);
2946
2947         assert ((char *)p == (char *)&scrh->tryloop + sizeof (scrh->tryloop));
2948
2949         p = scr->data_in;
2950
2951         *p++ =SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_IN));
2952         *p++ =PADDR (no_data);
2953         *p++ =SCR_COPY (sizeof (ticks));
2954         *p++ =(ncrcmd) KVAR (KVAR_TICKS);
2955         *p++ =NADDR (header.stamp.data);
2956         *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN;
2957         *p++ =offsetof (struct dsb, data[ 0]);
2958
2959         for (i=1; i<MAX_SCATTER; i++) {
2960                 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN));
2961                 *p++ =PADDR (checkatn);
2962                 *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN;
2963                 *p++ =offsetof (struct dsb, data[i]);
2964         };
2965
2966         *p++ =SCR_CALL;
2967         *p++ =PADDR (checkatn);
2968         *p++ =SCR_JUMP;
2969         *p++ =PADDR (no_data);
2970
2971         assert ((char *)p == (char *)&scr->data_in + sizeof (scr->data_in));
2972
2973         p = scr->data_out;
2974
2975         *p++ =SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_OUT));
2976         *p++ =PADDR (no_data);
2977         *p++ =SCR_COPY (sizeof (ticks));
2978         *p++ =(ncrcmd) KVAR (KVAR_TICKS);
2979         *p++ =NADDR (header.stamp.data);
2980         *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT;
2981         *p++ =offsetof (struct dsb, data[ 0]);
2982
2983         for (i=1; i<MAX_SCATTER; i++) {
2984                 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT));
2985                 *p++ =PADDR (dispatch);
2986                 *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT;
2987                 *p++ =offsetof (struct dsb, data[i]);
2988         };
2989
2990         *p++ =SCR_CALL;
2991         *p++ =PADDR (dispatch);
2992         *p++ =SCR_JUMP;
2993         *p++ =PADDR (no_data);
2994
2995         assert ((char *)p == (char *)&scr->data_out + sizeof (scr->data_out));
2996 }
2997
2998 /*==========================================================
2999 **
3000 **
3001 **      Copy and rebind a script.
3002 **
3003 **
3004 **==========================================================
3005 */
3006
3007 static void ncr_script_copy_and_bind (ncb_p np, ncrcmd *src, ncrcmd *dst, int len)
3008 {
3009         ncrcmd  opcode, new, old, tmp1, tmp2;
3010         ncrcmd  *start, *end;
3011         int relocs, offset;
3012
3013         start = src;
3014         end = src + len/4;
3015         offset = 0;
3016
3017         while (src < end) {
3018
3019                 opcode = *src++;
3020                 WRITESCRIPT_OFF(dst, offset, opcode);
3021                 offset += 4;
3022
3023                 /*
3024                 **      If we forget to change the length
3025                 **      in struct script, a field will be
3026                 **      padded with 0. This is an illegal
3027                 **      command.
3028                 */
3029
3030                 if (opcode == 0) {
3031                         printf ("%s: ERROR0 IN SCRIPT at %d.\n",
3032                                 ncr_name(np), (int) (src-start-1));
3033                         DELAY (1000000);
3034                 };
3035
3036                 if (DEBUG_FLAGS & DEBUG_SCRIPT)
3037                         printf ("%p:  <%x>\n",
3038                                 (src-1), (unsigned)opcode);
3039
3040                 /*
3041                 **      We don't have to decode ALL commands
3042                 */
3043                 switch (opcode >> 28) {
3044
3045                 case 0xc:
3046                         /*
3047                         **      COPY has TWO arguments.
3048                         */
3049                         relocs = 2;
3050                         tmp1 = src[0];
3051                         if ((tmp1 & RELOC_MASK) == RELOC_KVAR)
3052                                 tmp1 = 0;
3053                         tmp2 = src[1];
3054                         if ((tmp2 & RELOC_MASK) == RELOC_KVAR)
3055                                 tmp2 = 0;
3056                         if ((tmp1 ^ tmp2) & 3) {
3057                                 printf ("%s: ERROR1 IN SCRIPT at %d.\n",
3058                                         ncr_name(np), (int) (src-start-1));
3059                                 DELAY (1000000);
3060                         }
3061                         /*
3062                         **      If PREFETCH feature not enabled, remove
3063                         **      the NO FLUSH bit if present.
3064                         */
3065                         if ((opcode & SCR_NO_FLUSH) && !(np->features&FE_PFEN))
3066                                 WRITESCRIPT_OFF(dst, offset - 4,
3067                                     (opcode & ~SCR_NO_FLUSH));
3068                         break;
3069
3070                 case 0x0:
3071                         /*
3072                         **      MOVE (absolute address)
3073                         */
3074                         relocs = 1;
3075                         break;
3076
3077                 case 0x8:
3078                         /*
3079                         **      JUMP / CALL
3080                         **      dont't relocate if relative :-)
3081                         */
3082                         if (opcode & 0x00800000)
3083                                 relocs = 0;
3084                         else
3085                                 relocs = 1;
3086                         break;
3087
3088                 case 0x4:
3089                 case 0x5:
3090                 case 0x6:
3091                 case 0x7:
3092                         relocs = 1;
3093                         break;
3094
3095                 default:
3096                         relocs = 0;
3097                         break;
3098                 };
3099
3100                 if (relocs) {
3101                         while (relocs--) {
3102                                 old = *src++;
3103
3104                                 switch (old & RELOC_MASK) {
3105                                 case RELOC_REGISTER:
3106                                         new = (old & ~RELOC_MASK) + rman_get_start(np->reg_res);
3107                                         break;
3108                                 case RELOC_LABEL:
3109                                         new = (old & ~RELOC_MASK) + np->p_script;
3110                                         break;
3111                                 case RELOC_LABELH:
3112                                         new = (old & ~RELOC_MASK) + np->p_scripth;
3113                                         break;
3114                                 case RELOC_SOFTC:
3115                                         new = (old & ~RELOC_MASK) + vtophys(np);
3116                                         break;
3117                                 case RELOC_KVAR:
3118                                         if (((old & ~RELOC_MASK) <
3119                                              SCRIPT_KVAR_FIRST) ||
3120                                             ((old & ~RELOC_MASK) >
3121                                              SCRIPT_KVAR_LAST))
3122                                                 panic("ncr KVAR out of range");
3123                                         new = vtophys(script_kvars[old &
3124                                             ~RELOC_MASK]);
3125                                         break;
3126                                 case 0:
3127                                         /* Don't relocate a 0 address. */
3128                                         if (old == 0) {
3129                                                 new = old;
3130                                                 break;
3131                                         }
3132                                         /* fall through */
3133                                 default:
3134                                         panic("ncr_script_copy_and_bind: weird relocation %x @ %d\n", old, (int)(src - start));
3135                                         break;
3136                                 }
3137
3138                                 WRITESCRIPT_OFF(dst, offset, new);
3139                                 offset += 4;
3140                         }
3141                 } else {
3142                         WRITESCRIPT_OFF(dst, offset, *src++);
3143                         offset += 4;
3144                 }
3145
3146         };
3147 }
3148
3149 /*==========================================================
3150 **
3151 **
3152 **      Auto configuration.
3153 **
3154 **
3155 **==========================================================
3156 */
3157
3158 #if 0
3159 /*----------------------------------------------------------
3160 **
3161 **      Reduce the transfer length to the max value
3162 **      we can transfer safely.
3163 **
3164 **      Reading a block greater then MAX_SIZE from the
3165 **      raw (character) device exercises a memory leak
3166 **      in the vm subsystem. This is common to ALL devices.
3167 **      We have submitted a description of this bug to
3168 **      <FreeBSD-bugs@freefall.cdrom.com>.
3169 **      It should be fixed in the current release.
3170 **
3171 **----------------------------------------------------------
3172 */
3173
3174 void ncr_min_phys (struct  buf *bp)
3175 {
3176         if ((unsigned long)bp->b_bcount > MAX_SIZE) bp->b_bcount = MAX_SIZE;
3177 }
3178
3179 #endif
3180
3181 #if 0
3182 /*----------------------------------------------------------
3183 **
3184 **      Maximal number of outstanding requests per target.
3185 **
3186 **----------------------------------------------------------
3187 */
3188
3189 u_int32_t ncr_info (int unit)
3190 {
3191         return (1);   /* may be changed later */
3192 }
3193
3194 #endif
3195
3196 /*----------------------------------------------------------
3197 **
3198 **      NCR chip devices table and chip look up function.
3199 **      Features bit are defined in ncrreg.h. Is it the
3200 **      right place?
3201 **
3202 **----------------------------------------------------------
3203 */
3204 typedef struct {
3205         unsigned long   device_id;
3206         unsigned short  minrevid;
3207         char           *name;
3208         unsigned char   maxburst;
3209         unsigned char   maxoffs;
3210         unsigned char   clock_divn;
3211         unsigned int    features;
3212 } ncr_chip;
3213
3214 static ncr_chip ncr_chip_table[] = {
3215  {NCR_810_ID, 0x00,     "ncr 53c810 fast10 scsi",               4,  8, 4,
3216  FE_ERL}
3217  ,
3218  {NCR_810_ID, 0x10,     "ncr 53c810a fast10 scsi",              4,  8, 4,
3219  FE_ERL|FE_LDSTR|FE_PFEN|FE_BOF}
3220  ,
3221  {NCR_815_ID, 0x00,     "ncr 53c815 fast10 scsi",               4,  8, 4,
3222  FE_ERL|FE_BOF}
3223  ,
3224  {NCR_820_ID, 0x00,     "ncr 53c820 fast10 wide scsi",          4,  8, 4,
3225  FE_WIDE|FE_ERL}
3226  ,
3227  {NCR_825_ID, 0x00,     "ncr 53c825 fast10 wide scsi",          4,  8, 4,
3228  FE_WIDE|FE_ERL|FE_BOF}
3229  ,
3230  {NCR_825_ID, 0x10,     "ncr 53c825a fast10 wide scsi",         7,  8, 4,
3231  FE_WIDE|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3232  ,
3233  {NCR_860_ID, 0x00,     "ncr 53c860 fast20 scsi",               4,  8, 5,
3234  FE_ULTRA|FE_CLK80|FE_CACHE_SET|FE_LDSTR|FE_PFEN}
3235  ,
3236  {NCR_875_ID, 0x00,     "ncr 53c875 fast20 wide scsi",          7, 16, 5,
3237  FE_WIDE|FE_ULTRA|FE_CLK80|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3238  ,
3239  {NCR_875_ID, 0x02,     "ncr 53c875 fast20 wide scsi",          7, 16, 5,
3240  FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3241  ,
3242  {NCR_875_ID2, 0x00,    "ncr 53c875j fast20 wide scsi",         7, 16, 5,
3243  FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3244  ,
3245  {NCR_885_ID, 0x00,     "ncr 53c885 fast20 wide scsi",          7, 16, 5,
3246  FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3247  ,
3248  {NCR_895_ID, 0x00,     "ncr 53c895 fast40 wide scsi",          7, 31, 7,
3249  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3250  ,
3251  {NCR_896_ID, 0x00,     "ncr 53c896 fast40 wide scsi",          7, 31, 7,
3252  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3253  ,
3254  {NCR_895A_ID, 0x00,    "ncr 53c895a fast40 wide scsi",         7, 31, 7,
3255  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3256  ,
3257  {NCR_1510D_ID, 0x00,   "ncr 53c1510d fast40 wide scsi",        7, 31, 7,
3258  FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM}
3259 };
3260
3261 static int ncr_chip_lookup(u_long device_id, u_char revision_id)
3262 {
3263         int i, found;
3264
3265         found = -1;
3266         for (i = 0; i < sizeof(ncr_chip_table)/sizeof(ncr_chip_table[0]); i++) {
3267                 if (device_id   == ncr_chip_table[i].device_id &&
3268                     ncr_chip_table[i].minrevid <= revision_id) {
3269                         if (found < 0 ||
3270                             ncr_chip_table[found].minrevid
3271                               < ncr_chip_table[i].minrevid) {
3272                                 found = i;
3273                         }
3274                 }
3275         }
3276         return found;
3277 }
3278
3279 /*----------------------------------------------------------
3280 **
3281 **      Probe the hostadapter.
3282 **
3283 **----------------------------------------------------------
3284 */
3285
3286
3287
3288 static  int ncr_probe (device_t dev)
3289 {
3290         int i;
3291
3292         i = ncr_chip_lookup(pci_get_devid(dev), pci_get_revid(dev));
3293         if (i >= 0) {
3294                 device_set_desc(dev, ncr_chip_table[i].name);
3295                 return (-1000); /* Allows to use both ncr and sym */
3296         }
3297
3298         return (ENXIO);
3299 }
3300
3301
3302
3303 /*==========================================================
3304 **
3305 **      NCR chip clock divisor table.
3306 **      Divisors are multiplied by 10,000,000 in order to make
3307 **      calculations more simple.
3308 **
3309 **==========================================================
3310 */
3311
3312 #define _5M 5000000
3313 static u_long div_10M[] =
3314         {2*_5M, 3*_5M, 4*_5M, 6*_5M, 8*_5M, 12*_5M, 16*_5M};
3315
3316 /*===============================================================
3317 **
3318 **      NCR chips allow burst lengths of 2, 4, 8, 16, 32, 64, 128
3319 **      transfers. 32,64,128 are only supported by 875 and 895 chips.
3320 **      We use log base 2 (burst length) as internal code, with
3321 **      value 0 meaning "burst disabled".
3322 **
3323 **===============================================================
3324 */
3325
3326 /*
3327  *      Burst length from burst code.
3328  */
3329 #define burst_length(bc) (!(bc))? 0 : 1 << (bc)
3330
3331 /*
3332  *      Burst code from io register bits.
3333  */
3334 #define burst_code(dmode, ctest4, ctest5) \
3335         (ctest4) & 0x80? 0 : (((dmode) & 0xc0) >> 6) + ((ctest5) & 0x04) + 1
3336
3337 /*
3338  *      Set initial io register bits from burst code.
3339  */
3340 static void
3341 ncr_init_burst(ncb_p np, u_char bc)
3342 {
3343         np->rv_ctest4   &= ~0x80;
3344         np->rv_dmode    &= ~(0x3 << 6);
3345         np->rv_ctest5   &= ~0x4;
3346
3347         if (!bc) {
3348                 np->rv_ctest4   |= 0x80;
3349         }
3350         else {
3351                 --bc;
3352                 np->rv_dmode    |= ((bc & 0x3) << 6);
3353                 np->rv_ctest5   |= (bc & 0x4);
3354         }
3355 }
3356
3357 /*==========================================================
3358 **
3359 **
3360 **      Auto configuration:  attach and init a host adapter.
3361 **
3362 **
3363 **==========================================================
3364 */
3365
3366
3367 static int
3368 ncr_attach (device_t dev)
3369 {
3370         ncb_p np = (struct ncb*) device_get_softc(dev);
3371         u_char   rev = 0;
3372         u_long   period;
3373         int      i, rid;
3374         u_int8_t usrsync;
3375         u_int8_t usrwide;
3376         struct cam_devq *devq;
3377
3378         /*
3379         **      allocate and initialize structures.
3380         */
3381
3382         np->unit = device_get_unit(dev);
3383
3384         /*
3385         **      Try to map the controller chip to
3386         **      virtual and physical memory.
3387         */
3388
3389         np->reg_rid = 0x14;
3390         np->reg_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &np->reg_rid,
3391                                          0, ~0, 1, RF_ACTIVE);
3392         if (!np->reg_res) {
3393                 device_printf(dev, "could not map memory\n");
3394                 return ENXIO;
3395         }
3396
3397         /*
3398         **      Make the controller's registers available.
3399         **      Now the INB INW INL OUTB OUTW OUTL macros
3400         **      can be used safely.
3401         */
3402
3403         np->bst = rman_get_bustag(np->reg_res);
3404         np->bsh = rman_get_bushandle(np->reg_res);
3405
3406
3407 #ifdef NCR_IOMAPPED
3408         /*
3409         **      Try to map the controller chip into iospace.
3410         */
3411
3412         if (!pci_map_port (config_id, 0x10, &np->port))
3413                 return;
3414 #endif
3415
3416
3417         /*
3418         **      Save some controller register default values
3419         */
3420
3421         np->rv_scntl3   = INB(nc_scntl3) & 0x77;
3422         np->rv_dmode    = INB(nc_dmode)  & 0xce;
3423         np->rv_dcntl    = INB(nc_dcntl)  & 0xa9;
3424         np->rv_ctest3   = INB(nc_ctest3) & 0x01;
3425         np->rv_ctest4   = INB(nc_ctest4) & 0x88;
3426         np->rv_ctest5   = INB(nc_ctest5) & 0x24;
3427         np->rv_gpcntl   = INB(nc_gpcntl);
3428         np->rv_stest2   = INB(nc_stest2) & 0x20;
3429
3430         if (bootverbose >= 2) {
3431                 printf ("\tBIOS values:  SCNTL3:%02x DMODE:%02x  DCNTL:%02x\n",
3432                         np->rv_scntl3, np->rv_dmode, np->rv_dcntl);
3433                 printf ("\t              CTEST3:%02x CTEST4:%02x CTEST5:%02x\n",
3434                         np->rv_ctest3, np->rv_ctest4, np->rv_ctest5);
3435         }
3436
3437         np->rv_dcntl  |= NOCOM;
3438
3439         /*
3440         **      Do chip dependent initialization.
3441         */
3442
3443         rev = pci_get_revid(dev);
3444
3445         /*
3446         **      Get chip features from chips table.
3447         */
3448         i = ncr_chip_lookup(pci_get_devid(dev), rev);
3449
3450         if (i >= 0) {
3451                 np->maxburst    = ncr_chip_table[i].maxburst;
3452                 np->maxoffs     = ncr_chip_table[i].maxoffs;
3453                 np->clock_divn  = ncr_chip_table[i].clock_divn;
3454                 np->features    = ncr_chip_table[i].features;
3455         } else {        /* Should'nt happen if probe() is ok */
3456                 np->maxburst    = 4;
3457                 np->maxoffs     = 8;
3458                 np->clock_divn  = 4;
3459                 np->features    = FE_ERL;
3460         }
3461
3462         np->maxwide     = np->features & FE_WIDE ? 1 : 0;
3463         np->clock_khz   = np->features & FE_CLK80 ? 80000 : 40000;
3464         if      (np->features & FE_QUAD)        np->multiplier = 4;
3465         else if (np->features & FE_DBLR)        np->multiplier = 2;
3466         else                                    np->multiplier = 1;
3467
3468         /*
3469         **      Get the frequency of the chip's clock.
3470         **      Find the right value for scntl3.
3471         */
3472         if (np->features & (FE_ULTRA|FE_ULTRA2))
3473                 ncr_getclock(np, np->multiplier);
3474
3475 #ifdef NCR_TEKRAM_EEPROM
3476         if (bootverbose) {
3477                 printf ("%s: Tekram EEPROM read %s\n",
3478                         ncr_name(np),
3479                         read_tekram_eeprom (np, NULL) ?
3480                         "succeeded" : "failed");
3481         }
3482 #endif /* NCR_TEKRAM_EEPROM */
3483
3484         /*
3485          *      If scntl3 != 0, we assume BIOS is present.
3486          */
3487         if (np->rv_scntl3)
3488                 np->features |= FE_BIOS;
3489
3490         /*
3491          * Divisor to be used for async (timer pre-scaler).
3492          */
3493         i = np->clock_divn - 1;
3494         while (i >= 0) {
3495                 --i;
3496                 if (10ul * SCSI_NCR_MIN_ASYNC * np->clock_khz > div_10M[i]) {
3497                         ++i;
3498                         break;
3499                 }
3500         }
3501         np->rv_scntl3 = i+1;
3502
3503         /*
3504          * Minimum synchronous period factor supported by the chip.
3505          * Btw, 'period' is in tenths of nanoseconds.
3506          */
3507
3508         period = (4 * div_10M[0] + np->clock_khz - 1) / np->clock_khz;
3509         if      (period <= 250)         np->minsync = 10;
3510         else if (period <= 303)         np->minsync = 11;
3511         else if (period <= 500)         np->minsync = 12;
3512         else                            np->minsync = (period + 40 - 1) / 40;
3513
3514         /*
3515          * Check against chip SCSI standard support (SCSI-2,ULTRA,ULTRA2).
3516          */
3517
3518         if      (np->minsync < 25 && !(np->features & (FE_ULTRA|FE_ULTRA2)))
3519                 np->minsync = 25;
3520         else if (np->minsync < 12 && !(np->features & FE_ULTRA2))
3521                 np->minsync = 12;
3522
3523         /*
3524          * Maximum synchronous period factor supported by the chip.
3525          */
3526
3527         period = (11 * div_10M[np->clock_divn - 1]) / (4 * np->clock_khz);
3528         np->maxsync = period > 2540 ? 254 : period / 10;
3529
3530         /*
3531          * Now, some features available with Symbios compatible boards.
3532          * LED support through GPIO0 and DIFF support.
3533          */
3534
3535 #ifdef  SCSI_NCR_SYMBIOS_COMPAT
3536         if (!(np->rv_gpcntl & 0x01))
3537                 np->features |= FE_LED0;
3538 #if 0   /* Not safe enough without NVRAM support or user settable option */
3539         if (!(INB(nc_gpreg) & 0x08))
3540                 np->features |= FE_DIFF;
3541 #endif
3542 #endif  /* SCSI_NCR_SYMBIOS_COMPAT */
3543
3544         /*
3545          * Prepare initial IO registers settings.
3546          * Trust BIOS only if we believe we have one and if we want to.
3547          */
3548 #ifdef  SCSI_NCR_TRUST_BIOS
3549         if (!(np->features & FE_BIOS)) {
3550 #else
3551         if (1) {
3552 #endif
3553                 np->rv_dmode = 0;
3554                 np->rv_dcntl = NOCOM;
3555                 np->rv_ctest3 = 0;
3556                 np->rv_ctest4 = MPEE;
3557                 np->rv_ctest5 = 0;
3558                 np->rv_stest2 = 0;
3559
3560                 if (np->features & FE_ERL)
3561                         np->rv_dmode    |= ERL;   /* Enable Read Line */
3562                 if (np->features & FE_BOF)
3563                         np->rv_dmode    |= BOF;   /* Burst Opcode Fetch */
3564                 if (np->features & FE_ERMP)
3565                         np->rv_dmode    |= ERMP;  /* Enable Read Multiple */
3566                 if (np->features & FE_CLSE)
3567                         np->rv_dcntl    |= CLSE;  /* Cache Line Size Enable */
3568                 if (np->features & FE_WRIE)
3569                         np->rv_ctest3   |= WRIE;  /* Write and Invalidate */
3570                 if (np->features & FE_PFEN)
3571                         np->rv_dcntl    |= PFEN;  /* Prefetch Enable */
3572                 if (np->features & FE_DFS)
3573                         np->rv_ctest5   |= DFS;   /* Dma Fifo Size */
3574                 if (np->features & FE_DIFF)
3575                         np->rv_stest2   |= 0x20;  /* Differential mode */
3576                 ncr_init_burst(np, np->maxburst); /* Max dwords burst length */
3577         } else {
3578                 np->maxburst =
3579                         burst_code(np->rv_dmode, np->rv_ctest4, np->rv_ctest5);
3580         }
3581
3582         /*
3583         **      Get on-chip SRAM address, if supported
3584         */
3585         if ((np->features & FE_RAM) && sizeof(struct script) <= 4096) {
3586                 np->sram_rid = 0x18;
3587                 np->sram_res = bus_alloc_resource(dev, SYS_RES_MEMORY,
3588                                                   &np->sram_rid,
3589                                                   0, ~0, 1, RF_ACTIVE);
3590         }
3591
3592         /*
3593         **      Allocate structure for script relocation.
3594         */
3595         if (np->sram_res != NULL) {
3596                 np->script = NULL;
3597                 np->p_script = rman_get_start(np->sram_res);
3598                 np->bst2 = rman_get_bustag(np->sram_res);
3599                 np->bsh2 = rman_get_bushandle(np->sram_res);
3600         } else if (sizeof (struct script) > PAGE_SIZE) {
3601                 np->script  = (struct script*) vm_page_alloc_contig
3602                         (round_page(sizeof (struct script)),
3603                          0, 0xffffffff, PAGE_SIZE);
3604         } else {
3605                 np->script  = (struct script *)
3606                         malloc (sizeof (struct script), M_DEVBUF, M_WAITOK);
3607         }
3608
3609         /* XXX JGibbs - Use contigmalloc */
3610         if (sizeof (struct scripth) > PAGE_SIZE) {
3611                 np->scripth = (struct scripth*) vm_page_alloc_contig
3612                         (round_page(sizeof (struct scripth)),
3613                          0, 0xffffffff, PAGE_SIZE);
3614         } else
3615                 {
3616                 np->scripth = (struct scripth *)
3617                         malloc (sizeof (struct scripth), M_DEVBUF, M_WAITOK);
3618         }
3619
3620 #ifdef SCSI_NCR_PCI_CONFIG_FIXUP
3621         /*
3622         **      If cache line size is enabled, check PCI config space and
3623         **      try to fix it up if necessary.
3624         */
3625 #ifdef PCIR_CACHELNSZ   /* To be sure that new PCI stuff is present */
3626         {
3627                 u_char cachelnsz = pci_read_config(dev, PCIR_CACHELNSZ, 1);
3628                 u_short command  = pci_read_config(dev, PCIR_COMMAND, 2);
3629
3630                 if (!cachelnsz) {
3631                         cachelnsz = 8;
3632                         printf("%s: setting PCI cache line size register to %d.\n",
3633                                 ncr_name(np), (int)cachelnsz);
3634                         pci_write_config(dev, PCIR_CACHELNSZ, cachelnsz, 1);
3635                 }
3636
3637                 if (!(command & (1<<4))) {
3638                         command |= (1<<4);
3639                         printf("%s: setting PCI command write and invalidate.\n",
3640                                 ncr_name(np));
3641                         pci_write_config(dev, PCIR_COMMAND, command, 2);
3642                 }
3643         }
3644 #endif /* PCIR_CACHELNSZ */
3645
3646 #endif /* SCSI_NCR_PCI_CONFIG_FIXUP */
3647
3648         /* Initialize per-target user settings */
3649         usrsync = 0;
3650         if (SCSI_NCR_DFLT_SYNC) {
3651                 usrsync = SCSI_NCR_DFLT_SYNC;
3652                 if (usrsync > np->maxsync)
3653                         usrsync = np->maxsync;
3654                 if (usrsync < np->minsync)
3655                         usrsync = np->minsync;
3656         };
3657
3658         usrwide = (SCSI_NCR_MAX_WIDE);
3659         if (usrwide > np->maxwide) usrwide=np->maxwide;
3660
3661         for (i=0;i<MAX_TARGET;i++) {
3662                 tcb_p tp = &np->target[i];
3663
3664                 tp->tinfo.user.period = usrsync;
3665                 tp->tinfo.user.offset = usrsync != 0 ? np->maxoffs : 0;
3666                 tp->tinfo.user.width = usrwide;
3667                 tp->tinfo.disc_tag = NCR_CUR_DISCENB
3668                                    | NCR_CUR_TAGENB
3669                                    | NCR_USR_DISCENB
3670                                    | NCR_USR_TAGENB;
3671         }
3672
3673         /*
3674         **      Bells and whistles   ;-)
3675         */
3676         if (bootverbose)
3677                 printf("%s: minsync=%d, maxsync=%d, maxoffs=%d, %d dwords burst, %s dma fifo\n",
3678                 ncr_name(np), np->minsync, np->maxsync, np->maxoffs,
3679                 burst_length(np->maxburst),
3680                 (np->rv_ctest5 & DFS) ? "large" : "normal");
3681
3682         /*
3683         **      Print some complementary information that can be helpfull.
3684         */
3685         if (bootverbose)
3686                 printf("%s: %s, %s IRQ driver%s\n",
3687                         ncr_name(np),
3688                         np->rv_stest2 & 0x20 ? "differential" : "single-ended",
3689                         np->rv_dcntl & IRQM ? "totem pole" : "open drain",
3690                         np->sram_res ? ", using on-chip SRAM" : "");
3691
3692         /*
3693         **      Patch scripts to physical addresses
3694         */
3695         ncr_script_fill (&script0, &scripth0);
3696
3697         if (np->script)
3698                 np->p_script    = vtophys(np->script);
3699         np->p_scripth   = vtophys(np->scripth);
3700
3701         ncr_script_copy_and_bind (np, (ncrcmd *) &script0,
3702                         (ncrcmd *) np->script, sizeof(struct script));
3703
3704         ncr_script_copy_and_bind (np, (ncrcmd *) &scripth0,
3705                 (ncrcmd *) np->scripth, sizeof(struct scripth));
3706
3707         /*
3708         **    Patch the script for LED support.
3709         */
3710
3711         if (np->features & FE_LED0) {
3712                 WRITESCRIPT(reselect[0],  SCR_REG_REG(gpreg, SCR_OR,  0x01));
3713                 WRITESCRIPT(reselect1[0], SCR_REG_REG(gpreg, SCR_AND, 0xfe));
3714                 WRITESCRIPT(reselect2[0], SCR_REG_REG(gpreg, SCR_AND, 0xfe));
3715         }
3716
3717         /*
3718         **      init data structure
3719         */
3720
3721         np->jump_tcb.l_cmd      = SCR_JUMP;
3722         np->jump_tcb.l_paddr    = NCB_SCRIPTH_PHYS (np, abort);
3723
3724         /*
3725         **  Get SCSI addr of host adapter (set by bios?).
3726         */
3727
3728         np->myaddr = INB(nc_scid) & 0x07;
3729         if (!np->myaddr) np->myaddr = SCSI_NCR_MYADDR;
3730
3731 #ifdef NCR_DUMP_REG
3732         /*
3733         **      Log the initial register contents
3734         */
3735         {
3736                 int reg;
3737                 for (reg=0; reg<256; reg+=4) {
3738                         if (reg%16==0) printf ("reg[%2x]", reg);
3739                         printf (" %08x", (int)pci_conf_read (config_id, reg));
3740                         if (reg%16==12) printf ("\n");
3741                 }
3742         }
3743 #endif /* NCR_DUMP_REG */
3744
3745         /*
3746         **      Reset chip.
3747         */
3748
3749         OUTB (nc_istat,  SRST);
3750         DELAY (1000);
3751         OUTB (nc_istat,  0   );
3752
3753
3754         /*
3755         **      Now check the cache handling of the pci chipset.
3756         */
3757
3758         if (ncr_snooptest (np)) {
3759                 printf ("CACHE INCORRECTLY CONFIGURED.\n");
3760                 return EINVAL;
3761         };
3762
3763         /*
3764         **      Install the interrupt handler.
3765         */
3766
3767         rid = 0;
3768         np->irq_res = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1,
3769                                          RF_SHAREABLE | RF_ACTIVE);
3770         if (np->irq_res == NULL) {
3771                 device_printf(dev,
3772                               "interruptless mode: reduced performance.\n");
3773         } else {
3774                 bus_setup_intr(dev, np->irq_res, INTR_TYPE_CAM,
3775                                ncr_intr, np, &np->irq_handle);
3776         }
3777
3778         /*
3779         ** Create the device queue.  We only allow MAX_START-1 concurrent
3780         ** transactions so we can be sure to have one element free in our
3781         ** start queue to reset to the idle loop.
3782         */
3783         devq = cam_simq_alloc(MAX_START - 1);
3784         if (devq == NULL)
3785                 return ENOMEM;
3786
3787         /*
3788         **      Now tell the generic SCSI layer
3789         **      about our bus.
3790         */
3791         np->sim = cam_sim_alloc(ncr_action, ncr_poll, "ncr", np, np->unit,
3792                                 1, MAX_TAGS, devq);
3793         cam_simq_release(devq);
3794         if (np->sim == NULL)
3795                 return ENOMEM;
3796
3797
3798         if (xpt_bus_register(np->sim, 0) != CAM_SUCCESS) {
3799                 cam_sim_free(np->sim);
3800                 return ENOMEM;
3801         }
3802
3803         if (xpt_create_path(&np->path, /*periph*/NULL,
3804                             cam_sim_path(np->sim), CAM_TARGET_WILDCARD,
3805                             CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
3806                 xpt_bus_deregister(cam_sim_path(np->sim));
3807                 cam_sim_free(np->sim);
3808                 return ENOMEM;
3809         }
3810
3811         /*
3812         **      start the timeout daemon
3813         */
3814         ncr_timeout (np);
3815         np->lasttime=0;
3816
3817         return 0;
3818 }
3819
3820 /*==========================================================
3821 **
3822 **
3823 **      Process pending device interrupts.
3824 **
3825 **
3826 **==========================================================
3827 */
3828
3829 static void
3830 ncr_intr(vnp)
3831         void *vnp;
3832 {
3833         ncb_p np = vnp;
3834         int oldspl = splcam();
3835
3836         if (DEBUG_FLAGS & DEBUG_TINY) printf ("[");
3837
3838         if (INB(nc_istat) & (INTF|SIP|DIP)) {
3839                 /*
3840                 **      Repeat until no outstanding ints
3841                 */
3842                 do {
3843                         ncr_exception (np);
3844                 } while (INB(nc_istat) & (INTF|SIP|DIP));
3845
3846                 np->ticks = 100;
3847         };
3848
3849         if (DEBUG_FLAGS & DEBUG_TINY) printf ("]\n");
3850
3851         splx (oldspl);
3852 }
3853
3854 /*==========================================================
3855 **
3856 **
3857 **      Start execution of a SCSI command.
3858 **      This is called from the generic SCSI driver.
3859 **
3860 **
3861 **==========================================================
3862 */
3863
3864 static void
3865 ncr_action (struct cam_sim *sim, union ccb *ccb)
3866 {
3867         ncb_p np;
3868
3869         np = (ncb_p) cam_sim_softc(sim);
3870
3871         switch (ccb->ccb_h.func_code) {
3872         /* Common cases first */
3873         case XPT_SCSI_IO:       /* Execute the requested I/O operation */
3874         {
3875                 nccb_p cp;
3876                 lcb_p lp;
3877                 tcb_p tp;
3878                 int oldspl;
3879                 struct ccb_scsiio *csio;
3880                 u_int8_t *msgptr;
3881                 u_int msglen;
3882                 u_int msglen2;
3883                 int segments;
3884                 u_int8_t nego;
3885                 u_int8_t idmsg;
3886                 int qidx;
3887
3888                 tp = &np->target[ccb->ccb_h.target_id];
3889                 csio = &ccb->csio;
3890
3891                 oldspl = splcam();
3892
3893                 /*
3894                  * Last time we need to check if this CCB needs to
3895                  * be aborted.
3896                  */
3897                 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) {
3898                         xpt_done(ccb);
3899                         splx(oldspl);
3900                         return;
3901                 }
3902                 ccb->ccb_h.status |= CAM_SIM_QUEUED;
3903
3904                 /*---------------------------------------------------
3905                 **
3906                 **      Assign an nccb / bind ccb
3907                 **
3908                 **----------------------------------------------------
3909                 */
3910                 cp = ncr_get_nccb (np, ccb->ccb_h.target_id,
3911                                    ccb->ccb_h.target_lun);
3912                 if (cp == NULL) {
3913                         /* XXX JGibbs - Freeze SIMQ */
3914                         ccb->ccb_h.status = CAM_RESRC_UNAVAIL;
3915                         xpt_done(ccb);
3916                         return;
3917                 };
3918
3919                 cp->ccb = ccb;
3920
3921                 /*---------------------------------------------------
3922                 **
3923                 **      timestamp
3924                 **
3925                 **----------------------------------------------------
3926                 */
3927                 /*
3928                 ** XXX JGibbs - Isn't this expensive
3929                 **              enough to be conditionalized??
3930                 */
3931
3932                 bzero (&cp->phys.header.stamp, sizeof (struct tstamp));
3933                 cp->phys.header.stamp.start = ticks;
3934
3935                 nego = 0;
3936                 if (tp->nego_cp == NULL) {
3937
3938                         if (tp->tinfo.current.width
3939                          != tp->tinfo.goal.width) {
3940                                 tp->nego_cp = cp;
3941                                 nego = NS_WIDE;
3942                         } else if ((tp->tinfo.current.period
3943                                     != tp->tinfo.goal.period)
3944                                 || (tp->tinfo.current.offset
3945                                     != tp->tinfo.goal.offset)) {
3946                                 tp->nego_cp = cp;
3947                                 nego = NS_SYNC;
3948                         };
3949                 };
3950
3951                 /*---------------------------------------------------
3952                 **
3953                 **      choose a new tag ...
3954                 **
3955                 **----------------------------------------------------
3956                 */
3957                 lp = tp->lp[ccb->ccb_h.target_lun];
3958
3959                 if ((ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) != 0
3960                  && (ccb->csio.tag_action != CAM_TAG_ACTION_NONE)
3961                  && (nego == 0)) {
3962                         /*
3963                         **      assign a tag to this nccb
3964                         */
3965                         while (!cp->tag) {
3966                                 nccb_p cp2 = lp->next_nccb;
3967                                 lp->lasttag = lp->lasttag % 255 + 1;
3968                                 while (cp2 && cp2->tag != lp->lasttag)
3969                                         cp2 = cp2->next_nccb;
3970                                 if (cp2) continue;
3971                                 cp->tag=lp->lasttag;
3972                                 if (DEBUG_FLAGS & DEBUG_TAGS) {
3973                                         PRINT_ADDR(ccb);
3974                                         printf ("using tag #%d.\n", cp->tag);
3975                                 };
3976                         };
3977                 } else {
3978                         cp->tag=0;
3979                 };
3980
3981                 /*----------------------------------------------------
3982                 **
3983                 **      Build the identify / tag / sdtr message
3984                 **
3985                 **----------------------------------------------------
3986                 */
3987                 idmsg = MSG_IDENTIFYFLAG | ccb->ccb_h.target_lun;
3988                 if (tp->tinfo.disc_tag & NCR_CUR_DISCENB)
3989                         idmsg |= MSG_IDENTIFY_DISCFLAG;
3990
3991                 msgptr = cp->scsi_smsg;
3992                 msglen = 0;
3993                 msgptr[msglen++] = idmsg;
3994
3995                 if (cp->tag) {
3996                         msgptr[msglen++] = ccb->csio.tag_action;
3997                         msgptr[msglen++] = cp->tag;
3998                 }
3999
4000                 switch (nego) {
4001                 case NS_SYNC:
4002                         msgptr[msglen++] = MSG_EXTENDED;
4003                         msgptr[msglen++] = MSG_EXT_SDTR_LEN;
4004                         msgptr[msglen++] = MSG_EXT_SDTR;
4005                         msgptr[msglen++] = tp->tinfo.goal.period;
4006                         msgptr[msglen++] = tp->tinfo.goal.offset;;
4007                         if (DEBUG_FLAGS & DEBUG_NEGO) {
4008                                 PRINT_ADDR(ccb);
4009                                 printf ("sync msgout: ");
4010                                 ncr_show_msg (&cp->scsi_smsg [msglen-5]);
4011                                 printf (".\n");
4012                         };
4013                         break;
4014                 case NS_WIDE:
4015                         msgptr[msglen++] = MSG_EXTENDED;
4016                         msgptr[msglen++] = MSG_EXT_WDTR_LEN;
4017                         msgptr[msglen++] = MSG_EXT_WDTR;
4018                         msgptr[msglen++] = tp->tinfo.goal.width;
4019                         if (DEBUG_FLAGS & DEBUG_NEGO) {
4020                                 PRINT_ADDR(ccb);
4021                                 printf ("wide msgout: ");
4022                                 ncr_show_msg (&cp->scsi_smsg [msglen-4]);
4023                                 printf (".\n");
4024                         };
4025                         break;
4026                 };
4027
4028                 /*----------------------------------------------------
4029                 **
4030                 **      Build the identify message for getcc.
4031                 **
4032                 **----------------------------------------------------
4033                 */
4034
4035                 cp->scsi_smsg2 [0] = idmsg;
4036                 msglen2 = 1;
4037
4038                 /*----------------------------------------------------
4039                 **
4040                 **      Build the data descriptors
4041                 **
4042                 **----------------------------------------------------
4043                 */
4044
4045                 /* XXX JGibbs - Handle other types of I/O */
4046                 if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
4047                         segments = ncr_scatter(&cp->phys,
4048                                                (vm_offset_t)csio->data_ptr,
4049                                                (vm_size_t)csio->dxfer_len);
4050
4051                         if (segments < 0) {
4052                                 ccb->ccb_h.status = CAM_REQ_TOO_BIG;
4053                                 ncr_free_nccb(np, cp);
4054                                 splx(oldspl);
4055                                 xpt_done(ccb);
4056                                 return;
4057                         }
4058                         if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
4059                                 cp->phys.header.savep = NCB_SCRIPT_PHYS (np, data_in);
4060                                 cp->phys.header.goalp = cp->phys.header.savep +20 +segments*16;
4061                         } else { /* CAM_DIR_OUT */
4062                                 cp->phys.header.savep = NCB_SCRIPT_PHYS (np, data_out);
4063                                 cp->phys.header.goalp = cp->phys.header.savep +20 +segments*16;
4064                         }
4065                 } else {
4066                         cp->phys.header.savep = NCB_SCRIPT_PHYS (np, no_data);
4067                         cp->phys.header.goalp = cp->phys.header.savep;
4068                 }
4069
4070                 cp->phys.header.lastp = cp->phys.header.savep;
4071
4072
4073                 /*----------------------------------------------------
4074                 **
4075                 **      fill in nccb
4076                 **
4077                 **----------------------------------------------------
4078                 **
4079                 **
4080                 **      physical -> virtual backlink
4081                 **      Generic SCSI command
4082                 */
4083                 cp->phys.header.cp              = cp;
4084                 /*
4085                 **      Startqueue
4086                 */
4087                 cp->phys.header.launch.l_paddr  = NCB_SCRIPT_PHYS (np, select);
4088                 cp->phys.header.launch.l_cmd    = SCR_JUMP;
4089                 /*
4090                 **      select
4091                 */
4092                 cp->phys.select.sel_id          = ccb->ccb_h.target_id;
4093                 cp->phys.select.sel_scntl3      = tp->tinfo.wval;
4094                 cp->phys.select.sel_sxfer       = tp->tinfo.sval;
4095                 /*
4096                 **      message
4097                 */
4098                 cp->phys.smsg.addr              = CCB_PHYS (cp, scsi_smsg);
4099                 cp->phys.smsg.size              = msglen;
4100
4101                 cp->phys.smsg2.addr             = CCB_PHYS (cp, scsi_smsg2);
4102                 cp->phys.smsg2.size             = msglen2;
4103                 /*
4104                 **      command
4105                 */
4106                 /* XXX JGibbs - Support other command types */
4107                 cp->phys.cmd.addr               = vtophys (csio->cdb_io.cdb_bytes);
4108                 cp->phys.cmd.size               = csio->cdb_len;
4109                 /*
4110                 **      sense command
4111                 */
4112                 cp->phys.scmd.addr              = CCB_PHYS (cp, sensecmd);
4113                 cp->phys.scmd.size              = 6;
4114                 /*
4115                 **      patch requested size into sense command
4116                 */
4117                 cp->sensecmd[0]                 = 0x03;
4118                 cp->sensecmd[1]                 = ccb->ccb_h.target_lun << 5;
4119                 cp->sensecmd[4]                 = sizeof(struct scsi_sense_data);
4120                 cp->sensecmd[4]                 = csio->sense_len;
4121                 /*
4122                 **      sense data
4123                 */
4124                 cp->phys.sense.addr             = vtophys (&csio->sense_data);
4125                 cp->phys.sense.size             = csio->sense_len;
4126                 /*
4127                 **      status
4128                 */
4129                 cp->actualquirks                = QUIRK_NOMSG;
4130                 cp->host_status                 = nego ? HS_NEGOTIATE : HS_BUSY;
4131                 cp->s_status                    = SCSI_STATUS_ILLEGAL;
4132                 cp->parity_status               = 0;
4133
4134                 cp->xerr_status                 = XE_OK;
4135                 cp->sync_status                 = tp->tinfo.sval;
4136                 cp->nego_status                 = nego;
4137                 cp->wide_status                 = tp->tinfo.wval;
4138
4139                 /*----------------------------------------------------
4140                 **
4141                 **      Critical region: start this job.
4142                 **
4143                 **----------------------------------------------------
4144                 */
4145
4146                 /*
4147                 **      reselect pattern and activate this job.
4148                 */
4149
4150                 cp->jump_nccb.l_cmd     = (SCR_JUMP ^ IFFALSE (DATA (cp->tag)));
4151                 cp->tlimit              = time_second
4152                                         + ccb->ccb_h.timeout / 1000 + 2;
4153                 cp->magic               = CCB_MAGIC;
4154
4155                 /*
4156                 **      insert into start queue.
4157                 */
4158
4159                 qidx = np->squeueput + 1;
4160                 if (qidx >= MAX_START)
4161                         qidx = 0;
4162                 np->squeue [qidx         ] = NCB_SCRIPT_PHYS (np, idle);
4163                 np->squeue [np->squeueput] = CCB_PHYS (cp, phys);
4164                 np->squeueput = qidx;
4165
4166                 if(DEBUG_FLAGS & DEBUG_QUEUE)
4167                         printf("%s: queuepos=%d tryoffset=%d.\n",
4168                                ncr_name (np), np->squeueput,
4169                                (unsigned)(READSCRIPT(startpos[0]) -
4170                                (NCB_SCRIPTH_PHYS (np, tryloop))));
4171
4172                 /*
4173                 **      Script processor may be waiting for reselect.
4174                 **      Wake it up.
4175                 */
4176                 OUTB (nc_istat, SIGP);
4177
4178                 /*
4179                 **      and reenable interrupts
4180                 */
4181                 splx (oldspl);
4182                 break;
4183         }
4184         case XPT_RESET_DEV:     /* Bus Device Reset the specified SCSI device */
4185         case XPT_EN_LUN:                /* Enable LUN as a target */
4186         case XPT_TARGET_IO:             /* Execute target I/O request */
4187         case XPT_ACCEPT_TARGET_IO:      /* Accept Host Target Mode CDB */
4188         case XPT_CONT_TARGET_IO:        /* Continue Host Target I/O Connection*/
4189         case XPT_ABORT:                 /* Abort the specified CCB */
4190                 /* XXX Implement */
4191                 ccb->ccb_h.status = CAM_REQ_INVALID;
4192                 xpt_done(ccb);
4193                 break;
4194         case XPT_SET_TRAN_SETTINGS:
4195         {