git.oblomov.eu Git - linux-2.6/blob - drivers/staging/slicoss/slic.h

   1 /**************************************************************************
   2  *
   3  * Copyright (c) 2000-2002 Alacritech, Inc.  All rights reserved.
   4  *
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above
  13  *    copyright notice, this list of conditions and the following
  14  *    disclaimer in the documentation and/or other materials provided
  15  *    with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY ALACRITECH, INC. ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ALACRITECH, INC. OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  24  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  26  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  27  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * The views and conclusions contained in the software and documentation
  31  * are those of the authors and should not be interpreted as representing
  32  * official policies, either expressed or implied, of Alacritech, Inc.
  33  *
  34  **************************************************************************/
  35
  36 /*
  37  * FILENAME: slic.h
  38  *
  39  * This is the base set of header definitions for the SLICOSS driver.
  40  */
  41 #ifndef __SLIC_DRIVER_H__
  42 #define __SLIC_DRIVER_H__
  43
  44 /* firmware stuff */
  45 #define OASIS_UCODE_VERS_STRING "1.2"
  46 #define OASIS_UCODE_VERS_DATE   "2006/03/27 15:10:37"
  47 #define OASIS_UCODE_HOSTIF_ID   3
  48
  49 static s32 ONumSections = 0x2;
  50 static u32 OSectionSize[] = {
  51         0x00004000, 0x00010000,
  52 };
  53
  54 static u32 OSectionStart[] = {
  55         0x00000000, 0x00008000,
  56 };
  57
  58 #define MOJAVE_UCODE_VERS_STRING        "1.2"
  59 #define MOJAVE_UCODE_VERS_DATE          "2006/03/27 15:12:22"
  60 #define MOJAVE_UCODE_HOSTIF_ID          3
  61
  62 static s32 MNumSections = 0x2;
  63 static u32 MSectionSize[] =
  64 {
  65         0x00008000, 0x00010000,
  66 };
  67
  68 static u32 MSectionStart[] =
  69 {
  70         0x00000000, 0x00008000,
  71 };
  72
  73 #define GB_RCVUCODE_VERS_STRING "1.2"
  74 #define GB_RCVUCODE_VERS_DATE   "2006/03/27 15:12:15"
  75 static u32 OasisRcvUCodeLen = 512;
  76 static u32 GBRcvUCodeLen = 512;
  77 #define SECTION_SIZE 65536
  78
  79 struct slic_spinlock {
  80         spinlock_t      lock;
  81         unsigned long   flags;
  82 };
  83
  84 #define SLIC_RSPQ_PAGES_GB        10
  85 #define SLIC_RSPQ_BUFSINPAGE      (PAGE_SIZE / SLIC_RSPBUF_SIZE)
  86
  87 struct slic_rspqueue {
  88     u32             offset;
  89     u32             pageindex;
  90     u32             num_pages;
  91     struct slic_rspbuf *rspbuf;
  92     u32 *vaddr[SLIC_RSPQ_PAGES_GB];
  93     dma_addr_t          paddr[SLIC_RSPQ_PAGES_GB];
  94 };
  95
  96 #define SLIC_RCVQ_EXPANSION         1
  97 #define SLIC_RCVQ_ENTRIES           (256 * SLIC_RCVQ_EXPANSION)
  98 #define SLIC_RCVQ_MINENTRIES        (SLIC_RCVQ_ENTRIES / 2)
  99 #define SLIC_RCVQ_MAX_PROCESS_ISR   ((SLIC_RCVQ_ENTRIES * 4))
 100 #define SLIC_RCVQ_RCVBUFSIZE        2048
 101 #define SLIC_RCVQ_FILLENTRIES       (16 * SLIC_RCVQ_EXPANSION)
 102 #define SLIC_RCVQ_FILLTHRESH        (SLIC_RCVQ_ENTRIES - SLIC_RCVQ_FILLENTRIES)
 103
 104 struct slic_rcvqueue {
 105     struct sk_buff    *head;
 106     struct sk_buff    *tail;
 107     u32            count;
 108     u32            size;
 109     u32            errors;
 110 };
 111
 112 struct slic_rcvbuf_info {
 113     u32     id;
 114     u32     starttime;
 115     u32     stoptime;
 116     u32     slicworld;
 117     u32     lasttime;
 118     u32     lastid;
 119 };
 120 /*
 121  SLIC Handle structure.  Used to restrict handle values to
 122  32 bits by using an index rather than an address.
 123  Simplifies ucode in 64-bit systems
 124 */
 125 struct slic_handle_word {
 126         union {
 127                 struct {
 128                         ushort      index;
 129                         ushort      bottombits; /* to denote num bufs to card */
 130                 }  parts;
 131                 u32         whole;
 132         }  handle;
 133 };
 134
 135 struct slic_handle {
 136     struct slic_handle_word  token;  /* token passed between host and card*/
 137     ushort                      type;
 138     void *address;    /* actual address of the object*/
 139     ushort                      offset;
 140     struct slic_handle       *other_handle;
 141     struct slic_handle       *next;
 142 };
 143
 144 #define SLIC_HANDLE_FREE        0x0000
 145 #define SLIC_HANDLE_DATA        0x0001
 146 #define SLIC_HANDLE_CMD         0x0002
 147 #define SLIC_HANDLE_CONTEXT     0x0003
 148 #define SLIC_HANDLE_TEAM        0x0004
 149
 150 #define handle_index        handle.parts.index
 151 #define handle_bottom       handle.parts.bottombits
 152 #define handle_token        handle.whole
 153
 154 #define SLIC_HOSTCMD_SIZE    512
 155
 156 struct slic_hostcmd {
 157     struct slic_host64_cmd  cmd64;
 158     u32                    type;
 159     struct sk_buff            *skb;
 160     u32                    paddrl;
 161     u32                    paddrh;
 162     u32                    busy;
 163     u32                    cmdsize;
 164     ushort                     numbufs;
 165     struct slic_handle    *pslic_handle;/* handle associated with command */
 166     struct slic_hostcmd    *next;
 167     struct slic_hostcmd    *next_all;
 168 };
 169
 170 #define SLIC_CMDQ_CMDSINPAGE    (PAGE_SIZE / SLIC_HOSTCMD_SIZE)
 171 #define SLIC_CMD_DUMB            3
 172 #define SLIC_CMDQ_INITCMDS       256
 173 #define SLIC_CMDQ_MAXCMDS        256
 174 #define SLIC_CMDQ_MAXOUTSTAND    SLIC_CMDQ_MAXCMDS
 175 #define SLIC_CMDQ_MAXPAGES       (SLIC_CMDQ_MAXCMDS / SLIC_CMDQ_CMDSINPAGE)
 176 #define SLIC_CMDQ_INITPAGES      (SLIC_CMDQ_INITCMDS / SLIC_CMDQ_CMDSINPAGE)
 177
 178 struct slic_cmdqmem {
 179         int pagecnt;
 180         u32 *pages[SLIC_CMDQ_MAXPAGES];
 181         dma_addr_t dma_pages[SLIC_CMDQ_MAXPAGES];
 182 };
 183
 184 struct slic_cmdqueue {
 185         struct slic_hostcmd *head;
 186         struct slic_hostcmd *tail;
 187         int count;
 188         struct slic_spinlock lock;
 189 };
 190
 191 #ifdef STATUS_SUCCESS
 192 #undef STATUS_SUCCESS
 193 #endif
 194
 195 #define STATUS_SUCCESS              0
 196 #define STATUS_PENDING              0
 197 #define STATUS_FAILURE             -1
 198 #define STATUS_ERROR               -2
 199 #define STATUS_NOT_SUPPORTED       -3
 200 #define STATUS_BUFFER_TOO_SHORT    -4
 201
 202 #define SLIC_MAX_CARDS              32
 203 #define SLIC_MAX_PORTS              4        /* Max # of ports per card   */
 204 #if SLIC_DUMP_ENABLED
 205 /*
 206 Dump buffer size
 207
 208 This cannot be bigger than the max DMA size the card supports,
 209 given the current code structure in the host and ucode.
 210 Mojave supports 16K, Oasis supports 16K-1, so
 211 just set this at 15K, shouldnt make that much of a diff.
 212 */
 213 #define DUMP_BUF_SIZE               0x3C00
 214 #endif
 215
 216
 217 struct mcast_address {
 218         unsigned char address[6];
 219         struct mcast_address *next;
 220 };
 221
 222 #define CARD_DOWN        0x00000000
 223 #define CARD_UP          0x00000001
 224 #define CARD_FAIL        0x00000002
 225 #define CARD_DIAG        0x00000003
 226 #define CARD_SLEEP       0x00000004
 227
 228 #define ADAPT_DOWN             0x00
 229 #define ADAPT_UP               0x01
 230 #define ADAPT_FAIL             0x02
 231 #define ADAPT_RESET            0x03
 232 #define ADAPT_SLEEP            0x04
 233
 234 #define ADAPT_FLAGS_BOOTTIME            0x0001
 235 #define ADAPT_FLAGS_IS64BIT             0x0002
 236 #define ADAPT_FLAGS_PENDINGLINKDOWN     0x0004
 237 #define ADAPT_FLAGS_FIBERMEDIA          0x0008
 238 #define ADAPT_FLAGS_LOCKS_ALLOCED       0x0010
 239 #define ADAPT_FLAGS_INT_REGISTERED      0x0020
 240 #define ADAPT_FLAGS_LOAD_TIMER_SET      0x0040
 241 #define ADAPT_FLAGS_STATS_TIMER_SET     0x0080
 242 #define ADAPT_FLAGS_RESET_TIMER_SET     0x0100
 243
 244 #define LINK_DOWN              0x00
 245 #define LINK_CONFIG            0x01
 246 #define LINK_UP                0x02
 247
 248 #define LINK_10MB              0x00
 249 #define LINK_100MB             0x01
 250 #define LINK_AUTOSPEED         0x02
 251 #define LINK_1000MB            0x03
 252 #define LINK_10000MB           0x04
 253
 254 #define LINK_HALFD             0x00
 255 #define LINK_FULLD             0x01
 256 #define LINK_AUTOD             0x02
 257
 258 #define MAC_DIRECTED     0x00000001
 259 #define MAC_BCAST        0x00000002
 260 #define MAC_MCAST        0x00000004
 261 #define MAC_PROMISC      0x00000008
 262 #define MAC_LOOPBACK     0x00000010
 263 #define MAC_ALLMCAST     0x00000020
 264
 265 #define SLIC_DUPLEX(x)    ((x == LINK_FULLD) ? "FDX" : "HDX")
 266 #define SLIC_SPEED(x)     ((x == LINK_100MB) ? "100Mb" : ((x == LINK_1000MB) ?\
 267                                 "1000Mb" : " 10Mb"))
 268 #define SLIC_LINKSTATE(x) ((x == LINK_DOWN) ? "Down" : "Up  ")
 269 #define SLIC_ADAPTER_STATE(x) ((x == ADAPT_UP) ? "UP" : "Down")
 270 #define SLIC_CARD_STATE(x)    ((x == CARD_UP) ? "UP" : "Down")
 271
 272 struct slic_iface_stats {
 273     /*
 274      * Stats
 275      */
 276     u64        xmt_bytes;
 277     u64        xmt_ucast;
 278     u64        xmt_mcast;
 279     u64        xmt_bcast;
 280     u64        xmt_errors;
 281     u64        xmt_discards;
 282     u64        xmit_collisions;
 283     u64        xmit_excess_xmit_collisions;
 284     u64        rcv_bytes;
 285     u64        rcv_ucast;
 286     u64        rcv_mcast;
 287     u64        rcv_bcast;
 288     u64        rcv_errors;
 289     u64        rcv_discards;
 290 };
 291
 292 struct sliccp_stats {
 293     u64        xmit_tcp_segs;
 294     u64        xmit_tcp_bytes;
 295     u64        rcv_tcp_segs;
 296     u64        rcv_tcp_bytes;
 297 };
 298
 299 struct slicnet_stats {
 300     struct sliccp_stats        tcp;
 301     struct slic_iface_stats      iface;
 302 };
 303
 304 #define SLIC_LOADTIMER_PERIOD     1
 305 #define SLIC_INTAGG_DEFAULT       200
 306 #define SLIC_LOAD_0               0
 307 #define SLIC_INTAGG_0             0
 308 #define SLIC_LOAD_1               8000
 309 #define SLIC_LOAD_2               10000
 310 #define SLIC_LOAD_3               12000
 311 #define SLIC_LOAD_4               14000
 312 #define SLIC_LOAD_5               16000
 313 #define SLIC_INTAGG_1             50
 314 #define SLIC_INTAGG_2             100
 315 #define SLIC_INTAGG_3             150
 316 #define SLIC_INTAGG_4             200
 317 #define SLIC_INTAGG_5             250
 318 #define SLIC_LOAD_1GB             3000
 319 #define SLIC_LOAD_2GB             6000
 320 #define SLIC_LOAD_3GB             12000
 321 #define SLIC_LOAD_4GB             24000
 322 #define SLIC_LOAD_5GB             48000
 323 #define SLIC_INTAGG_1GB           50
 324 #define SLIC_INTAGG_2GB           75
 325 #define SLIC_INTAGG_3GB           100
 326 #define SLIC_INTAGG_4GB           100
 327 #define SLIC_INTAGG_5GB           100
 328
 329 struct ether_header {
 330     unsigned char    ether_dhost[6];
 331     unsigned char    ether_shost[6];
 332     ushort   ether_type;
 333 };
 334
 335 struct sliccard {
 336     uint              busnumber;
 337     uint              slotnumber;
 338     uint              state;
 339     uint              cardnum;
 340     uint              card_size;
 341     uint              adapters_activated;
 342     uint              adapters_allocated;
 343     uint              adapters_sleeping;
 344     uint              gennumber;
 345     u32           events;
 346     u32           loadlevel_current;
 347     u32           load;
 348     uint              reset_in_progress;
 349     u32           pingstatus;
 350     u32           bad_pingstatus;
 351     struct timer_list loadtimer;
 352     u32           loadtimerset;
 353     uint              config_set;
 354     struct slic_config  config;
 355     struct dentry      *debugfs_dir;
 356     struct dentry      *debugfs_cardinfo;
 357     struct adapter  *master;
 358     struct adapter  *adapter[SLIC_MAX_PORTS];
 359     struct sliccard *next;
 360     u32             error_interrupts;
 361     u32             error_rmiss_interrupts;
 362     u32             rcv_interrupts;
 363     u32             xmit_interrupts;
 364     u32             num_isrs;
 365     u32             false_interrupts;
 366     u32             max_isr_rcvs;
 367     u32             max_isr_xmits;
 368     u32             rcv_interrupt_yields;
 369     u32             tx_packets;
 370 #if SLIC_DUMP_ENABLED
 371     u32             dumpstatus;           /* Result of dump UPR */
 372     void *cmdbuffer;
 373
 374     ulong               cmdbuffer_phys;
 375     u32             cmdbuffer_physl;
 376     u32             cmdbuffer_physh;
 377
 378     u32             dump_count;
 379     struct task_struct *dump_task_id;
 380     u32             dump_wait_count;
 381     uint                dumpthread_running; /* has a dump thread been init'd  */
 382     uint                dump_requested;     /* 0 no, 1 = reqstd 2=curr 3=done */
 383     u32             dumptime_start;
 384     u32             dumptime_complete;
 385     u32             dumptime_delta;
 386     void *dumpbuffer;
 387     ulong               dumpbuffer_phys;
 388     u32             dumpbuffer_physl;
 389     u32             dumpbuffer_physh;
 390     wait_queue_head_t   dump_wq;
 391     struct file        *dumphandle;
 392     mm_segment_t        dumpfile_fs;
 393 #endif
 394     u32             debug_ix;
 395     ushort              reg_type[32];
 396     ushort              reg_offset[32];
 397     u32             reg_value[32];
 398     u32             reg_valueh[32];
 399 };
 400
 401 #define NUM_CFG_SPACES      2
 402 #define NUM_CFG_REGS        64
 403 #define NUM_CFG_REG_ULONGS  (NUM_CFG_REGS / sizeof(u32))
 404
 405 struct physcard {
 406     struct adapter  *adapter[SLIC_MAX_PORTS];
 407     struct physcard *next;
 408     uint                adapters_allocd;
 409
 410  /*  the following is not currently needed
 411     u32               bridge_busnum;
 412     u32               bridge_cfg[NUM_CFG_SPACES][NUM_CFG_REG_ULONGS];
 413  */
 414 };
 415
 416 struct base_driver {
 417     struct slic_spinlock driver_lock;
 418     u32              num_slic_cards;
 419     u32              num_slic_ports;
 420     u32              num_slic_ports_active;
 421     u32              dynamic_intagg;
 422     struct sliccard  *slic_card;
 423     struct physcard  *phys_card;
 424     uint                 cardnuminuse[SLIC_MAX_CARDS];
 425 };
 426
 427 struct slic_shmem {
 428     volatile u32          isr;
 429     volatile u32          linkstatus;
 430     volatile struct slic_stats     inicstats;
 431 };
 432
 433 struct slic_reg_params {
 434     u32       linkspeed;
 435     u32       linkduplex;
 436     u32       fail_on_bad_eeprom;
 437 };
 438
 439 struct slic_upr {
 440     uint               adapter;
 441     u32            upr_request;
 442     u32            upr_data;
 443     u32            upr_data_h;
 444     u32            upr_buffer;
 445     u32            upr_buffer_h;
 446     struct slic_upr *next;
 447 };
 448
 449 struct slic_ifevents {
 450     uint        oflow802;
 451     uint        uflow802;
 452     uint        Tprtoflow;
 453     uint        rcvearly;
 454     uint        Bufov;
 455     uint        Carre;
 456     uint        Longe;
 457     uint        Invp;
 458     uint        Crc;
 459     uint        Drbl;
 460     uint        Code;
 461     uint        IpHlen;
 462     uint        IpLen;
 463     uint        IpCsum;
 464     uint        TpCsum;
 465     uint        TpHlen;
 466 };
 467
 468 struct adapter {
 469     void *ifp;
 470     struct sliccard *card;
 471     uint                port;
 472     struct physcard *physcard;
 473     uint                physport;
 474     uint                cardindex;
 475     uint                card_size;
 476     uint                chipid;
 477     struct net_device  *netdev;
 478     struct net_device  *next_netdevice;
 479     struct slic_spinlock     adapter_lock;
 480     struct slic_spinlock     reset_lock;
 481     struct pci_dev     *pcidev;
 482     uint                busnumber;
 483     uint                slotnumber;
 484     uint                functionnumber;
 485     ushort              vendid;
 486     ushort              devid;
 487     ushort              subsysid;
 488     u32             irq;
 489     void __iomem *memorybase;
 490     u32             memorylength;
 491     u32             drambase;
 492     u32             dramlength;
 493     uint                queues_initialized;
 494     uint                allocated;
 495     uint                activated;
 496     u32             intrregistered;
 497     uint                isp_initialized;
 498     uint                gennumber;
 499     u32             curaddrupper;
 500     struct slic_shmem      *pshmem;
 501     dma_addr_t          phys_shmem;
 502     u32             isrcopy;
 503     __iomem struct slic_regs       *slic_regs;
 504     unsigned char               state;
 505     unsigned char               linkstate;
 506     unsigned char               linkspeed;
 507     unsigned char               linkduplex;
 508     uint                flags;
 509     unsigned char               macaddr[6];
 510     unsigned char               currmacaddr[6];
 511     u32             macopts;
 512     ushort              devflags_prev;
 513     u64             mcastmask;
 514     struct mcast_address   *mcastaddrs;
 515     struct slic_upr   *upr_list;
 516     uint                upr_busy;
 517     struct timer_list   pingtimer;
 518     u32             pingtimerset;
 519     struct timer_list   statstimer;
 520     u32             statstimerset;
 521     struct timer_list   loadtimer;
 522     u32             loadtimerset;
 523     struct dentry      *debugfs_entry;
 524     struct slic_spinlock     upr_lock;
 525     struct slic_spinlock     bit64reglock;
 526     struct slic_rspqueue     rspqueue;
 527     struct slic_rcvqueue     rcvqueue;
 528     struct slic_cmdqueue     cmdq_free;
 529     struct slic_cmdqueue     cmdq_done;
 530     struct slic_cmdqueue     cmdq_all;
 531     struct slic_cmdqmem      cmdqmem;
 532     /*
 533      *  SLIC Handles
 534     */
 535     struct slic_handle slic_handles[SLIC_CMDQ_MAXCMDS+1]; /* Object handles*/
 536     struct slic_handle *pfree_slic_handles;          /* Free object handles*/
 537     struct slic_spinlock     handle_lock;           /* Object handle list lock*/
 538     ushort              slic_handle_ix;
 539
 540     u32             xmitq_full;
 541     u32             all_reg_writes;
 542     u32             icr_reg_writes;
 543     u32             isr_reg_writes;
 544     u32             error_interrupts;
 545     u32             error_rmiss_interrupts;
 546     u32             rx_errors;
 547     u32             rcv_drops;
 548     u32             rcv_interrupts;
 549     u32             xmit_interrupts;
 550     u32             linkevent_interrupts;
 551     u32             upr_interrupts;
 552     u32             num_isrs;
 553     u32             false_interrupts;
 554     u32             tx_packets;
 555     u32             xmit_completes;
 556     u32             tx_drops;
 557     u32             rcv_broadcasts;
 558     u32             rcv_multicasts;
 559     u32             rcv_unicasts;
 560     u32             max_isr_rcvs;
 561     u32             max_isr_xmits;
 562     u32             rcv_interrupt_yields;
 563     u32             intagg_period;
 564     struct inicpm_state    *inicpm_info;
 565     void *pinicpm_info;
 566     struct slic_reg_params   reg_params;
 567     struct slic_ifevents  if_events;
 568     struct slic_stats        inicstats_prev;
 569     struct slicnet_stats     slic_stats;
 570     struct net_device_stats stats;
 571 };
 572
 573 #if SLIC_DUMP_ENABLED
 574 #define SLIC_DUMP_REQUESTED      1
 575 #define SLIC_DUMP_IN_PROGRESS    2
 576 #define SLIC_DUMP_DONE           3
 577
 578 /****************************************************************************
 579  *
 580  * Microcode crash information structure.  This
 581  * structure is written out to the card's SRAM when the microcode panic's.
 582  *
 583  ****************************************************************************/
 584 struct slic_crash_info {
 585     ushort  cpu_id;
 586     ushort  crash_pc;
 587 };
 588
 589 #define CRASH_INFO_OFFSET   0x155C
 590
 591 #endif
 592
 593 #define UPDATE_STATS(largestat, newstat, oldstat)                        \
 594 {                                                                        \
 595     if ((newstat) < (oldstat))                                           \
 596         (largestat) += ((newstat) + (0xFFFFFFFF - oldstat + 1));         \
 597     else                                                                 \
 598         (largestat) += ((newstat) - (oldstat));                          \
 599 }
 600
 601 #define UPDATE_STATS_GB(largestat, newstat, oldstat)                     \
 602 {                                                                        \
 603     (largestat) += ((newstat) - (oldstat));                              \
 604 }
 605
 606 #define ETHER_EQ_ADDR(_AddrA, _AddrB, _Result)                           \
 607 {                                                                        \
 608     _Result = TRUE;                                                      \
 609     if (*(u32 *)(_AddrA) != *(u32 *)(_AddrB))                          \
 610         _Result = FALSE;                                                 \
 611     if (*(u16 *)(&((_AddrA)[4])) != *(u16 *)(&((_AddrB)[4])))        \
 612         _Result = FALSE;                                                 \
 613 }
 614
 615 #if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
 616 #define   SLIC_GET_ADDR_LOW(_addr)  (u32)((u64)(_addr) & \
 617         0x00000000FFFFFFFF)
 618 #define   SLIC_GET_ADDR_HIGH(_addr)  (u32)(((u64)(_addr) >> 32) & \
 619         0x00000000FFFFFFFF)
 620 #else
 621 #define   SLIC_GET_ADDR_LOW(_addr)   (u32)_addr
 622 #define   SLIC_GET_ADDR_HIGH(_addr)  (u32)0
 623 #endif
 624
 625 #define FLUSH       TRUE
 626 #define DONT_FLUSH  FALSE
 627
 628 #define SIOCSLICDUMPCARD         (SIOCDEVPRIVATE+9)
 629 #define SIOCSLICSETINTAGG        (SIOCDEVPRIVATE+10)
 630 #define SIOCSLICTRACEDUMP        (SIOCDEVPRIVATE+11)
 631
 632 #endif /*  __SLIC_DRIVER_H__ */