drivers/scsi/sym53c8xx_2/sym_fw1.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family
   4  * of PCI-SCSI IO processors.
   5  *
   6  * Copyright (C) 1999-2001  Gerard Roudier <groudier@free.fr>
   7  *
   8  * This driver is derived from the Linux sym53c8xx driver.
   9  * Copyright (C) 1998-2000  Gerard Roudier
  10  *
  11  * The sym53c8xx driver is derived from the ncr53c8xx driver that had been
  12  * a port of the FreeBSD ncr driver to Linux-1.2.13.
  13  *
  14  * The original ncr driver has been written for 386bsd and FreeBSD by
  15  *         Wolfgang Stanglmeier        <wolf@cologne.de>
  16  *         Stefan Esser                <se@mi.Uni-Koeln.de>
  17  * Copyright (C) 1994  Wolfgang Stanglmeier
  18  *
  19  * Other major contributions:
  20  *
  21  * NVRAM detection and reading.
  22  * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
  23  *
  24  *-----------------------------------------------------------------------------
  25  */
  26
  27 /*
  28  *  Scripts for SYMBIOS-Processor
  29  *
  30  *  We have to know the offsets of all labels before we reach
  31  *  them (for forward jumps). Therefore we declare a struct
  32  *  here. If you make changes inside the script,
  33  *
  34  *  DONT FORGET TO CHANGE THE LENGTHS HERE!
  35  */
  36
  37 /*
  38  *  Script fragments which are loaded into the on-chip RAM
  39  *  of 825A, 875, 876, 895, 895A, 896 and 1010 chips.
  40  *  Must not exceed 4K bytes.
  41  */
  42 struct SYM_FWA_SCR {
  43         u32 start               [ 11];
  44         u32 getjob_begin        [  4];
  45         u32 _sms_a10            [  5];
  46         u32 getjob_end          [  4];
  47         u32 _sms_a20            [  4];
  48 #ifdef SYM_CONF_TARGET_ROLE_SUPPORT
  49         u32 select              [  8];
  50 #else
  51         u32 select              [  6];
  52 #endif
  53         u32 _sms_a30            [  5];
  54         u32 wf_sel_done         [  2];
  55         u32 send_ident          [  2];
  56 #ifdef SYM_CONF_IARB_SUPPORT
  57         u32 select2             [  8];
  58 #else
  59         u32 select2             [  2];
  60 #endif
  61         u32 command             [  2];
  62         u32 dispatch            [ 28];
  63         u32 sel_no_cmd          [ 10];
  64         u32 init                [  6];
  65         u32 clrack              [  4];
  66         u32 datai_done          [ 11];
  67         u32 datai_done_wsr      [ 20];
  68         u32 datao_done          [ 11];
  69         u32 datao_done_wss      [  6];
  70         u32 datai_phase         [  5];
  71         u32 datao_phase         [  5];
  72         u32 msg_in              [  2];
  73         u32 msg_in2             [ 10];
  74 #ifdef SYM_CONF_IARB_SUPPORT
  75         u32 status              [ 14];
  76 #else
  77         u32 status              [ 10];
  78 #endif
  79         u32 complete            [  6];
  80         u32 complete2           [  8];
  81         u32 _sms_a40            [ 12];
  82         u32 done                [  5];
  83         u32 _sms_a50            [  5];
  84         u32 _sms_a60            [  2];
  85         u32 done_end            [  4];
  86         u32 complete_error      [  5];
  87         u32 save_dp             [ 11];
  88         u32 restore_dp          [  7];
  89         u32 disconnect          [ 11];
  90         u32 disconnect2         [  5];
  91         u32 _sms_a65            [  3];
  92 #ifdef SYM_CONF_IARB_SUPPORT
  93         u32 idle                [  4];
  94 #else
  95         u32 idle                [  2];
  96 #endif
  97 #ifdef SYM_CONF_IARB_SUPPORT
  98         u32 ungetjob            [  7];
  99 #else
 100         u32 ungetjob            [  5];
 101 #endif
 102 #ifdef SYM_CONF_TARGET_ROLE_SUPPORT
 103         u32 reselect            [  4];
 104 #else
 105         u32 reselect            [  2];
 106 #endif
 107         u32 reselected          [ 19];
 108         u32 _sms_a70            [  6];
 109         u32 _sms_a80            [  4];
 110         u32 reselected1         [ 25];
 111         u32 _sms_a90            [  4];
 112         u32 resel_lun0          [  7];
 113         u32 _sms_a100           [  4];
 114         u32 resel_tag           [  8];
 115 #if   SYM_CONF_MAX_TASK*4 > 512
 116         u32 _sms_a110           [ 23];
 117 #elif SYM_CONF_MAX_TASK*4 > 256
 118         u32 _sms_a110           [ 17];
 119 #else
 120         u32 _sms_a110           [ 13];
 121 #endif
 122         u32 _sms_a120           [  2];
 123         u32 resel_go            [  4];
 124         u32 _sms_a130           [  7];
 125         u32 resel_dsa           [  2];
 126         u32 resel_dsa1          [  4];
 127         u32 _sms_a140           [  7];
 128         u32 resel_no_tag        [  4];
 129         u32 _sms_a145           [  7];
 130         u32 data_in             [SYM_CONF_MAX_SG * 2];
 131         u32 data_in2            [  4];
 132         u32 data_out            [SYM_CONF_MAX_SG * 2];
 133         u32 data_out2           [  4];
 134         u32 pm0_data            [ 12];
 135         u32 pm0_data_out        [  6];
 136         u32 pm0_data_end        [  7];
 137         u32 pm_data_end         [  4];
 138         u32 _sms_a150           [  4];
 139         u32 pm1_data            [ 12];
 140         u32 pm1_data_out        [  6];
 141         u32 pm1_data_end        [  9];
 142 };
 143
 144 /*
 145  *  Script fragments which stay in main memory for all chips
 146  *  except for chips that support 8K on-chip RAM.
 147  */
 148 struct SYM_FWB_SCR {
 149         u32 no_data             [  2];
 150 #ifdef SYM_CONF_TARGET_ROLE_SUPPORT
 151         u32 sel_for_abort       [ 18];
 152 #else
 153         u32 sel_for_abort       [ 16];
 154 #endif
 155         u32 sel_for_abort_1     [  2];
 156         u32 msg_in_etc          [ 12];
 157         u32 msg_received        [  5];
 158         u32 msg_weird_seen      [  5];
 159         u32 msg_extended        [ 17];
 160         u32 _sms_b10            [  4];
 161         u32 msg_bad             [  6];
 162         u32 msg_weird           [  4];
 163         u32 msg_weird1          [  8];
 164         u32 wdtr_resp           [  6];
 165         u32 send_wdtr           [  4];
 166         u32 sdtr_resp           [  6];
 167         u32 send_sdtr           [  4];
 168         u32 ppr_resp            [  6];
 169         u32 send_ppr            [  4];
 170         u32 nego_bad_phase      [  4];
 171         u32 msg_out             [  4];
 172         u32 msg_out_done        [  4];
 173         u32 data_ovrun          [  3];
 174         u32 data_ovrun1         [ 22];
 175         u32 data_ovrun2         [  8];
 176         u32 abort_resel         [ 16];
 177         u32 resend_ident        [  4];
 178         u32 ident_break         [  4];
 179         u32 ident_break_atn     [  4];
 180         u32 sdata_in            [  6];
 181         u32 resel_bad_lun       [  4];
 182         u32 bad_i_t_l           [  4];
 183         u32 bad_i_t_l_q         [  4];
 184         u32 bad_status          [  7];
 185         u32 wsr_ma_helper       [  4];
 186
 187         /* Data area */
 188         u32 zero                [  1];
 189         u32 scratch             [  1];
 190         u32 scratch1            [  1];
 191         u32 prev_done           [  1];
 192         u32 done_pos            [  1];
 193         u32 nextjob             [  1];
 194         u32 startpos            [  1];
 195         u32 targtbl             [  1];
 196 };
 197
 198 /*
 199  *  Script fragments used at initialisations.
 200  *  Only runs out of main memory.
 201  */
 202 struct SYM_FWZ_SCR {
 203         u32 snooptest           [  9];
 204         u32 snoopend            [  2];
 205 };
 206
 207 static struct SYM_FWA_SCR SYM_FWA_SCR = {
 208 /*--------------------------< START >----------------------------*/ {
 209         /*
 210          *  Switch the LED on.
 211          *  Will be patched with a NO_OP if LED
 212          *  not needed or not desired.
 213          */
 214         SCR_REG_REG (gpreg, SCR_AND, 0xfe),
 215                 0,
 216         /*
 217          *      Clear SIGP.
 218          */
 219         SCR_FROM_REG (ctest2),
 220                 0,
 221         /*
 222          *  Stop here if the C code wants to perform
 223          *  some error recovery procedure manually.
 224          *  (Indicate this by setting SEM in ISTAT)
 225          */
 226         SCR_FROM_REG (istat),
 227                 0,
 228         /*
 229          *  Report to the C code the next position in
 230          *  the start queue the SCRIPTS will schedule.
 231          *  The C code must not change SCRATCHA.
 232          */
 233         SCR_COPY (4),
 234                 PADDR_B (startpos),
 235                 RADDR_1 (scratcha),
 236         SCR_INT ^ IFTRUE (MASK (SEM, SEM)),
 237                 SIR_SCRIPT_STOPPED,
 238         /*
 239          *  Start the next job.
 240          *
 241          *  @DSA     = start point for this job.
 242          *  SCRATCHA = address of this job in the start queue.
 243          *
 244          *  We will restore startpos with SCRATCHA if we fails the
 245          *  arbitration or if it is the idle job.
 246          *
 247          *  The below GETJOB_BEGIN to GETJOB_END section of SCRIPTS
 248          *  is a critical path. If it is partially executed, it then
 249          *  may happen that the job address is not yet in the DSA
 250          *  and the next queue position points to the next JOB.
 251          */
 252 }/*-------------------------< GETJOB_BEGIN >---------------------*/,{
 253         /*
 254          *  Copy to a fixed location both the next STARTPOS
 255          *  and the current JOB address, using self modifying
 256          *  SCRIPTS.
 257          */
 258         SCR_COPY (4),
 259                 RADDR_1 (scratcha),
 260                 PADDR_A (_sms_a10),
 261         SCR_COPY (8),
 262 }/*-------------------------< _SMS_A10 >-------------------------*/,{
 263                 0,
 264                 PADDR_B (nextjob),
 265         /*
 266          *  Move the start address to TEMP using self-
 267          *  modifying SCRIPTS and jump indirectly to
 268          *  that address.
 269          */
 270         SCR_COPY (4),
 271                 PADDR_B (nextjob),
 272                 RADDR_1 (dsa),
 273 }/*-------------------------< GETJOB_END >-----------------------*/,{
 274         SCR_COPY (4),
 275                 RADDR_1 (dsa),
 276                 PADDR_A (_sms_a20),
 277         SCR_COPY (4),
 278 }/*-------------------------< _SMS_A20 >-------------------------*/,{
 279                 0,
 280                 RADDR_1 (temp),
 281         SCR_RETURN,
 282                 0,
 283 }/*-------------------------< SELECT >---------------------------*/,{
 284         /*
 285          *  DSA contains the address of a scheduled
 286          *      data structure.
 287          *
 288          *  SCRATCHA contains the address of the start queue
 289          *      entry which points to the next job.
 290          *
 291          *  Set Initiator mode.
 292          *
 293          *  (Target mode is left as an exercise for the reader)
 294          */
 295 #ifdef SYM_CONF_TARGET_ROLE_SUPPORT
 296         SCR_CLR (SCR_TRG),
 297                 0,
 298 #endif
 299         /*
 300          *      And try to select this target.
 301          */
 302         SCR_SEL_TBL_ATN ^ offsetof (struct sym_dsb, select),
 303                 PADDR_A (ungetjob),
 304         /*
 305          *  Now there are 4 possibilities:
 306          *
 307          *  (1) The chip loses arbitration.
 308          *  This is ok, because it will try again,
 309          *  when the bus becomes idle.
 310          *  (But beware of the timeout function!)
 311          *
 312          *  (2) The chip is reselected.
 313          *  Then the script processor takes the jump
 314          *  to the RESELECT label.
 315          *
 316          *  (3) The chip wins arbitration.
 317          *  Then it will execute SCRIPTS instruction until
 318          *  the next instruction that checks SCSI phase.
 319          *  Then will stop and wait for selection to be
 320          *  complete or selection time-out to occur.
 321          *
 322          *  After having won arbitration, the SCRIPTS
 323          *  processor is able to execute instructions while
 324          *  the SCSI core is performing SCSI selection.
 325          */
 326
 327         /*
 328          *  Copy the CCB header to a fixed location
 329          *  in the HCB using self-modifying SCRIPTS.
 330          */
 331         SCR_COPY (4),
 332                 RADDR_1 (dsa),
 333                 PADDR_A (_sms_a30),
 334         SCR_COPY (sizeof(struct sym_ccbh)),
 335 }/*-------------------------< _SMS_A30 >-------------------------*/,{
 336                 0,
 337                 HADDR_1 (ccb_head),
 338         /*
 339          *  Initialize the status register
 340          */
 341         SCR_COPY (4),
 342                 HADDR_1 (ccb_head.status),
 343                 RADDR_1 (scr0),
 344 }/*-------------------------< WF_SEL_DONE >----------------------*/,{
 345         SCR_INT ^ IFFALSE (WHEN (SCR_MSG_OUT)),
 346                 SIR_SEL_ATN_NO_MSG_OUT,
 347 }/*-------------------------< SEND_IDENT >-----------------------*/,{
 348         /*
 349          *  Selection complete.
 350          *  Send the IDENTIFY and possibly the TAG message
 351          *  and negotiation message if present.
 352          */
 353         SCR_MOVE_TBL ^ SCR_MSG_OUT,
 354                 offsetof (struct sym_dsb, smsg),
 355 }/*-------------------------< SELECT2 >--------------------------*/,{
 356 #ifdef SYM_CONF_IARB_SUPPORT
 357         /*
 358          *  Set IMMEDIATE ARBITRATION if we have been given
 359          *  a hint to do so. (Some job to do after this one).
 360          */
 361         SCR_FROM_REG (HF_REG),
 362                 0,
 363         SCR_JUMPR ^ IFFALSE (MASK (HF_HINT_IARB, HF_HINT_IARB)),
 364                 8,
 365         SCR_REG_REG (scntl1, SCR_OR, IARB),
 366                 0,
 367 #endif
 368         /*
 369          *  Anticipate the COMMAND phase.
 370          *  This is the PHASE we expect at this point.
 371          */
 372         SCR_JUMP ^ IFFALSE (WHEN (SCR_COMMAND)),
 373                 PADDR_A (sel_no_cmd),
 374 }/*-------------------------< COMMAND >--------------------------*/,{
 375         /*
 376          *  ... and send the command
 377          */
 378         SCR_MOVE_TBL ^ SCR_COMMAND,
 379                 offsetof (struct sym_dsb, cmd),
 380 }/*-------------------------< DISPATCH >-------------------------*/,{
 381         /*
 382          *  MSG_IN is the only phase that shall be
 383          *  entered at least once for each (re)selection.
 384          *  So we test it first.
 385          */
 386         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_IN)),
 387                 PADDR_A (msg_in),
 388         SCR_JUMP ^ IFTRUE (IF (SCR_DATA_OUT)),
 389                 PADDR_A (datao_phase),
 390         SCR_JUMP ^ IFTRUE (IF (SCR_DATA_IN)),
 391                 PADDR_A (datai_phase),
 392         SCR_JUMP ^ IFTRUE (IF (SCR_STATUS)),
 393                 PADDR_A (status),
 394         SCR_JUMP ^ IFTRUE (IF (SCR_COMMAND)),
 395                 PADDR_A (command),
 396         SCR_JUMP ^ IFTRUE (IF (SCR_MSG_OUT)),
 397                 PADDR_B (msg_out),
 398         /*
 399          *  Discard as many illegal phases as
 400          *  required and tell the C code about.
 401          */
 402         SCR_JUMPR ^ IFFALSE (WHEN (SCR_ILG_OUT)),
 403                 16,
 404         SCR_MOVE_ABS (1) ^ SCR_ILG_OUT,
 405                 HADDR_1 (scratch),
 406         SCR_JUMPR ^ IFTRUE (WHEN (SCR_ILG_OUT)),
 407                 -16,
 408         SCR_JUMPR ^ IFFALSE (WHEN (SCR_ILG_IN)),
 409                 16,
 410         SCR_MOVE_ABS (1) ^ SCR_ILG_IN,
 411                 HADDR_1 (scratch),
 412         SCR_JUMPR ^ IFTRUE (WHEN (SCR_ILG_IN)),
 413                 -16,
 414         SCR_INT,
 415                 SIR_BAD_PHASE,
 416         SCR_JUMP,
 417                 PADDR_A (dispatch),
 418 }/*-------------------------< SEL_NO_CMD >-----------------------*/,{
 419         /*
 420          *  The target does not switch to command
 421          *  phase after IDENTIFY has been sent.
 422          *
 423          *  If it stays in MSG OUT phase send it
 424          *  the IDENTIFY again.
 425          */
 426         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)),
 427                 PADDR_B (resend_ident),
 428         /*
 429          *  If target does not switch to MSG IN phase
 430          *  and we sent a negotiation, assert the
 431          *  failure immediately.
 432          */
 433         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_IN)),
 434                 PADDR_A (dispatch),
 435         SCR_FROM_REG (HS_REG),
 436                 0,
 437         SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)),
 438                 SIR_NEGO_FAILED,
 439         /*
 440          *  Jump to dispatcher.
 441          */
 442         SCR_JUMP,
 443                 PADDR_A (dispatch),
 444 }/*-------------------------< INIT >-----------------------------*/,{
 445         /*
 446          *  Wait for the SCSI RESET signal to be
 447          *  inactive before restarting operations,
 448          *  since the chip may hang on SEL_ATN
 449          *  if SCSI RESET is active.
 450          */
 451         SCR_FROM_REG (sstat0),
 452                 0,
 453         SCR_JUMPR ^ IFTRUE (MASK (IRST, IRST)),
 454                 -16,
 455         SCR_JUMP,
 456                 PADDR_A (start),
 457 }/*-------------------------< CLRACK >---------------------------*/,{
 458         /*
 459          *  Terminate possible pending message phase.
 460          */
 461         SCR_CLR (SCR_ACK),
 462                 0,
 463         SCR_JUMP,
 464                 PADDR_A (dispatch),
 465 }/*-------------------------< DATAI_DONE >-----------------------*/,{
 466         /*
 467          *  Save current pointer to LASTP.
 468          */
 469         SCR_COPY (4),
 470                 RADDR_1 (temp),
 471                 HADDR_1 (ccb_head.lastp),
 472         /*
 473          *  If the SWIDE is not full, jump to dispatcher.
 474          *  We anticipate a STATUS phase.
 475          */
 476         SCR_FROM_REG (scntl2),
 477                 0,
 478         SCR_JUMP ^ IFTRUE (MASK (WSR, WSR)),
 479                 PADDR_A (datai_done_wsr),
 480         SCR_JUMP ^ IFTRUE (WHEN (SCR_STATUS)),
 481                 PADDR_A (status),
 482         SCR_JUMP,
 483                 PADDR_A (dispatch),
 484 }/*-------------------------< DATAI_DONE_WSR >-------------------*/,{
 485         /*
 486          *  The SWIDE is full.
 487          *  Clear this condition.
 488          */
 489         SCR_REG_REG (scntl2, SCR_OR, WSR),
 490                 0,
 491         /*
 492          *  We are expecting an IGNORE RESIDUE message
 493          *  from the device, otherwise we are in data
 494          *  overrun condition. Check against MSG_IN phase.
 495          */
 496         SCR_INT ^ IFFALSE (WHEN (SCR_MSG_IN)),
 497                 SIR_SWIDE_OVERRUN,
 498         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
 499                 PADDR_A (dispatch),
 500         /*
 501          *  We are in MSG_IN phase,
 502          *  Read the first byte of the message.
 503          *  If it is not an IGNORE RESIDUE message,
 504          *  signal overrun and jump to message
 505          *  processing.
 506          */
 507         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
 508                 HADDR_1 (msgin[0]),
 509         SCR_INT ^ IFFALSE (DATA (M_IGN_RESIDUE)),
 510                 SIR_SWIDE_OVERRUN,
 511         SCR_JUMP ^ IFFALSE (DATA (M_IGN_RESIDUE)),
 512                 PADDR_A (msg_in2),
 513         /*
 514          *  We got the message we expected.
 515          *  Read the 2nd byte, and jump to dispatcher.
 516          */
 517         SCR_CLR (SCR_ACK),
 518                 0,
 519         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
 520                 HADDR_1 (msgin[1]),
 521         SCR_CLR (SCR_ACK),
 522                 0,
 523         SCR_JUMP,
 524                 PADDR_A (dispatch),
 525 }/*-------------------------< DATAO_DONE >-----------------------*/,{
 526         /*
 527          *  Save current pointer to LASTP.
 528          */
 529         SCR_COPY (4),
 530                 RADDR_1 (temp),
 531                 HADDR_1 (ccb_head.lastp),
 532         /*
 533          *  If the SODL is not full jump to dispatcher.
 534          *  We anticipate a STATUS phase.
 535          */
 536         SCR_FROM_REG (scntl2),
 537                 0,
 538         SCR_JUMP ^ IFTRUE (MASK (WSS, WSS)),
 539                 PADDR_A (datao_done_wss),
 540         SCR_JUMP ^ IFTRUE (WHEN (SCR_STATUS)),
 541                 PADDR_A (status),
 542         SCR_JUMP,
 543                 PADDR_A (dispatch),
 544 }/*-------------------------< DATAO_DONE_WSS >-------------------*/,{
 545         /*
 546          *  The SODL is full, clear this condition.
 547          */
 548         SCR_REG_REG (scntl2, SCR_OR, WSS),
 549                 0,
 550         /*
 551          *  And signal a DATA UNDERRUN condition
 552          *  to the C code.
 553          */
 554         SCR_INT,
 555                 SIR_SODL_UNDERRUN,
 556         SCR_JUMP,
 557                 PADDR_A (dispatch),
 558 }/*-------------------------< DATAI_PHASE >----------------------*/,{
 559         /*
 560          *  Jump to current pointer.
 561          */
 562         SCR_COPY (4),
 563                 HADDR_1 (ccb_head.lastp),
 564                 RADDR_1 (temp),
 565         SCR_RETURN,
 566                 0,
 567 }/*-------------------------< DATAO_PHASE >----------------------*/,{
 568         /*
 569          *  Jump to current pointer.
 570          */
 571         SCR_COPY (4),
 572                 HADDR_1 (ccb_head.lastp),
 573                 RADDR_1 (temp),
 574         SCR_RETURN,
 575                 0,
 576 }/*-------------------------< MSG_IN >---------------------------*/,{
 577         /*
 578          *  Get the first byte of the message.
 579          *
 580          *  The script processor doesn't negate the
 581          *  ACK signal after this transfer.
 582          */
 583         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
 584                 HADDR_1 (msgin[0]),
 585 }/*-------------------------< MSG_IN2 >--------------------------*/,{
 586         /*
 587          *  Check first against 1 byte messages
 588          *  that we handle from SCRIPTS.
 589          */
 590         SCR_JUMP ^ IFTRUE (DATA (M_COMPLETE)),
 591                 PADDR_A (complete),
 592         SCR_JUMP ^ IFTRUE (DATA (M_DISCONNECT)),
 593                 PADDR_A (disconnect),
 594         SCR_JUMP ^ IFTRUE (DATA (M_SAVE_DP)),
 595                 PADDR_A (save_dp),
 596         SCR_JUMP ^ IFTRUE (DATA (M_RESTORE_DP)),
 597                 PADDR_A (restore_dp),
 598         /*
 599          *  We handle all other messages from the
 600          *  C code, so no need to waste on-chip RAM
 601          *  for those ones.
 602          */
 603         SCR_JUMP,
 604                 PADDR_B (msg_in_etc),
 605 }/*-------------------------< STATUS >---------------------------*/,{
 606         /*
 607          *  get the status
 608          */
 609         SCR_MOVE_ABS (1) ^ SCR_STATUS,
 610                 HADDR_1 (scratch),
 611 #ifdef SYM_CONF_IARB_SUPPORT
 612         /*
 613          *  If STATUS is not GOOD, clear IMMEDIATE ARBITRATION,
 614          *  since we may have to tamper the start queue from
 615          *  the C code.
 616          */
 617         SCR_JUMPR ^ IFTRUE (DATA (S_GOOD)),
 618                 8,
 619         SCR_REG_REG (scntl1, SCR_AND, ~IARB),
 620                 0,
 621 #endif
 622         /*
 623          *  save status to scsi_status.
 624          *  mark as complete.
 625          */
 626         SCR_TO_REG (SS_REG),
 627                 0,
 628         SCR_LOAD_REG (HS_REG, HS_COMPLETE),
 629                 0,
 630         /*
 631          *  Anticipate the MESSAGE PHASE for
 632          *  the TASK COMPLETE message.
 633          */
 634         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_IN)),
 635                 PADDR_A (msg_in),
 636         SCR_JUMP,
 637                 PADDR_A (dispatch),
 638 }/*-------------------------< COMPLETE >-------------------------*/,{
 639         /*
 640          *  Complete message.
 641          *
 642          *  When we terminate the cycle by clearing ACK,
 643          *  the target may disconnect immediately.
 644          *
 645          *  We don't want to be told of an "unexpected disconnect",
 646          *  so we disable this feature.
 647          */
 648         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
 649                 0,
 650         /*
 651          *  Terminate cycle ...
 652          */
 653         SCR_CLR (SCR_ACK|SCR_ATN),
 654                 0,
 655         /*
 656          *  ... and wait for the disconnect.
 657          */
 658         SCR_WAIT_DISC,
 659                 0,
 660 }/*-------------------------< COMPLETE2 >------------------------*/,{
 661         /*
 662          *  Save host status.
 663          */
 664         SCR_COPY (4),
 665                 RADDR_1 (scr0),
 666                 HADDR_1 (ccb_head.status),
 667         /*
 668          *  Move back the CCB header using self-modifying
 669          *  SCRIPTS.
 670          */
 671         SCR_COPY (4),
 672                 RADDR_1 (dsa),
 673                 PADDR_A (_sms_a40),
 674         SCR_COPY (sizeof(struct sym_ccbh)),
 675                 HADDR_1 (ccb_head),
 676 }/*-------------------------< _SMS_A40 >-------------------------*/,{
 677                 0,
 678         /*
 679          *  Some bridges may reorder DMA writes to memory.
 680          *  We donnot want the CPU to deal with completions
 681          *  without all the posted write having been flushed
 682          *  to memory. This DUMMY READ should flush posted
 683          *  buffers prior to the CPU having to deal with
 684          *  completions.
 685          */
 686         SCR_COPY (4),                   /* DUMMY READ */
 687                 HADDR_1 (ccb_head.status),
 688                 RADDR_1 (scr0),
 689         /*
 690          *  If command resulted in not GOOD status,
 691          *  call the C code if needed.
 692          */
 693         SCR_FROM_REG (SS_REG),
 694                 0,
 695         SCR_CALL ^ IFFALSE (DATA (S_GOOD)),
 696                 PADDR_B (bad_status),
 697         /*
 698          *  If we performed an auto-sense, call
 699          *  the C code to synchronyze task aborts
 700          *  with UNIT ATTENTION conditions.
 701          */
 702         SCR_FROM_REG (HF_REG),
 703                 0,
 704         SCR_JUMP ^ IFFALSE (MASK (0 ,(HF_SENSE|HF_EXT_ERR))),
 705                 PADDR_A (complete_error),
 706 }/*-------------------------< DONE >-----------------------------*/,{
 707         /*
 708          *  Copy the DSA to the DONE QUEUE and
 709          *  signal completion to the host.
 710          *  If we are interrupted between DONE
 711          *  and DONE_END, we must reset, otherwise
 712          *  the completed CCB may be lost.
 713          */
 714         SCR_COPY (4),
 715                 PADDR_B (done_pos),
 716                 PADDR_A (_sms_a50),
 717         SCR_COPY (4),
 718                 RADDR_1 (dsa),
 719 }/*-------------------------< _SMS_A50 >-------------------------*/,{
 720                 0,
 721         SCR_COPY (4),
 722                 PADDR_B (done_pos),
 723                 PADDR_A (_sms_a60),
 724         /*
 725          *  The instruction below reads the DONE QUEUE next
 726          *  free position from memory.
 727          *  In addition it ensures that all PCI posted writes
 728          *  are flushed and so the DSA value of the done
 729          *  CCB is visible by the CPU before INTFLY is raised.
 730          */
 731         SCR_COPY (8),
 732 }/*-------------------------< _SMS_A60 >-------------------------*/,{
 733                 0,
 734                 PADDR_B (prev_done),
 735 }/*-------------------------< DONE_END >-------------------------*/,{
 736         SCR_INT_FLY,
 737                 0,
 738         SCR_JUMP,
 739                 PADDR_A (start),
 740 }/*-------------------------< COMPLETE_ERROR >-------------------*/,{
 741         SCR_COPY (4),
 742                 PADDR_B (startpos),
 743                 RADDR_1 (scratcha),
 744         SCR_INT,
 745                 SIR_COMPLETE_ERROR,
 746 }/*-------------------------< SAVE_DP >--------------------------*/,{
 747         /*
 748          *  Clear ACK immediately.
 749          *  No need to delay it.
 750          */
 751         SCR_CLR (SCR_ACK),
 752                 0,
 753         /*
 754          *  Keep track we received a SAVE DP, so
 755          *  we will switch to the other PM context
 756          *  on the next PM since the DP may point
 757          *  to the current PM context.
 758          */
 759         SCR_REG_REG (HF_REG, SCR_OR, HF_DP_SAVED),
 760                 0,
 761         /*
 762          *  SAVE_DP message:
 763          *  Copy LASTP to SAVEP.
 764          */
 765         SCR_COPY (4),
 766                 HADDR_1 (ccb_head.lastp),
 767                 HADDR_1 (ccb_head.savep),
 768         /*
 769          *  Anticipate the MESSAGE PHASE for
 770          *  the DISCONNECT message.
 771          */
 772         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_IN)),
 773                 PADDR_A (msg_in),
 774         SCR_JUMP,
 775                 PADDR_A (dispatch),
 776 }/*-------------------------< RESTORE_DP >-----------------------*/,{
 777         /*
 778          *  Clear ACK immediately.
 779          *  No need to delay it.
 780          */
 781         SCR_CLR (SCR_ACK),
 782                 0,
 783         /*
 784          *  Copy SAVEP to LASTP.
 785          */
 786         SCR_COPY (4),
 787                 HADDR_1 (ccb_head.savep),
 788                 HADDR_1 (ccb_head.lastp),
 789         SCR_JUMP,
 790                 PADDR_A (dispatch),
 791 }/*-------------------------< DISCONNECT >-----------------------*/,{
 792         /*
 793          *  DISCONNECTing  ...
 794          *
 795          *  disable the "unexpected disconnect" feature,
 796          *  and remove the ACK signal.
 797          */
 798         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
 799                 0,
 800         SCR_CLR (SCR_ACK|SCR_ATN),
 801                 0,
 802         /*
 803          *  Wait for the disconnect.
 804          */
 805         SCR_WAIT_DISC,
 806                 0,
 807         /*
 808          *  Status is: DISCONNECTED.
 809          */
 810         SCR_LOAD_REG (HS_REG, HS_DISCONNECT),
 811                 0,
 812         /*
 813          *  Save host status.
 814          */
 815         SCR_COPY (4),
 816                 RADDR_1 (scr0),
 817                 HADDR_1 (ccb_head.status),
 818 }/*-------------------------< DISCONNECT2 >----------------------*/,{
 819         /*
 820          *  Move back the CCB header using self-modifying
 821          *  SCRIPTS.
 822          */
 823         SCR_COPY (4),
 824                 RADDR_1 (dsa),
 825                 PADDR_A (_sms_a65),
 826         SCR_COPY (sizeof(struct sym_ccbh)),
 827                 HADDR_1 (ccb_head),
 828 }/*-------------------------< _SMS_A65 >-------------------------*/,{
 829                 0,
 830         SCR_JUMP,
 831                 PADDR_A (start),
 832 }/*-------------------------< IDLE >-----------------------------*/,{
 833         /*
 834          *  Nothing to do?
 835          *  Switch the LED off and wait for reselect.
 836          *  Will be patched with a NO_OP if LED
 837          *  not needed or not desired.
 838          */
 839         SCR_REG_REG (gpreg, SCR_OR, 0x01),
 840                 0,
 841 #ifdef SYM_CONF_IARB_SUPPORT
 842         SCR_JUMPR,
 843                 8,
 844 #endif
 845 }/*-------------------------< UNGETJOB >-------------------------*/,{
 846 #ifdef SYM_CONF_IARB_SUPPORT
 847         /*
 848          *  Set IMMEDIATE ARBITRATION, for the next time.
 849          *  This will give us better chance to win arbitration
 850          *  for the job we just wanted to do.
 851          */
 852         SCR_REG_REG (scntl1, SCR_OR, IARB),
 853                 0,
 854 #endif
 855         /*
 856          *  We are not able to restart the SCRIPTS if we are
 857          *  interrupted and these instruction haven't been
 858          *  all executed. BTW, this is very unlikely to
 859          *  happen, but we check that from the C code.
 860          */
 861         SCR_LOAD_REG (dsa, 0xff),
 862                 0,
 863         SCR_COPY (4),
 864                 RADDR_1 (scratcha),
 865                 PADDR_B (startpos),
 866 }/*-------------------------< RESELECT >-------------------------*/,{
 867 #ifdef SYM_CONF_TARGET_ROLE_SUPPORT
 868         /*
 869          *  Make sure we are in initiator mode.
 870          */
 871         SCR_CLR (SCR_TRG),
 872                 0,
 873 #endif
 874         /*
 875          *  Sleep waiting for a reselection.
 876          */
 877         SCR_WAIT_RESEL,
 878                 PADDR_A(start),
 879 }/*-------------------------< RESELECTED >-----------------------*/,{
 880         /*
 881          *  Switch the LED on.
 882          *  Will be patched with a NO_OP if LED
 883          *  not needed or not desired.
 884          */
 885         SCR_REG_REG (gpreg, SCR_AND, 0xfe),
 886                 0,
 887         /*
 888          *  load the target id into the sdid
 889          */
 890         SCR_REG_SFBR (ssid, SCR_AND, 0x8F),
 891                 0,
 892         SCR_TO_REG (sdid),
 893                 0,
 894         /*
 895          *  Load the target control block address
 896          */
 897         SCR_COPY (4),
 898                 PADDR_B (targtbl),
 899                 RADDR_1 (dsa),
 900         SCR_SFBR_REG (dsa, SCR_SHL, 0),
 901                 0,
 902         SCR_REG_REG (dsa, SCR_SHL, 0),
 903                 0,
 904         SCR_REG_REG (dsa, SCR_AND, 0x3c),
 905                 0,
 906         SCR_COPY (4),
 907                 RADDR_1 (dsa),
 908                 PADDR_A (_sms_a70),
 909         SCR_COPY (4),
 910 }/*-------------------------< _SMS_A70 >-------------------------*/,{
 911                 0,
 912                 RADDR_1 (dsa),
 913         /*
 914          *  Copy the TCB header to a fixed place in
 915          *  the HCB.
 916          */
 917         SCR_COPY (4),
 918                 RADDR_1 (dsa),
 919                 PADDR_A (_sms_a80),
 920         SCR_COPY (sizeof(struct sym_tcbh)),
 921 }/*-------------------------< _SMS_A80 >-------------------------*/,{
 922                 0,
 923                 HADDR_1 (tcb_head),
 924         /*
 925          *  We expect MESSAGE IN phase.
 926          *  If not, get help from the C code.
 927          */
 928         SCR_INT ^ IFFALSE (WHEN (SCR_MSG_IN)),
 929                 SIR_RESEL_NO_MSG_IN,
 930 }/*-------------------------< RESELECTED1 >----------------------*/,{
 931         /*
 932          *  Load the synchronous transfer registers.
 933          */
 934         SCR_COPY (1),
 935                 HADDR_1 (tcb_head.wval),
 936                 RADDR_1 (scntl3),
 937         SCR_COPY (1),
 938                 HADDR_1 (tcb_head.sval),
 939                 RADDR_1 (sxfer),
 940         /*
 941          *  Get the IDENTIFY message.
 942          */
 943         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
 944                 HADDR_1 (msgin),
 945         /*
 946          *  If IDENTIFY LUN #0, use a faster path
 947          *  to find the LCB structure.
 948          */
 949         SCR_JUMP ^ IFTRUE (MASK (0x80, 0xbf)),
 950                 PADDR_A (resel_lun0),
 951         /*
 952          *  If message isn't an IDENTIFY,
 953          *  tell the C code about.
 954          */
 955         SCR_INT ^ IFFALSE (MASK (0x80, 0x80)),
 956                 SIR_RESEL_NO_IDENTIFY,
 957         /*
 958          *  It is an IDENTIFY message,
 959          *  Load the LUN control block address.
 960          */
 961         SCR_COPY (4),
 962                 HADDR_1 (tcb_head.luntbl_sa),
 963                 RADDR_1 (dsa),
 964         SCR_SFBR_REG (dsa, SCR_SHL, 0),
 965                 0,
 966         SCR_REG_REG (dsa, SCR_SHL, 0),
 967                 0,
 968         SCR_REG_REG (dsa, SCR_AND, 0xfc),
 969                 0,
 970         SCR_COPY (4),
 971                 RADDR_1 (dsa),
 972                 PADDR_A (_sms_a90),
 973         SCR_COPY (4),
 974 }/*-------------------------< _SMS_A90 >-------------------------*/,{
 975                 0,
 976                 RADDR_1 (dsa),
 977         SCR_JUMPR,
 978                 12,
 979 }/*-------------------------< RESEL_LUN0 >-----------------------*/,{
 980         /*
 981          *  LUN 0 special case (but usual one :))
 982          */
 983         SCR_COPY (4),
 984                 HADDR_1 (tcb_head.lun0_sa),
 985                 RADDR_1 (dsa),
 986         /*
 987          *  Jump indirectly to the reselect action for this LUN.
 988          *  (lcb.head.resel_sa assumed at offset zero of lcb).
 989          */
 990         SCR_COPY (4),
 991                 RADDR_1 (dsa),
 992                 PADDR_A (_sms_a100),
 993         SCR_COPY (4),
 994 }/*-------------------------< _SMS_A100 >------------------------*/,{
 995                 0,
 996                 RADDR_1 (temp),
 997         SCR_RETURN,
 998                 0,
 999         /* In normal situations, we jump to RESEL_TAG or RESEL_NO_TAG */
1000 }/*-------------------------< RESEL_TAG >------------------------*/,{
1001         /*
1002          *  ACK the IDENTIFY previously received.
1003          */
1004         SCR_CLR (SCR_ACK),
1005                 0,
1006         /*
1007          *  It shall be a tagged command.
1008          *  Read SIMPLE+TAG.
1009          *  The C code will deal with errors.
1010          *  Aggressive optimization, isn't it? :)
1011          */
1012         SCR_MOVE_ABS (2) ^ SCR_MSG_IN,
1013                 HADDR_1 (msgin),
1014         /*
1015          *  Copy the LCB header to a fixed place in
1016          *  the HCB using self-modifying SCRIPTS.
1017          */
1018         SCR_COPY (4),
1019                 RADDR_1 (dsa),
1020                 PADDR_A (_sms_a110),
1021         SCR_COPY (sizeof(struct sym_lcbh)),
1022 }/*-------------------------< _SMS_A110 >------------------------*/,{
1023                 0,
1024                 HADDR_1 (lcb_head),
1025         /*
1026          *  Load the pointer to the tagged task
1027          *  table for this LUN.
1028          */
1029         SCR_COPY (4),
1030                 HADDR_1 (lcb_head.itlq_tbl_sa),
1031                 RADDR_1 (dsa),
1032         /*
1033          *  The SIDL still contains the TAG value.
1034          *  Aggressive optimization, isn't it? :):)
1035          */
1036         SCR_REG_SFBR (sidl, SCR_SHL, 0),
1037                 0,
1038 #if SYM_CONF_MAX_TASK*4 > 512
1039         SCR_JUMPR ^ IFFALSE (CARRYSET),
1040                 8,
1041         SCR_REG_REG (dsa1, SCR_OR, 2),
1042                 0,
1043         SCR_REG_REG (sfbr, SCR_SHL, 0),
1044                 0,
1045         SCR_JUMPR ^ IFFALSE (CARRYSET),
1046                 8,
1047         SCR_REG_REG (dsa1, SCR_OR, 1),
1048                 0,
1049 #elif SYM_CONF_MAX_TASK*4 > 256
1050         SCR_JUMPR ^ IFFALSE (CARRYSET),
1051                 8,
1052         SCR_REG_REG (dsa1, SCR_OR, 1),
1053                 0,
1054 #endif
1055         /*
1056          *  Retrieve the DSA of this task.
1057          *  JUMP indirectly to the restart point of the CCB.
1058          */
1059         SCR_SFBR_REG (dsa, SCR_AND, 0xfc),
1060                 0,
1061         SCR_COPY (4),
1062                 RADDR_1 (dsa),
1063                 PADDR_A (_sms_a120),
1064         SCR_COPY (4),
1065 }/*-------------------------< _SMS_A120 >------------------------*/,{
1066                 0,
1067                 RADDR_1 (dsa),
1068 }/*-------------------------< RESEL_GO >-------------------------*/,{
1069         SCR_COPY (4),
1070                 RADDR_1 (dsa),
1071                 PADDR_A (_sms_a130),
1072         /*
1073          *  Move 'ccb.phys.head.go' action to
1074          *  scratch/scratch1. So scratch1 will
1075          *  contain the 'restart' field of the
1076          *  'go' structure.
1077          */
1078         SCR_COPY (8),
1079 }/*-------------------------< _SMS_A130 >------------------------*/,{
1080                 0,
1081                 PADDR_B (scratch),
1082         SCR_COPY (4),
1083                 PADDR_B (scratch1), /* phys.head.go.restart */
1084                 RADDR_1 (temp),
1085         SCR_RETURN,
1086                 0,
1087         /* In normal situations we branch to RESEL_DSA */
1088 }/*-------------------------< RESEL_DSA >------------------------*/,{
1089         /*
1090          *  ACK the IDENTIFY or TAG previously received.
1091          */
1092         SCR_CLR (SCR_ACK),
1093                 0,
1094 }/*-------------------------< RESEL_DSA1 >-----------------------*/,{
1095         /*
1096          *  Copy the CCB header to a fixed location
1097          *  in the HCB using self-modifying SCRIPTS.
1098          */
1099         SCR_COPY (4),
1100                 RADDR_1 (dsa),
1101                 PADDR_A (_sms_a140),
1102         SCR_COPY (sizeof(struct sym_ccbh)),
1103 }/*-------------------------< _SMS_A140 >------------------------*/,{
1104                 0,
1105                 HADDR_1 (ccb_head),
1106         /*
1107          *  Initialize the status register
1108          */
1109         SCR_COPY (4),
1110                 HADDR_1 (ccb_head.status),
1111                 RADDR_1 (scr0),
1112         /*
1113          *  Jump to dispatcher.
1114          */
1115         SCR_JUMP,
1116                 PADDR_A (dispatch),
1117 }/*-------------------------< RESEL_NO_TAG >---------------------*/,{
1118         /*
1119          *  Copy the LCB header to a fixed place in
1120          *  the HCB using self-modifying SCRIPTS.
1121          */
1122         SCR_COPY (4),
1123                 RADDR_1 (dsa),
1124                 PADDR_A (_sms_a145),
1125         SCR_COPY (sizeof(struct sym_lcbh)),
1126 }/*-------------------------< _SMS_A145 >------------------------*/,{
1127                 0,
1128                 HADDR_1 (lcb_head),
1129         /*
1130          *  Load the DSA with the unique ITL task.
1131          */
1132         SCR_COPY (4),
1133                 HADDR_1 (lcb_head.itl_task_sa),
1134                 RADDR_1 (dsa),
1135         SCR_JUMP,
1136                 PADDR_A (resel_go),
1137 }/*-------------------------< DATA_IN >--------------------------*/,{
1138 /*
1139  *  Because the size depends on the
1140  *  #define SYM_CONF_MAX_SG parameter,
1141  *  it is filled in at runtime.
1142  *
1143  *  ##===========< i=0; i<SYM_CONF_MAX_SG >=========
1144  *  ||  SCR_CHMOV_TBL ^ SCR_DATA_IN,
1145  *  ||          offsetof (struct sym_dsb, data[ i]),
1146  *  ##==========================================
1147  */
1148 0
1149 }/*-------------------------< DATA_IN2 >-------------------------*/,{
1150         SCR_CALL,
1151                 PADDR_A (datai_done),
1152         SCR_JUMP,
1153                 PADDR_B (data_ovrun),
1154 }/*-------------------------< DATA_OUT >-------------------------*/,{
1155 /*
1156  *  Because the size depends on the
1157  *  #define SYM_CONF_MAX_SG parameter,
1158  *  it is filled in at runtime.
1159  *
1160  *  ##===========< i=0; i<SYM_CONF_MAX_SG >=========
1161  *  ||  SCR_CHMOV_TBL ^ SCR_DATA_OUT,
1162  *  ||          offsetof (struct sym_dsb, data[ i]),
1163  *  ##==========================================
1164  */
1165 0
1166 }/*-------------------------< DATA_OUT2 >------------------------*/,{
1167         SCR_CALL,
1168                 PADDR_A (datao_done),
1169         SCR_JUMP,
1170                 PADDR_B (data_ovrun),
1171 }/*-------------------------< PM0_DATA >-------------------------*/,{
1172         /*
1173          *  Read our host flags to SFBR, so we will be able
1174          *  to check against the data direction we expect.
1175          */
1176         SCR_FROM_REG (HF_REG),
1177                 0,
1178         /*
1179          *  Check against actual DATA PHASE.
1180          */
1181         SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_IN)),
1182                 PADDR_A (pm0_data_out),
1183         /*
1184          *  Actual phase is DATA IN.
1185          *  Check against expected direction.
1186          */
1187         SCR_JUMP ^ IFFALSE (MASK (HF_DATA_IN, HF_DATA_IN)),
1188                 PADDR_B (data_ovrun),
1189         /*
1190          *  Keep track we are moving data from the
1191          *  PM0 DATA mini-script.
1192          */
1193         SCR_REG_REG (HF_REG, SCR_OR, HF_IN_PM0),
1194                 0,
1195         /*
1196          *  Move the data to memory.
1197          */
1198         SCR_CHMOV_TBL ^ SCR_DATA_IN,
1199                 offsetof (struct sym_ccb, phys.pm0.sg),
1200         SCR_JUMP,
1201                 PADDR_A (pm0_data_end),
1202 }/*-------------------------< PM0_DATA_OUT >---------------------*/,{
1203         /*
1204          *  Actual phase is DATA OUT.
1205          *  Check against expected direction.
1206          */
1207         SCR_JUMP ^ IFTRUE (MASK (HF_DATA_IN, HF_DATA_IN)),
1208                 PADDR_B (data_ovrun),
1209         /*
1210          *  Keep track we are moving data from the
1211          *  PM0 DATA mini-script.
1212          */
1213         SCR_REG_REG (HF_REG, SCR_OR, HF_IN_PM0),
1214                 0,
1215         /*
1216          *  Move the data from memory.
1217          */
1218         SCR_CHMOV_TBL ^ SCR_DATA_OUT,
1219                 offsetof (struct sym_ccb, phys.pm0.sg),
1220 }/*-------------------------< PM0_DATA_END >---------------------*/,{
1221         /*
1222          *  Clear the flag that told we were moving
1223          *  data from the PM0 DATA mini-script.
1224          */
1225         SCR_REG_REG (HF_REG, SCR_AND, (~HF_IN_PM0)),
1226                 0,
1227         /*
1228          *  Return to the previous DATA script which
1229          *  is guaranteed by design (if no bug) to be
1230          *  the main DATA script for this transfer.
1231          */
1232         SCR_COPY (4),
1233                 RADDR_1 (dsa),
1234                 RADDR_1 (scratcha),
1235         SCR_REG_REG (scratcha, SCR_ADD, offsetof (struct sym_ccb,phys.pm0.ret)),
1236                 0,
1237 }/*-------------------------< PM_DATA_END >----------------------*/,{
1238         SCR_COPY (4),
1239                 RADDR_1 (scratcha),
1240                 PADDR_A (_sms_a150),
1241         SCR_COPY (4),
1242 }/*-------------------------< _SMS_A150 >------------------------*/,{
1243                 0,
1244                 RADDR_1 (temp),
1245         SCR_RETURN,
1246                 0,
1247 }/*-------------------------< PM1_DATA >-------------------------*/,{
1248         /*
1249          *  Read our host flags to SFBR, so we will be able
1250          *  to check against the data direction we expect.
1251          */
1252         SCR_FROM_REG (HF_REG),
1253                 0,
1254         /*
1255          *  Check against actual DATA PHASE.
1256          */
1257         SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_IN)),
1258                 PADDR_A (pm1_data_out),
1259         /*
1260          *  Actual phase is DATA IN.
1261          *  Check against expected direction.
1262          */
1263         SCR_JUMP ^ IFFALSE (MASK (HF_DATA_IN, HF_DATA_IN)),
1264                 PADDR_B (data_ovrun),
1265         /*
1266          *  Keep track we are moving data from the
1267          *  PM1 DATA mini-script.
1268          */
1269         SCR_REG_REG (HF_REG, SCR_OR, HF_IN_PM1),
1270                 0,
1271         /*
1272          *  Move the data to memory.
1273          */
1274         SCR_CHMOV_TBL ^ SCR_DATA_IN,
1275                 offsetof (struct sym_ccb, phys.pm1.sg),
1276         SCR_JUMP,
1277                 PADDR_A (pm1_data_end),
1278 }/*-------------------------< PM1_DATA_OUT >---------------------*/,{
1279         /*
1280          *  Actual phase is DATA OUT.
1281          *  Check against expected direction.
1282          */
1283         SCR_JUMP ^ IFTRUE (MASK (HF_DATA_IN, HF_DATA_IN)),
1284                 PADDR_B (data_ovrun),
1285         /*
1286          *  Keep track we are moving data from the
1287          *  PM1 DATA mini-script.
1288          */
1289         SCR_REG_REG (HF_REG, SCR_OR, HF_IN_PM1),
1290                 0,
1291         /*
1292          *  Move the data from memory.
1293          */
1294         SCR_CHMOV_TBL ^ SCR_DATA_OUT,
1295                 offsetof (struct sym_ccb, phys.pm1.sg),
1296 }/*-------------------------< PM1_DATA_END >---------------------*/,{
1297         /*
1298          *  Clear the flag that told we were moving
1299          *  data from the PM1 DATA mini-script.
1300          */
1301         SCR_REG_REG (HF_REG, SCR_AND, (~HF_IN_PM1)),
1302                 0,
1303         /*
1304          *  Return to the previous DATA script which
1305          *  is guaranteed by design (if no bug) to be
1306          *  the main DATA script for this transfer.
1307          */
1308         SCR_COPY (4),
1309                 RADDR_1 (dsa),
1310                 RADDR_1 (scratcha),
1311         SCR_REG_REG (scratcha, SCR_ADD, offsetof (struct sym_ccb,phys.pm1.ret)),
1312                 0,
1313         SCR_JUMP,
1314                 PADDR_A (pm_data_end),
1315 }/*--------------------------<>----------------------------------*/
1316 };
1317
1318 static struct SYM_FWB_SCR SYM_FWB_SCR = {
1319 /*-------------------------< NO_DATA >--------------------------*/ {
1320         SCR_JUMP,
1321                 PADDR_B (data_ovrun),
1322 }/*-------------------------< SEL_FOR_ABORT >--------------------*/,{
1323         /*
1324          *  We are jumped here by the C code, if we have
1325          *  some target to reset or some disconnected
1326          *  job to abort. Since error recovery is a serious
1327          *  busyness, we will really reset the SCSI BUS, if
1328          *  case of a SCSI interrupt occurring in this path.
1329          */
1330
1331 #ifdef SYM_CONF_TARGET_ROLE_SUPPORT
1332         /*
1333          *  Set initiator mode.
1334          */
1335         SCR_CLR (SCR_TRG),
1336                 0,
1337 #endif
1338         /*
1339          *      And try to select this target.
1340          */
1341         SCR_SEL_TBL_ATN ^ offsetof (struct sym_hcb, abrt_sel),
1342                 PADDR_A (reselect),
1343         /*
1344          *  Wait for the selection to complete or
1345          *  the selection to time out.
1346          */
1347         SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_OUT)),
1348                 -8,
1349         /*
1350          *  Call the C code.
1351          */
1352         SCR_INT,
1353                 SIR_TARGET_SELECTED,
1354         /*
1355          *  The C code should let us continue here.
1356          *  Send the 'kiss of death' message.
1357          *  We expect an immediate disconnect once
1358          *  the target has eaten the message.
1359          */
1360         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
1361                 0,
1362         SCR_MOVE_TBL ^ SCR_MSG_OUT,
1363                 offsetof (struct sym_hcb, abrt_tbl),
1364         SCR_CLR (SCR_ACK|SCR_ATN),
1365                 0,
1366         SCR_WAIT_DISC,
1367                 0,
1368         /*
1369          *  Tell the C code that we are done.
1370          */
1371         SCR_INT,
1372                 SIR_ABORT_SENT,
1373 }/*-------------------------< SEL_FOR_ABORT_1 >------------------*/,{
1374         /*
1375          *  Jump at scheduler.
1376          */
1377         SCR_JUMP,
1378                 PADDR_A (start),
1379 }/*-------------------------< MSG_IN_ETC >-----------------------*/,{
1380         /*
1381          *  If it is an EXTENDED (variable size message)
1382          *  Handle it.
1383          */
1384         SCR_JUMP ^ IFTRUE (DATA (M_EXTENDED)),
1385                 PADDR_B (msg_extended),
1386         /*
1387          *  Let the C code handle any other
1388          *  1 byte message.
1389          */
1390         SCR_JUMP ^ IFTRUE (MASK (0x00, 0xf0)),
1391                 PADDR_B (msg_received),
1392         SCR_JUMP ^ IFTRUE (MASK (0x10, 0xf0)),
1393                 PADDR_B (msg_received),
1394         /*
1395          *  We donnot handle 2 bytes messages from SCRIPTS.
1396          *  So, let the C code deal with these ones too.
1397          */
1398         SCR_JUMP ^ IFFALSE (MASK (0x20, 0xf0)),
1399                 PADDR_B (msg_weird_seen),
1400         SCR_CLR (SCR_ACK),
1401                 0,
1402         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
1403                 HADDR_1 (msgin[1]),
1404 }/*-------------------------< MSG_RECEIVED >---------------------*/,{
1405         SCR_COPY (4),                   /* DUMMY READ */
1406                 HADDR_1 (scratch),
1407                 RADDR_1 (scratcha),
1408         SCR_INT,
1409                 SIR_MSG_RECEIVED,
1410 }/*-------------------------< MSG_WEIRD_SEEN >-------------------*/,{
1411         SCR_COPY (4),                   /* DUMMY READ */
1412                 HADDR_1 (scratch),
1413                 RADDR_1 (scratcha),
1414         SCR_INT,
1415                 SIR_MSG_WEIRD,
1416 }/*-------------------------< MSG_EXTENDED >---------------------*/,{
1417         /*
1418          *  Clear ACK and get the next byte
1419          *  assumed to be the message length.
1420          */
1421         SCR_CLR (SCR_ACK),
1422                 0,
1423         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
1424                 HADDR_1 (msgin[1]),
1425         /*
1426          *  Try to catch some unlikely situations as 0 length
1427          *  or too large the length.
1428          */
1429         SCR_JUMP ^ IFTRUE (DATA (0)),
1430                 PADDR_B (msg_weird_seen),
1431         SCR_TO_REG (scratcha),
1432                 0,
1433         SCR_REG_REG (sfbr, SCR_ADD, (256-8)),
1434                 0,
1435         SCR_JUMP ^ IFTRUE (CARRYSET),
1436                 PADDR_B (msg_weird_seen),
1437         /*
1438          *  We donnot handle extended messages from SCRIPTS.
1439          *  Read the amount of data corresponding to the
1440          *  message length and call the C code.
1441          */
1442         SCR_COPY (1),
1443                 RADDR_1 (scratcha),
1444                 PADDR_B (_sms_b10),
1445         SCR_CLR (SCR_ACK),
1446                 0,
1447 }/*-------------------------< _SMS_B10 >-------------------------*/,{
1448         SCR_MOVE_ABS (0) ^ SCR_MSG_IN,
1449                 HADDR_1 (msgin[2]),
1450         SCR_JUMP,
1451                 PADDR_B (msg_received),
1452 }/*-------------------------< MSG_BAD >--------------------------*/,{
1453         /*
1454          *  unimplemented message - reject it.
1455          */
1456         SCR_INT,
1457                 SIR_REJECT_TO_SEND,
1458         SCR_SET (SCR_ATN),
1459                 0,
1460         SCR_JUMP,
1461                 PADDR_A (clrack),
1462 }/*-------------------------< MSG_WEIRD >------------------------*/,{
1463         /*
1464          *  weird message received
1465          *  ignore all MSG IN phases and reject it.
1466          */
1467         SCR_INT,
1468                 SIR_REJECT_TO_SEND,
1469         SCR_SET (SCR_ATN),
1470                 0,
1471 }/*-------------------------< MSG_WEIRD1 >-----------------------*/,{
1472         SCR_CLR (SCR_ACK),
1473                 0,
1474         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)),
1475                 PADDR_A (dispatch),
1476         SCR_MOVE_ABS (1) ^ SCR_MSG_IN,
1477                 HADDR_1 (scratch),
1478         SCR_JUMP,
1479                 PADDR_B (msg_weird1),
1480 }/*-------------------------< WDTR_RESP >------------------------*/,{
1481         /*
1482          *  let the target fetch our answer.
1483          */
1484         SCR_SET (SCR_ATN),
1485                 0,
1486         SCR_CLR (SCR_ACK),
1487                 0,
1488         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
1489                 PADDR_B (nego_bad_phase),
1490 }/*-------------------------< SEND_WDTR >------------------------*/,{
1491         /*
1492          *  Send the M_X_WIDE_REQ
1493          */
1494         SCR_MOVE_ABS (4) ^ SCR_MSG_OUT,
1495                 HADDR_1 (msgout),
1496         SCR_JUMP,
1497                 PADDR_B (msg_out_done),
1498 }/*-------------------------< SDTR_RESP >------------------------*/,{
1499         /*
1500          *  let the target fetch our answer.
1501          */
1502         SCR_SET (SCR_ATN),
1503                 0,
1504         SCR_CLR (SCR_ACK),
1505                 0,
1506         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
1507                 PADDR_B (nego_bad_phase),
1508 }/*-------------------------< SEND_SDTR >------------------------*/,{
1509         /*
1510          *  Send the M_X_SYNC_REQ
1511          */
1512         SCR_MOVE_ABS (5) ^ SCR_MSG_OUT,
1513                 HADDR_1 (msgout),
1514         SCR_JUMP,
1515                 PADDR_B (msg_out_done),
1516 }/*-------------------------< PPR_RESP >-------------------------*/,{
1517         /*
1518          *  let the target fetch our answer.
1519          */
1520         SCR_SET (SCR_ATN),
1521                 0,
1522         SCR_CLR (SCR_ACK),
1523                 0,
1524         SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_OUT)),
1525                 PADDR_B (nego_bad_phase),
1526 }/*-------------------------< SEND_PPR >-------------------------*/,{
1527         /*
1528          *  Send the M_X_PPR_REQ
1529          */
1530         SCR_MOVE_ABS (8) ^ SCR_MSG_OUT,
1531                 HADDR_1 (msgout),
1532         SCR_JUMP,
1533                 PADDR_B (msg_out_done),
1534 }/*-------------------------< NEGO_BAD_PHASE >-------------------*/,{
1535         SCR_INT,
1536                 SIR_NEGO_PROTO,
1537         SCR_JUMP,
1538                 PADDR_A (dispatch),
1539 }/*-------------------------< MSG_OUT >--------------------------*/,{
1540         /*
1541          *  The target requests a message.
1542          *  We donnot send messages that may
1543          *  require the device to go to bus free.
1544          */
1545         SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
1546                 HADDR_1 (msgout),
1547         /*
1548          *  ... wait for the next phase
1549          *  if it's a message out, send it again, ...
1550          */
1551         SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)),
1552                 PADDR_B (msg_out),
1553 }/*-------------------------< MSG_OUT_DONE >---------------------*/,{
1554         /*
1555          *  Let the C code be aware of the
1556          *  sent message and clear the message.
1557          */
1558         SCR_INT,
1559                 SIR_MSG_OUT_DONE,
1560         /*
1561          *  ... and process the next phase
1562          */
1563         SCR_JUMP,
1564                 PADDR_A (dispatch),
1565 }/*-------------------------< DATA_OVRUN >-----------------------*/,{
1566         /*
1567          *  Zero scratcha that will count the
1568          *  extras bytes.
1569          */
1570         SCR_COPY (4),
1571                 PADDR_B (zero),
1572                 RADDR_1 (scratcha),
1573 }/*-------------------------< DATA_OVRUN1 >----------------------*/,{
1574         /*
1575          *  The target may want to transfer too much data.
1576          *
1577          *  If phase is DATA OUT write 1 byte and count it.
1578          */
1579         SCR_JUMPR ^ IFFALSE (WHEN (SCR_DATA_OUT)),
1580                 16,
1581         SCR_CHMOV_ABS (1) ^ SCR_DATA_OUT,
1582                 HADDR_1 (scratch),
1583         SCR_JUMP,
1584                 PADDR_B (data_ovrun2),
1585         /*
1586          *  If WSR is set, clear this condition, and
1587          *  count this byte.
1588          */
1589         SCR_FROM_REG (scntl2),
1590                 0,
1591         SCR_JUMPR ^ IFFALSE (MASK (WSR, WSR)),
1592                 16,
1593         SCR_REG_REG (scntl2, SCR_OR, WSR),
1594                 0,
1595         SCR_JUMP,
1596                 PADDR_B (data_ovrun2),
1597         /*
1598          *  Finally check against DATA IN phase.
1599          *  Signal data overrun to the C code
1600          *  and jump to dispatcher if not so.
1601          *  Read 1 byte otherwise and count it.
1602          */
1603         SCR_JUMPR ^ IFTRUE (WHEN (SCR_DATA_IN)),
1604                 16,
1605         SCR_INT,
1606                 SIR_DATA_OVERRUN,
1607         SCR_JUMP,
1608                 PADDR_A (dispatch),
1609         SCR_CHMOV_ABS (1) ^ SCR_DATA_IN,
1610                 HADDR_1 (scratch),
1611 }/*-------------------------< DATA_OVRUN2 >----------------------*/,{
1612         /*
1613          *  Count this byte.
1614          *  This will allow to return a negative
1615          *  residual to user.
1616          */
1617         SCR_REG_REG (scratcha,  SCR_ADD,  0x01),
1618                 0,
1619         SCR_REG_REG (scratcha1, SCR_ADDC, 0),
1620                 0,
1621         SCR_REG_REG (scratcha2, SCR_ADDC, 0),
1622                 0,
1623         /*
1624          *  .. and repeat as required.
1625          */
1626         SCR_JUMP,
1627                 PADDR_B (data_ovrun1),
1628 }/*-------------------------< ABORT_RESEL >----------------------*/,{
1629         SCR_SET (SCR_ATN),
1630                 0,
1631         SCR_CLR (SCR_ACK),
1632                 0,
1633         /*
1634          *  send the abort/abortag/reset message
1635          *  we expect an immediate disconnect
1636          */
1637         SCR_REG_REG (scntl2, SCR_AND, 0x7f),
1638                 0,
1639         SCR_MOVE_ABS (1) ^ SCR_MSG_OUT,
1640                 HADDR_1 (msgout),
1641         SCR_CLR (SCR_ACK|SCR_ATN),
1642                 0,
1643         SCR_WAIT_DISC,
1644                 0,
1645         SCR_INT,
1646                 SIR_RESEL_ABORTED,
1647         SCR_JUMP,
1648                 PADDR_A (start),
1649 }/*-------------------------< RESEND_IDENT >---------------------*/,{
1650         /*
1651          *  The target stays in MSG OUT phase after having acked
1652          *  Identify [+ Tag [+ Extended message ]]. Targets shall
1653          *  behave this way on parity error.
1654          *  We must send it again all the messages.
1655          */
1656         SCR_SET (SCR_ATN), /* Shall be asserted 2 deskew delays before the  */
1657                 0,         /* 1rst ACK = 90 ns. Hope the chip isn't too fast */
1658         SCR_JUMP,
1659                 PADDR_A (send_ident),
1660 }/*-------------------------< IDENT_BREAK >----------------------*/,{
1661         SCR_CLR (SCR_ATN),
1662                 0,
1663         SCR_JUMP,
1664                 PADDR_A (select2),
1665 }/*-------------------------< IDENT_BREAK_ATN >------------------*/,{
1666         SCR_SET (SCR_ATN),
1667                 0,
1668         SCR_JUMP,
1669                 PADDR_A (select2),
1670 }/*-------------------------< SDATA_IN >-------------------------*/,{
1671         SCR_CHMOV_TBL ^ SCR_DATA_IN,
1672                 offsetof (struct sym_dsb, sense),
1673         SCR_CALL,
1674                 PADDR_A (datai_done),
1675         SCR_JUMP,
1676                 PADDR_B (data_ovrun),
1677 }/*-------------------------< RESEL_BAD_LUN >--------------------*/,{
1678         /*
1679          *  Message is an IDENTIFY, but lun is unknown.
1680          *  Signal problem to C code for logging the event.
1681          *  Send a M_ABORT to clear all pending tasks.
1682          */
1683         SCR_INT,
1684                 SIR_RESEL_BAD_LUN,
1685         SCR_JUMP,
1686                 PADDR_B (abort_resel),
1687 }/*-------------------------< BAD_I_T_L >------------------------*/,{
1688         /*
1689          *  We donnot have a task for that I_T_L.
1690          *  Signal problem to C code for logging the event.
1691          *  Send a M_ABORT message.
1692          */
1693         SCR_INT,
1694                 SIR_RESEL_BAD_I_T_L,
1695         SCR_JUMP,
1696                 PADDR_B (abort_resel),
1697 }/*-------------------------< BAD_I_T_L_Q >----------------------*/,{
1698         /*
1699          *  We donnot have a task that matches the tag.
1700          *  Signal problem to C code for logging the event.
1701          *  Send a M_ABORTTAG message.
1702          */
1703         SCR_INT,
1704                 SIR_RESEL_BAD_I_T_L_Q,
1705         SCR_JUMP,
1706                 PADDR_B (abort_resel),
1707 }/*-------------------------< BAD_STATUS >-----------------------*/,{
1708         /*
1709          *  Anything different from INTERMEDIATE
1710          *  CONDITION MET should be a bad SCSI status,
1711          *  given that GOOD status has already been tested.
1712          *  Call the C code.
1713          */
1714         SCR_COPY (4),
1715                 PADDR_B (startpos),
1716                 RADDR_1 (scratcha),
1717         SCR_INT ^ IFFALSE (DATA (S_COND_MET)),
1718                 SIR_BAD_SCSI_STATUS,
1719         SCR_RETURN,
1720                 0,
1721 }/*-------------------------< WSR_MA_HELPER >--------------------*/,{
1722         /*
1723          *  Helper for the C code when WSR bit is set.
1724          *  Perform the move of the residual byte.
1725          */
1726         SCR_CHMOV_TBL ^ SCR_DATA_IN,
1727                 offsetof (struct sym_ccb, phys.wresid),
1728         SCR_JUMP,
1729                 PADDR_A (dispatch),
1730
1731 }/*-------------------------< ZERO >-----------------------------*/,{
1732         SCR_DATA_ZERO,
1733 }/*-------------------------< SCRATCH >--------------------------*/,{
1734         SCR_DATA_ZERO, /* MUST BE BEFORE SCRATCH1 */
1735 }/*-------------------------< SCRATCH1 >-------------------------*/,{
1736         SCR_DATA_ZERO,
1737 }/*-------------------------< PREV_DONE >------------------------*/,{
1738         SCR_DATA_ZERO, /* MUST BE BEFORE DONE_POS ! */
1739 }/*-------------------------< DONE_POS >-------------------------*/,{
1740         SCR_DATA_ZERO,
1741 }/*-------------------------< NEXTJOB >--------------------------*/,{
1742         SCR_DATA_ZERO, /* MUST BE BEFORE STARTPOS ! */
1743 }/*-------------------------< STARTPOS >-------------------------*/,{
1744         SCR_DATA_ZERO,
1745 }/*-------------------------< TARGTBL >--------------------------*/,{
1746         SCR_DATA_ZERO,
1747 }/*--------------------------<>----------------------------------*/
1748 };
1749
1750 static struct SYM_FWZ_SCR SYM_FWZ_SCR = {
1751  /*-------------------------< SNOOPTEST >------------------------*/{
1752         /*
1753          *  Read the variable.
1754          */
1755         SCR_COPY (4),
1756                 HADDR_1 (scratch),
1757                 RADDR_1 (scratcha),
1758         /*
1759          *  Write the variable.
1760          */
1761         SCR_COPY (4),
1762                 RADDR_1 (temp),
1763                 HADDR_1 (scratch),
1764         /*
1765          *  Read back the variable.
1766          */
1767         SCR_COPY (4),
1768                 HADDR_1 (scratch),
1769                 RADDR_1 (temp),
1770 }/*-------------------------< SNOOPEND >-------------------------*/,{
1771         /*
1772          *  And stop.
1773          */
1774         SCR_INT,
1775                 99,
1776 }/*--------------------------<>----------------------------------*/
1777 };