sys/dev/ic/dp83932var.h

   1 /*      $NetBSD: dp83932var.h,v 1.11 2008/04/28 20:23:49 martin Exp $   */
   2
   3 /*-
   4  * Copyright (c) 2001 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #ifndef _DEV_IC_DP83932VAR_H_
  33 #define _DEV_IC_DP83932VAR_H_
  34
  35 /*
  36  * Data structure definitions for the National Semiconductor DP83932
  37  * Systems-Oriented Network Interface Controller (SONIC).
  38  */
  39
  40 /*
  41  * NOTE: The control data for the SONIC must not cross a 64k boundary,
  42  * so we have to be careful about how we size things.
  43  *
  44  * Also, since the SONIC is only a 10Mb/s chip, and systems on which
  45  * it is present tend to be low on memory, we try to keep the data
  46  * structure sizes small.
  47  */
  48
  49 /*
  50  * Transmit descriptor list size.
  51  */
  52 #define SONIC_NTXDESC           32
  53 #define SONIC_NTXDESC_MASK      (SONIC_NTXDESC - 1)
  54 #define SONIC_NEXTTX(x)         (((x) + 1) & SONIC_NTXDESC_MASK)
  55
  56 /*
  57  * Receive descriptor list size.
  58  */
  59 #define SONIC_NRXDESC           32
  60 #define SONIC_NRXDESC_MASK      (SONIC_NRXDESC - 1)
  61 #define SONIC_NEXTRX(x)         (((x) + 1) & SONIC_NRXDESC_MASK)
  62 #define SONIC_PREVRX(x)         (((x) - 1) & SONIC_NRXDESC_MASK)
  63 #define SONIC_RXSEQ_TO_DESC(x)  ((x) & SONIC_NRXDESC_MASK)
  64
  65 /*
  66  * Number of CAM entries.
  67  */
  68 #define SONIC_NCAMENT           16
  69
  70 /*
  71  * Control structures are DMA'd to the SONIC chip.  We allocate them in
  72  * a single clump that maps to a single DMA segment to make several things
  73  * easier.
  74  */
  75 struct sonic_control_data16 {
  76         /*
  77          * The transmit descriptors.
  78          */
  79         struct sonic_tda16 scd_txdescs[SONIC_NTXDESC];
  80
  81         /*
  82          * The receive descriptors.
  83          */
  84         struct sonic_rda16 scd_rxdescs[SONIC_NRXDESC];
  85
  86         /*
  87          * The receive resource descriptors.
  88          */
  89         struct sonic_rra16 scd_rxbufs[SONIC_NRXDESC];
  90
  91         /*
  92          * The CAM descriptors.
  93          */
  94         struct sonic_cda16 scd_cam[SONIC_NCAMENT];
  95         uint16_t scd_camenable;
  96 };
  97
  98 #define SONIC_CDOFF16(x)        offsetof(struct sonic_control_data16, x)
  99 #define SONIC_CDTXOFF16(x)      SONIC_CDOFF16(scd_txdescs[(x)])
 100 #define SONIC_CDRXOFF16(x)      SONIC_CDOFF16(scd_rxdescs[(x)])
 101 #define SONIC_CDRROFF16(x)      SONIC_CDOFF16(scd_rxbufs[(x)])
 102 #define SONIC_CDCAMOFF16        SONIC_CDOFF16(scd_cam)
 103 #define SONIC_CDCAMSIZE16       \
 104         (sizeof(struct sonic_cda16) * SONIC_NCAMENT + sizeof(uint16_t))
 105
 106 struct sonic_control_data32 {
 107         /*
 108          * The transmit descriptors.
 109          */
 110         struct sonic_tda32 scd_txdescs[SONIC_NTXDESC];
 111
 112         /*
 113          * The receive descriptors.
 114          */
 115         struct sonic_rda32 scd_rxdescs[SONIC_NRXDESC];
 116
 117         /*
 118          * The receive resource descriptors.
 119          */
 120         struct sonic_rra32 scd_rxbufs[SONIC_NRXDESC];
 121
 122         /*
 123          * The CAM descriptors.
 124          */
 125         struct sonic_cda32 scd_cam[SONIC_NCAMENT];
 126         uint32_t scd_camenable;
 127 };
 128
 129 #define SONIC_CDOFF32(x)        offsetof(struct sonic_control_data32, x)
 130 #define SONIC_CDTXOFF32(x)      SONIC_CDOFF32(scd_txdescs[(x)])
 131 #define SONIC_CDRXOFF32(x)      SONIC_CDOFF32(scd_rxdescs[(x)])
 132 #define SONIC_CDRROFF32(x)      SONIC_CDOFF32(scd_rxbufs[(x)])
 133 #define SONIC_CDCAMOFF32        SONIC_CDOFF32(scd_cam)
 134 #define SONIC_CDCAMSIZE32       \
 135         (sizeof(struct sonic_cda32) * SONIC_NCAMENT + sizeof(uint32_t))
 136
 137 /*
 138  * Software state for transmit and receive descriptors.
 139  */
 140 struct sonic_descsoft {
 141         struct mbuf *ds_mbuf;           /* head of mbuf chain */
 142         bus_dmamap_t ds_dmamap;         /* our DMA map */
 143 };
 144
 145 /*
 146  * Software state per device.
 147  */
 148 struct sonic_softc {
 149         device_t sc_dev;                /* generic device information */
 150         bus_space_tag_t sc_st;          /* bus space tag */
 151         bus_space_handle_t sc_sh;       /* bus space handle */
 152         bus_dma_tag_t sc_dmat;          /* bus DMA tag */
 153         struct ethercom sc_ethercom;    /* ethernet common data */
 154
 155         int sc_32bit;                   /* use 32-bit mode */
 156         int sc_bigendian;               /* BMODE -> Vcc */
 157
 158         /* Our register map. */
 159         bus_addr_t sc_regmap[SONIC_NREGS];
 160
 161         bus_dmamap_t sc_cddmamap;       /* control data DMA map */
 162 #define sc_cddma        sc_cddmamap->dm_segs[0].ds_addr
 163         bus_dmamap_t sc_nulldmamap;     /* DMA map for the pad buffer */
 164 #define sc_nulldma     sc_nulldmamap->dm_segs[0].ds_addr
 165
 166         /*
 167          * Software state for transmit and receive descriptors.
 168          */
 169         struct sonic_descsoft sc_txsoft[SONIC_NTXDESC];
 170         struct sonic_descsoft sc_rxsoft[SONIC_NRXDESC];
 171
 172         /*
 173          * Control data structures.
 174          */
 175         union {
 176                 struct sonic_control_data16 *cdun_16;
 177                 struct sonic_control_data32 *cdun_32;
 178         } sc_cdun;
 179 #define sc_cdata16      sc_cdun.cdun_16
 180 #define sc_cdata32      sc_cdun.cdun_32
 181
 182 #define sc_tda16        sc_cdun.cdun_16->scd_txdescs
 183 #define sc_rda16        sc_cdun.cdun_16->scd_rxdescs
 184 #define sc_rra16        sc_cdun.cdun_16->scd_rxbufs
 185 #define sc_cda16        sc_cdun.cdun_16->scd_cam
 186 #define sc_cdaenable16  sc_cdun.cdun_16->scd_camenable
 187
 188 #define sc_tda32        sc_cdun.cdun_32->scd_txdescs
 189 #define sc_rda32        sc_cdun.cdun_32->scd_rxdescs
 190 #define sc_rra32        sc_cdun.cdun_32->scd_rxbufs
 191 #define sc_cda32        sc_cdun.cdun_32->scd_cam
 192 #define sc_cdaenable32  sc_cdun.cdun_32->scd_camenable
 193
 194         int     sc_txpending;           /* number of Tx requests pending */
 195         int     sc_txdirty;             /* first dirty Tx descriptor */
 196         int     sc_txlast;              /* last used Tx descriptor */
 197
 198         int     sc_rxptr;               /* next ready Rx descriptor */
 199
 200         uint16_t sc_imr;                /* prototype IMR */
 201         uint16_t sc_dcr;                /* prototype DCR */
 202         uint16_t sc_dcr2;               /* prototype DCR2 */
 203 };
 204
 205 #define CSR_READ(sc, reg)                                               \
 206         bus_space_read_2((sc)->sc_st, (sc)->sc_sh,                      \
 207             (sc)->sc_regmap[(reg)])
 208
 209 #define CSR_WRITE(sc, reg, val)                                         \
 210         bus_space_write_2((sc)->sc_st, (sc)->sc_sh,                     \
 211             (sc)->sc_regmap[(reg)], (val))
 212
 213 #define SONIC_CDTXADDR16(sc, x)                                         \
 214         ((sc)->sc_cddma + SONIC_CDTXOFF16((x)))
 215
 216 #define SONIC_CDTXADDR32(sc, x)                                         \
 217         ((sc)->sc_cddma + SONIC_CDTXOFF32((x)))
 218
 219 #define SONIC_CDTXADDR(sc, x)                                           \
 220         ((sc)->sc_32bit ? SONIC_CDTXADDR32((sc), (x)) :                 \
 221             SONIC_CDTXADDR16((sc), (x)))
 222
 223 #define SONIC_CDRXADDR16(sc, x)                                         \
 224         ((sc)->sc_cddma + SONIC_CDRXOFF16((x)))
 225
 226 #define SONIC_CDRXADDR32(sc, x)                                         \
 227         ((sc)->sc_cddma + SONIC_CDRXOFF32((x)))
 228
 229 #define SONIC_CDRXADDR(sc, x)                                           \
 230         ((sc)->sc_32bit ? SONIC_CDRXADDR32((sc), (x)) :                 \
 231             SONIC_CDRXADDR16((sc), (x)))
 232
 233 #define SONIC_CDRRADDR(sc, x)                                           \
 234         ((sc)->sc_cddma +                                               \
 235          ((sc)->sc_32bit ? SONIC_CDRROFF32((x)) : SONIC_CDRROFF16((x))))
 236
 237 #define SONIC_CDCAMADDR(sc)                                             \
 238         ((sc)->sc_cddma +                                               \
 239          ((sc)->sc_32bit ? SONIC_CDCAMOFF32 : SONIC_CDCAMOFF16))
 240
 241 #define SONIC_CDTXSYNC16(sc, x, ops)                                    \
 242         bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_cddmamap,               \
 243             SONIC_CDTXOFF16((x)), sizeof(struct sonic_tda16), (ops))
 244
 245 #define SONIC_CDTXSYNC32(sc, x, ops)                                    \
 246         bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_cddmamap,               \
 247             SONIC_CDTXOFF32((x)), sizeof(struct sonic_tda32), (ops))
 248
 249 #define SONIC_CDRXSYNC16(sc, x, ops)                                    \
 250         bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_cddmamap,               \
 251             SONIC_CDRXOFF16((x)), sizeof(struct sonic_rda16), (ops))
 252
 253 #define SONIC_CDRXSYNC32(sc, x, ops)                                    \
 254         bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_cddmamap,               \
 255             SONIC_CDRXOFF32((x)), sizeof(struct sonic_rda32), (ops))
 256
 257 #define SONIC_CDRRSYNC16(sc, x, ops)                                    \
 258         bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_cddmamap,               \
 259             SONIC_CDRROFF16((x)), sizeof(struct sonic_rra16), (ops))
 260
 261 #define SONIC_CDRRSYNC32(sc, x, ops)                                    \
 262         bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_cddmamap,               \
 263             SONIC_CDRROFF32((x)), sizeof(struct sonic_rra32), (ops))
 264
 265 #define SONIC_CDCAMSYNC(sc, ops)                                        \
 266 do {                                                                    \
 267         if ((sc)->sc_32bit)                                             \
 268                 bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_cddmamap,       \
 269                     SONIC_CDCAMOFF32, SONIC_CDCAMSIZE32,                \
 270                     (ops));                                             \
 271         else                                                            \
 272                 bus_dmamap_sync((sc)->sc_dmat, (sc)->sc_cddmamap,       \
 273                     SONIC_CDCAMOFF16, SONIC_CDCAMSIZE16,                \
 274                     (ops));                                             \
 275 } while (/*CONSTCOND*/0)
 276
 277 #define SONIC_INIT_RXDESC(sc, x)                                        \
 278 do {                                                                    \
 279         struct sonic_descsoft *__ds = &(sc)->sc_rxsoft[(x)];            \
 280         struct mbuf *__m = __ds->ds_mbuf;                               \
 281                                                                         \
 282         if ((sc)->sc_32bit) {                                           \
 283                 /*                                                      \
 284                  * Unfortuantely, in 32-bit mode, the Rx buffer must    \
 285                  * be 32-bit aligned.                                   \
 286                  */                                                     \
 287                 struct sonic_rda32 *__rda = &(sc)->sc_rda32[(x)];       \
 288                 struct sonic_rda32 *__prda =                            \
 289                     &(sc)->sc_rda32[SONIC_PREVRX((x))];                 \
 290                 struct sonic_rra32 *__rra = &(sc)->sc_rra32[(x)];       \
 291                                                                         \
 292                 __m->m_data = __m->m_ext.ext_buf;                       \
 293                                                                         \
 294                 __rra->rra_ptr1 =                                       \
 295                     __ds->ds_dmamap->dm_segs[0].ds_addr >> 16;          \
 296                 __rra->rra_ptr0 =                                       \
 297                     __ds->ds_dmamap->dm_segs[0].ds_addr & 0xffff;       \
 298                 __rra->rra_wc1 = 0;                                     \
 299                 __rra->rra_wc0 = (ETHER_MAX_LEN + 6) / 2;               \
 300                                                                         \
 301                 __rda->rda_link =                                       \
 302                     (SONIC_CDRXADDR32((sc), SONIC_NEXTRX((x))) & 0xffff) |\
 303                     RDA_LINK_EOL;                                       \
 304                 __rda->rda_inuse = 1;                                   \
 305                                                                         \
 306                 __prda->rda_link = SONIC_CDRXADDR32((sc), (x));         \
 307                                                                         \
 308                 SONIC_CDRRSYNC32((sc), (x), BUS_DMASYNC_PREWRITE);      \
 309                 SONIC_CDRXSYNC32((sc), (x),                             \
 310                     BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);          \
 311                 SONIC_CDRXSYNC32((sc), SONIC_PREVRX(x),                 \
 312                     BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);          \
 313         } else {                                                        \
 314                 /*                                                      \
 315                  * In 16-bit mode, we scoot the packet forward 2 bytes  \
 316                  * so that the payload after the Ethernet header is     \
 317                  * suitably aligned.                                    \
 318                  */                                                     \
 319                 struct sonic_rda16 *__rda = &(sc)->sc_rda16[(x)];       \
 320                 struct sonic_rda16 *__prda =                            \
 321                     &(sc)->sc_rda16[SONIC_PREVRX((x))];                 \
 322                 struct sonic_rra16 *__rra = &(sc)->sc_rra16[(x)];       \
 323                                                                         \
 324                 __m->m_data = __m->m_ext.ext_buf + 2;                   \
 325                                                                         \
 326                 __rra->rra_ptr1 =                                       \
 327                     __ds->ds_dmamap->dm_segs[0].ds_addr >> 16;          \
 328                 __rra->rra_ptr0 =                                       \
 329                     (__ds->ds_dmamap->dm_segs[0].ds_addr + 2) & 0xffff; \
 330                 __rra->rra_wc1 = 0;                                     \
 331                 __rra->rra_wc0 = (ETHER_MAX_LEN + 2) / 2;               \
 332                                                                         \
 333                 __rda->rda_link =                                       \
 334                     (SONIC_CDRXADDR16((sc), SONIC_NEXTRX((x))) & 0xffff) |\
 335                     RDA_LINK_EOL;                                       \
 336                 __rda->rda_inuse = 1;                                   \
 337                                                                         \
 338                 __prda->rda_link = SONIC_CDRXADDR16((sc), (x));         \
 339                                                                         \
 340                 SONIC_CDRRSYNC16((sc), (x), BUS_DMASYNC_PREWRITE);      \
 341                 SONIC_CDRXSYNC16((sc), (x),                             \
 342                     BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);          \
 343                 SONIC_CDRXSYNC16((sc), SONIC_PREVRX(x),                 \
 344                     BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);          \
 345         }                                                               \
 346 } while (/*CONSTCOND*/0)
 347
 348 static __inline uint16_t __unused
 349 htosonic16(struct sonic_softc *sc, uint16_t val)
 350 {
 351
 352         if (sc->sc_bigendian)
 353                 return (htobe16(val));
 354         return (htole16(val));
 355 }
 356
 357 static __inline uint16_t __unused
 358 sonic16toh(struct sonic_softc *sc, uint16_t val)
 359 {
 360
 361         if (sc->sc_bigendian)
 362                 return (be16toh(val));
 363         return (le16toh(val));
 364 }
 365
 366 static __inline uint32_t __unused
 367 htosonic32(struct sonic_softc *sc, uint32_t val)
 368 {
 369
 370         if (sc->sc_bigendian)
 371                 return (htobe32(val));
 372         return (htole32(val));
 373 }
 374
 375 static __inline uint32_t __unused
 376 sonic32toh(struct sonic_softc *sc, uint32_t val)
 377 {
 378
 379         if (sc->sc_bigendian)
 380                 return (be32toh(val));
 381         return (le32toh(val));
 382 }
 383
 384 #ifdef _KERNEL
 385 void    sonic_attach(struct sonic_softc *, const uint8_t *);
 386 int     sonic_intr(void *);
 387 #endif /* _KERNEL */
 388
 389 #endif /* _DEV_IC_DP83932VAR_H_ */