drivers/scsi/sym53c8xx_2/sym_hipd.h

   1 /*
   2  * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family
   3  * of PCI-SCSI IO processors.
   4  *
   5  * Copyright (C) 1999-2001  Gerard Roudier <groudier@free.fr>
   6  *
   7  * This driver is derived from the Linux sym53c8xx driver.
   8  * Copyright (C) 1998-2000  Gerard Roudier
   9  *
  10  * The sym53c8xx driver is derived from the ncr53c8xx driver that had been
  11  * a port of the FreeBSD ncr driver to Linux-1.2.13.
  12  *
  13  * The original ncr driver has been written for 386bsd and FreeBSD by
  14  *         Wolfgang Stanglmeier        <wolf@cologne.de>
  15  *         Stefan Esser                <se@mi.Uni-Koeln.de>
  16  * Copyright (C) 1994  Wolfgang Stanglmeier
  17  *
  18  * Other major contributions:
  19  *
  20  * NVRAM detection and reading.
  21  * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk>
  22  *
  23  *-----------------------------------------------------------------------------
  24  *
  25  * This program is free software; you can redistribute it and/or modify
  26  * it under the terms of the GNU General Public License as published by
  27  * the Free Software Foundation; either version 2 of the License, or
  28  * (at your option) any later version.
  29  *
  30  * This program is distributed in the hope that it will be useful,
  31  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  32  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33  * GNU General Public License for more details.
  34  *
  35  * You should have received a copy of the GNU General Public License
  36  * along with this program; if not, write to the Free Software
  37  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  38  */
  39
  40 #include <linux/gfp.h>
  41
  42 #ifndef SYM_HIPD_H
  43 #define SYM_HIPD_H
  44
  45 /*
  46  *  Generic driver options.
  47  *
  48  *  They may be defined in platform specific headers, if they
  49  *  are useful.
  50  *
  51  *    SYM_OPT_HANDLE_DIR_UNKNOWN
  52  *        When this option is set, the SCRIPTS used by the driver
  53  *        are able to handle SCSI transfers with direction not
  54  *        supplied by user.
  55  *        (set for Linux-2.0.X)
  56  *
  57  *    SYM_OPT_HANDLE_DEVICE_QUEUEING
  58  *        When this option is set, the driver will use a queue per
  59  *        device and handle QUEUE FULL status requeuing internally.
  60  *
  61  *    SYM_OPT_LIMIT_COMMAND_REORDERING
  62  *        When this option is set, the driver tries to limit tagged
  63  *        command reordering to some reasonnable value.
  64  *        (set for Linux)
  65  */
  66 #if 0
  67 #define SYM_OPT_HANDLE_DIR_UNKNOWN
  68 #define SYM_OPT_HANDLE_DEVICE_QUEUEING
  69 #define SYM_OPT_LIMIT_COMMAND_REORDERING
  70 #endif
  71
  72 /*
  73  *  Active debugging tags and verbosity.
  74  *  Both DEBUG_FLAGS and sym_verbose can be redefined
  75  *  by the platform specific code to something else.
  76  */
  77 #define DEBUG_ALLOC     (0x0001)
  78 #define DEBUG_PHASE     (0x0002)
  79 #define DEBUG_POLL      (0x0004)
  80 #define DEBUG_QUEUE     (0x0008)
  81 #define DEBUG_RESULT    (0x0010)
  82 #define DEBUG_SCATTER   (0x0020)
  83 #define DEBUG_SCRIPT    (0x0040)
  84 #define DEBUG_TINY      (0x0080)
  85 #define DEBUG_TIMING    (0x0100)
  86 #define DEBUG_NEGO      (0x0200)
  87 #define DEBUG_TAGS      (0x0400)
  88 #define DEBUG_POINTER   (0x0800)
  89
  90 #ifndef DEBUG_FLAGS
  91 #define DEBUG_FLAGS     (0x0000)
  92 #endif
  93
  94 #ifndef sym_verbose
  95 #define sym_verbose     (np->verbose)
  96 #endif
  97
  98 /*
  99  *  These ones should have been already defined.
 100  */
 101 #ifndef assert
 102 #define assert(expression) { \
 103         if (!(expression)) { \
 104                 (void)panic( \
 105                         "assertion \"%s\" failed: file \"%s\", line %d\n", \
 106                         #expression, \
 107                         __FILE__, __LINE__); \
 108         } \
 109 }
 110 #endif
 111
 112 /*
 113  *  Number of tasks per device we want to handle.
 114  */
 115 #if     SYM_CONF_MAX_TAG_ORDER > 8
 116 #error  "more than 256 tags per logical unit not allowed."
 117 #endif
 118 #define SYM_CONF_MAX_TASK       (1<<SYM_CONF_MAX_TAG_ORDER)
 119
 120 /*
 121  *  Donnot use more tasks that we can handle.
 122  */
 123 #ifndef SYM_CONF_MAX_TAG
 124 #define SYM_CONF_MAX_TAG        SYM_CONF_MAX_TASK
 125 #endif
 126 #if     SYM_CONF_MAX_TAG > SYM_CONF_MAX_TASK
 127 #undef  SYM_CONF_MAX_TAG
 128 #define SYM_CONF_MAX_TAG        SYM_CONF_MAX_TASK
 129 #endif
 130
 131 /*
 132  *    This one means 'NO TAG for this job'
 133  */
 134 #define NO_TAG  (256)
 135
 136 /*
 137  *  Number of SCSI targets.
 138  */
 139 #if     SYM_CONF_MAX_TARGET > 16
 140 #error  "more than 16 targets not allowed."
 141 #endif
 142
 143 /*
 144  *  Number of logical units per target.
 145  */
 146 #if     SYM_CONF_MAX_LUN > 64
 147 #error  "more than 64 logical units per target not allowed."
 148 #endif
 149
 150 /*
 151  *    Asynchronous pre-scaler (ns). Shall be 40 for
 152  *    the SCSI timings to be compliant.
 153  */
 154 #define SYM_CONF_MIN_ASYNC (40)
 155
 156
 157 /*
 158  * MEMORY ALLOCATOR.
 159  */
 160
 161 #define SYM_MEM_WARN    1       /* Warn on failed operations */
 162
 163 #define SYM_MEM_PAGE_ORDER 0    /* 1 PAGE  maximum */
 164 #define SYM_MEM_CLUSTER_SHIFT   (PAGE_SHIFT+SYM_MEM_PAGE_ORDER)
 165 #define SYM_MEM_FREE_UNUSED     /* Free unused pages immediately */
 166 /*
 167  *  Shortest memory chunk is (1<<SYM_MEM_SHIFT), currently 16.
 168  *  Actual allocations happen as SYM_MEM_CLUSTER_SIZE sized.
 169  *  (1 PAGE at a time is just fine).
 170  */
 171 #define SYM_MEM_SHIFT   4
 172 #define SYM_MEM_CLUSTER_SIZE    (1UL << SYM_MEM_CLUSTER_SHIFT)
 173 #define SYM_MEM_CLUSTER_MASK    (SYM_MEM_CLUSTER_SIZE-1)
 174
 175 /*
 176  *  Number of entries in the START and DONE queues.
 177  *
 178  *  We limit to 1 PAGE in order to succeed allocation of
 179  *  these queues. Each entry is 8 bytes long (2 DWORDS).
 180  */
 181 #ifdef  SYM_CONF_MAX_START
 182 #define SYM_CONF_MAX_QUEUE (SYM_CONF_MAX_START+2)
 183 #else
 184 #define SYM_CONF_MAX_QUEUE (7*SYM_CONF_MAX_TASK+2)
 185 #define SYM_CONF_MAX_START (SYM_CONF_MAX_QUEUE-2)
 186 #endif
 187
 188 #if     SYM_CONF_MAX_QUEUE > SYM_MEM_CLUSTER_SIZE/8
 189 #undef  SYM_CONF_MAX_QUEUE
 190 #define SYM_CONF_MAX_QUEUE (SYM_MEM_CLUSTER_SIZE/8)
 191 #undef  SYM_CONF_MAX_START
 192 #define SYM_CONF_MAX_START (SYM_CONF_MAX_QUEUE-2)
 193 #endif
 194
 195 /*
 196  *  For this one, we want a short name :-)
 197  */
 198 #define MAX_QUEUE       SYM_CONF_MAX_QUEUE
 199
 200 /*
 201  *  Common definitions for both bus space based and legacy IO methods.
 202  */
 203
 204 #define INB_OFF(np, o)          ioread8(np->s.ioaddr + (o))
 205 #define INW_OFF(np, o)          ioread16(np->s.ioaddr + (o))
 206 #define INL_OFF(np, o)          ioread32(np->s.ioaddr + (o))
 207
 208 #define OUTB_OFF(np, o, val)    iowrite8((val), np->s.ioaddr + (o))
 209 #define OUTW_OFF(np, o, val)    iowrite16((val), np->s.ioaddr + (o))
 210 #define OUTL_OFF(np, o, val)    iowrite32((val), np->s.ioaddr + (o))
 211
 212 #define INB(np, r)              INB_OFF(np, offsetof(struct sym_reg, r))
 213 #define INW(np, r)              INW_OFF(np, offsetof(struct sym_reg, r))
 214 #define INL(np, r)              INL_OFF(np, offsetof(struct sym_reg, r))
 215
 216 #define OUTB(np, r, v)          OUTB_OFF(np, offsetof(struct sym_reg, r), (v))
 217 #define OUTW(np, r, v)          OUTW_OFF(np, offsetof(struct sym_reg, r), (v))
 218 #define OUTL(np, r, v)          OUTL_OFF(np, offsetof(struct sym_reg, r), (v))
 219
 220 #define OUTONB(np, r, m)        OUTB(np, r, INB(np, r) | (m))
 221 #define OUTOFFB(np, r, m)       OUTB(np, r, INB(np, r) & ~(m))
 222 #define OUTONW(np, r, m)        OUTW(np, r, INW(np, r) | (m))
 223 #define OUTOFFW(np, r, m)       OUTW(np, r, INW(np, r) & ~(m))
 224 #define OUTONL(np, r, m)        OUTL(np, r, INL(np, r) | (m))
 225 #define OUTOFFL(np, r, m)       OUTL(np, r, INL(np, r) & ~(m))
 226
 227 /*
 228  *  We normally want the chip to have a consistent view
 229  *  of driver internal data structures when we restart it.
 230  *  Thus these macros.
 231  */
 232 #define OUTL_DSP(np, v)                         \
 233         do {                                    \
 234                 MEMORY_WRITE_BARRIER();         \
 235                 OUTL(np, nc_dsp, (v));          \
 236         } while (0)
 237
 238 #define OUTONB_STD()                            \
 239         do {                                    \
 240                 MEMORY_WRITE_BARRIER();         \
 241                 OUTONB(np, nc_dcntl, (STD|NOCOM));      \
 242         } while (0)
 243
 244 /*
 245  *  Command control block states.
 246  */
 247 #define HS_IDLE         (0)
 248 #define HS_BUSY         (1)
 249 #define HS_NEGOTIATE    (2)     /* sync/wide data transfer*/
 250 #define HS_DISCONNECT   (3)     /* Disconnected by target */
 251 #define HS_WAIT         (4)     /* waiting for resource   */
 252
 253 #define HS_DONEMASK     (0x80)
 254 #define HS_COMPLETE     (4|HS_DONEMASK)
 255 #define HS_SEL_TIMEOUT  (5|HS_DONEMASK) /* Selection timeout      */
 256 #define HS_UNEXPECTED   (6|HS_DONEMASK) /* Unexpected disconnect  */
 257 #define HS_COMP_ERR     (7|HS_DONEMASK) /* Completed with error   */
 258
 259 /*
 260  *  Software Interrupt Codes
 261  */
 262 #define SIR_BAD_SCSI_STATUS     (1)
 263 #define SIR_SEL_ATN_NO_MSG_OUT  (2)
 264 #define SIR_MSG_RECEIVED        (3)
 265 #define SIR_MSG_WEIRD           (4)
 266 #define SIR_NEGO_FAILED         (5)
 267 #define SIR_NEGO_PROTO          (6)
 268 #define SIR_SCRIPT_STOPPED      (7)
 269 #define SIR_REJECT_TO_SEND      (8)
 270 #define SIR_SWIDE_OVERRUN       (9)
 271 #define SIR_SODL_UNDERRUN       (10)
 272 #define SIR_RESEL_NO_MSG_IN     (11)
 273 #define SIR_RESEL_NO_IDENTIFY   (12)
 274 #define SIR_RESEL_BAD_LUN       (13)
 275 #define SIR_TARGET_SELECTED     (14)
 276 #define SIR_RESEL_BAD_I_T_L     (15)
 277 #define SIR_RESEL_BAD_I_T_L_Q   (16)
 278 #define SIR_ABORT_SENT          (17)
 279 #define SIR_RESEL_ABORTED       (18)
 280 #define SIR_MSG_OUT_DONE        (19)
 281 #define SIR_COMPLETE_ERROR      (20)
 282 #define SIR_DATA_OVERRUN        (21)
 283 #define SIR_BAD_PHASE           (22)
 284 #if     SYM_CONF_DMA_ADDRESSING_MODE == 2
 285 #define SIR_DMAP_DIRTY          (23)
 286 #define SIR_MAX                 (23)
 287 #else
 288 #define SIR_MAX                 (22)
 289 #endif
 290
 291 /*
 292  *  Extended error bit codes.
 293  *  xerr_status field of struct sym_ccb.
 294  */
 295 #define XE_EXTRA_DATA   (1)     /* unexpected data phase         */
 296 #define XE_BAD_PHASE    (1<<1)  /* illegal phase (4/5)           */
 297 #define XE_PARITY_ERR   (1<<2)  /* unrecovered SCSI parity error */
 298 #define XE_SODL_UNRUN   (1<<3)  /* ODD transfer in DATA OUT phase */
 299 #define XE_SWIDE_OVRUN  (1<<4)  /* ODD transfer in DATA IN phase */
 300
 301 /*
 302  *  Negotiation status.
 303  *  nego_status field of struct sym_ccb.
 304  */
 305 #define NS_SYNC         (1)
 306 #define NS_WIDE         (2)
 307 #define NS_PPR          (3)
 308
 309 /*
 310  *  A CCB hashed table is used to retrieve CCB address
 311  *  from DSA value.
 312  */
 313 #define CCB_HASH_SHIFT          8
 314 #define CCB_HASH_SIZE           (1UL << CCB_HASH_SHIFT)
 315 #define CCB_HASH_MASK           (CCB_HASH_SIZE-1)
 316 #if 1
 317 #define CCB_HASH_CODE(dsa)      \
 318         (((dsa) >> (_LGRU16_(sizeof(struct sym_ccb)))) & CCB_HASH_MASK)
 319 #else
 320 #define CCB_HASH_CODE(dsa)      (((dsa) >> 9) & CCB_HASH_MASK)
 321 #endif
 322
 323 #if     SYM_CONF_DMA_ADDRESSING_MODE == 2
 324 /*
 325  *  We may want to use segment registers for 64 bit DMA.
 326  *  16 segments registers -> up to 64 GB addressable.
 327  */
 328 #define SYM_DMAP_SHIFT  (4)
 329 #define SYM_DMAP_SIZE   (1u<<SYM_DMAP_SHIFT)
 330 #define SYM_DMAP_MASK   (SYM_DMAP_SIZE-1)
 331 #endif
 332
 333 /*
 334  *  Device flags.
 335  */
 336 #define SYM_DISC_ENABLED        (1)
 337 #define SYM_TAGS_ENABLED        (1<<1)
 338 #define SYM_SCAN_BOOT_DISABLED  (1<<2)
 339 #define SYM_SCAN_LUNS_DISABLED  (1<<3)
 340
 341 /*
 342  *  Host adapter miscellaneous flags.
 343  */
 344 #define SYM_AVOID_BUS_RESET     (1)
 345
 346 /*
 347  *  Misc.
 348  */
 349 #define SYM_SNOOP_TIMEOUT (10000000)
 350 #define BUS_8_BIT       0
 351 #define BUS_16_BIT      1
 352
 353 /*
 354  *  Gather negotiable parameters value
 355  */
 356 struct sym_trans {
 357         u8 period;
 358         u8 offset;
 359         unsigned int width:1;
 360         unsigned int iu:1;
 361         unsigned int dt:1;
 362         unsigned int qas:1;
 363         unsigned int check_nego:1;
 364 };
 365
 366 /*
 367  *  Global TCB HEADER.
 368  *
 369  *  Due to lack of indirect addressing on earlier NCR chips,
 370  *  this substructure is copied from the TCB to a global
 371  *  address after selection.
 372  *  For SYMBIOS chips that support LOAD/STORE this copy is
 373  *  not needed and thus not performed.
 374  */
 375 struct sym_tcbh {
 376         /*
 377          *  Scripts bus addresses of LUN table accessed from scripts.
 378          *  LUN #0 is a special case, since multi-lun devices are rare,
 379          *  and we we want to speed-up the general case and not waste
 380          *  resources.
 381          */
 382         u32     luntbl_sa;      /* bus address of this table    */
 383         u32     lun0_sa;        /* bus address of LCB #0        */
 384         /*
 385          *  Actual SYNC/WIDE IO registers value for this target.
 386          *  'sval', 'wval' and 'uval' are read from SCRIPTS and
 387          *  so have alignment constraints.
 388          */
 389 /*0*/   u_char  uval;           /* -> SCNTL4 register           */
 390 /*1*/   u_char  sval;           /* -> SXFER  io register        */
 391 /*2*/   u_char  filler1;
 392 /*3*/   u_char  wval;           /* -> SCNTL3 io register        */
 393 };
 394
 395 /*
 396  *  Target Control Block
 397  */
 398 struct sym_tcb {
 399         /*
 400          *  TCB header.
 401          *  Assumed at offset 0.
 402          */
 403 /*0*/   struct sym_tcbh head;
 404
 405         /*
 406          *  LUN table used by the SCRIPTS processor.
 407          *  An array of bus addresses is used on reselection.
 408          */
 409         u32     *luntbl;        /* LCBs bus address table       */
 410
 411         /*
 412          *  LUN table used by the C code.
 413          */
 414         struct sym_lcb *lun0p;          /* LCB of LUN #0 (usual case)   */
 415 #if SYM_CONF_MAX_LUN > 1
 416         struct sym_lcb **lunmp;         /* Other LCBs [1..MAX_LUN]      */
 417 #endif
 418
 419         /*
 420          *  Bitmap that tells about LUNs that succeeded at least
 421          *  1 IO and therefore assumed to be a real device.
 422          *  Avoid useless allocation of the LCB structure.
 423          */
 424         u32     lun_map[(SYM_CONF_MAX_LUN+31)/32];
 425
 426         /*
 427          *  Bitmap that tells about LUNs that haven't yet an LCB
 428          *  allocated (not discovered or LCB allocation failed).
 429          */
 430         u32     busy0_map[(SYM_CONF_MAX_LUN+31)/32];
 431
 432 #ifdef  SYM_HAVE_STCB
 433         /*
 434          *  O/S specific data structure.
 435          */
 436         struct sym_stcb s;
 437 #endif
 438
 439         /* Transfer goal */
 440         struct sym_trans tgoal;
 441
 442         /*
 443          * Keep track of the CCB used for the negotiation in order
 444          * to ensure that only 1 negotiation is queued at a time.
 445          */
 446         struct sym_ccb *  nego_cp;      /* CCB used for the nego                */
 447
 448         /*
 449          *  Set when we want to reset the device.
 450          */
 451         u_char  to_reset;
 452
 453         /*
 454          *  Other user settable limits and options.
 455          *  These limits are read from the NVRAM if present.
 456          */
 457         u_char  usrflags;
 458         u_short usrtags;
 459         struct scsi_target *starget;
 460 };
 461
 462 /*
 463  *  Global LCB HEADER.
 464  *
 465  *  Due to lack of indirect addressing on earlier NCR chips,
 466  *  this substructure is copied from the LCB to a global
 467  *  address after selection.
 468  *  For SYMBIOS chips that support LOAD/STORE this copy is
 469  *  not needed and thus not performed.
 470  */
 471 struct sym_lcbh {
 472         /*
 473          *  SCRIPTS address jumped by SCRIPTS on reselection.
 474          *  For not probed logical units, this address points to
 475          *  SCRIPTS that deal with bad LU handling (must be at
 476          *  offset zero of the LCB for that reason).
 477          */
 478 /*0*/   u32     resel_sa;
 479
 480         /*
 481          *  Task (bus address of a CCB) read from SCRIPTS that points
 482          *  to the unique ITL nexus allowed to be disconnected.
 483          */
 484         u32     itl_task_sa;
 485
 486         /*
 487          *  Task table bus address (read from SCRIPTS).
 488          */
 489         u32     itlq_tbl_sa;
 490 };
 491
 492 /*
 493  *  Logical Unit Control Block
 494  */
 495 struct sym_lcb {
 496         /*
 497          *  TCB header.
 498          *  Assumed at offset 0.
 499          */
 500 /*0*/   struct sym_lcbh head;
 501
 502         /*
 503          *  Task table read from SCRIPTS that contains pointers to
 504          *  ITLQ nexuses. The bus address read from SCRIPTS is
 505          *  inside the header.
 506          */
 507         u32     *itlq_tbl;      /* Kernel virtual address       */
 508
 509         /*
 510          *  Busy CCBs management.
 511          */
 512         u_short busy_itlq;      /* Number of busy tagged CCBs   */
 513         u_short busy_itl;       /* Number of busy untagged CCBs */
 514
 515         /*
 516          *  Circular tag allocation buffer.
 517          */
 518         u_short ia_tag;         /* Tag allocation index         */
 519         u_short if_tag;         /* Tag release index            */
 520         u_char  *cb_tags;       /* Circular tags buffer         */
 521
 522         /*
 523          *  O/S specific data structure.
 524          */
 525 #ifdef  SYM_HAVE_SLCB
 526         struct sym_slcb s;
 527 #endif
 528
 529 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
 530         /*
 531          *  Optionnaly the driver can handle device queueing,
 532          *  and requeues internally command to redo.
 533          */
 534         SYM_QUEHEAD waiting_ccbq;
 535         SYM_QUEHEAD started_ccbq;
 536         int     num_sgood;
 537         u_short started_tags;
 538         u_short started_no_tag;
 539         u_short started_max;
 540         u_short started_limit;
 541 #endif
 542
 543 #ifdef SYM_OPT_LIMIT_COMMAND_REORDERING
 544         /*
 545          *  Optionally the driver can try to prevent SCSI
 546          *  IOs from being reordered too much.
 547          */
 548         u_char          tags_si;        /* Current index to tags sum    */
 549         u_short         tags_sum[2];    /* Tags sum counters            */
 550         u_short         tags_since;     /* # of tags since last switch  */
 551 #endif
 552
 553         /*
 554          *  Set when we want to clear all tasks.
 555          */
 556         u_char to_clear;
 557
 558         /*
 559          *  Capabilities.
 560          */
 561         u_char  user_flags;
 562         u_char  curr_flags;
 563 };
 564
 565 /*
 566  *  Action from SCRIPTS on a task.
 567  *  Is part of the CCB, but is also used separately to plug
 568  *  error handling action to perform from SCRIPTS.
 569  */
 570 struct sym_actscr {
 571         u32     start;          /* Jumped by SCRIPTS after selection    */
 572         u32     restart;        /* Jumped by SCRIPTS on relection       */
 573 };
 574
 575 /*
 576  *  Phase mismatch context.
 577  *
 578  *  It is part of the CCB and is used as parameters for the
 579  *  DATA pointer. We need two contexts to handle correctly the
 580  *  SAVED DATA POINTER.
 581  */
 582 struct sym_pmc {
 583         struct  sym_tblmove sg; /* Updated interrupted SG block */
 584         u32     ret;            /* SCRIPT return address        */
 585 };
 586
 587 /*
 588  *  LUN control block lookup.
 589  *  We use a direct pointer for LUN #0, and a table of
 590  *  pointers which is only allocated for devices that support
 591  *  LUN(s) > 0.
 592  */
 593 #if SYM_CONF_MAX_LUN <= 1
 594 #define sym_lp(tp, lun) (!lun) ? (tp)->lun0p : NULL
 595 #else
 596 #define sym_lp(tp, lun) \
 597         (!lun) ? (tp)->lun0p : (tp)->lunmp ? (tp)->lunmp[(lun)] : NULL
 598 #endif
 599
 600 /*
 601  *  Status are used by the host and the script processor.
 602  *
 603  *  The last four bytes (status[4]) are copied to the
 604  *  scratchb register (declared as scr0..scr3) just after the
 605  *  select/reselect, and copied back just after disconnecting.
 606  *  Inside the script the XX_REG are used.
 607  */
 608
 609 /*
 610  *  Last four bytes (script)
 611  */
 612 #define  HX_REG scr0
 613 #define  HX_PRT nc_scr0
 614 #define  HS_REG scr1
 615 #define  HS_PRT nc_scr1
 616 #define  SS_REG scr2
 617 #define  SS_PRT nc_scr2
 618 #define  HF_REG scr3
 619 #define  HF_PRT nc_scr3
 620
 621 /*
 622  *  Last four bytes (host)
 623  */
 624 #define  host_xflags   phys.head.status[0]
 625 #define  host_status   phys.head.status[1]
 626 #define  ssss_status   phys.head.status[2]
 627 #define  host_flags    phys.head.status[3]
 628
 629 /*
 630  *  Host flags
 631  */
 632 #define HF_IN_PM0       1u
 633 #define HF_IN_PM1       (1u<<1)
 634 #define HF_ACT_PM       (1u<<2)
 635 #define HF_DP_SAVED     (1u<<3)
 636 #define HF_SENSE        (1u<<4)
 637 #define HF_EXT_ERR      (1u<<5)
 638 #define HF_DATA_IN      (1u<<6)
 639 #ifdef SYM_CONF_IARB_SUPPORT
 640 #define HF_HINT_IARB    (1u<<7)
 641 #endif
 642
 643 /*
 644  *  More host flags
 645  */
 646 #if     SYM_CONF_DMA_ADDRESSING_MODE == 2
 647 #define HX_DMAP_DIRTY   (1u<<7)
 648 #endif
 649
 650 /*
 651  *  Global CCB HEADER.
 652  *
 653  *  Due to lack of indirect addressing on earlier NCR chips,
 654  *  this substructure is copied from the ccb to a global
 655  *  address after selection (or reselection) and copied back
 656  *  before disconnect.
 657  *  For SYMBIOS chips that support LOAD/STORE this copy is
 658  *  not needed and thus not performed.
 659  */
 660
 661 struct sym_ccbh {
 662         /*
 663          *  Start and restart SCRIPTS addresses (must be at 0).
 664          */
 665 /*0*/   struct sym_actscr go;
 666
 667         /*
 668          *  SCRIPTS jump address that deal with data pointers.
 669          *  'savep' points to the position in the script responsible
 670          *  for the actual transfer of data.
 671          *  It's written on reception of a SAVE_DATA_POINTER message.
 672          */
 673         u32     savep;          /* Jump address to saved data pointer   */
 674         u32     lastp;          /* SCRIPTS address at end of data       */
 675 #ifdef  SYM_OPT_HANDLE_DIR_UNKNOWN
 676         u32     wlastp;
 677 #endif
 678
 679         /*
 680          *  Status fields.
 681          */
 682         u8      status[4];
 683 };
 684
 685 /*
 686  *  GET/SET the value of the data pointer used by SCRIPTS.
 687  *
 688  *  We must distinguish between the LOAD/STORE-based SCRIPTS
 689  *  that use directly the header in the CCB, and the NCR-GENERIC
 690  *  SCRIPTS that use the copy of the header in the HCB.
 691  */
 692 #if     SYM_CONF_GENERIC_SUPPORT
 693 #define sym_set_script_dp(np, cp, dp)                           \
 694         do {                                                    \
 695                 if (np->features & FE_LDSTR)                    \
 696                         cp->phys.head.lastp = cpu_to_scr(dp);   \
 697                 else                                            \
 698                         np->ccb_head.lastp = cpu_to_scr(dp);    \
 699         } while (0)
 700 #define sym_get_script_dp(np, cp)                               \
 701         scr_to_cpu((np->features & FE_LDSTR) ?                  \
 702                 cp->phys.head.lastp : np->ccb_head.lastp)
 703 #else
 704 #define sym_set_script_dp(np, cp, dp)                           \
 705         do {                                                    \
 706                 cp->phys.head.lastp = cpu_to_scr(dp);           \
 707         } while (0)
 708
 709 #define sym_get_script_dp(np, cp) (cp->phys.head.lastp)
 710 #endif
 711
 712 /*
 713  *  Data Structure Block
 714  *
 715  *  During execution of a ccb by the script processor, the
 716  *  DSA (data structure address) register points to this
 717  *  substructure of the ccb.
 718  */
 719 struct sym_dsb {
 720         /*
 721          *  CCB header.
 722          *  Also assumed at offset 0 of the sym_ccb structure.
 723          */
 724 /*0*/   struct sym_ccbh head;
 725
 726         /*
 727          *  Phase mismatch contexts.
 728          *  We need two to handle correctly the SAVED DATA POINTER.
 729          *  MUST BOTH BE AT OFFSET < 256, due to using 8 bit arithmetic
 730          *  for address calculation from SCRIPTS.
 731          */
 732         struct sym_pmc pm0;
 733         struct sym_pmc pm1;
 734
 735         /*
 736          *  Table data for Script
 737          */
 738         struct sym_tblsel  select;
 739         struct sym_tblmove smsg;
 740         struct sym_tblmove smsg_ext;
 741         struct sym_tblmove cmd;
 742         struct sym_tblmove sense;
 743         struct sym_tblmove wresid;
 744         struct sym_tblmove data [SYM_CONF_MAX_SG];
 745 };
 746
 747 /*
 748  *  Our Command Control Block
 749  */
 750 struct sym_ccb {
 751         /*
 752          *  This is the data structure which is pointed by the DSA
 753          *  register when it is executed by the script processor.
 754          *  It must be the first entry.
 755          */
 756         struct sym_dsb phys;
 757
 758         /*
 759          *  Pointer to CAM ccb and related stuff.
 760          */
 761         struct scsi_cmnd *cmd;  /* CAM scsiio ccb               */
 762         u8      cdb_buf[16];    /* Copy of CDB                  */
 763 #define SYM_SNS_BBUF_LEN 32
 764         u8      sns_bbuf[SYM_SNS_BBUF_LEN]; /* Bounce buffer for sense data */
 765         int     data_len;       /* Total data length            */
 766         int     segments;       /* Number of SG segments        */
 767
 768         u8      order;          /* Tag type (if tagged command) */
 769         unsigned char odd_byte_adjustment;      /* odd-sized req on wide bus */
 770
 771         u_char  nego_status;    /* Negotiation status           */
 772         u_char  xerr_status;    /* Extended error flags         */
 773         u32     extra_bytes;    /* Extraneous bytes transferred */
 774
 775         /*
 776          *  Message areas.
 777          *  We prepare a message to be sent after selection.
 778          *  We may use a second one if the command is rescheduled
 779          *  due to CHECK_CONDITION or COMMAND TERMINATED.
 780          *  Contents are IDENTIFY and SIMPLE_TAG.
 781          *  While negotiating sync or wide transfer,
 782          *  a SDTR or WDTR message is appended.
 783          */
 784         u_char  scsi_smsg [12];
 785         u_char  scsi_smsg2[12];
 786
 787         /*
 788          *  Auto request sense related fields.
 789          */
 790         u_char  sensecmd[6];    /* Request Sense command        */
 791         u_char  sv_scsi_status; /* Saved SCSI status            */
 792         u_char  sv_xerr_status; /* Saved extended status        */
 793         int     sv_resid;       /* Saved residual               */
 794
 795         /*
 796          *  Other fields.
 797          */
 798         u32     ccb_ba;         /* BUS address of this CCB      */
 799         u_short tag;            /* Tag for this transfer        */
 800                                 /*  NO_TAG means no tag         */
 801         u_char  target;
 802         u_char  lun;
 803         struct sym_ccb *link_ccbh;      /* Host adapter CCB hash chain  */
 804         SYM_QUEHEAD link_ccbq;  /* Link to free/busy CCB queue  */
 805         u32     startp;         /* Initial data pointer         */
 806         u32     goalp;          /* Expected last data pointer   */
 807 #ifdef  SYM_OPT_HANDLE_DIR_UNKNOWN
 808         u32     wgoalp;
 809 #endif
 810         int     ext_sg;         /* Extreme data pointer, used   */
 811         int     ext_ofs;        /*  to calculate the residual.  */
 812 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
 813         SYM_QUEHEAD link2_ccbq; /* Link for device queueing     */
 814         u_char  started;        /* CCB queued to the squeue     */
 815 #endif
 816         u_char  to_abort;       /* Want this IO to be aborted   */
 817 #ifdef SYM_OPT_LIMIT_COMMAND_REORDERING
 818         u_char  tags_si;        /* Lun tags sum index (0,1)     */
 819 #endif
 820 };
 821
 822 #define CCB_BA(cp,lbl)  cpu_to_scr(cp->ccb_ba + offsetof(struct sym_ccb, lbl))
 823
 824 #ifdef  SYM_OPT_HANDLE_DIR_UNKNOWN
 825 #define sym_goalp(cp) ((cp->host_flags & HF_DATA_IN) ? cp->goalp : cp->wgoalp)
 826 #else
 827 #define sym_goalp(cp) (cp->goalp)
 828 #endif
 829
 830 typedef struct device *m_pool_ident_t;
 831
 832 /*
 833  *  Host Control Block
 834  */
 835 struct sym_hcb {
 836         /*
 837          *  Global headers.
 838          *  Due to poorness of addressing capabilities, earlier
 839          *  chips (810, 815, 825) copy part of the data structures
 840          *  (CCB, TCB and LCB) in fixed areas.
 841          */
 842 #if     SYM_CONF_GENERIC_SUPPORT
 843         struct sym_ccbh ccb_head;
 844         struct sym_tcbh tcb_head;
 845         struct sym_lcbh lcb_head;
 846 #endif
 847         /*
 848          *  Idle task and invalid task actions and
 849          *  their bus addresses.
 850          */
 851         struct sym_actscr idletask, notask, bad_itl, bad_itlq;
 852         u32 idletask_ba, notask_ba, bad_itl_ba, bad_itlq_ba;
 853
 854         /*
 855          *  Dummy lun table to protect us against target
 856          *  returning bad lun number on reselection.
 857          */
 858         u32     *badluntbl;     /* Table physical address       */
 859         u32     badlun_sa;      /* SCRIPT handler BUS address   */
 860
 861         /*
 862          *  Bus address of this host control block.
 863          */
 864         u32     hcb_ba;
 865
 866         /*
 867          *  Bit 32-63 of the on-chip RAM bus address in LE format.
 868          *  The START_RAM64 script loads the MMRS and MMWS from this
 869          *  field.
 870          */
 871         u32     scr_ram_seg;
 872
 873         /*
 874          *  Initial value of some IO register bits.
 875          *  These values are assumed to have been set by BIOS, and may
 876          *  be used to probe adapter implementation differences.
 877          */
 878         u_char  sv_scntl0, sv_scntl3, sv_dmode, sv_dcntl, sv_ctest3, sv_ctest4,
 879                 sv_ctest5, sv_gpcntl, sv_stest2, sv_stest4, sv_scntl4,
 880                 sv_stest1;
 881
 882         /*
 883          *  Actual initial value of IO register bits used by the
 884          *  driver. They are loaded at initialisation according to
 885          *  features that are to be enabled/disabled.
 886          */
 887         u_char  rv_scntl0, rv_scntl3, rv_dmode, rv_dcntl, rv_ctest3, rv_ctest4,
 888                 rv_ctest5, rv_stest2, rv_ccntl0, rv_ccntl1, rv_scntl4;
 889
 890         /*
 891          *  Target data.
 892          */
 893         struct sym_tcb  target[SYM_CONF_MAX_TARGET];
 894
 895         /*
 896          *  Target control block bus address array used by the SCRIPT
 897          *  on reselection.
 898          */
 899         u32             *targtbl;
 900         u32             targtbl_ba;
 901
 902         /*
 903          *  DMA pool handle for this HBA.
 904          */
 905         m_pool_ident_t  bus_dmat;
 906
 907         /*
 908          *  O/S specific data structure
 909          */
 910         struct sym_shcb s;
 911
 912         /*
 913          *  Physical bus addresses of the chip.
 914          */
 915         u32             mmio_ba;        /* MMIO 32 bit BUS address      */
 916         int             mmio_ws;        /* MMIO Window size             */
 917
 918         u32             ram_ba;         /* RAM 32 bit BUS address       */
 919         int             ram_ws;         /* RAM window size              */
 920
 921         /*
 922          *  SCRIPTS virtual and physical bus addresses.
 923          *  'script'  is loaded in the on-chip RAM if present.
 924          *  'scripth' stays in main memory for all chips except the
 925          *  53C895A, 53C896 and 53C1010 that provide 8K on-chip RAM.
 926          */
 927         u_char          *scripta0;      /* Copy of scripts A, B, Z      */
 928         u_char          *scriptb0;
 929         u_char          *scriptz0;
 930         u32             scripta_ba;     /* Actual scripts A, B, Z       */
 931         u32             scriptb_ba;     /* 32 bit bus addresses.        */
 932         u32             scriptz_ba;
 933         u_short         scripta_sz;     /* Actual size of script A, B, Z*/
 934         u_short         scriptb_sz;
 935         u_short         scriptz_sz;
 936
 937         /*
 938          *  Bus addresses, setup and patch methods for
 939          *  the selected firmware.
 940          */
 941         struct sym_fwa_ba fwa_bas;      /* Useful SCRIPTA bus addresses */
 942         struct sym_fwb_ba fwb_bas;      /* Useful SCRIPTB bus addresses */
 943         struct sym_fwz_ba fwz_bas;      /* Useful SCRIPTZ bus addresses */
 944         void            (*fw_setup)(struct sym_hcb *np, struct sym_fw *fw);
 945         void            (*fw_patch)(struct sym_hcb *np);
 946         char            *fw_name;
 947
 948         /*
 949          *  General controller parameters and configuration.
 950          */
 951         u_short device_id;      /* PCI device id                */
 952         u_char  revision_id;    /* PCI device revision id       */
 953         u_int   features;       /* Chip features map            */
 954         u_char  myaddr;         /* SCSI id of the adapter       */
 955         u_char  maxburst;       /* log base 2 of dwords burst   */
 956         u_char  maxwide;        /* Maximum transfer width       */
 957         u_char  minsync;        /* Min sync period factor (ST)  */
 958         u_char  maxsync;        /* Max sync period factor (ST)  */
 959         u_char  maxoffs;        /* Max scsi offset        (ST)  */
 960         u_char  minsync_dt;     /* Min sync period factor (DT)  */
 961         u_char  maxsync_dt;     /* Max sync period factor (DT)  */
 962         u_char  maxoffs_dt;     /* Max scsi offset        (DT)  */
 963         u_char  multiplier;     /* Clock multiplier (1,2,4)     */
 964         u_char  clock_divn;     /* Number of clock divisors     */
 965         u32     clock_khz;      /* SCSI clock frequency in KHz  */
 966         u32     pciclk_khz;     /* Estimated PCI clock  in KHz  */
 967         /*
 968          *  Start queue management.
 969          *  It is filled up by the host processor and accessed by the
 970          *  SCRIPTS processor in order to start SCSI commands.
 971          */
 972         volatile                /* Prevent code optimizations   */
 973         u32     *squeue;        /* Start queue virtual address  */
 974         u32     squeue_ba;      /* Start queue BUS address      */
 975         u_short squeueput;      /* Next free slot of the queue  */
 976         u_short actccbs;        /* Number of allocated CCBs     */
 977
 978         /*
 979          *  Command completion queue.
 980          *  It is the same size as the start queue to avoid overflow.
 981          */
 982         u_short dqueueget;      /* Next position to scan        */
 983         volatile                /* Prevent code optimizations   */
 984         u32     *dqueue;        /* Completion (done) queue      */
 985         u32     dqueue_ba;      /* Done queue BUS address       */
 986
 987         /*
 988          *  Miscellaneous buffers accessed by the scripts-processor.
 989          *  They shall be DWORD aligned, because they may be read or
 990          *  written with a script command.
 991          */
 992         u_char          msgout[8];      /* Buffer for MESSAGE OUT       */
 993         u_char          msgin [8];      /* Buffer for MESSAGE IN        */
 994         u32             lastmsg;        /* Last SCSI message sent       */
 995         u32             scratch;        /* Scratch for SCSI receive     */
 996                                         /* Also used for cache test     */
 997         /*
 998          *  Miscellaneous configuration and status parameters.
 999          */
1000         u_char          usrflags;       /* Miscellaneous user flags     */
1001         u_char          scsi_mode;      /* Current SCSI BUS mode        */
1002         u_char          verbose;        /* Verbosity for this controller*/
1003
1004         /*
1005          *  CCB lists and queue.
1006          */
1007         struct sym_ccb **ccbh;                  /* CCBs hashed by DSA value     */
1008                                         /* CCB_HASH_SIZE lists of CCBs  */
1009         SYM_QUEHEAD     free_ccbq;      /* Queue of available CCBs      */
1010         SYM_QUEHEAD     busy_ccbq;      /* Queue of busy CCBs           */
1011
1012         /*
1013          *  During error handling and/or recovery,
1014          *  active CCBs that are to be completed with
1015          *  error or requeued are moved from the busy_ccbq
1016          *  to the comp_ccbq prior to completion.
1017          */
1018         SYM_QUEHEAD     comp_ccbq;
1019
1020 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
1021         SYM_QUEHEAD     dummy_ccbq;
1022 #endif
1023
1024         /*
1025          *  IMMEDIATE ARBITRATION (IARB) control.
1026          *
1027          *  We keep track in 'last_cp' of the last CCB that has been
1028          *  queued to the SCRIPTS processor and clear 'last_cp' when
1029          *  this CCB completes. If last_cp is not zero at the moment
1030          *  we queue a new CCB, we set a flag in 'last_cp' that is
1031          *  used by the SCRIPTS as a hint for setting IARB.
1032          *  We donnot set more than 'iarb_max' consecutive hints for
1033          *  IARB in order to leave devices a chance to reselect.
1034          *  By the way, any non zero value of 'iarb_max' is unfair. :)
1035          */
1036 #ifdef SYM_CONF_IARB_SUPPORT
1037         u_short         iarb_max;       /* Max. # consecutive IARB hints*/
1038         u_short         iarb_count;     /* Actual # of these hints      */
1039         struct sym_ccb *        last_cp;
1040 #endif
1041
1042         /*
1043          *  Command abort handling.
1044          *  We need to synchronize tightly with the SCRIPTS
1045          *  processor in order to handle things correctly.
1046          */
1047         u_char          abrt_msg[4];    /* Message to send buffer       */
1048         struct sym_tblmove abrt_tbl;    /* Table for the MOV of it      */
1049         struct sym_tblsel  abrt_sel;    /* Sync params for selection    */
1050         u_char          istat_sem;      /* Tells the chip to stop (SEM) */
1051
1052         /*
1053          *  64 bit DMA handling.
1054          */
1055 #if     SYM_CONF_DMA_ADDRESSING_MODE != 0
1056         u_char  use_dac;                /* Use PCI DAC cycles           */
1057 #if     SYM_CONF_DMA_ADDRESSING_MODE == 2
1058         u_char  dmap_dirty;             /* Dma segments registers dirty */
1059         u32     dmap_bah[SYM_DMAP_SIZE];/* Segment registers map        */
1060 #endif
1061 #endif
1062 };
1063
1064 #define HCB_BA(np, lbl) (np->hcb_ba + offsetof(struct sym_hcb, lbl))
1065
1066
1067 /*
1068  *  FIRMWARES (sym_fw.c)
1069  */
1070 struct sym_fw * sym_find_firmware(struct sym_chip *chip);
1071 void sym_fw_bind_script(struct sym_hcb *np, u32 *start, int len);
1072
1073 /*
1074  *  Driver methods called from O/S specific code.
1075  */
1076 char *sym_driver_name(void);
1077 void sym_print_xerr(struct scsi_cmnd *cmd, int x_status);
1078 int sym_reset_scsi_bus(struct sym_hcb *np, int enab_int);
1079 struct sym_chip *sym_lookup_chip_table(u_short device_id, u_char revision);
1080 void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp);
1081 #ifdef SYM_OPT_HANDLE_DEVICE_QUEUEING
1082 void sym_start_next_ccbs(struct sym_hcb *np, struct sym_lcb *lp, int maxn);
1083 #endif
1084 void sym_start_up(struct sym_hcb *np, int reason);
1085 void sym_interrupt(struct sym_hcb *np);
1086 int sym_clear_tasks(struct sym_hcb *np, int cam_status, int target, int lun, int task);
1087 struct sym_ccb *sym_get_ccb(struct sym_hcb *np, struct scsi_cmnd *cmd, u_char tag_order);
1088 void sym_free_ccb(struct sym_hcb *np, struct sym_ccb *cp);
1089 struct sym_lcb *sym_alloc_lcb(struct sym_hcb *np, u_char tn, u_char ln);
1090 int sym_queue_scsiio(struct sym_hcb *np, struct scsi_cmnd *csio, struct sym_ccb *cp);
1091 int sym_abort_scsiio(struct sym_hcb *np, struct scsi_cmnd *ccb, int timed_out);
1092 int sym_reset_scsi_target(struct sym_hcb *np, int target);
1093 void sym_hcb_free(struct sym_hcb *np);
1094 int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram *nvram);
1095
1096 /*
1097  *  Build a scatter/gather entry.
1098  *
1099  *  For 64 bit systems, we use the 8 upper bits of the size field
1100  *  to provide bus address bits 32-39 to the SCRIPTS processor.
1101  *  This allows the 895A, 896, 1010 to address up to 1 TB of memory.
1102  */
1103
1104 #if   SYM_CONF_DMA_ADDRESSING_MODE == 0
1105 #define sym_build_sge(np, data, badd, len)      \
1106 do {                                            \
1107         (data)->addr = cpu_to_scr(badd);        \
1108         (data)->size = cpu_to_scr(len);         \
1109 } while (0)
1110 #elif SYM_CONF_DMA_ADDRESSING_MODE == 1
1111 #define sym_build_sge(np, data, badd, len)                              \
1112 do {                                                                    \
1113         (data)->addr = cpu_to_scr(badd);                                \
1114         (data)->size = cpu_to_scr((((badd) >> 8) & 0xff000000) + len);  \
1115 } while (0)
1116 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
1117 int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s);
1118 static __inline void
1119 sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len)
1120 {
1121         u32 h = (badd>>32);
1122         int s = (h&SYM_DMAP_MASK);
1123
1124         if (h != np->dmap_bah[s])
1125                 goto bad;
1126 good:
1127         (data)->addr = cpu_to_scr(badd);
1128         (data)->size = cpu_to_scr((s<<24) + len);
1129         return;
1130 bad:
1131         s = sym_lookup_dmap(np, h, s);
1132         goto good;
1133 }
1134 #else
1135 #error "Unsupported DMA addressing mode"
1136 #endif
1137
1138 /*
1139  *  Set up data pointers used by SCRIPTS.
1140  *  Called from O/S specific code.
1141  */
1142 static inline void sym_setup_data_pointers(struct sym_hcb *np,
1143                 struct sym_ccb *cp, int dir)
1144 {
1145         u32 lastp, goalp;
1146
1147         /*
1148          *  No segments means no data.
1149          */
1150         if (!cp->segments)
1151                 dir = DMA_NONE;
1152
1153         /*
1154          *  Set the data pointer.
1155          */
1156         switch(dir) {
1157 #ifdef  SYM_OPT_HANDLE_DIR_UNKNOWN
1158         case DMA_BIDIRECTIONAL:
1159 #endif
1160         case DMA_TO_DEVICE:
1161                 goalp = SCRIPTA_BA(np, data_out2) + 8;
1162                 lastp = goalp - 8 - (cp->segments * (2*4));
1163 #ifdef  SYM_OPT_HANDLE_DIR_UNKNOWN
1164                 cp->wgoalp = cpu_to_scr(goalp);
1165                 if (dir != DMA_BIDIRECTIONAL)
1166                         break;
1167                 cp->phys.head.wlastp = cpu_to_scr(lastp);
1168                 /* fall through */
1169 #else
1170                 break;
1171 #endif
1172         case DMA_FROM_DEVICE:
1173                 cp->host_flags |= HF_DATA_IN;
1174                 goalp = SCRIPTA_BA(np, data_in2) + 8;
1175                 lastp = goalp - 8 - (cp->segments * (2*4));
1176                 break;
1177         case DMA_NONE:
1178         default:
1179 #ifdef  SYM_OPT_HANDLE_DIR_UNKNOWN
1180                 cp->host_flags |= HF_DATA_IN;
1181 #endif
1182                 lastp = goalp = SCRIPTB_BA(np, no_data);
1183                 break;
1184         }
1185
1186         /*
1187          *  Set all pointers values needed by SCRIPTS.
1188          */
1189         cp->phys.head.lastp = cpu_to_scr(lastp);
1190         cp->phys.head.savep = cpu_to_scr(lastp);
1191         cp->startp          = cp->phys.head.savep;
1192         cp->goalp           = cpu_to_scr(goalp);
1193
1194 #ifdef  SYM_OPT_HANDLE_DIR_UNKNOWN
1195         /*
1196          *  If direction is unknown, start at data_io.
1197          */
1198         if (dir == DMA_BIDIRECTIONAL)
1199                 cp->phys.head.savep = cpu_to_scr(SCRIPTB_BA(np, data_io));
1200 #endif
1201 }
1202
1203 /*
1204  *  MEMORY ALLOCATOR.
1205  */
1206
1207 #define sym_get_mem_cluster()   \
1208         (void *) __get_free_pages(GFP_ATOMIC, SYM_MEM_PAGE_ORDER)
1209 #define sym_free_mem_cluster(p) \
1210         free_pages((unsigned long)p, SYM_MEM_PAGE_ORDER)
1211
1212 /*
1213  *  Link between free memory chunks of a given size.
1214  */
1215 typedef struct sym_m_link {
1216         struct sym_m_link *next;
1217 } *m_link_p;
1218
1219 /*
1220  *  Virtual to bus physical translation for a given cluster.
1221  *  Such a structure is only useful with DMA abstraction.
1222  */
1223 typedef struct sym_m_vtob {     /* Virtual to Bus address translation */
1224         struct sym_m_vtob *next;
1225         void *vaddr;            /* Virtual address */
1226         dma_addr_t baddr;       /* Bus physical address */
1227 } *m_vtob_p;
1228
1229 /* Hash this stuff a bit to speed up translations */
1230 #define VTOB_HASH_SHIFT         5
1231 #define VTOB_HASH_SIZE          (1UL << VTOB_HASH_SHIFT)
1232 #define VTOB_HASH_MASK          (VTOB_HASH_SIZE-1)
1233 #define VTOB_HASH_CODE(m)       \
1234         ((((unsigned long)(m)) >> SYM_MEM_CLUSTER_SHIFT) & VTOB_HASH_MASK)
1235
1236 /*
1237  *  Memory pool of a given kind.
1238  *  Ideally, we want to use:
1239  *  1) 1 pool for memory we donnot need to involve in DMA.
1240  *  2) The same pool for controllers that require same DMA
1241  *     constraints and features.
1242  *     The OS specific m_pool_id_t thing and the sym_m_pool_match()
1243  *     method are expected to tell the driver about.
1244  */
1245 typedef struct sym_m_pool {
1246         m_pool_ident_t  dev_dmat;       /* Identifies the pool (see above) */
1247         void * (*get_mem_cluster)(struct sym_m_pool *);
1248 #ifdef  SYM_MEM_FREE_UNUSED
1249         void (*free_mem_cluster)(struct sym_m_pool *, void *);
1250 #endif
1251 #define M_GET_MEM_CLUSTER()             mp->get_mem_cluster(mp)
1252 #define M_FREE_MEM_CLUSTER(p)           mp->free_mem_cluster(mp, p)
1253         int nump;
1254         m_vtob_p vtob[VTOB_HASH_SIZE];
1255         struct sym_m_pool *next;
1256         struct sym_m_link h[SYM_MEM_CLUSTER_SHIFT - SYM_MEM_SHIFT + 1];
1257 } *m_pool_p;
1258
1259 /*
1260  *  Alloc, free and translate addresses to bus physical
1261  *  for DMAable memory.
1262  */
1263 void *__sym_calloc_dma(m_pool_ident_t dev_dmat, int size, char *name);
1264 void __sym_mfree_dma(m_pool_ident_t dev_dmat, void *m, int size, char *name);
1265 dma_addr_t __vtobus(m_pool_ident_t dev_dmat, void *m);
1266
1267 /*
1268  * Verbs used by the driver code for DMAable memory handling.
1269  * The _uvptv_ macro avoids a nasty warning about pointer to volatile
1270  * being discarded.
1271  */
1272 #define _uvptv_(p) ((void *)((u_long)(p)))
1273
1274 #define _sym_calloc_dma(np, l, n)       __sym_calloc_dma(np->bus_dmat, l, n)
1275 #define _sym_mfree_dma(np, p, l, n)     \
1276                         __sym_mfree_dma(np->bus_dmat, _uvptv_(p), l, n)
1277 #define sym_calloc_dma(l, n)            _sym_calloc_dma(np, l, n)
1278 #define sym_mfree_dma(p, l, n)          _sym_mfree_dma(np, p, l, n)
1279 #define vtobus(p)                       __vtobus(np->bus_dmat, _uvptv_(p))
1280
1281 /*
1282  *  We have to provide the driver memory allocator with methods for
1283  *  it to maintain virtual to bus physical address translations.
1284  */
1285
1286 #define sym_m_pool_match(mp_id1, mp_id2)        (mp_id1 == mp_id2)
1287
1288 static __inline void *sym_m_get_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp)
1289 {
1290         void *vaddr = NULL;
1291         dma_addr_t baddr = 0;
1292
1293         vaddr = dma_alloc_coherent(mp->dev_dmat, SYM_MEM_CLUSTER_SIZE, &baddr,
1294                         GFP_ATOMIC);
1295         if (vaddr) {
1296                 vbp->vaddr = vaddr;
1297                 vbp->baddr = baddr;
1298         }
1299         return vaddr;
1300 }
1301
1302 static __inline void sym_m_free_dma_mem_cluster(m_pool_p mp, m_vtob_p vbp)
1303 {
1304         dma_free_coherent(mp->dev_dmat, SYM_MEM_CLUSTER_SIZE, vbp->vaddr,
1305                         vbp->baddr);
1306 }
1307
1308 #endif /* SYM_HIPD_H */