release/src-rt/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) 2011, 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 321146 2012-03-14 08:27:23Z $
  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 #ifdef WL_MULTIQUEUE
  62 typedef void (*di_txflush_t)(hnddma_t *dmah);
  63 typedef void (*di_txflush_clear_t)(hnddma_t *dmah);
  64 #endif /* WL_MULTIQUEUE */
  65 typedef int (*di_txfast_t)(hnddma_t *dmah, void *p, bool commit);
  66 typedef int (*di_txunframed_t)(hnddma_t *dmah, void *p, uint len, bool commit);
  67 typedef void* (*di_getpos_t)(hnddma_t *di, bool direction);
  68 typedef void (*di_fifoloopbackenable_t)(hnddma_t *dmah);
  69 typedef bool  (*di_txstopped_t)(hnddma_t *dmah);
  70 typedef bool  (*di_rxstopped_t)(hnddma_t *dmah);
  71 typedef bool  (*di_rxenable_t)(hnddma_t *dmah);
  72 typedef bool  (*di_rxenabled_t)(hnddma_t *dmah);
  73 typedef void* (*di_rx_t)(hnddma_t *dmah);
  74 typedef bool (*di_rxfill_t)(hnddma_t *dmah);
  75 typedef void (*di_txreclaim_t)(hnddma_t *dmah, txd_range_t range);
  76 typedef void (*di_rxreclaim_t)(hnddma_t *dmah);
  77 typedef uintptr (*di_getvar_t)(hnddma_t *dmah, const char *name);
  78 typedef void* (*di_getnexttxp_t)(hnddma_t *dmah, txd_range_t range);
  79 typedef void* (*di_getnextrxp_t)(hnddma_t *dmah, bool forceall);
  80 typedef void* (*di_peeknexttxp_t)(hnddma_t *dmah);
  81 typedef void* (*di_peekntxp_t)(hnddma_t *dmah, int *len, void *txps[], txd_range_t range);
  82 typedef void* (*di_peeknextrxp_t)(hnddma_t *dmah);
  83 typedef void (*di_rxparam_get_t)(hnddma_t *dmah, uint16 *rxoffset, uint16 *rxbufsize);
  84 typedef void (*di_txblock_t)(hnddma_t *dmah);
  85 typedef void (*di_txunblock_t)(hnddma_t *dmah);
  86 typedef uint (*di_txactive_t)(hnddma_t *dmah);
  87 typedef void (*di_txrotate_t)(hnddma_t *dmah);
  88 typedef void (*di_counterreset_t)(hnddma_t *dmah);
  89 typedef uint (*di_ctrlflags_t)(hnddma_t *dmah, uint mask, uint flags);
  90 typedef char* (*di_dump_t)(hnddma_t *dmah, struct bcmstrbuf *b, bool dumpring);
  91 typedef char* (*di_dumptx_t)(hnddma_t *dmah, struct bcmstrbuf *b, bool dumpring);
  92 typedef char* (*di_dumprx_t)(hnddma_t *dmah, struct bcmstrbuf *b, bool dumpring);
  93 typedef uint (*di_rxactive_t)(hnddma_t *dmah);
  94 typedef uint (*di_txpending_t)(hnddma_t *dmah);
  95 typedef uint (*di_txcommitted_t)(hnddma_t *dmah);
  96 typedef int (*di_pktpool_set_t)(hnddma_t *dmah, pktpool_t *pool);
  97 typedef bool (*di_rxtxerror_t)(hnddma_t *dmah, bool istx);
  98 typedef void (*di_burstlen_set_t)(hnddma_t *dmah, uint8 rxburstlen, uint8 txburstlen);
  99 typedef uint (*di_avoidancecnt_t)(hnddma_t *dmah);
 100 typedef void (*di_param_set_t)(hnddma_t *dmah, uint16 paramid, uint16 paramval);
 101 typedef bool (*dma_glom_enable_t) (hnddma_t *dmah, uint32 val);
 102 /* dma opsvec */
 103 typedef struct di_fcn_s {
 104         di_detach_t             detach;
 105         di_txinit_t             txinit;
 106         di_txreset_t            txreset;
 107         di_txenabled_t          txenabled;
 108         di_txsuspend_t          txsuspend;
 109         di_txresume_t           txresume;
 110         di_txsuspended_t        txsuspended;
 111         di_txsuspendedidle_t    txsuspendedidle;
 112 #ifdef WL_MULTIQUEUE
 113         di_txflush_t            txflush;
 114         di_txflush_clear_t      txflush_clear;
 115 #endif /* WL_MULTIQUEUE */
 116         di_txfast_t             txfast;
 117         di_txunframed_t         txunframed;
 118         di_getpos_t             getpos;
 119         di_txstopped_t          txstopped;
 120         di_txreclaim_t          txreclaim;
 121         di_getnexttxp_t         getnexttxp;
 122         di_peeknexttxp_t        peeknexttxp;
 123         di_peekntxp_t           peekntxp;
 124         di_txblock_t            txblock;
 125         di_txunblock_t          txunblock;
 126         di_txactive_t           txactive;
 127         di_txrotate_t           txrotate;
 128
 129         di_rxinit_t             rxinit;
 130         di_rxreset_t            rxreset;
 131         di_rxidle_t             rxidle;
 132         di_rxstopped_t          rxstopped;
 133         di_rxenable_t           rxenable;
 134         di_rxenabled_t          rxenabled;
 135         di_rx_t                 rx;
 136         di_rxfill_t             rxfill;
 137         di_rxreclaim_t          rxreclaim;
 138         di_getnextrxp_t         getnextrxp;
 139         di_peeknextrxp_t        peeknextrxp;
 140         di_rxparam_get_t        rxparam_get;
 141
 142         di_fifoloopbackenable_t fifoloopbackenable;
 143         di_getvar_t             d_getvar;
 144         di_counterreset_t       counterreset;
 145         di_ctrlflags_t          ctrlflags;
 146         di_dump_t               dump;
 147         di_dumptx_t             dumptx;
 148         di_dumprx_t             dumprx;
 149         di_rxactive_t           rxactive;
 150         di_txpending_t          txpending;
 151         di_txcommitted_t        txcommitted;
 152         di_pktpool_set_t        pktpool_set;
 153         di_rxtxerror_t          rxtxerror;
 154         di_burstlen_set_t       burstlen_set;
 155         di_avoidancecnt_t       avoidancecnt;
 156         di_param_set_t          param_set;
 157         dma_glom_enable_t       glom_enab;
 158         uint                    endnum;
 159 } di_fcn_t;
 160
 161 /*
 162  * Exported data structure (read-only)
 163  */
 164 /* export structure */
 165 struct hnddma_pub {
 166         const di_fcn_t  *di_fn;         /* DMA function pointers */
 167         uint            txavail;        /* # free tx descriptors */
 168         uint            dmactrlflags;   /* dma control flags */
 169
 170         /* rx error counters */
 171         uint            rxgiants;       /* rx giant frames */
 172         uint            rxnobuf;        /* rx out of dma descriptors */
 173         /* tx error counters */
 174         uint            txnobuf;        /* tx out of dma descriptors */
 175         uint            txnodesc;       /* tx out of dma descriptors running count */
 176 };
 177
 178
 179 extern hnddma_t * dma_attach(osl_t *osh, const char *name, si_t *sih,
 180         volatile void *dmaregstx, volatile void *dmaregsrx,
 181         uint ntxd, uint nrxd, uint rxbufsize, int rxextheadroom, uint nrxpost,
 182         uint rxoffset, uint *msg_level);
 183 #ifdef BCMDMA32
 184
 185 #define dma_detach(di)                  ((di)->di_fn->detach(di))
 186 #define dma_txreset(di)                 ((di)->di_fn->txreset(di))
 187 #define dma_rxreset(di)                 ((di)->di_fn->rxreset(di))
 188 #define dma_rxidle(di)                  ((di)->di_fn->rxidle(di))
 189 #define dma_txinit(di)                  ((di)->di_fn->txinit(di))
 190 #define dma_txenabled(di)               ((di)->di_fn->txenabled(di))
 191 #define dma_rxinit(di)                  ((di)->di_fn->rxinit(di))
 192 #define dma_txsuspend(di)               ((di)->di_fn->txsuspend(di))
 193 #define dma_txresume(di)                ((di)->di_fn->txresume(di))
 194 #define dma_txsuspended(di)             ((di)->di_fn->txsuspended(di))
 195 #define dma_txsuspendedidle(di)         ((di)->di_fn->txsuspendedidle(di))
 196 #ifdef WL_MULTIQUEUE
 197 #define dma_txflush(di)                 ((di)->di_fn->txflush(di))
 198 #define dma_txflush_clear(di)           ((di)->di_fn->txflush_clear(di))
 199 #endif /* WL_MULTIQUEUE */
 200 #define dma_txfast(di, p, commit)       ((di)->di_fn->txfast(di, p, commit))
 201 #define dma_fifoloopbackenable(di)      ((di)->di_fn->fifoloopbackenable(di))
 202 #define dma_txstopped(di)               ((di)->di_fn->txstopped(di))
 203 #define dma_rxstopped(di)               ((di)->di_fn->rxstopped(di))
 204 #define dma_rxenable(di)                ((di)->di_fn->rxenable(di))
 205 #define dma_rxenabled(di)               ((di)->di_fn->rxenabled(di))
 206 #define dma_rx(di)                      ((di)->di_fn->rx(di))
 207 #define dma_rxfill(di)                  ((di)->di_fn->rxfill(di))
 208 #define dma_txreclaim(di, range)        ((di)->di_fn->txreclaim(di, range))
 209 #define dma_rxreclaim(di)               ((di)->di_fn->rxreclaim(di))
 210 #define dma_getvar(di, name)            ((di)->di_fn->d_getvar(di, name))
 211 #define dma_getnexttxp(di, range)       ((di)->di_fn->getnexttxp(di, range))
 212 #define dma_getnextrxp(di, forceall)    ((di)->di_fn->getnextrxp(di, forceall))
 213 #define dma_peeknexttxp(di)             ((di)->di_fn->peeknexttxp(di))
 214 #define dma_peekntxp(di, l, t, r)       ((di)->di_fn->peekntxp(di, l, t, r))
 215 #define dma_peeknextrxp(di)             ((di)->di_fn->peeknextrxp(di))
 216 #define dma_rxparam_get(di, off, bufs)  ((di)->di_fn->rxparam_get(di, off, bufs))
 217
 218 #define dma_txblock(di)                 ((di)->di_fn->txblock(di))
 219 #define dma_txunblock(di)               ((di)->di_fn->txunblock(di))
 220 #define dma_txactive(di)                ((di)->di_fn->txactive(di))
 221 #define dma_rxactive(di)                ((di)->di_fn->rxactive(di))
 222 #define dma_txrotate(di)                ((di)->di_fn->txrotate(di))
 223 #define dma_counterreset(di)            ((di)->di_fn->counterreset(di))
 224 #define dma_ctrlflags(di, mask, flags)  ((di)->di_fn->ctrlflags((di), (mask), (flags)))
 225 #define dma_txpending(di)               ((di)->di_fn->txpending(di))
 226 #define dma_txcommitted(di)             ((di)->di_fn->txcommitted(di))
 227 #define dma_pktpool_set(di, pool)       ((di)->di_fn->pktpool_set((di), (pool)))
 228 #if defined(BCMDBG)
 229 #define dma_dump(di, buf, dumpring)     ((di)->di_fn->dump(di, buf, dumpring))
 230 #define dma_dumptx(di, buf, dumpring)   ((di)->di_fn->dumptx(di, buf, dumpring))
 231 #define dma_dumprx(di, buf, dumpring)   ((di)->di_fn->dumprx(di, buf, dumpring))
 232 #endif
 233 #define dma_rxtxerror(di, istx) ((di)->di_fn->rxtxerror(di, istx))
 234 #define dma_burstlen_set(di, rxlen, txlen)      ((di)->di_fn->burstlen_set(di, rxlen, txlen))
 235 #define dma_avoidance_cnt(di)           ((di)->di_fn->avoidancecnt(di))
 236 #define dma_param_set(di, paramid, paramval)    ((di)->di_fn->param_set(di, paramid, paramval))
 237
 238 #else /* BCMDMA32 */
 239 extern const di_fcn_t dma64proc;
 240
 241 #define dma_detach(di)                  (dma64proc.detach(di))
 242 #define dma_txreset(di)                 (dma64proc.txreset(di))
 243 #define dma_rxreset(di)                 (dma64proc.rxreset(di))
 244 #define dma_rxidle(di)                  (dma64proc.rxidle(di))
 245 #define dma_txinit(di)                  (dma64proc.txinit(di))
 246 #define dma_txenabled(di)               (dma64proc.txenabled(di))
 247 #define dma_rxinit(di)                  (dma64proc.rxinit(di))
 248 #define dma_txsuspend(di)               (dma64proc.txsuspend(di))
 249 #define dma_txresume(di)                (dma64proc.txresume(di))
 250 #define dma_txsuspended(di)             (dma64proc.txsuspended(di))
 251 #define dma_txsuspendedidle(di)         (dma64proc.txsuspendedidle(di))
 252 #ifdef WL_MULTIQUEUE
 253 #define dma_txflush(di)                 (dma64proc.txflush(di))
 254 #define dma_txflush_clear(di)           (dma64proc.txflush_clear(di))
 255 #endif /* WL_MULTIQUEUE */
 256 #define dma_txfast(di, p, commit)       (dma64proc.txfast(di, p, commit))
 257 #define dma_txunframed(di, p, l, commit)(dma64proc.txunframed(di, p, l, commit))
 258 #define dma_getpos(di, dir)             (dma64proc.getpos(di, dir))
 259 #define dma_fifoloopbackenable(di)      (dma64proc.fifoloopbackenable(di))
 260 #define dma_txstopped(di)               (dma64proc.txstopped(di))
 261 #define dma_rxstopped(di)               (dma64proc.rxstopped(di))
 262 #define dma_rxenable(di)                (dma64proc.rxenable(di))
 263 #define dma_rxenabled(di)               (dma64proc.rxenabled(di))
 264 #define dma_rx(di)                      (dma64proc.rx(di))
 265 #define dma_rxfill(di)                  (dma64proc.rxfill(di))
 266 #define dma_txreclaim(di, range)        (dma64proc.txreclaim(di, range))
 267 #define dma_rxreclaim(di)               (dma64proc.rxreclaim(di))
 268 #define dma_getvar(di, name)            (dma64proc.d_getvar(di, name))
 269 #define dma_getnexttxp(di, range)       (dma64proc.getnexttxp(di, range))
 270 #define dma_getnextrxp(di, forceall)    (dma64proc.getnextrxp(di, forceall))
 271 #define dma_peeknexttxp(di)             (dma64proc.peeknexttxp(di))
 272 #define dma_peekntxp(di, l, t, r)       (dma64proc.peekntxp(di, l, t, r))
 273 #define dma_peeknextrxp(di)             (dma64proc.peeknextrxp(di))
 274 #define dma_rxparam_get(di, off, bufs)  (dma64proc.rxparam_get(di, off, bufs))
 275
 276 #define dma_txblock(di)                 (dma64proc.txblock(di))
 277 #define dma_txunblock(di)               (dma64proc.txunblock(di))
 278 #define dma_txactive(di)                (dma64proc.txactive(di))
 279 #define dma_rxactive(di)                (dma64proc.rxactive(di))
 280 #define dma_txrotate(di)                (dma64proc.txrotate(di))
 281 #define dma_counterreset(di)            (dma64proc.counterreset(di))
 282 #define dma_ctrlflags(di, mask, flags)  (dma64proc.ctrlflags((di), (mask), (flags)))
 283 #define dma_txpending(di)               (dma64proc.txpending(di))
 284 #define dma_txcommitted(di)             (dma64proc.txcommitted(di))
 285 #define dma_pktpool_set(di, pool)       (dma64proc.pktpool_set((di), (pool)))
 286 #if defined(BCMDBG)
 287 #define dma_dump(di, buf, dumpring)     (dma64proc.dump(di, buf, dumpring))
 288 #define dma_dumptx(di, buf, dumpring)   (dma64proc.dumptx(di, buf, dumpring))
 289 #define dma_dumprx(di, buf, dumpring)   (dma64proc.dumprx(di, buf, dumpring))
 290 #endif
 291 #define dma_rxtxerror(di, istx) (dma64proc.rxtxerror(di, istx))
 292 #define dma_burstlen_set(di, rxlen, txlen)      (dma64proc.burstlen_set(di, rxlen, txlen))
 293 #define dma_avoidance_cnt(di)           (dma64proc.avoidancecnt(di))
 294 #define dma_param_set(di, paramid, paramval)    (dma64proc.param_set(di, paramid, paramval))
 295
 296 #define dma_glom_enable(di, val)        (dma64proc.glom_enab(di, val))
 297
 298 #endif /* BCMDMA32 */
 299
 300 /* return addresswidth allowed
 301  * This needs to be done after SB attach but before dma attach.
 302  * SB attach provides ability to probe backplane and dma core capabilities
 303  * This info is needed by DMA_ALLOC_CONSISTENT in dma attach
 304  */
 305 extern uint dma_addrwidth(si_t *sih, void *dmaregs);
 306
 307 /* pio helpers */
 308 extern void dma_txpioloopback(osl_t *osh, dma32regs_t *);
 309
 310 #endif  /* _hnddma_h_ */