sys/dev/disk/sym/sym_fw1.h

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