release/src-rt-6.x.4708/include/hnddma.h

   1 /*
   2  * Generic Broadcom Home Networking Division (HND) DMA engine SW interface
   3  * This supports the following chips: BCM42xx, 44xx, 47xx .
   4  *
   5  * Copyright (C) 2012, Broadcom Corporation. All Rights Reserved.
   6  *
   7  * Permission to use, copy, modify, and/or distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  14  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  16  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  17  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  *
  19  * $Id: hnddma.h 370836 2012-11-23 23:19:04Z $
  20  */
  21
  22 #ifndef _hnddma_h_
  23 #define _hnddma_h_
  24
  25 #ifndef _hnddma_pub_
  26 #define _hnddma_pub_
  27 typedef const struct hnddma_pub hnddma_t;
  28 #endif /* _hnddma_pub_ */
  29
  30 /* range param for dma_getnexttxp() and dma_txreclaim */
  31 typedef enum txd_range {
  32         HNDDMA_RANGE_ALL                = 1,
  33         HNDDMA_RANGE_TRANSMITTED,
  34         HNDDMA_RANGE_TRANSFERED
  35 } txd_range_t;
  36
  37 /* dma parameters id */
  38 enum dma_param_id {
  39         HNDDMA_PID_TX_MULTI_OUTSTD_RD   = 0,
  40         HNDDMA_PID_TX_PREFETCH_CTL,
  41         HNDDMA_PID_TX_PREFETCH_THRESH,
  42         HNDDMA_PID_TX_BURSTLEN,
  43
  44         HNDDMA_PID_RX_PREFETCH_CTL      = 0x100,
  45         HNDDMA_PID_RX_PREFETCH_THRESH,
  46         HNDDMA_PID_RX_BURSTLEN
  47 };
  48
  49 /* dma function type */
  50 typedef void (*di_detach_t)(hnddma_t *dmah);
  51 typedef bool (*di_txreset_t)(hnddma_t *dmah);
  52 typedef bool (*di_rxreset_t)(hnddma_t *dmah);
  53 typedef bool (*di_rxidle_t)(hnddma_t *dmah);
  54 typedef void (*di_txinit_t)(hnddma_t *dmah);
  55 typedef bool (*di_txenabled_t)(hnddma_t *dmah);
  56 typedef void (*di_rxinit_t)(hnddma_t *dmah);
  57 typedef void (*di_txsuspend_t)(hnddma_t *dmah);
  58 typedef void (*di_txresume_t)(hnddma_t *dmah);
  59 typedef bool (*di_txsuspended_t)(hnddma_t *dmah);
  60 typedef bool (*di_txsuspendedidle_t)(hnddma_t *dmah);
  61 typedef void (*di_txflush_t)(hnddma_t *dmah);
  62 typedef void (*di_txflush_clear_t)(hnddma_t *dmah);
  63 typedef int (*di_txfast_t)(hnddma_t *dmah, void *p, bool commit);
  64 typedef int (*di_txunframed_t)(hnddma_t *dmah, void *p, uint len, bool commit);
  65 typedef void* (*di_getpos_t)(hnddma_t *di, bool direction);
  66 typedef void (*di_fifoloopbackenable_t)(hnddma_t *dmah);
  67 typedef bool  (*di_txstopped_t)(hnddma_t *dmah);
  68 typedef bool  (*di_rxstopped_t)(hnddma_t *dmah);
  69 typedef bool  (*di_rxenable_t)(hnddma_t *dmah);
  70 typedef bool  (*di_rxenabled_t)(hnddma_t *dmah);
  71 typedef void* (*di_rx_t)(hnddma_t *dmah);
  72 typedef bool (*di_rxfill_t)(hnddma_t *dmah);
  73 typedef void (*di_txreclaim_t)(hnddma_t *dmah, txd_range_t range);
  74 typedef void (*di_rxreclaim_t)(hnddma_t *dmah);
  75 typedef uintptr (*di_getvar_t)(hnddma_t *dmah, const char *name);
  76 typedef void* (*di_getnexttxp_t)(hnddma_t *dmah, txd_range_t range);
  77 typedef void* (*di_getnextrxp_t)(hnddma_t *dmah, bool forceall);
  78 typedef void* (*di_peeknexttxp_t)(hnddma_t *dmah);
  79 typedef void* (*di_peekntxp_t)(hnddma_t *dmah, int *len, void *txps[], txd_range_t range);
  80 typedef void* (*di_peeknextrxp_t)(hnddma_t *dmah);
  81 typedef void (*di_rxparam_get_t)(hnddma_t *dmah, uint16 *rxoffset, uint16 *rxbufsize);
  82 typedef void (*di_txblock_t)(hnddma_t *dmah);
  83 typedef void (*di_txunblock_t)(hnddma_t *dmah);
  84 typedef uint (*di_txactive_t)(hnddma_t *dmah);
  85 typedef void (*di_txrotate_t)(hnddma_t *dmah);
  86 typedef void (*di_counterreset_t)(hnddma_t *dmah);
  87 typedef uint (*di_ctrlflags_t)(hnddma_t *dmah, uint mask, uint flags);
  88 typedef char* (*di_dump_t)(hnddma_t *dmah, struct bcmstrbuf *b, bool dumpring);
  89 typedef char* (*di_dumptx_t)(hnddma_t *dmah, struct bcmstrbuf *b, bool dumpring);
  90 typedef char* (*di_dumprx_t)(hnddma_t *dmah, struct bcmstrbuf *b, bool dumpring);
  91 typedef uint (*di_rxactive_t)(hnddma_t *dmah);
  92 typedef uint (*di_txpending_t)(hnddma_t *dmah);
  93 typedef uint (*di_txcommitted_t)(hnddma_t *dmah);
  94 typedef int (*di_pktpool_set_t)(hnddma_t *dmah, pktpool_t *pool);
  95 typedef bool (*di_rxtxerror_t)(hnddma_t *dmah, bool istx);
  96 typedef void (*di_burstlen_set_t)(hnddma_t *dmah, uint8 rxburstlen, uint8 txburstlen);
  97 typedef uint (*di_avoidancecnt_t)(hnddma_t *dmah);
  98 typedef void (*di_param_set_t)(hnddma_t *dmah, uint16 paramid, uint16 paramval);
  99 typedef bool (*dma_glom_enable_t) (hnddma_t *dmah, uint32 val);
 100 typedef uint (*dma_active_rxbuf_t) (hnddma_t *dmah);
 101 /* dma opsvec */
 102 typedef struct di_fcn_s {
 103         di_detach_t             detach;
 104         di_txinit_t             txinit;
 105         di_txreset_t            txreset;
 106         di_txenabled_t          txenabled;
 107         di_txsuspend_t          txsuspend;
 108         di_txresume_t           txresume;
 109         di_txsuspended_t        txsuspended;
 110         di_txsuspendedidle_t    txsuspendedidle;
 111         di_txflush_t            txflush;
 112         di_txflush_clear_t      txflush_clear;
 113         di_txfast_t             txfast;
 114         di_txunframed_t         txunframed;
 115         di_getpos_t             getpos;
 116         di_txstopped_t          txstopped;
 117         di_txreclaim_t          txreclaim;
 118         di_getnexttxp_t         getnexttxp;
 119         di_peeknexttxp_t        peeknexttxp;
 120         di_peekntxp_t           peekntxp;
 121         di_txblock_t            txblock;
 122         di_txunblock_t          txunblock;
 123         di_txactive_t           txactive;
 124         di_txrotate_t           txrotate;
 125
 126         di_rxinit_t             rxinit;
 127         di_rxreset_t            rxreset;
 128         di_rxidle_t             rxidle;
 129         di_rxstopped_t          rxstopped;
 130         di_rxenable_t           rxenable;
 131         di_rxenabled_t          rxenabled;
 132         di_rx_t                 rx;
 133         di_rxfill_t             rxfill;
 134         di_rxreclaim_t          rxreclaim;
 135         di_getnextrxp_t         getnextrxp;
 136         di_peeknextrxp_t        peeknextrxp;
 137         di_rxparam_get_t        rxparam_get;
 138
 139         di_fifoloopbackenable_t fifoloopbackenable;
 140         di_getvar_t             d_getvar;
 141         di_counterreset_t       counterreset;
 142         di_ctrlflags_t          ctrlflags;
 143         di_dump_t               dump;
 144         di_dumptx_t             dumptx;
 145         di_dumprx_t             dumprx;
 146         di_rxactive_t           rxactive;
 147         di_txpending_t          txpending;
 148         di_txcommitted_t        txcommitted;
 149         di_pktpool_set_t        pktpool_set;
 150         di_rxtxerror_t          rxtxerror;
 151         di_burstlen_set_t       burstlen_set;
 152         di_avoidancecnt_t       avoidancecnt;
 153         di_param_set_t          param_set;
 154         dma_glom_enable_t       glom_enab;
 155         dma_active_rxbuf_t dma_activerxbuf;
 156         uint                    endnum;
 157 } di_fcn_t;
 158
 159 /*
 160  * Exported data structure (read-only)
 161  */
 162 /* export structure */
 163 struct hnddma_pub {
 164         const di_fcn_t  *di_fn;         /* DMA function pointers */
 165         uint            txavail;        /* # free tx descriptors */
 166         uint            dmactrlflags;   /* dma control flags */
 167
 168         /* rx error counters */
 169         uint            rxgiants;       /* rx giant frames */
 170         uint            rxnobuf;        /* rx out of dma descriptors */
 171         /* tx error counters */
 172         uint            txnobuf;        /* tx out of dma descriptors */
 173         uint            txnodesc;       /* tx out of dma descriptors running count */
 174 };
 175
 176
 177 extern hnddma_t * dma_attach(osl_t *osh, const char *name, si_t *sih,
 178         volatile void *dmaregstx, volatile void *dmaregsrx,
 179         uint ntxd, uint nrxd, uint rxbufsize, int rxextheadroom, uint nrxpost,
 180         uint rxoffset, uint *msg_level);
 181 #ifdef BCMDMA32
 182
 183 #define dma_detach(di)                  ((di)->di_fn->detach(di))
 184 #define dma_txreset(di)                 ((di)->di_fn->txreset(di))
 185 #define dma_rxreset(di)                 ((di)->di_fn->rxreset(di))
 186 #define dma_rxidle(di)                  ((di)->di_fn->rxidle(di))
 187 #define dma_txinit(di)                  ((di)->di_fn->txinit(di))
 188 #define dma_txenabled(di)               ((di)->di_fn->txenabled(di))
 189 #define dma_rxinit(di)                  ((di)->di_fn->rxinit(di))
 190 #define dma_txsuspend(di)               ((di)->di_fn->txsuspend(di))
 191 #define dma_txresume(di)                ((di)->di_fn->txresume(di))
 192 #define dma_txsuspended(di)             ((di)->di_fn->txsuspended(di))
 193 #define dma_txsuspendedidle(di)         ((di)->di_fn->txsuspendedidle(di))
 194 #define dma_txflush(di)                 ((di)->di_fn->txflush(di))
 195 #define dma_txflush_clear(di)           ((di)->di_fn->txflush_clear(di))
 196 #define dma_txfast(di, p, commit)       ((di)->di_fn->txfast(di, p, commit))
 197 #define dma_fifoloopbackenable(di)      ((di)->di_fn->fifoloopbackenable(di))
 198 #define dma_txstopped(di)               ((di)->di_fn->txstopped(di))
 199 #define dma_rxstopped(di)               ((di)->di_fn->rxstopped(di))
 200 #define dma_rxenable(di)                ((di)->di_fn->rxenable(di))
 201 #define dma_rxenabled(di)               ((di)->di_fn->rxenabled(di))
 202 #define dma_rx(di)                      ((di)->di_fn->rx(di))
 203 #define dma_rxfill(di)                  ((di)->di_fn->rxfill(di))
 204 #define dma_txreclaim(di, range)        ((di)->di_fn->txreclaim(di, range))
 205 #define dma_rxreclaim(di)               ((di)->di_fn->rxreclaim(di))
 206 #define dma_getvar(di, name)            ((di)->di_fn->d_getvar(di, name))
 207 #define dma_getnexttxp(di, range)       ((di)->di_fn->getnexttxp(di, range))
 208 #define dma_getnextrxp(di, forceall)    ((di)->di_fn->getnextrxp(di, forceall))
 209 #define dma_peeknexttxp(di)             ((di)->di_fn->peeknexttxp(di))
 210 #define dma_peekntxp(di, l, t, r)       ((di)->di_fn->peekntxp(di, l, t, r))
 211 #define dma_peeknextrxp(di)             ((di)->di_fn->peeknextrxp(di))
 212 #define dma_rxparam_get(di, off, bufs)  ((di)->di_fn->rxparam_get(di, off, bufs))
 213
 214 #define dma_txblock(di)                 ((di)->di_fn->txblock(di))
 215 #define dma_txunblock(di)               ((di)->di_fn->txunblock(di))
 216 #define dma_txactive(di)                ((di)->di_fn->txactive(di))
 217 #define dma_rxactive(di)                ((di)->di_fn->rxactive(di))
 218 #define dma_txrotate(di)                ((di)->di_fn->txrotate(di))
 219 #define dma_counterreset(di)            ((di)->di_fn->counterreset(di))
 220 #define dma_ctrlflags(di, mask, flags)  ((di)->di_fn->ctrlflags((di), (mask), (flags)))
 221 #define dma_txpending(di)               ((di)->di_fn->txpending(di))
 222 #define dma_txcommitted(di)             ((di)->di_fn->txcommitted(di))
 223 #define dma_pktpool_set(di, pool)       ((di)->di_fn->pktpool_set((di), (pool)))
 224 #if defined(BCMDBG)
 225 #define dma_dump(di, buf, dumpring)     ((di)->di_fn->dump(di, buf, dumpring))
 226 #define dma_dumptx(di, buf, dumpring)   ((di)->di_fn->dumptx(di, buf, dumpring))
 227 #define dma_dumprx(di, buf, dumpring)   ((di)->di_fn->dumprx(di, buf, dumpring))
 228 #endif
 229 #define dma_rxtxerror(di, istx) ((di)->di_fn->rxtxerror(di, istx))
 230 #define dma_burstlen_set(di, rxlen, txlen)      ((di)->di_fn->burstlen_set(di, rxlen, txlen))
 231 #define dma_avoidance_cnt(di)           ((di)->di_fn->avoidancecnt(di))
 232 #define dma_param_set(di, paramid, paramval)    ((di)->di_fn->param_set(di, paramid, paramval))
 233
 234 #else /* BCMDMA32 */
 235 extern const di_fcn_t dma64proc;
 236
 237 #define dma_detach(di)                  (dma64proc.detach(di))
 238 #define dma_txreset(di)                 (dma64proc.txreset(di))
 239 #define dma_rxreset(di)                 (dma64proc.rxreset(di))
 240 #define dma_rxidle(di)                  (dma64proc.rxidle(di))
 241 #define dma_txinit(di)                  (dma64proc.txinit(di))
 242 #define dma_txenabled(di)               (dma64proc.txenabled(di))
 243 #define dma_rxinit(di)                  (dma64proc.rxinit(di))
 244 #define dma_txsuspend(di)               (dma64proc.txsuspend(di))
 245 #define dma_txresume(di)                (dma64proc.txresume(di))
 246 #define dma_txsuspended(di)             (dma64proc.txsuspended(di))
 247 #define dma_txsuspendedidle(di)         (dma64proc.txsuspendedidle(di))
 248 #define dma_txflush(di)                 (dma64proc.txflush(di))
 249 #define dma_txflush_clear(di)           (dma64proc.txflush_clear(di))
 250 #define dma_txfast(di, p, commit)       (dma64proc.txfast(di, p, commit))
 251 #define dma_txunframed(di, p, l, commit)(dma64proc.txunframed(di, p, l, commit))
 252 #define dma_getpos(di, dir)             (dma64proc.getpos(di, dir))
 253 #define dma_fifoloopbackenable(di)      (dma64proc.fifoloopbackenable(di))
 254 #define dma_txstopped(di)               (dma64proc.txstopped(di))
 255 #define dma_rxstopped(di)               (dma64proc.rxstopped(di))
 256 #define dma_rxenable(di)                (dma64proc.rxenable(di))
 257 #define dma_rxenabled(di)               (dma64proc.rxenabled(di))
 258 #define dma_rx(di)                      (dma64proc.rx(di))
 259 #define dma_rxfill(di)                  (dma64proc.rxfill(di))
 260 #define dma_txreclaim(di, range)        (dma64proc.txreclaim(di, range))
 261 #define dma_rxreclaim(di)               (dma64proc.rxreclaim(di))
 262 #define dma_getvar(di, name)            (dma64proc.d_getvar(di, name))
 263 #define dma_getnexttxp(di, range)       (dma64proc.getnexttxp(di, range))
 264 #define dma_getnextrxp(di, forceall)    (dma64proc.getnextrxp(di, forceall))
 265 #define dma_peeknexttxp(di)             (dma64proc.peeknexttxp(di))
 266 #define dma_peekntxp(di, l, t, r)       (dma64proc.peekntxp(di, l, t, r))
 267 #define dma_peeknextrxp(di)             (dma64proc.peeknextrxp(di))
 268 #define dma_rxparam_get(di, off, bufs)  (dma64proc.rxparam_get(di, off, bufs))
 269
 270 #define dma_txblock(di)                 (dma64proc.txblock(di))
 271 #define dma_txunblock(di)               (dma64proc.txunblock(di))
 272 #define dma_txactive(di)                (dma64proc.txactive(di))
 273 #define dma_rxactive(di)                (dma64proc.rxactive(di))
 274 #define dma_txrotate(di)                (dma64proc.txrotate(di))
 275 #define dma_counterreset(di)            (dma64proc.counterreset(di))
 276 #define dma_ctrlflags(di, mask, flags)  (dma64proc.ctrlflags((di), (mask), (flags)))
 277 #define dma_txpending(di)               (dma64proc.txpending(di))
 278 #define dma_txcommitted(di)             (dma64proc.txcommitted(di))
 279 #define dma_pktpool_set(di, pool)       (dma64proc.pktpool_set((di), (pool)))
 280 #if defined(BCMDBG)
 281 #define dma_dump(di, buf, dumpring)     (dma64proc.dump(di, buf, dumpring))
 282 #define dma_dumptx(di, buf, dumpring)   (dma64proc.dumptx(di, buf, dumpring))
 283 #define dma_dumprx(di, buf, dumpring)   (dma64proc.dumprx(di, buf, dumpring))
 284 #endif
 285 #define dma_rxtxerror(di, istx) (dma64proc.rxtxerror(di, istx))
 286 #define dma_burstlen_set(di, rxlen, txlen)      (dma64proc.burstlen_set(di, rxlen, txlen))
 287 #define dma_avoidance_cnt(di)           (dma64proc.avoidancecnt(di))
 288 #define dma_param_set(di, paramid, paramval)    (dma64proc.param_set(di, paramid, paramval))
 289
 290 #define dma_glom_enable(di, val)        (dma64proc.glom_enab(di, val))
 291 #define dma_activerxbuf(di)     (dma64proc.dma_activerxbuf(di))
 292
 293 #endif /* BCMDMA32 */
 294
 295 /* return addresswidth allowed
 296  * This needs to be done after SB attach but before dma attach.
 297  * SB attach provides ability to probe backplane and dma core capabilities
 298  * This info is needed by DMA_ALLOC_CONSISTENT in dma attach
 299  */
 300 extern uint dma_addrwidth(si_t *sih, void *dmaregs);
 301
 302 /* pio helpers */
 303 extern void dma_txpioloopback(osl_t *osh, dma32regs_t *);
 304
 305 #endif  /* _hnddma_h_ */