sys/dev/hatm/if_hatmvar.h

   1 /*-
   2  * Copyright (c) 2001-2003
   3  *      Fraunhofer Institute for Open Communication Systems (FhG Fokus).
   4  *      All rights reserved.
   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  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * Author: Hartmut Brandt <harti@freebsd.org>
  28  *
  29  * $FreeBSD$
  30  *
  31  * Fore HE driver for NATM
  32  */
  33
  34 /*
  35  * Debug statistics of the HE driver
  36  */
  37 struct istats {
  38         uint32_t        tdprq_full;
  39         uint32_t        hbuf_error;
  40         uint32_t        crc_error;
  41         uint32_t        len_error;
  42         uint32_t        flow_closed;
  43         uint32_t        flow_drop;
  44         uint32_t        tpd_no_mem;
  45         uint32_t        rx_seg;
  46         uint32_t        empty_hbuf;
  47         uint32_t        short_aal5;
  48         uint32_t        badlen_aal5;
  49         uint32_t        bug_bad_isw;
  50         uint32_t        bug_no_irq_upd;
  51         uint32_t        itype_tbrq;
  52         uint32_t        itype_tpd;
  53         uint32_t        itype_rbps;
  54         uint32_t        itype_rbpl;
  55         uint32_t        itype_rbrq;
  56         uint32_t        itype_rbrqt;
  57         uint32_t        itype_unknown;
  58         uint32_t        itype_phys;
  59         uint32_t        itype_err;
  60         uint32_t        defrag;
  61         uint32_t        mcc;
  62         uint32_t        oec;
  63         uint32_t        dcc;
  64         uint32_t        cec;
  65         uint32_t        no_rcv_mbuf;
  66 };
  67
  68 /* Card memory layout parameters */
  69 #define HE_CONFIG_MEM_LAYOUT {                                          \
  70         {                       /* 155 */                               \
  71           20,                   /* cells_per_row */                     \
  72           1024,                 /* bytes_per_row */                     \
  73           512,                  /* r0_numrows */                        \
  74           1018,                 /* tx_numrows */                        \
  75           512,                  /* r1_numrows */                        \
  76           6,                    /* r0_startrow */                       \
  77           2                     /* cells_per_lbuf */                    \
  78         }, {                    /* 622 */                               \
  79           40,                   /* cells_per_row */                     \
  80           2048,                 /* bytes_per_row */                     \
  81           256,                  /* r0_numrows */                        \
  82           512,                  /* tx_numrows */                        \
  83           256,                  /* r1_numrows */                        \
  84           0,                    /* r0_startrow */                       \
  85           4                     /* cells_per_lbuf */                    \
  86         }                                                               \
  87 }
  88
  89 /*********************************************************************/
  90 struct hatm_softc;
  91
  92 /*
  93  * A chunk of DMA-able memory
  94  */
  95 struct dmamem {
  96         u_int           size;           /* in bytes */
  97         u_int           align;          /* alignement */
  98         bus_dma_tag_t   tag;            /* DMA tag */
  99         void            *base;          /* the memory */
 100         bus_addr_t      paddr;          /* physical address */
 101         bus_dmamap_t    map;            /* the MAP */
 102 };
 103
 104 /*
 105  * RBP (Receive Buffer Pool) queue entry and queue.
 106  */
 107 struct herbp {
 108         u_int           size;           /* RBP number of entries (power of two) */
 109         u_int           thresh;         /* interrupt treshold */
 110         uint32_t        bsize;          /* buffer size in bytes */
 111         u_int           offset;         /* free space at start for small bufs */
 112         uint32_t        mask;           /* mask for index */
 113         struct dmamem   mem;            /* the queue area */
 114         struct he_rbpen *rbp;
 115         uint32_t        head, tail;     /* head and tail */
 116 };
 117
 118 /*
 119  * RBRQ (Receive Buffer Return Queue) entry and queue.
 120  */
 121 struct herbrq {
 122         u_int           size;           /* number of entries */
 123         u_int           thresh;         /* interrupt threshold */
 124         u_int           tout;           /* timeout value */
 125         u_int           pcnt;           /* packet count threshold */
 126         struct dmamem   mem;            /* memory */
 127         struct he_rbrqen *rbrq;
 128         uint32_t        head;           /* driver end */
 129 };
 130
 131 /*
 132  * TPDRQ (Transmit Packet Descriptor Ready Queue) entry and queue
 133  */
 134 struct hetpdrq {
 135         u_int           size;           /* number of entries */
 136         struct dmamem   mem;            /* memory */
 137         struct he_tpdrqen *tpdrq;
 138         u_int           head;           /* head (copy of adapter) */
 139         u_int           tail;           /* written back to adapter */
 140 };
 141
 142 /*
 143  * TBRQ (Transmit Buffer Return Queue) entry and queue
 144  */
 145 struct hetbrq {
 146         u_int           size;           /* number of entries */
 147         u_int           thresh;         /* interrupt threshold */
 148         struct dmamem   mem;            /* memory */
 149         struct he_tbrqen *tbrq;
 150         u_int           head;           /* adapter end */
 151 };
 152
 153 /*==================================================================*/
 154
 155 /*
 156  * TPDs are 32 byte and must be aligned on 64 byte boundaries. That means,
 157  * that half of the space is free. We use this space to plug in a link for
 158  * the list of free TPDs. Note, that the m_act member of the mbufs contain
 159  * a pointer to the dmamap.
 160  *
 161  * The maximum number of TDPs is the size of the common transmit packet
 162  * descriptor ready queue plus the sizes of the transmit buffer return queues
 163  * (currently only queue 0). We allocate and map these TPD when initializing
 164  * the card. We also allocate on DMA map for each TPD. Only the map in the
 165  * last TPD of a packets is used when a packet is transmitted.
 166  * This is signalled by having the mbuf member of this TPD non-zero and
 167  * pointing to the mbuf.
 168  */
 169 #define HE_TPD_SIZE             64
 170 struct tpd {
 171         struct he_tpd           tpd;    /* at beginning */
 172         SLIST_ENTRY(tpd)        link;   /* free cid list link */
 173         struct mbuf             *mbuf;  /* the buf chain */
 174         bus_dmamap_t            map;    /* map */
 175         uint32_t                cid;    /* CID */
 176         uint16_t                no;     /* number of this tpd */
 177 };
 178 SLIST_HEAD(tpd_list, tpd);
 179
 180 #define TPD_SET_USED(SC, I) do {                                \
 181         (SC)->tpd_used[(I) / 8] |= (1 << ((I) % 8));            \
 182     } while (0)
 183
 184 #define TPD_CLR_USED(SC, I) do {                                \
 185         (SC)->tpd_used[(I) / 8] &= ~(1 << ((I) % 8));           \
 186     } while (0)
 187
 188 #define TPD_TST_USED(SC, I) ((SC)->tpd_used[(I) / 8] & (1 << ((I) % 8)))
 189
 190 #define TPD_ADDR(SC, I) ((struct tpd *)((char *)sc->tpds.base + \
 191     (I) * HE_TPD_SIZE))
 192
 193 /*==================================================================*/
 194
 195 /*
 196  * External MBUFs. The card needs a lot of mbufs in the pools for high
 197  * performance. The problem with using mbufs directly is that we would need
 198  * a dmamap for each of the mbufs. This can exhaust iommu space on the sparc
 199  * and it eats also a lot of processing time. So we use external mbufs
 200  * for the small buffers and clusters for the large buffers.
 201  * For receive group 0 we use 5 ATM cells, for group 1 one (52 byte) ATM
 202  * cell. The mbuf storage is allocated pagewise and one dmamap is used per
 203  * page.
 204  *
 205  * The handle we give to the card for the small buffers is a word combined
 206  * of the page number and the number of the chunk in the page. This restricts
 207  * the number of chunks per page to 256 (8 bit) and the number of pages to
 208  * 65536 (16 bits).
 209  *
 210  * A chunk may be in one of three states: free, on the card and floating around
 211  * in the system. If it is free, it is on one of the two free lists and
 212  * start with a struct mbufx_free. Each page has a bitmap that tracks where
 213  * its chunks are.
 214  *
 215  * For large buffers we use mbuf clusters. Here we have two problems: we need
 216  * to track the buffers on the card (in the case we want to stop it) and
 217  * we need to map the 64bit mbuf address to a 26bit handle for 64-bit machines.
 218  * The card uses the buffers in the order we give it to the card. Therefor
 219  * we can use a private array holding pointers to the mbufs as a circular
 220  * queue for both tasks. This is done with the lbufs member of softc. The
 221  * handle for these buffer is the lbufs index ored with a flag.
 222  */
 223
 224 /* data space in each external mbuf */
 225 #define MBUF0_SIZE      (5 * 48)        /* 240 */
 226 #define MBUF1_SIZE      (52)            /* 1 raw cell */
 227
 228 /* size of the buffer. Must fit data, offset and header */
 229 #define MBUF0_CHUNK     256             /* 16 free bytes */
 230 #define MBUF1_CHUNK     96              /* 44 free bytes */
 231
 232 /* start of actual data in buffer */
 233 #define MBUF0_OFFSET    0
 234 #define MBUF1_OFFSET    16
 235
 236 #define MBUFL_OFFSET    16              /* two pointers for HARP */
 237
 238 #if PAGE_SIZE > 8192
 239 #define MBUF_ALLOC_SIZE (8192)
 240 #else
 241 #define MBUF_ALLOC_SIZE (PAGE_SIZE)
 242 #endif
 243
 244 /* each allocated page has one of these structures at its very end. */
 245 struct mbuf_page_hdr {
 246         uint16_t        nchunks;        /* chunks on this page */
 247         bus_dmamap_t    map;            /* the DMA MAP */
 248         uint32_t        phys;           /* physical base address */
 249         uint32_t        hdroff;         /* chunk header offset */
 250         uint32_t        chunksize;      /* chunk size */
 251         u_int           pool;           /* pool number */
 252 };
 253 struct mbuf_page {
 254         char    storage[MBUF_ALLOC_SIZE - sizeof(struct mbuf_page_hdr)];
 255         struct mbuf_page_hdr    hdr;
 256 };
 257
 258 /* numbers per page */
 259 #define MBUF0_PER_PAGE  ((MBUF_ALLOC_SIZE - sizeof(struct mbuf_page_hdr)) / \
 260     MBUF0_CHUNK)
 261 #define MBUF1_PER_PAGE  ((MBUF_ALLOC_SIZE - sizeof(struct mbuf_page_hdr)) / \
 262     MBUF1_CHUNK)
 263
 264 /*
 265  * Convert to/from handles
 266  */
 267 /* small buffers */
 268 #define MBUF_MAKE_HANDLE(PAGENO, CHUNKNO) \
 269         ((((PAGENO) << 10) | (CHUNKNO)) << HE_REGS_RBRQ_ADDR)
 270 #define MBUF_MAKE_LHANDLE(INDEX) \
 271         (MBUF_LARGE_FLAG | ((INDEX) << HE_REGS_RBRQ_ADDR))
 272
 273 /* large buffers */
 274 #define MBUF_PARSE_HANDLE(HANDLE, PAGENO, CHUNKNO) do {                 \
 275         (CHUNKNO) = ((HANDLE) >> HE_REGS_RBRQ_ADDR) & 0x3ff;            \
 276         (PAGENO) = (((HANDLE) >> 10) >> HE_REGS_RBRQ_ADDR) & 0x3fff;    \
 277     } while (0)
 278 #define MBUF_PARSE_LHANDLE(HANDLE, INDEX) do {                          \
 279         (INDEX) = ((HANDLE) >> HE_REGS_RBRQ_ADDR) & 0xffffff;           \
 280     } while (0)
 281
 282 #define MBUF_LARGE_FLAG 0x80000000
 283
 284 /* chunks have the following structure at the end (8 byte) */
 285 struct mbuf_chunk_hdr {
 286         uint16_t        pageno;
 287         uint8_t         chunkno;
 288         uint8_t         flags;
 289         u_int           ref_cnt;
 290 };
 291 #define MBUF_CARD       0x01    /* buffer is on card */
 292 #define MBUF_USED       0x02    /* buffer is somewhere in the system */
 293
 294 #define MBUFX_STORAGE_SIZE(X) (MBUF##X##_CHUNK  \
 295     - sizeof(struct mbuf_chunk_hdr))
 296
 297 struct mbuf0_chunk {
 298         char                    storage[MBUFX_STORAGE_SIZE(0)];
 299         struct mbuf_chunk_hdr   hdr;
 300 };
 301
 302 struct mbuf1_chunk {
 303         char                    storage[MBUFX_STORAGE_SIZE(1)];
 304         struct mbuf_chunk_hdr   hdr;
 305 };
 306
 307 struct mbufx_free {
 308         struct mbufx_free       *link;
 309 };
 310
 311 /*==================================================================*/
 312
 313 /*
 314  * Interrupt queue
 315  */
 316 struct heirq {
 317         u_int           size;   /* number of entries */
 318         u_int           thresh; /* re-interrupt threshold */
 319         u_int           line;   /* interrupt line to use */
 320         struct dmamem   mem;    /* interrupt queues */
 321         uint32_t *      irq;    /* interrupt queue */
 322         uint32_t        head;   /* head index */
 323         uint32_t *      tailp;  /* pointer to tail */
 324         struct hatm_softc *sc;  /* back pointer */
 325         u_int           group;  /* interrupt group */
 326 };
 327
 328 /*
 329  * This structure describes all information for a VCC open on the card.
 330  * The array of these structures is indexed by the compressed connection ID
 331  * (CID). This structure must begin with the atmio_vcc.
 332  */
 333 struct hevcc {
 334         struct atmio_vcc param;         /* traffic parameters */
 335         void *          rxhand;         /* NATM protocol block */
 336         u_int           vflags;         /* private flags */
 337         uint32_t        ipackets;
 338         uint32_t        opackets;
 339         uint32_t        ibytes;
 340         uint32_t        obytes;
 341
 342         u_int           rc;             /* rate control group for CBR */
 343         struct mbuf *   chain;          /* partial received PDU */
 344         struct mbuf *   last;           /* last mbuf in chain */
 345         u_int           ntpds;          /* number of active TPDs */
 346 };
 347 #define HE_VCC_OPEN             0x000f0000
 348 #define HE_VCC_RX_OPEN          0x00010000
 349 #define HE_VCC_RX_CLOSING       0x00020000
 350 #define HE_VCC_TX_OPEN          0x00040000
 351 #define HE_VCC_TX_CLOSING       0x00080000
 352 #define HE_VCC_FLOW_CTRL        0x00100000
 353
 354 /*
 355  * CBR rate groups
 356  */
 357 struct herg {
 358         u_int   refcnt;         /* how many connections reference this group */
 359         u_int   rate;           /* the value */
 360 };
 361
 362 /*
 363  * Softc
 364  */
 365 struct hatm_softc {
 366         struct ifnet            *ifp;
 367         struct mtx              mtx;            /* lock */
 368         struct ifmedia          media;          /* media */
 369         device_t                dev;            /* device */
 370         int                     memid;          /* resoure id for memory */
 371         struct resource *       memres;         /* memory resource */
 372         bus_space_handle_t      memh;           /* handle */
 373         bus_space_tag_t         memt;           /* ... and tag */
 374         bus_dma_tag_t           parent_tag;     /* global restriction */
 375         struct cv               vcc_cv;         /* condition variable */
 376         int                     irqid;          /* resource id */
 377         struct resource *       irqres;         /* resource */
 378         void *                  ih;             /* interrupt handle */
 379         struct utopia           utopia;         /* utopia state */
 380
 381         /* rest has to be reset by stop */
 382         int                     he622;          /* this is a HE622 */
 383         int                     pci64;          /* 64bit bus */
 384         char                    prod_id[HE_EEPROM_PROD_ID_LEN + 1];
 385         char                    rev[HE_EEPROM_REV_LEN + 1];
 386         struct heirq            irq_0;          /* interrupt queues 0 */
 387
 388         /* generic network controller state */
 389         u_int                   cells_per_row;
 390         u_int                   bytes_per_row;
 391         u_int                   r0_numrows;
 392         u_int                   tx_numrows;
 393         u_int                   r1_numrows;
 394         u_int                   r0_startrow;
 395         u_int                   tx_startrow;
 396         u_int                   r1_startrow;
 397         u_int                   cells_per_lbuf;
 398         u_int                   r0_numbuffs;
 399         u_int                   r1_numbuffs;
 400         u_int                   tx_numbuffs;
 401
 402         /* HSP */
 403         struct he_hsp           *hsp;
 404         struct dmamem           hsp_mem;
 405
 406         /*** TX ***/
 407         struct hetbrq           tbrq;           /* TBRQ 0 */
 408         struct hetpdrq          tpdrq;          /* TPDRQ */
 409         struct tpd_list         tpd_free;       /* Free TPDs */
 410         u_int                   tpd_nfree;      /* number of free TPDs */
 411         u_int                   tpd_total;      /* total TPDs */
 412         uint8_t                 *tpd_used;      /* bitmap of used TPDs */
 413         struct dmamem           tpds;           /* TPD memory */
 414         bus_dma_tag_t           tx_tag;         /* DMA tag for all tx mbufs */
 415
 416         /*** RX ***/
 417         /* receive/transmit groups */
 418         struct herbp            rbp_s0;         /* RBPS0 */
 419         struct herbp            rbp_l0;         /* RBPL0 */
 420         struct herbp            rbp_s1;         /* RBPS1 */
 421         struct herbrq           rbrq_0;         /* RBRQ0 */
 422         struct herbrq           rbrq_1;         /* RBRQ1 */
 423
 424         /* list of external mbuf storage */
 425         bus_dma_tag_t           mbuf_tag;
 426         struct mbuf_page        **mbuf_pages;
 427         u_int                   mbuf_npages;
 428         u_int                   mbuf_max_pages;
 429         struct mbufx_free       *mbuf_list[2];
 430
 431         /* mbuf cluster tracking and mapping for group 0 */
 432         struct mbuf             **lbufs;        /* mbufs */
 433         bus_dmamap_t            *rmaps;         /* DMA maps */
 434         u_int                   lbufs_size;
 435         u_int                   lbufs_next;
 436
 437         /* VCCs */
 438         struct hevcc            *vccs[HE_MAX_VCCS];
 439         u_int                   cbr_bw;         /* BW allocated to CBR */
 440         u_int                   max_tpd;        /* per VCC */
 441         u_int                   open_vccs;
 442         uma_zone_t              vcc_zone;
 443
 444         /* rate groups */
 445         struct herg             rate_ctrl[HE_REGN_CS_STPER];
 446
 447         /* memory offsets */
 448         u_int                   tsrb, tsrc, tsrd;
 449         u_int                   rsrb;
 450
 451         struct cv               cv_rcclose;     /* condition variable */
 452         uint32_t                rate_grid[16][16]; /* our copy */
 453
 454         /* sysctl support */
 455         struct sysctl_ctx_list  sysctl_ctx;
 456         struct sysctl_oid       *sysctl_tree;
 457
 458         /* internal statistics */
 459         struct istats           istats;
 460
 461         u_int                   mpsafe;
 462
 463 #ifdef HATM_DEBUG
 464         /* debugging */
 465         u_int                   debug;
 466
 467         /* transmit mbuf count */
 468         int                     txmbuf;
 469 #endif
 470 };
 471
 472 #define READ4(SC,OFF)   bus_space_read_4(SC->memt, SC->memh, (OFF))
 473 #define READ2(SC,OFF)   bus_space_read_2(SC->memt, SC->memh, (OFF))
 474 #define READ1(SC,OFF)   bus_space_read_1(SC->memt, SC->memh, (OFF))
 475
 476 #define WRITE4(SC,OFF,VAL) bus_space_write_4(SC->memt, SC->memh, (OFF), (VAL))
 477 #define WRITE2(SC,OFF,VAL) bus_space_write_2(SC->memt, SC->memh, (OFF), (VAL))
 478 #define WRITE1(SC,OFF,VAL) bus_space_write_1(SC->memt, SC->memh, (OFF), (VAL))
 479
 480 #define BARRIER_R(SC) bus_space_barrier(SC->memt, SC->memh, 0, HE_REGO_END, \
 481         BUS_SPACE_BARRIER_READ)
 482 #define BARRIER_W(SC) bus_space_barrier(SC->memt, SC->memh, 0, HE_REGO_END, \
 483         BUS_SPACE_BARRIER_WRITE)
 484 #define BARRIER_RW(SC) bus_space_barrier(SC->memt, SC->memh, 0, HE_REGO_END, \
 485         BUS_SPACE_BARRIER_READ | BUS_SPACE_BARRIER_WRITE)
 486
 487 #define READ_SUNI(SC,OFF) READ4(SC, HE_REGO_SUNI + 4 * (OFF))
 488 #define WRITE_SUNI(SC,OFF,VAL) WRITE4(SC, HE_REGO_SUNI + 4 * (OFF), (VAL))
 489
 490 #define READ_LB4(SC,OFF)                                                \
 491     ({                                                                  \
 492         WRITE4(SC, HE_REGO_LB_MEM_ADDR, (OFF));                         \
 493         WRITE4(SC, HE_REGO_LB_MEM_ACCESS,                               \
 494             (HE_REGM_LB_MEM_HNDSHK | HE_REGM_LB_MEM_READ));             \
 495         while((READ4(SC, HE_REGO_LB_MEM_ACCESS) & HE_REGM_LB_MEM_HNDSHK))\
 496                 ;                                                       \
 497         READ4(SC, HE_REGO_LB_MEM_DATA);                                 \
 498     })
 499 #define WRITE_LB4(SC,OFF,VAL)                                           \
 500     do {                                                                \
 501         WRITE4(SC, HE_REGO_LB_MEM_ADDR, (OFF));                         \
 502         WRITE4(SC, HE_REGO_LB_MEM_DATA, (VAL));                         \
 503         WRITE4(SC, HE_REGO_LB_MEM_ACCESS,                               \
 504             (HE_REGM_LB_MEM_HNDSHK | HE_REGM_LB_MEM_WRITE));            \
 505         while((READ4(SC, HE_REGO_LB_MEM_ACCESS) & HE_REGM_LB_MEM_HNDSHK))\
 506                 ;                                                       \
 507     } while(0)
 508
 509 #define WRITE_MEM4(SC,OFF,VAL,SPACE)                                    \
 510     do {                                                                \
 511         WRITE4(SC, HE_REGO_CON_DAT, (VAL));                             \
 512         WRITE4(SC, HE_REGO_CON_CTL,                                     \
 513             (SPACE | HE_REGM_CON_WE | HE_REGM_CON_STATUS | (OFF)));     \
 514         while((READ4(SC, HE_REGO_CON_CTL) & HE_REGM_CON_STATUS) != 0)   \
 515                 ;                                                       \
 516     } while(0)
 517
 518 #define READ_MEM4(SC,OFF,SPACE)                                 \
 519     ({                                                                  \
 520         WRITE4(SC, HE_REGO_CON_CTL,                                     \
 521             (SPACE | HE_REGM_CON_STATUS | (OFF)));                      \
 522         while((READ4(SC, HE_REGO_CON_CTL) & HE_REGM_CON_STATUS) != 0)   \
 523                 ;                                                       \
 524         READ4(SC, HE_REGO_CON_DAT);                                     \
 525     })
 526
 527 #define WRITE_TCM4(SC,OFF,VAL) WRITE_MEM4(SC,(OFF),(VAL),HE_REGM_CON_TCM)
 528 #define WRITE_RCM4(SC,OFF,VAL) WRITE_MEM4(SC,(OFF),(VAL),HE_REGM_CON_RCM)
 529 #define WRITE_MBOX4(SC,OFF,VAL) WRITE_MEM4(SC,(OFF),(VAL),HE_REGM_CON_MBOX)
 530
 531 #define READ_TCM4(SC,OFF) READ_MEM4(SC,(OFF),HE_REGM_CON_TCM)
 532 #define READ_RCM4(SC,OFF) READ_MEM4(SC,(OFF),HE_REGM_CON_RCM)
 533 #define READ_MBOX4(SC,OFF) READ_MEM4(SC,(OFF),HE_REGM_CON_MBOX)
 534
 535 #define WRITE_TCM(SC,OFF,BYTES,VAL)                                     \
 536         WRITE_MEM4(SC,(OFF) | ((~(BYTES) & 0xf) << HE_REGS_CON_DIS),    \
 537             (VAL), HE_REGM_CON_TCM)
 538 #define WRITE_RCM(SC,OFF,BYTES,VAL)                                     \
 539         WRITE_MEM4(SC,(OFF) | ((~(BYTES) & 0xf) << HE_REGS_CON_DIS),    \
 540             (VAL), HE_REGM_CON_RCM)
 541
 542 #define READ_TSR(SC,CID,NR)                                             \
 543     ({                                                                  \
 544         uint32_t _v;                                                    \
 545         if((NR) <= 7) {                                                 \
 546                 _v = READ_TCM4(SC, HE_REGO_TSRA(0,CID,NR));             \
 547         } else if((NR) <= 11) {                                         \
 548                 _v = READ_TCM4(SC, HE_REGO_TSRB((SC)->tsrb,CID,(NR-8)));\
 549         } else if((NR) <= 13) {                                         \
 550                 _v = READ_TCM4(SC, HE_REGO_TSRC((SC)->tsrc,CID,(NR-12)));\
 551         } else {                                                        \
 552                 _v = READ_TCM4(SC, HE_REGO_TSRD((SC)->tsrd,CID));       \
 553         }                                                               \
 554         _v;                                                             \
 555     })
 556
 557 #define WRITE_TSR(SC,CID,NR,BEN,VAL)                                    \
 558     do {                                                                \
 559         if((NR) <= 7) {                                                 \
 560                 WRITE_TCM(SC, HE_REGO_TSRA(0,CID,NR),BEN,VAL);          \
 561         } else if((NR) <= 11) {                                         \
 562                 WRITE_TCM(SC, HE_REGO_TSRB((SC)->tsrb,CID,(NR-8)),BEN,VAL);\
 563         } else if((NR) <= 13) {                                         \
 564                 WRITE_TCM(SC, HE_REGO_TSRC((SC)->tsrc,CID,(NR-12)),BEN,VAL);\
 565         } else {                                                        \
 566                 WRITE_TCM(SC, HE_REGO_TSRD((SC)->tsrd,CID),BEN,VAL);    \
 567         }                                                               \
 568     } while(0)
 569
 570 #define READ_RSR(SC,CID,NR)                                             \
 571     ({                                                                  \
 572         uint32_t _v;                                                    \
 573         if((NR) <= 7) {                                                 \
 574                 _v = READ_RCM4(SC, HE_REGO_RSRA(0,CID,NR));             \
 575         } else {                                                        \
 576                 _v = READ_RCM4(SC, HE_REGO_RSRB((SC)->rsrb,CID,(NR-8)));\
 577         }                                                               \
 578         _v;                                                             \
 579     })
 580
 581 #define WRITE_RSR(SC,CID,NR,BEN,VAL)                                    \
 582     do {                                                                \
 583         if((NR) <= 7) {                                                 \
 584                 WRITE_RCM(SC, HE_REGO_RSRA(0,CID,NR),BEN,VAL);          \
 585         } else {                                                        \
 586                 WRITE_RCM(SC, HE_REGO_RSRB((SC)->rsrb,CID,(NR-8)),BEN,VAL);\
 587         }                                                               \
 588     } while(0)
 589
 590 #ifdef HATM_DEBUG
 591 #define DBG(SC, FL, PRINT) do {                                         \
 592         if((SC)->debug & DBG_##FL) {                                    \
 593                 if_printf((SC)->ifp, "%s: ", __func__);                 \
 594                 printf PRINT;                                           \
 595                 printf("\n");                                           \
 596         }                                                               \
 597     } while (0)
 598
 599 enum {
 600         DBG_DUMMY       = 0x0001,       /* default value for -DHATM_DEBUG */
 601         DBG_RX          = 0x0002,
 602         DBG_TX          = 0x0004,
 603         DBG_VCC         = 0x0008,
 604         DBG_IOCTL       = 0x0010,
 605         DBG_ATTACH      = 0x0020,
 606         DBG_INTR        = 0x0040,
 607         DBG_DMA         = 0x0080,
 608         DBG_DMAH        = 0x0100,
 609         DBG_DUMP        = 0x0200,
 610
 611         DBG_ALL         = 0x03ff
 612 };
 613
 614 #else
 615 #define DBG(SC, FL, PRINT)
 616 #endif
 617
 618 u_int hatm_cps2atmf(uint32_t);
 619 u_int hatm_atmf2cps(uint32_t);
 620
 621 void hatm_intr(void *);
 622 int hatm_ioctl(struct ifnet *, u_long, caddr_t);
 623 void hatm_initialize(struct hatm_softc *);
 624 void hatm_stop(struct hatm_softc *sc);
 625 void hatm_start(struct ifnet *);
 626
 627 void hatm_rx(struct hatm_softc *sc, u_int cid, u_int flags, struct mbuf *m,
 628     u_int len);
 629 void hatm_tx_complete(struct hatm_softc *sc, struct tpd *tpd, uint32_t);
 630
 631 int hatm_tx_vcc_can_open(struct hatm_softc *sc, u_int cid, struct hevcc *);
 632 void hatm_tx_vcc_open(struct hatm_softc *sc, u_int cid);
 633 void hatm_rx_vcc_open(struct hatm_softc *sc, u_int cid);
 634 void hatm_tx_vcc_close(struct hatm_softc *sc, u_int cid);
 635 void hatm_rx_vcc_close(struct hatm_softc *sc, u_int cid);
 636 void hatm_tx_vcc_closed(struct hatm_softc *sc, u_int cid);
 637 void hatm_vcc_closed(struct hatm_softc *sc, u_int cid);
 638 void hatm_load_vc(struct hatm_softc *sc, u_int cid, int reopen);
 639
 640 void hatm_ext_free(struct mbufx_free **, struct mbufx_free *);