drivers/scsi/sym53c8xx_2/sym_hipd.h

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