projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix zd1211rw typo and call (#1241)
[openwrt.git] / package / broadcom-wl / src / kmod / hnddma.c
1 /*
2 * Generic Broadcom Home Networking Division (HND) DMA module.
3 * This supports the following chips: BCM42xx, 44xx, 47xx .
4 *
5 * Copyright 2006, Broadcom Corporation
6 * All Rights Reserved.
7 *
8 * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
9 * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
10 * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
11 * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
12 *
13 * $Id: hnddma.c,v 1.11 2006/04/08 07:12:42 honor Exp $
14 */
15
16 #include <typedefs.h>
17 #include <bcmdefs.h>
18 #include <osl.h>
19 #include "linux_osl.h"
20 #include <bcmendian.h>
21 #include <sbconfig.h>
22 #include <bcmutils.h>
23 #include <bcmdevs.h>
24 #include <sbutils.h>
25
26 #include "sbhnddma.h"
27 #include "hnddma.h"
28
29 /* debug/trace */
30 #define DMA_ERROR(args)
31 #define DMA_TRACE(args)
32
33 /* default dma message level (if input msg_level pointer is null in dma_attach()) */
34 static uint dma_msg_level =
35 0;
36
37 #define MAXNAMEL 8 /* 8 char names */
38
39 #define DI_INFO(dmah) (dma_info_t *)dmah
40
41 /* dma engine software state */
42 typedef struct dma_info {
43 struct hnddma_pub hnddma; /* exported structure, don't use hnddma_t,
44 * which could be const
45 */
46 uint *msg_level; /* message level pointer */
47 char name[MAXNAMEL]; /* callers name for diag msgs */
48
49 void *osh; /* os handle */
50 sb_t *sbh; /* sb handle */
51
52 bool dma64; /* dma64 enabled */
53 bool addrext; /* this dma engine supports DmaExtendedAddrChanges */
54
55 dma32regs_t *d32txregs; /* 32 bits dma tx engine registers */
56 dma32regs_t *d32rxregs; /* 32 bits dma rx engine registers */
57 dma64regs_t *d64txregs; /* 64 bits dma tx engine registers */
58 dma64regs_t *d64rxregs; /* 64 bits dma rx engine registers */
59
60 uint32 dma64align; /* either 8k or 4k depends on number of dd */
61 dma32dd_t *txd32; /* pointer to dma32 tx descriptor ring */
62 dma64dd_t *txd64; /* pointer to dma64 tx descriptor ring */
63 uint ntxd; /* # tx descriptors tunable */
64 uint txin; /* index of next descriptor to reclaim */
65 uint txout; /* index of next descriptor to post */
66 void **txp; /* pointer to parallel array of pointers to packets */
67 osldma_t *tx_dmah; /* DMA TX descriptor ring handle */
68 osldma_t **txp_dmah; /* DMA TX packet data handle */
69 ulong txdpa; /* physical address of descriptor ring */
70 uint txdalign; /* #bytes added to alloc'd mem to align txd */
71 uint txdalloc; /* #bytes allocated for the ring */
72
73 dma32dd_t *rxd32; /* pointer to dma32 rx descriptor ring */
74 dma64dd_t *rxd64; /* pointer to dma64 rx descriptor ring */
75 uint nrxd; /* # rx descriptors tunable */
76 uint rxin; /* index of next descriptor to reclaim */
77 uint rxout; /* index of next descriptor to post */
78 void **rxp; /* pointer to parallel array of pointers to packets */
79 osldma_t *rx_dmah; /* DMA RX descriptor ring handle */
80 osldma_t **rxp_dmah; /* DMA RX packet data handle */
81 ulong rxdpa; /* physical address of descriptor ring */
82 uint rxdalign; /* #bytes added to alloc'd mem to align rxd */
83 uint rxdalloc; /* #bytes allocated for the ring */
84
85 /* tunables */
86 uint rxbufsize; /* rx buffer size in bytes,
87 not including the extra headroom
88 */
89 uint nrxpost; /* # rx buffers to keep posted */
90 uint rxoffset; /* rxcontrol offset */
91 uint ddoffsetlow; /* add to get dma address of descriptor ring, low 32 bits */
92 uint ddoffsethigh; /* high 32 bits */
93 uint dataoffsetlow; /* add to get dma address of data buffer, low 32 bits */
94 uint dataoffsethigh; /* high 32 bits */
95 } dma_info_t;
96
97 #ifdef BCMDMA64
98 #define DMA64_ENAB(di) ((di)->dma64)
99 #define DMA64_CAP TRUE
100 #else
101 #define DMA64_ENAB(di) (0)
102 #define DMA64_CAP FALSE
103 #endif
104
105 /* descriptor bumping macros */
106 #define XXD(x, n) ((x) & ((n) - 1)) /* faster than %, but n must be power of 2 */
107 #define TXD(x) XXD((x), di->ntxd)
108 #define RXD(x) XXD((x), di->nrxd)
109 #define NEXTTXD(i) TXD(i + 1)
110 #define PREVTXD(i) TXD(i - 1)
111 #define NEXTRXD(i) RXD(i + 1)
112 #define NTXDACTIVE(h, t) TXD(t - h)
113 #define NRXDACTIVE(h, t) RXD(t - h)
114
115 /* macros to convert between byte offsets and indexes */
116 #define B2I(bytes, type) ((bytes) / sizeof(type))
117 #define I2B(index, type) ((index) * sizeof(type))
118
119 #define PCI32ADDR_HIGH 0xc0000000 /* address[31:30] */
120 #define PCI32ADDR_HIGH_SHIFT 30 /* address[31:30] */
121
122
123 /* common prototypes */
124 static bool _dma_isaddrext(dma_info_t *di);
125 static bool _dma_alloc(dma_info_t *di, uint direction);
126 static void _dma_detach(dma_info_t *di);
127 static void _dma_ddtable_init(dma_info_t *di, uint direction, ulong pa);
128 static void _dma_rxinit(dma_info_t *di);
129 static void *_dma_rx(dma_info_t *di);
130 static void _dma_rxfill(dma_info_t *di);
131 static void _dma_rxreclaim(dma_info_t *di);
132 static void _dma_rxenable(dma_info_t *di);
133 static void * _dma_getnextrxp(dma_info_t *di, bool forceall);
134
135 static void _dma_txblock(dma_info_t *di);
136 static void _dma_txunblock(dma_info_t *di);
137 static uint _dma_txactive(dma_info_t *di);
138
139 static void* _dma_peeknexttxp(dma_info_t *di);
140 static uintptr _dma_getvar(dma_info_t *di, const char *name);
141 static void _dma_counterreset(dma_info_t *di);
142 static void _dma_fifoloopbackenable(dma_info_t *di);
143
144 /* ** 32 bit DMA prototypes */
145 static bool dma32_alloc(dma_info_t *di, uint direction);
146 static bool dma32_txreset(dma_info_t *di);
147 static bool dma32_rxreset(dma_info_t *di);
148 static bool dma32_txsuspendedidle(dma_info_t *di);
149 static int dma32_txfast(dma_info_t *di, void *p0, bool commit);
150 static void *dma32_getnexttxp(dma_info_t *di, bool forceall);
151 static void *dma32_getnextrxp(dma_info_t *di, bool forceall);
152 static void dma32_txrotate(dma_info_t *di);
153 static bool dma32_rxidle(dma_info_t *di);
154 static void dma32_txinit(dma_info_t *di);
155 static bool dma32_txenabled(dma_info_t *di);
156 static void dma32_txsuspend(dma_info_t *di);
157 static void dma32_txresume(dma_info_t *di);
158 static bool dma32_txsuspended(dma_info_t *di);
159 static void dma32_txreclaim(dma_info_t *di, bool forceall);
160 static bool dma32_txstopped(dma_info_t *di);
161 static bool dma32_rxstopped(dma_info_t *di);
162 static bool dma32_rxenabled(dma_info_t *di);
163 static bool _dma32_addrext(osl_t *osh, dma32regs_t *dma32regs);
164
165 /* ** 64 bit DMA prototypes and stubs */
166 #ifdef BCMDMA64
167 static bool dma64_alloc(dma_info_t *di, uint direction);
168 static bool dma64_txreset(dma_info_t *di);
169 static bool dma64_rxreset(dma_info_t *di);
170 static bool dma64_txsuspendedidle(dma_info_t *di);
171 static int dma64_txfast(dma_info_t *di, void *p0, bool commit);
172 static void *dma64_getnexttxp(dma_info_t *di, bool forceall);
173 static void *dma64_getnextrxp(dma_info_t *di, bool forceall);
174 static void dma64_txrotate(dma_info_t *di);
175
176 static bool dma64_rxidle(dma_info_t *di);
177 static void dma64_txinit(dma_info_t *di);
178 static bool dma64_txenabled(dma_info_t *di);
179 static void dma64_txsuspend(dma_info_t *di);
180 static void dma64_txresume(dma_info_t *di);
181 static bool dma64_txsuspended(dma_info_t *di);
182 static void dma64_txreclaim(dma_info_t *di, bool forceall);
183 static bool dma64_txstopped(dma_info_t *di);
184 static bool dma64_rxstopped(dma_info_t *di);
185 static bool dma64_rxenabled(dma_info_t *di);
186 static bool _dma64_addrext(osl_t *osh, dma64regs_t *dma64regs);
187
188 #else
189 static bool dma64_alloc(dma_info_t *di, uint direction) { return FALSE; }
190 static bool dma64_txreset(dma_info_t *di) { return FALSE; }
191 static bool dma64_rxreset(dma_info_t *di) { return FALSE; }
192 static bool dma64_txsuspendedidle(dma_info_t *di) { return FALSE;}
193 static int dma64_txfast(dma_info_t *di, void *p0, bool commit) { return 0; }
194 static void *dma64_getnexttxp(dma_info_t *di, bool forceall) { return NULL; }
195 static void *dma64_getnextrxp(dma_info_t *di, bool forceall) { return NULL; }
196 static void dma64_txrotate(dma_info_t *di) { return; }
197
198 static bool dma64_rxidle(dma_info_t *di) { return FALSE; }
199 static void dma64_txinit(dma_info_t *di) { return; }
200 static bool dma64_txenabled(dma_info_t *di) { return FALSE; }
201 static void dma64_txsuspend(dma_info_t *di) { return; }
202 static void dma64_txresume(dma_info_t *di) { return; }
203 static bool dma64_txsuspended(dma_info_t *di) {return FALSE; }
204 static void dma64_txreclaim(dma_info_t *di, bool forceall) { return; }
205 static bool dma64_txstopped(dma_info_t *di) { return FALSE; }
206 static bool dma64_rxstopped(dma_info_t *di) { return FALSE; }
207 static bool dma64_rxenabled(dma_info_t *di) { return FALSE; }
208 static bool _dma64_addrext(osl_t *osh, dma64regs_t *dma64regs) { return FALSE; }
209
210 #endif /* BCMDMA64 */
211
212
213
214 static di_fcn_t dma64proc = {
215 (di_detach_t)_dma_detach,
216 (di_txinit_t)dma64_txinit,
217 (di_txreset_t)dma64_txreset,
218 (di_txenabled_t)dma64_txenabled,
219 (di_txsuspend_t)dma64_txsuspend,
220 (di_txresume_t)dma64_txresume,
221 (di_txsuspended_t)dma64_txsuspended,
222 (di_txsuspendedidle_t)dma64_txsuspendedidle,
223 (di_txfast_t)dma64_txfast,
224 (di_txstopped_t)dma64_txstopped,
225 (di_txreclaim_t)dma64_txreclaim,
226 (di_getnexttxp_t)dma64_getnexttxp,
227 (di_peeknexttxp_t)_dma_peeknexttxp,
228 (di_txblock_t)_dma_txblock,
229 (di_txunblock_t)_dma_txunblock,
230 (di_txactive_t)_dma_txactive,
231 (di_txrotate_t)dma64_txrotate,
232
233 (di_rxinit_t)_dma_rxinit,
234 (di_rxreset_t)dma64_rxreset,
235 (di_rxidle_t)dma64_rxidle,
236 (di_rxstopped_t)dma64_rxstopped,
237 (di_rxenable_t)_dma_rxenable,
238 (di_rxenabled_t)dma64_rxenabled,
239 (di_rx_t)_dma_rx,
240 (di_rxfill_t)_dma_rxfill,
241 (di_rxreclaim_t)_dma_rxreclaim,
242 (di_getnextrxp_t)_dma_getnextrxp,
243
244 (di_fifoloopbackenable_t)_dma_fifoloopbackenable,
245 (di_getvar_t)_dma_getvar,
246 (di_counterreset_t)_dma_counterreset,
247
248 NULL,
249 NULL,
250 NULL,
251 34
252 };
253
254 static di_fcn_t dma32proc = {
255 (di_detach_t)_dma_detach,
256 (di_txinit_t)dma32_txinit,
257 (di_txreset_t)dma32_txreset,
258 (di_txenabled_t)dma32_txenabled,
259 (di_txsuspend_t)dma32_txsuspend,
260 (di_txresume_t)dma32_txresume,
261 (di_txsuspended_t)dma32_txsuspended,
262 (di_txsuspendedidle_t)dma32_txsuspendedidle,
263 (di_txfast_t)dma32_txfast,
264 (di_txstopped_t)dma32_txstopped,
265 (di_txreclaim_t)dma32_txreclaim,
266 (di_getnexttxp_t)dma32_getnexttxp,
267 (di_peeknexttxp_t)_dma_peeknexttxp,
268 (di_txblock_t)_dma_txblock,
269 (di_txunblock_t)_dma_txunblock,
270 (di_txactive_t)_dma_txactive,
271 (di_txrotate_t)dma32_txrotate,
272
273 (di_rxinit_t)_dma_rxinit,
274 (di_rxreset_t)dma32_rxreset,
275 (di_rxidle_t)dma32_rxidle,
276 (di_rxstopped_t)dma32_rxstopped,
277 (di_rxenable_t)_dma_rxenable,
278 (di_rxenabled_t)dma32_rxenabled,
279 (di_rx_t)_dma_rx,
280 (di_rxfill_t)_dma_rxfill,
281 (di_rxreclaim_t)_dma_rxreclaim,
282 (di_getnextrxp_t)_dma_getnextrxp,
283
284 (di_fifoloopbackenable_t)_dma_fifoloopbackenable,
285 (di_getvar_t)_dma_getvar,
286 (di_counterreset_t)_dma_counterreset,
287
288 NULL,
289 NULL,
290 NULL,
291 34
292 };
293
294 hnddma_t *
295 dma_attach(osl_t *osh, char *name, sb_t *sbh, void *dmaregstx, void *dmaregsrx,
296 uint ntxd, uint nrxd, uint rxbufsize, uint nrxpost, uint rxoffset, uint *msg_level)
297 {
298 dma_info_t *di;
299 uint size;
300
301 /* allocate private info structure */
302 if ((di = MALLOC(osh, sizeof (dma_info_t))) == NULL) {
303 return (NULL);
304 }
305 bzero((char *)di, sizeof(dma_info_t));
306
307 di->msg_level = msg_level ? msg_level : &dma_msg_level;
308
309 /* old chips w/o sb is no longer supported */
310 ASSERT(sbh != NULL);
311
312 di->dma64 = ((sb_coreflagshi(sbh, 0, 0) & SBTMH_DMA64) == SBTMH_DMA64);
313
314 #ifndef BCMDMA64
315 if (di->dma64) {
316 DMA_ERROR(("dma_attach: driver doesn't have the capability to support "
317 "64 bits DMA\n"));
318 goto fail;
319 }
320 #endif
321
322 /* check arguments */
323 ASSERT(ISPOWEROF2(ntxd));
324 ASSERT(ISPOWEROF2(nrxd));
325 if (nrxd == 0)
326 ASSERT(dmaregsrx == NULL);
327 if (ntxd == 0)
328 ASSERT(dmaregstx == NULL);
329
330
331 /* init dma reg pointer */
332 if (di->dma64) {
333 ASSERT(ntxd <= D64MAXDD);
334 ASSERT(nrxd <= D64MAXDD);
335 di->d64txregs = (dma64regs_t *)dmaregstx;
336 di->d64rxregs = (dma64regs_t *)dmaregsrx;
337
338 di->dma64align = D64RINGALIGN;
339 if ((ntxd < D64MAXDD / 2) && (nrxd < D64MAXDD / 2)) {
340 /* for smaller dd table, HW relax the alignment requirement */
341 di->dma64align = D64RINGALIGN / 2;
342 }
343 } else {
344 ASSERT(ntxd <= D32MAXDD);
345 ASSERT(nrxd <= D32MAXDD);
346 di->d32txregs = (dma32regs_t *)dmaregstx;
347 di->d32rxregs = (dma32regs_t *)dmaregsrx;
348 }
349
350 DMA_TRACE(("%s: dma_attach: %s osh %p ntxd %d nrxd %d rxbufsize %d nrxpost %d "
351 "rxoffset %d dmaregstx %p dmaregsrx %p\n",
352 name, (di->dma64 ? "DMA64" : "DMA32"), osh, ntxd, nrxd, rxbufsize,
353 nrxpost, rxoffset, dmaregstx, dmaregsrx));
354
355 /* make a private copy of our callers name */
356 strncpy(di->name, name, MAXNAMEL);
357 di->name[MAXNAMEL-1] = '\0';
358
359 di->osh = osh;
360 di->sbh = sbh;
361
362 /* save tunables */
363 di->ntxd = ntxd;
364 di->nrxd = nrxd;
365
366 /* the actual dma size doesn't include the extra headroom */
367 if (rxbufsize > BCMEXTRAHDROOM)
368 di->rxbufsize = rxbufsize - BCMEXTRAHDROOM;
369 else
370 di->rxbufsize = rxbufsize;
371
372 di->nrxpost = nrxpost;
373 di->rxoffset = rxoffset;
374
375 /*
376 * figure out the DMA physical address offset for dd and data
377 * for old chips w/o sb, use zero
378 * for new chips w sb,
379 * PCI/PCIE: they map silicon backplace address to zero based memory, need offset
380 * Other bus: use zero
381 * SB_BUS BIGENDIAN kludge: use sdram swapped region for data buffer, not descriptor
382 */
383 di->ddoffsetlow = 0;
384 di->dataoffsetlow = 0;
385 /* for pci bus, add offset */
386 if (sbh->bustype == PCI_BUS) {
387 if ((sbh->buscoretype == SB_PCIE) && di->dma64) {
388 /* pcie with DMA64 */
389 di->ddoffsetlow = 0;
390 di->ddoffsethigh = SB_PCIE_DMA_H32;
391 } else {
392 /* pci(DMA32/DMA64) or pcie with DMA32 */
393 di->ddoffsetlow = SB_PCI_DMA;
394 di->ddoffsethigh = 0;
395 }
396 di->dataoffsetlow = di->ddoffsetlow;
397 di->dataoffsethigh = di->ddoffsethigh;
398 }
399
400 #if defined(__mips__) && defined(IL_BIGENDIAN)
401 di->dataoffsetlow = di->dataoffsetlow + SB_SDRAM_SWAPPED;
402 #endif
403
404 di->addrext = _dma_isaddrext(di);
405
406 /* allocate tx packet pointer vector */
407 if (ntxd) {
408 size = ntxd * sizeof(void *);
409 if ((di->txp = MALLOC(osh, size)) == NULL) {
410 DMA_ERROR(("%s: dma_attach: out of tx memory, malloced %d bytes\n",
411 di->name, MALLOCED(osh)));
412 goto fail;
413 }
414 bzero((char *)di->txp, size);
415 }
416
417 /* allocate rx packet pointer vector */
418 if (nrxd) {
419 size = nrxd * sizeof(void *);
420 if ((di->rxp = MALLOC(osh, size)) == NULL) {
421 DMA_ERROR(("%s: dma_attach: out of rx memory, malloced %d bytes\n",
422 di->name, MALLOCED(osh)));
423 goto fail;
424 }
425 bzero((char *)di->rxp, size);
426 }
427
428 /* allocate transmit descriptor ring, only need ntxd descriptors but it must be aligned */
429 if (ntxd) {
430 if (!_dma_alloc(di, DMA_TX))
431 goto fail;
432 }
433
434 /* allocate receive descriptor ring, only need nrxd descriptors but it must be aligned */
435 if (nrxd) {
436 if (!_dma_alloc(di, DMA_RX))
437 goto fail;
438 }
439
440 if ((di->ddoffsetlow == SB_PCI_DMA) && (di->txdpa > SB_PCI_DMA_SZ) && !di->addrext) {
441 DMA_ERROR(("%s: dma_attach: txdpa 0x%lx: addrext not supported\n",
442 di->name, di->txdpa));
443 goto fail;
444 }
445 if ((di->ddoffsetlow == SB_PCI_DMA) && (di->rxdpa > SB_PCI_DMA_SZ) && !di->addrext) {
446 DMA_ERROR(("%s: dma_attach: rxdpa 0x%lx: addrext not supported\n",
447 di->name, di->rxdpa));
448 goto fail;
449 }
450
451 DMA_TRACE(("ddoffsetlow 0x%x ddoffsethigh 0x%x dataoffsetlow 0x%x dataoffsethigh "
452 "0x%x addrext %d\n", di->ddoffsetlow, di->ddoffsethigh, di->dataoffsetlow,
453 di->dataoffsethigh, di->addrext));
454
455 /* allocate tx packet pointer vector and DMA mapping vectors */
456 if (ntxd) {
457
458 size = ntxd * sizeof(osldma_t **);
459 if ((di->txp_dmah = (osldma_t **)MALLOC(osh, size)) == NULL)
460 goto fail;
461 bzero((char*)di->txp_dmah, size);
462 }else
463 di->txp_dmah = NULL;
464
465 /* allocate rx packet pointer vector and DMA mapping vectors */
466 if (nrxd) {
467
468 size = nrxd * sizeof(osldma_t **);
469 if ((di->rxp_dmah = (osldma_t **)MALLOC(osh, size)) == NULL)
470 goto fail;
471 bzero((char*)di->rxp_dmah, size);
472
473 } else
474 di->rxp_dmah = NULL;
475
476 /* initialize opsvec of function pointers */
477 di->hnddma.di_fn = DMA64_ENAB(di) ? dma64proc : dma32proc;
478
479 return ((hnddma_t *)di);
480
481 fail:
482 _dma_detach(di);
483 return (NULL);
484 }
485
486 /* init the tx or rx descriptor */
487 static INLINE void
488 dma32_dd_upd(dma_info_t *di, dma32dd_t *ddring, ulong pa, uint outidx, uint32 *flags,
489 uint32 bufcount)
490 {
491 /* dma32 uses 32 bits control to fit both flags and bufcounter */
492 *flags = *flags | (bufcount & CTRL_BC_MASK);
493
494 if ((di->dataoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
495 W_SM(&ddring[outidx].addr, BUS_SWAP32(pa + di->dataoffsetlow));
496 W_SM(&ddring[outidx].ctrl, BUS_SWAP32(*flags));
497 } else {
498 /* address extension */
499 uint32 ae;
500 ASSERT(di->addrext);
501 ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
502 pa &= ~PCI32ADDR_HIGH;
503
504 *flags |= (ae << CTRL_AE_SHIFT);
505 W_SM(&ddring[outidx].addr, BUS_SWAP32(pa + di->dataoffsetlow));
506 W_SM(&ddring[outidx].ctrl, BUS_SWAP32(*flags));
507 }
508 }
509
510 static INLINE void
511 dma64_dd_upd(dma_info_t *di, dma64dd_t *ddring, ulong pa, uint outidx, uint32 *flags,
512 uint32 bufcount)
513 {
514 uint32 ctrl2 = bufcount & D64_CTRL2_BC_MASK;
515
516 /* PCI bus with big(>1G) physical address, use address extension */
517 if ((di->dataoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
518 W_SM(&ddring[outidx].addrlow, BUS_SWAP32(pa + di->dataoffsetlow));
519 W_SM(&ddring[outidx].addrhigh, BUS_SWAP32(0 + di->dataoffsethigh));
520 W_SM(&ddring[outidx].ctrl1, BUS_SWAP32(*flags));
521 W_SM(&ddring[outidx].ctrl2, BUS_SWAP32(ctrl2));
522 } else {
523 /* address extension */
524 uint32 ae;
525 ASSERT(di->addrext);
526
527 ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
528 pa &= ~PCI32ADDR_HIGH;
529
530 ctrl2 |= (ae << D64_CTRL2_AE_SHIFT) & D64_CTRL2_AE;
531 W_SM(&ddring[outidx].addrlow, BUS_SWAP32(pa + di->dataoffsetlow));
532 W_SM(&ddring[outidx].addrhigh, BUS_SWAP32(0 + di->dataoffsethigh));
533 W_SM(&ddring[outidx].ctrl1, BUS_SWAP32(*flags));
534 W_SM(&ddring[outidx].ctrl2, BUS_SWAP32(ctrl2));
535 }
536 }
537
538 static bool
539 _dma32_addrext(osl_t *osh, dma32regs_t *dma32regs)
540 {
541 uint32 w;
542
543 OR_REG(osh, &dma32regs->control, XC_AE);
544 w = R_REG(osh, &dma32regs->control);
545 AND_REG(osh, &dma32regs->control, ~XC_AE);
546 return ((w & XC_AE) == XC_AE);
547 }
548
549 static bool
550 _dma_alloc(dma_info_t *di, uint direction)
551 {
552 if (DMA64_ENAB(di)) {
553 return dma64_alloc(di, direction);
554 } else {
555 return dma32_alloc(di, direction);
556 }
557 }
558
559 /* !! may be called with core in reset */
560 static void
561 _dma_detach(dma_info_t *di)
562 {
563 if (di == NULL)
564 return;
565
566 DMA_TRACE(("%s: dma_detach\n", di->name));
567
568 /* shouldn't be here if descriptors are unreclaimed */
569 ASSERT(di->txin == di->txout);
570 ASSERT(di->rxin == di->rxout);
571
572 /* free dma descriptor rings */
573 if (DMA64_ENAB(di)) {
574 if (di->txd64)
575 DMA_FREE_CONSISTENT(di->osh, ((int8*)(uintptr)di->txd64 - di->txdalign),
576 di->txdalloc, (di->txdpa - di->txdalign), &di->tx_dmah);
577 if (di->rxd64)
578 DMA_FREE_CONSISTENT(di->osh, ((int8*)(uintptr)di->rxd64 - di->rxdalign),
579 di->rxdalloc, (di->rxdpa - di->rxdalign), &di->rx_dmah);
580 } else {
581 if (di->txd32)
582 DMA_FREE_CONSISTENT(di->osh, ((int8*)(uintptr)di->txd32 - di->txdalign),
583 di->txdalloc, (di->txdpa - di->txdalign), &di->tx_dmah);
584 if (di->rxd32)
585 DMA_FREE_CONSISTENT(di->osh, ((int8*)(uintptr)di->rxd32 - di->rxdalign),
586 di->rxdalloc, (di->rxdpa - di->rxdalign), &di->rx_dmah);
587 }
588
589 /* free packet pointer vectors */
590 if (di->txp)
591 MFREE(di->osh, (void *)di->txp, (di->ntxd * sizeof(void *)));
592 if (di->rxp)
593 MFREE(di->osh, (void *)di->rxp, (di->nrxd * sizeof(void *)));
594
595 /* free tx packet DMA handles */
596 if (di->txp_dmah)
597 MFREE(di->osh, (void *)di->txp_dmah, di->ntxd * sizeof(osldma_t **));
598
599 /* free rx packet DMA handles */
600 if (di->rxp_dmah)
601 MFREE(di->osh, (void *)di->rxp_dmah, di->nrxd * sizeof(osldma_t **));
602
603 /* free our private info structure */
604 MFREE(di->osh, (void *)di, sizeof(dma_info_t));
605
606 }
607
608 /* return TRUE if this dma engine supports DmaExtendedAddrChanges, otherwise FALSE */
609 static bool
610 _dma_isaddrext(dma_info_t *di)
611 {
612 if (DMA64_ENAB(di)) {
613 /* DMA64 supports full 32 bits or 64 bits. AE is always valid */
614
615 /* not all tx or rx channel are available */
616 if (di->d64txregs != NULL) {
617 if (!_dma64_addrext(di->osh, di->d64txregs)) {
618 DMA_ERROR(("%s: _dma_isaddrext: DMA64 tx doesn't have AE set\n",
619 di->name));
620 ASSERT(0);
621 }
622 return TRUE;
623 } else if (di->d64rxregs != NULL) {
624 if (!_dma64_addrext(di->osh, di->d64rxregs)) {
625 DMA_ERROR(("%s: _dma_isaddrext: DMA64 rx doesn't have AE set\n",
626 di->name));
627 ASSERT(0);
628 }
629 return TRUE;
630 }
631 return FALSE;
632 } else if (di->d32txregs)
633 return (_dma32_addrext(di->osh, di->d32txregs));
634 else if (di->d32rxregs)
635 return (_dma32_addrext(di->osh, di->d32rxregs));
636 return FALSE;
637 }
638
639 /* initialize descriptor table base address */
640 static void
641 _dma_ddtable_init(dma_info_t *di, uint direction, ulong pa)
642 {
643 if (DMA64_ENAB(di)) {
644
645 if ((di->ddoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
646 if (direction == DMA_TX) {
647 W_REG(di->osh, &di->d64txregs->addrlow, (pa + di->ddoffsetlow));
648 W_REG(di->osh, &di->d64txregs->addrhigh, di->ddoffsethigh);
649 } else {
650 W_REG(di->osh, &di->d64rxregs->addrlow, (pa + di->ddoffsetlow));
651 W_REG(di->osh, &di->d64rxregs->addrhigh, di->ddoffsethigh);
652 }
653 } else {
654 /* DMA64 32bits address extension */
655 uint32 ae;
656 ASSERT(di->addrext);
657
658 /* shift the high bit(s) from pa to ae */
659 ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
660 pa &= ~PCI32ADDR_HIGH;
661
662 if (direction == DMA_TX) {
663 W_REG(di->osh, &di->d64txregs->addrlow, (pa + di->ddoffsetlow));
664 W_REG(di->osh, &di->d64txregs->addrhigh, di->ddoffsethigh);
665 SET_REG(di->osh, &di->d64txregs->control, D64_XC_AE,
666 (ae << D64_XC_AE_SHIFT));
667 } else {
668 W_REG(di->osh, &di->d64rxregs->addrlow, (pa + di->ddoffsetlow));
669 W_REG(di->osh, &di->d64rxregs->addrhigh, di->ddoffsethigh);
670 SET_REG(di->osh, &di->d64rxregs->control, D64_RC_AE,
671 (ae << D64_RC_AE_SHIFT));
672 }
673 }
674
675 } else {
676 if ((di->ddoffsetlow != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
677 if (direction == DMA_TX)
678 W_REG(di->osh, &di->d32txregs->addr, (pa + di->ddoffsetlow));
679 else
680 W_REG(di->osh, &di->d32rxregs->addr, (pa + di->ddoffsetlow));
681 } else {
682 /* dma32 address extension */
683 uint32 ae;
684 ASSERT(di->addrext);
685
686 /* shift the high bit(s) from pa to ae */
687 ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
688 pa &= ~PCI32ADDR_HIGH;
689
690 if (direction == DMA_TX) {
691 W_REG(di->osh, &di->d32txregs->addr, (pa + di->ddoffsetlow));
692 SET_REG(di->osh, &di->d32txregs->control, XC_AE, ae <<XC_AE_SHIFT);
693 } else {
694 W_REG(di->osh, &di->d32rxregs->addr, (pa + di->ddoffsetlow));
695 SET_REG(di->osh, &di->d32rxregs->control, RC_AE, ae <<RC_AE_SHIFT);
696 }
697 }
698 }
699 }
700
701 static void
702 _dma_fifoloopbackenable(dma_info_t *di)
703 {
704 DMA_TRACE(("%s: dma_fifoloopbackenable\n", di->name));
705 if (DMA64_ENAB(di))
706 OR_REG(di->osh, &di->d64txregs->control, D64_XC_LE);
707 else
708 OR_REG(di->osh, &di->d32txregs->control, XC_LE);
709 }
710
711 static void
712 _dma_rxinit(dma_info_t *di)
713 {
714 DMA_TRACE(("%s: dma_rxinit\n", di->name));
715
716 if (di->nrxd == 0)
717 return;
718
719 di->rxin = di->rxout = 0;
720
721 /* clear rx descriptor ring */
722 if (DMA64_ENAB(di)) {
723 BZERO_SM((void *)(uintptr)di->rxd64, (di->nrxd * sizeof(dma64dd_t)));
724 _dma_rxenable(di);
725 _dma_ddtable_init(di, DMA_RX, di->rxdpa);
726 } else {
727 BZERO_SM((void *)(uintptr)di->rxd32, (di->nrxd * sizeof(dma32dd_t)));
728 _dma_rxenable(di);
729 _dma_ddtable_init(di, DMA_RX, di->rxdpa);
730 }
731 }
732
733 static void
734 _dma_rxenable(dma_info_t *di)
735 {
736 DMA_TRACE(("%s: dma_rxenable\n", di->name));
737
738 if (DMA64_ENAB(di))
739 W_REG(di->osh, &di->d64rxregs->control,
740 ((di->rxoffset << D64_RC_RO_SHIFT) | D64_RC_RE));
741 else
742 W_REG(di->osh, &di->d32rxregs->control, ((di->rxoffset << RC_RO_SHIFT) | RC_RE));
743 }
744
745 /* !! rx entry routine, returns a pointer to the next frame received,
746 * or NULL if there are no more
747 */
748 static void *
749 _dma_rx(dma_info_t *di)
750 {
751 void *p;
752 uint len;
753 int skiplen = 0;
754
755 while ((p = _dma_getnextrxp(di, FALSE))) {
756 /* skip giant packets which span multiple rx descriptors */
757 if (skiplen > 0) {
758 skiplen -= di->rxbufsize;
759 if (skiplen < 0)
760 skiplen = 0;
761 PKTFREE(di->osh, p, FALSE);
762 continue;
763 }
764
765 len = ltoh16(*(uint16*)(PKTDATA(di->osh, p)));
766 DMA_TRACE(("%s: dma_rx len %d\n", di->name, len));
767
768 /* bad frame length check */
769 if (len > (di->rxbufsize - di->rxoffset)) {
770 DMA_ERROR(("%s: dma_rx: bad frame length (%d)\n", di->name, len));
771 if (len > 0)
772 skiplen = len - (di->rxbufsize - di->rxoffset);
773 PKTFREE(di->osh, p, FALSE);
774 di->hnddma.rxgiants++;
775 continue;
776 }
777
778 /* set actual length */
779 PKTSETLEN(di->osh, p, (di->rxoffset + len));
780
781 break;
782 }
783
784 return (p);
785 }
786
787 /* post receive buffers */
788 static void
789 _dma_rxfill(dma_info_t *di)
790 {
791 void *p;
792 uint rxin, rxout;
793 uint32 flags = 0;
794 uint n;
795 uint i;
796 uint32 pa;
797 uint extra_offset = 0;
798
799 /*
800 * Determine how many receive buffers we're lacking
801 * from the full complement, allocate, initialize,
802 * and post them, then update the chip rx lastdscr.
803 */
804
805 rxin = di->rxin;
806 rxout = di->rxout;
807
808 n = di->nrxpost - NRXDACTIVE(rxin, rxout);
809
810 DMA_TRACE(("%s: dma_rxfill: post %d\n", di->name, n));
811
812 if (di->rxbufsize > BCMEXTRAHDROOM)
813 extra_offset = BCMEXTRAHDROOM;
814
815 for (i = 0; i < n; i++) {
816 /* the di->rxbufsize doesn't include the extra headroom, we need to add it to the
817 size to be allocated
818 */
819 if ((p = PKTGET(di->osh, di->rxbufsize + extra_offset,
820 FALSE)) == NULL) {
821 DMA_ERROR(("%s: dma_rxfill: out of rxbufs\n", di->name));
822 di->hnddma.rxnobuf++;
823 break;
824 }
825 /* reserve an extra headroom, if applicable */
826 if (extra_offset)
827 PKTPULL(di->osh, p, extra_offset);
828
829 /* Do a cached write instead of uncached write since DMA_MAP
830 * will flush the cache.
831 */
832 *(uint32*)(PKTDATA(di->osh, p)) = 0;
833
834 pa = (uint32) DMA_MAP(di->osh, PKTDATA(di->osh, p),
835 di->rxbufsize, DMA_RX, p);
836
837 ASSERT(ISALIGNED(pa, 4));
838
839 /* save the free packet pointer */
840 ASSERT(di->rxp[rxout] == NULL);
841 di->rxp[rxout] = p;
842
843 /* reset flags for each descriptor */
844 flags = 0;
845 if (DMA64_ENAB(di)) {
846 if (rxout == (di->nrxd - 1))
847 flags = D64_CTRL1_EOT;
848
849 dma64_dd_upd(di, di->rxd64, pa, rxout, &flags, di->rxbufsize);
850 } else {
851 if (rxout == (di->nrxd - 1))
852 flags = CTRL_EOT;
853
854 dma32_dd_upd(di, di->rxd32, pa, rxout, &flags, di->rxbufsize);
855 }
856 rxout = NEXTRXD(rxout);
857 }
858
859 di->rxout = rxout;
860
861 /* update the chip lastdscr pointer */
862 if (DMA64_ENAB(di)) {
863 W_REG(di->osh, &di->d64rxregs->ptr, I2B(rxout, dma64dd_t));
864 } else {
865 W_REG(di->osh, &di->d32rxregs->ptr, I2B(rxout, dma32dd_t));
866 }
867 }
868
869 /* like getnexttxp but no reclaim */
870 static void *
871 _dma_peeknexttxp(dma_info_t *di)
872 {
873 uint end, i;
874
875 if (di->ntxd == 0)
876 return (NULL);
877
878 if (DMA64_ENAB(di)) {
879 end = B2I(R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_CD_MASK, dma64dd_t);
880 } else {
881 end = B2I(R_REG(di->osh, &di->d32txregs->status) & XS_CD_MASK, dma32dd_t);
882 }
883
884 for (i = di->txin; i != end; i = NEXTTXD(i))
885 if (di->txp[i])
886 return (di->txp[i]);
887
888 return (NULL);
889 }
890
891 static void
892 _dma_rxreclaim(dma_info_t *di)
893 {
894 void *p;
895
896 /* "unused local" warning suppression for OSLs that
897 * define PKTFREE() without using the di->osh arg
898 */
899 di = di;
900
901 DMA_TRACE(("%s: dma_rxreclaim\n", di->name));
902
903 while ((p = _dma_getnextrxp(di, TRUE)))
904 PKTFREE(di->osh, p, FALSE);
905 }
906
907 static void *
908 _dma_getnextrxp(dma_info_t *di, bool forceall)
909 {
910 if (di->nrxd == 0)
911 return (NULL);
912
913 if (DMA64_ENAB(di)) {
914 return dma64_getnextrxp(di, forceall);
915 } else {
916 return dma32_getnextrxp(di, forceall);
917 }
918 }
919
920 static void
921 _dma_txblock(dma_info_t *di)
922 {
923 di->hnddma.txavail = 0;
924 }
925
926 static void
927 _dma_txunblock(dma_info_t *di)
928 {
929 di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
930 }
931
932 static uint
933 _dma_txactive(dma_info_t *di)
934 {
935 return (NTXDACTIVE(di->txin, di->txout));
936 }
937
938 static void
939 _dma_counterreset(dma_info_t *di)
940 {
941 /* reset all software counter */
942 di->hnddma.rxgiants = 0;
943 di->hnddma.rxnobuf = 0;
944 di->hnddma.txnobuf = 0;
945 }
946
947 /* get the address of the var in order to change later */
948 static uintptr
949 _dma_getvar(dma_info_t *di, const char *name)
950 {
951 if (!strcmp(name, "&txavail"))
952 return ((uintptr) &(di->hnddma.txavail));
953 else {
954 ASSERT(0);
955 }
956 return (0);
957 }
958
959 void
960 dma_txpioloopback(osl_t *osh, dma32regs_t *regs)
961 {
962 OR_REG(osh, &regs->control, XC_LE);
963 }
964
965
966
967 /* 32 bits DMA functions */
968 static void
969 dma32_txinit(dma_info_t *di)
970 {
971 DMA_TRACE(("%s: dma_txinit\n", di->name));
972
973 if (di->ntxd == 0)
974 return;
975
976 di->txin = di->txout = 0;
977 di->hnddma.txavail = di->ntxd - 1;
978
979 /* clear tx descriptor ring */
980 BZERO_SM((void *)(uintptr)di->txd32, (di->ntxd * sizeof(dma32dd_t)));
981 W_REG(di->osh, &di->d32txregs->control, XC_XE);
982 _dma_ddtable_init(di, DMA_TX, di->txdpa);
983 }
984
985 static bool
986 dma32_txenabled(dma_info_t *di)
987 {
988 uint32 xc;
989
990 /* If the chip is dead, it is not enabled :-) */
991 xc = R_REG(di->osh, &di->d32txregs->control);
992 return ((xc != 0xffffffff) && (xc & XC_XE));
993 }
994
995 static void
996 dma32_txsuspend(dma_info_t *di)
997 {
998 DMA_TRACE(("%s: dma_txsuspend\n", di->name));
999
1000 if (di->ntxd == 0)
1001 return;
1002
1003 OR_REG(di->osh, &di->d32txregs->control, XC_SE);
1004 }
1005
1006 static void
1007 dma32_txresume(dma_info_t *di)
1008 {
1009 DMA_TRACE(("%s: dma_txresume\n", di->name));
1010
1011 if (di->ntxd == 0)
1012 return;
1013
1014 AND_REG(di->osh, &di->d32txregs->control, ~XC_SE);
1015 }
1016
1017 static bool
1018 dma32_txsuspended(dma_info_t *di)
1019 {
1020 return (di->ntxd == 0) || ((R_REG(di->osh, &di->d32txregs->control) & XC_SE) == XC_SE);
1021 }
1022
1023 static void
1024 dma32_txreclaim(dma_info_t *di, bool forceall)
1025 {
1026 void *p;
1027
1028 DMA_TRACE(("%s: dma_txreclaim %s\n", di->name, forceall ? "all" : ""));
1029
1030 while ((p = dma32_getnexttxp(di, forceall)))
1031 PKTFREE(di->osh, p, TRUE);
1032 }
1033
1034 static bool
1035 dma32_txstopped(dma_info_t *di)
1036 {
1037 return ((R_REG(di->osh, &di->d32txregs->status) & XS_XS_MASK) == XS_XS_STOPPED);
1038 }
1039
1040 static bool
1041 dma32_rxstopped(dma_info_t *di)
1042 {
1043 return ((R_REG(di->osh, &di->d32rxregs->status) & RS_RS_MASK) == RS_RS_STOPPED);
1044 }
1045
1046 static bool
1047 dma32_alloc(dma_info_t *di, uint direction)
1048 {
1049 uint size;
1050 uint ddlen;
1051 void *va;
1052
1053 ddlen = sizeof(dma32dd_t);
1054
1055 size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
1056
1057 if (!ISALIGNED(DMA_CONSISTENT_ALIGN, D32RINGALIGN))
1058 size += D32RINGALIGN;
1059
1060
1061 if (direction == DMA_TX) {
1062 if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->txdpa, &di->tx_dmah)) == NULL) {
1063 DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(ntxd) failed\n",
1064 di->name));
1065 return FALSE;
1066 }
1067
1068 di->txd32 = (dma32dd_t *) ROUNDUP((uintptr)va, D32RINGALIGN);
1069 di->txdalign = (uint)((int8*)(uintptr)di->txd32 - (int8*)va);
1070 di->txdpa += di->txdalign;
1071 di->txdalloc = size;
1072 ASSERT(ISALIGNED((uintptr)di->txd32, D32RINGALIGN));
1073 } else {
1074 if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->rxdpa, &di->rx_dmah)) == NULL) {
1075 DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(nrxd) failed\n",
1076 di->name));
1077 return FALSE;
1078 }
1079 di->rxd32 = (dma32dd_t *) ROUNDUP((uintptr)va, D32RINGALIGN);
1080 di->rxdalign = (uint)((int8*)(uintptr)di->rxd32 - (int8*)va);
1081 di->rxdpa += di->rxdalign;
1082 di->rxdalloc = size;
1083 ASSERT(ISALIGNED((uintptr)di->rxd32, D32RINGALIGN));
1084 }
1085
1086 return TRUE;
1087 }
1088
1089 static bool
1090 dma32_txreset(dma_info_t *di)
1091 {
1092 uint32 status;
1093
1094 if (di->ntxd == 0)
1095 return TRUE;
1096
1097 /* suspend tx DMA first */
1098 W_REG(di->osh, &di->d32txregs->control, XC_SE);
1099 SPINWAIT(((status = (R_REG(di->osh, &di->d32txregs->status) & XS_XS_MASK))
1100 != XS_XS_DISABLED) &&
1101 (status != XS_XS_IDLE) &&
1102 (status != XS_XS_STOPPED),
1103 (10000));
1104
1105 W_REG(di->osh, &di->d32txregs->control, 0);
1106 SPINWAIT(((status = (R_REG(di->osh,
1107 &di->d32txregs->status) & XS_XS_MASK)) != XS_XS_DISABLED),
1108 10000);
1109
1110 /* wait for the last transaction to complete */
1111 OSL_DELAY(300);
1112
1113 return (status == XS_XS_DISABLED);
1114 }
1115
1116 static bool
1117 dma32_rxidle(dma_info_t *di)
1118 {
1119 DMA_TRACE(("%s: dma_rxidle\n", di->name));
1120
1121 if (di->nrxd == 0)
1122 return TRUE;
1123
1124 return ((R_REG(di->osh, &di->d32rxregs->status) & RS_CD_MASK) ==
1125 R_REG(di->osh, &di->d32rxregs->ptr));
1126 }
1127
1128 static bool
1129 dma32_rxreset(dma_info_t *di)
1130 {
1131 uint32 status;
1132
1133 if (di->nrxd == 0)
1134 return TRUE;
1135
1136 W_REG(di->osh, &di->d32rxregs->control, 0);
1137 SPINWAIT(((status = (R_REG(di->osh,
1138 &di->d32rxregs->status) & RS_RS_MASK)) != RS_RS_DISABLED),
1139 10000);
1140
1141 return (status == RS_RS_DISABLED);
1142 }
1143
1144 static bool
1145 dma32_rxenabled(dma_info_t *di)
1146 {
1147 uint32 rc;
1148
1149 rc = R_REG(di->osh, &di->d32rxregs->control);
1150 return ((rc != 0xffffffff) && (rc & RC_RE));
1151 }
1152
1153 static bool
1154 dma32_txsuspendedidle(dma_info_t *di)
1155 {
1156 if (di->ntxd == 0)
1157 return TRUE;
1158
1159 if (!(R_REG(di->osh, &di->d32txregs->control) & XC_SE))
1160 return 0;
1161
1162 if ((R_REG(di->osh, &di->d32txregs->status) & XS_XS_MASK) != XS_XS_IDLE)
1163 return 0;
1164
1165 OSL_DELAY(2);
1166 return ((R_REG(di->osh, &di->d32txregs->status) & XS_XS_MASK) == XS_XS_IDLE);
1167 }
1168
1169 /* !! tx entry routine
1170 * supports full 32bit dma engine buffer addressing so
1171 * dma buffers can cross 4 Kbyte page boundaries.
1172 */
1173 static int
1174 dma32_txfast(dma_info_t *di, void *p0, bool commit)
1175 {
1176 void *p, *next;
1177 uchar *data;
1178 uint len;
1179 uint txout;
1180 uint32 flags = 0;
1181 uint32 pa;
1182
1183 DMA_TRACE(("%s: dma_txfast\n", di->name));
1184
1185 txout = di->txout;
1186
1187 /*
1188 * Walk the chain of packet buffers
1189 * allocating and initializing transmit descriptor entries.
1190 */
1191 for (p = p0; p; p = next) {
1192 data = PKTDATA(di->osh, p);
1193 len = PKTLEN(di->osh, p);
1194 next = PKTNEXT(di->osh, p);
1195
1196 /* return nonzero if out of tx descriptors */
1197 if (NEXTTXD(txout) == di->txin)
1198 goto outoftxd;
1199
1200 if (len == 0)
1201 continue;
1202
1203 /* get physical address of buffer start */
1204 pa = (uint32) DMA_MAP(di->osh, data, len, DMA_TX, p);
1205
1206 flags = 0;
1207 if (p == p0)
1208 flags |= CTRL_SOF;
1209 if (next == NULL)
1210 flags |= (CTRL_IOC | CTRL_EOF);
1211 if (txout == (di->ntxd - 1))
1212 flags |= CTRL_EOT;
1213
1214 dma32_dd_upd(di, di->txd32, pa, txout, &flags, len);
1215 ASSERT(di->txp[txout] == NULL);
1216
1217 txout = NEXTTXD(txout);
1218 }
1219
1220 /* if last txd eof not set, fix it */
1221 if (!(flags & CTRL_EOF))
1222 W_SM(&di->txd32[PREVTXD(txout)].ctrl, BUS_SWAP32(flags | CTRL_IOC | CTRL_EOF));
1223
1224 /* save the packet */
1225 di->txp[PREVTXD(txout)] = p0;
1226
1227 /* bump the tx descriptor index */
1228 di->txout = txout;
1229
1230 /* kick the chip */
1231 if (commit)
1232 W_REG(di->osh, &di->d32txregs->ptr, I2B(txout, dma32dd_t));
1233
1234 /* tx flow control */
1235 di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
1236
1237 return (0);
1238
1239 outoftxd:
1240 DMA_ERROR(("%s: dma_txfast: out of txds\n", di->name));
1241 PKTFREE(di->osh, p0, TRUE);
1242 di->hnddma.txavail = 0;
1243 di->hnddma.txnobuf++;
1244 return (-1);
1245 }
1246
1247 /*
1248 * Reclaim next completed txd (txds if using chained buffers) and
1249 * return associated packet.
1250 * If 'force' is true, reclaim txd(s) and return associated packet
1251 * regardless of the value of the hardware "curr" pointer.
1252 */
1253 static void *
1254 dma32_getnexttxp(dma_info_t *di, bool forceall)
1255 {
1256 uint start, end, i;
1257 void *txp;
1258
1259 DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
1260
1261 if (di->ntxd == 0)
1262 return (NULL);
1263
1264 txp = NULL;
1265
1266 start = di->txin;
1267 if (forceall)
1268 end = di->txout;
1269 else
1270 end = B2I(R_REG(di->osh, &di->d32txregs->status) & XS_CD_MASK, dma32dd_t);
1271
1272 if ((start == 0) && (end > di->txout))
1273 goto bogus;
1274
1275 for (i = start; i != end && !txp; i = NEXTTXD(i)) {
1276 DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->txd32[i].addr)) - di->dataoffsetlow),
1277 (BUS_SWAP32(R_SM(&di->txd32[i].ctrl)) & CTRL_BC_MASK),
1278 DMA_TX, di->txp[i]);
1279
1280 W_SM(&di->txd32[i].addr, 0xdeadbeef);
1281 txp = di->txp[i];
1282 di->txp[i] = NULL;
1283 }
1284
1285 di->txin = i;
1286
1287 /* tx flow control */
1288 di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
1289
1290 return (txp);
1291
1292 bogus:
1293 /*
1294 DMA_ERROR(("dma_getnexttxp: bogus curr: start %d end %d txout %d force %d\n",
1295 start, end, di->txout, forceall));
1296 */
1297 return (NULL);
1298 }
1299
1300 static void *
1301 dma32_getnextrxp(dma_info_t *di, bool forceall)
1302 {
1303 uint i;
1304 void *rxp;
1305
1306 /* if forcing, dma engine must be disabled */
1307 ASSERT(!forceall || !dma32_rxenabled(di));
1308
1309 i = di->rxin;
1310
1311 /* return if no packets posted */
1312 if (i == di->rxout)
1313 return (NULL);
1314
1315 /* ignore curr if forceall */
1316 if (!forceall && (i == B2I(R_REG(di->osh, &di->d32rxregs->status) & RS_CD_MASK, dma32dd_t)))
1317 return (NULL);
1318
1319 /* get the packet pointer that corresponds to the rx descriptor */
1320 rxp = di->rxp[i];
1321 ASSERT(rxp);
1322 di->rxp[i] = NULL;
1323
1324 /* clear this packet from the descriptor ring */
1325 DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->rxd32[i].addr)) - di->dataoffsetlow),
1326 di->rxbufsize, DMA_RX, rxp);
1327
1328 W_SM(&di->rxd32[i].addr, 0xdeadbeef);
1329
1330 di->rxin = NEXTRXD(i);
1331
1332 return (rxp);
1333 }
1334
1335 /*
1336 * Rotate all active tx dma ring entries "forward" by (ActiveDescriptor - txin).
1337 */
1338 static void
1339 dma32_txrotate(dma_info_t *di)
1340 {
1341 uint ad;
1342 uint nactive;
1343 uint rot;
1344 uint old, new;
1345 uint32 w;
1346 uint first, last;
1347
1348 ASSERT(dma32_txsuspendedidle(di));
1349
1350 nactive = _dma_txactive(di);
1351 ad = B2I(((R_REG(di->osh, &di->d32txregs->status) & XS_AD_MASK) >> XS_AD_SHIFT), dma32dd_t);
1352 rot = TXD(ad - di->txin);
1353
1354 ASSERT(rot < di->ntxd);
1355
1356 /* full-ring case is a lot harder - don't worry about this */
1357 if (rot >= (di->ntxd - nactive)) {
1358 DMA_ERROR(("%s: dma_txrotate: ring full - punt\n", di->name));
1359 return;
1360 }
1361
1362 first = di->txin;
1363 last = PREVTXD(di->txout);
1364
1365 /* move entries starting at last and moving backwards to first */
1366 for (old = last; old != PREVTXD(first); old = PREVTXD(old)) {
1367 new = TXD(old + rot);
1368
1369 /*
1370 * Move the tx dma descriptor.
1371 * EOT is set only in the last entry in the ring.
1372 */
1373 w = BUS_SWAP32(R_SM(&di->txd32[old].ctrl)) & ~CTRL_EOT;
1374 if (new == (di->ntxd - 1))
1375 w |= CTRL_EOT;
1376 W_SM(&di->txd32[new].ctrl, BUS_SWAP32(w));
1377 W_SM(&di->txd32[new].addr, R_SM(&di->txd32[old].addr));
1378
1379 /* zap the old tx dma descriptor address field */
1380 W_SM(&di->txd32[old].addr, BUS_SWAP32(0xdeadbeef));
1381
1382 /* move the corresponding txp[] entry */
1383 ASSERT(di->txp[new] == NULL);
1384 di->txp[new] = di->txp[old];
1385 di->txp[old] = NULL;
1386 }
1387
1388 /* update txin and txout */
1389 di->txin = ad;
1390 di->txout = TXD(di->txout + rot);
1391 di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
1392
1393 /* kick the chip */
1394 W_REG(di->osh, &di->d32txregs->ptr, I2B(di->txout, dma32dd_t));
1395 }
1396
1397 /* 64 bits DMA functions */
1398
1399 #ifdef BCMDMA64
1400 static void
1401 dma64_txinit(dma_info_t *di)
1402 {
1403 DMA_TRACE(("%s: dma_txinit\n", di->name));
1404
1405 if (di->ntxd == 0)
1406 return;
1407
1408 di->txin = di->txout = 0;
1409 di->hnddma.txavail = di->ntxd - 1;
1410
1411 /* clear tx descriptor ring */
1412 BZERO_SM((void *)(uintptr)di->txd64, (di->ntxd * sizeof(dma64dd_t)));
1413 W_REG(di->osh, &di->d64txregs->control, D64_XC_XE);
1414 _dma_ddtable_init(di, DMA_TX, di->txdpa);
1415 }
1416
1417 static bool
1418 dma64_txenabled(dma_info_t *di)
1419 {
1420 uint32 xc;
1421
1422 /* If the chip is dead, it is not enabled :-) */
1423 xc = R_REG(di->osh, &di->d64txregs->control);
1424 return ((xc != 0xffffffff) && (xc & D64_XC_XE));
1425 }
1426
1427 static void
1428 dma64_txsuspend(dma_info_t *di)
1429 {
1430 DMA_TRACE(("%s: dma_txsuspend\n", di->name));
1431
1432 if (di->ntxd == 0)
1433 return;
1434
1435 OR_REG(di->osh, &di->d64txregs->control, D64_XC_SE);
1436 }
1437
1438 static void
1439 dma64_txresume(dma_info_t *di)
1440 {
1441 DMA_TRACE(("%s: dma_txresume\n", di->name));
1442
1443 if (di->ntxd == 0)
1444 return;
1445
1446 AND_REG(di->osh, &di->d64txregs->control, ~D64_XC_SE);
1447 }
1448
1449 static bool
1450 dma64_txsuspended(dma_info_t *di)
1451 {
1452 return (di->ntxd == 0) || ((R_REG(di->osh, &di->d64txregs->control) & D64_XC_SE)
1453 == D64_XC_SE);
1454 }
1455
1456 static void
1457 dma64_txreclaim(dma_info_t *di, bool forceall)
1458 {
1459 void *p;
1460
1461 DMA_TRACE(("%s: dma_txreclaim %s\n", di->name, forceall ? "all" : ""));
1462
1463 while ((p = dma64_getnexttxp(di, forceall)))
1464 PKTFREE(di->osh, p, TRUE);
1465 }
1466
1467 static bool
1468 dma64_txstopped(dma_info_t *di)
1469 {
1470 return ((R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK) == D64_XS0_XS_STOPPED);
1471 }
1472
1473 static bool
1474 dma64_rxstopped(dma_info_t *di)
1475 {
1476 return ((R_REG(di->osh, &di->d64rxregs->status0) & D64_RS0_RS_MASK) == D64_RS0_RS_STOPPED);
1477 }
1478
1479 static bool
1480 dma64_alloc(dma_info_t *di, uint direction)
1481 {
1482 uint size;
1483 uint ddlen;
1484 uint32 alignbytes;
1485 void *va;
1486
1487 ddlen = sizeof(dma64dd_t);
1488
1489 size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
1490
1491 alignbytes = di->dma64align;
1492
1493 if (!ISALIGNED(DMA_CONSISTENT_ALIGN, alignbytes))
1494 size += alignbytes;
1495
1496 if (direction == DMA_TX) {
1497 if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->txdpa, &di->tx_dmah)) == NULL) {
1498 DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(ntxd) failed\n",
1499 di->name));
1500 return FALSE;
1501 }
1502
1503 di->txd64 = (dma64dd_t *) ROUNDUP((uintptr)va, alignbytes);
1504 di->txdalign = (uint)((int8*)(uintptr)di->txd64 - (int8*)va);
1505 di->txdpa += di->txdalign;
1506 di->txdalloc = size;
1507 ASSERT(ISALIGNED((uintptr)di->txd64, alignbytes));
1508 } else {
1509 if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->rxdpa, &di->rx_dmah)) == NULL) {
1510 DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(nrxd) failed\n",
1511 di->name));
1512 return FALSE;
1513 }
1514 di->rxd64 = (dma64dd_t *) ROUNDUP((uintptr)va, alignbytes);
1515 di->rxdalign = (uint)((int8*)(uintptr)di->rxd64 - (int8*)va);
1516 di->rxdpa += di->rxdalign;
1517 di->rxdalloc = size;
1518 ASSERT(ISALIGNED((uintptr)di->rxd64, alignbytes));
1519 }
1520
1521 return TRUE;
1522 }
1523
1524 static bool
1525 dma64_txreset(dma_info_t *di)
1526 {
1527 uint32 status;
1528
1529 if (di->ntxd == 0)
1530 return TRUE;
1531
1532 /* suspend tx DMA first */
1533 W_REG(di->osh, &di->d64txregs->control, D64_XC_SE);
1534 SPINWAIT(((status = (R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK)) !=
1535 D64_XS0_XS_DISABLED) &&
1536 (status != D64_XS0_XS_IDLE) &&
1537 (status != D64_XS0_XS_STOPPED),
1538 10000);
1539
1540 W_REG(di->osh, &di->d64txregs->control, 0);
1541 SPINWAIT(((status = (R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK)) !=
1542 D64_XS0_XS_DISABLED),
1543 10000);
1544
1545 /* wait for the last transaction to complete */
1546 OSL_DELAY(300);
1547
1548 return (status == D64_XS0_XS_DISABLED);
1549 }
1550
1551 static bool
1552 dma64_rxidle(dma_info_t *di)
1553 {
1554 DMA_TRACE(("%s: dma_rxidle\n", di->name));
1555
1556 if (di->nrxd == 0)
1557 return TRUE;
1558
1559 return ((R_REG(di->osh, &di->d64rxregs->status0) & D64_RS0_CD_MASK) ==
1560 R_REG(di->osh, &di->d64rxregs->ptr));
1561 }
1562
1563 static bool
1564 dma64_rxreset(dma_info_t *di)
1565 {
1566 uint32 status;
1567
1568 if (di->nrxd == 0)
1569 return TRUE;
1570
1571 W_REG(di->osh, &di->d64rxregs->control, 0);
1572 SPINWAIT(((status = (R_REG(di->osh, &di->d64rxregs->status0) & D64_RS0_RS_MASK)) !=
1573 D64_RS0_RS_DISABLED),
1574 10000);
1575
1576 return (status == D64_RS0_RS_DISABLED);
1577 }
1578
1579 static bool
1580 dma64_rxenabled(dma_info_t *di)
1581 {
1582 uint32 rc;
1583
1584 rc = R_REG(di->osh, &di->d64rxregs->control);
1585 return ((rc != 0xffffffff) && (rc & D64_RC_RE));
1586 }
1587
1588 static bool
1589 dma64_txsuspendedidle(dma_info_t *di)
1590 {
1591
1592 if (di->ntxd == 0)
1593 return TRUE;
1594
1595 if (!(R_REG(di->osh, &di->d64txregs->control) & D64_XC_SE))
1596 return 0;
1597
1598 if ((R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_XS_MASK) == D64_XS0_XS_IDLE)
1599 return 1;
1600
1601 return 0;
1602 }
1603
1604
1605 /* !! tx entry routine */
1606 static int
1607 dma64_txfast(dma_info_t *di, void *p0, bool commit)
1608 {
1609 void *p, *next;
1610 uchar *data;
1611 uint len;
1612 uint txout;
1613 uint32 flags = 0;
1614 uint32 pa;
1615
1616 DMA_TRACE(("%s: dma_txfast\n", di->name));
1617
1618 txout = di->txout;
1619
1620 /*
1621 * Walk the chain of packet buffers
1622 * allocating and initializing transmit descriptor entries.
1623 */
1624 for (p = p0; p; p = next) {
1625 data = PKTDATA(di->osh, p);
1626 len = PKTLEN(di->osh, p);
1627 next = PKTNEXT(di->osh, p);
1628
1629 /* return nonzero if out of tx descriptors */
1630 if (NEXTTXD(txout) == di->txin)
1631 goto outoftxd;
1632
1633 if (len == 0)
1634 continue;
1635
1636 /* get physical address of buffer start */
1637 pa = (uint32) DMA_MAP(di->osh, data, len, DMA_TX, p);
1638
1639 flags = 0;
1640 if (p == p0)
1641 flags |= D64_CTRL1_SOF;
1642 if (next == NULL)
1643 flags |= (D64_CTRL1_IOC | D64_CTRL1_EOF);
1644 if (txout == (di->ntxd - 1))
1645 flags |= D64_CTRL1_EOT;
1646
1647 dma64_dd_upd(di, di->txd64, pa, txout, &flags, len);
1648 ASSERT(di->txp[txout] == NULL);
1649
1650 txout = NEXTTXD(txout);
1651 }
1652
1653 /* if last txd eof not set, fix it */
1654 if (!(flags & D64_CTRL1_EOF))
1655 W_SM(&di->txd64[PREVTXD(txout)].ctrl1,
1656 BUS_SWAP32(flags | D64_CTRL1_IOC | D64_CTRL1_EOF));
1657
1658 /* save the packet */
1659 di->txp[PREVTXD(txout)] = p0;
1660
1661 /* bump the tx descriptor index */
1662 di->txout = txout;
1663
1664 /* kick the chip */
1665 if (commit)
1666 W_REG(di->osh, &di->d64txregs->ptr, I2B(txout, dma64dd_t));
1667
1668 /* tx flow control */
1669 di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
1670
1671 return (0);
1672
1673 outoftxd:
1674 DMA_ERROR(("%s: dma_txfast: out of txds\n", di->name));
1675 PKTFREE(di->osh, p0, TRUE);
1676 di->hnddma.txavail = 0;
1677 di->hnddma.txnobuf++;
1678 return (-1);
1679 }
1680
1681 /*
1682 * Reclaim next completed txd (txds if using chained buffers) and
1683 * return associated packet.
1684 * If 'force' is true, reclaim txd(s) and return associated packet
1685 * regardless of the value of the hardware "curr" pointer.
1686 */
1687 static void *
1688 dma64_getnexttxp(dma_info_t *di, bool forceall)
1689 {
1690 uint start, end, i;
1691 void *txp;
1692
1693 DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
1694
1695 if (di->ntxd == 0)
1696 return (NULL);
1697
1698 txp = NULL;
1699
1700 start = di->txin;
1701 if (forceall)
1702 end = di->txout;
1703 else
1704 end = B2I(R_REG(di->osh, &di->d64txregs->status0) & D64_XS0_CD_MASK, dma64dd_t);
1705
1706 if ((start == 0) && (end > di->txout))
1707 goto bogus;
1708
1709 for (i = start; i != end && !txp; i = NEXTTXD(i)) {
1710 DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->txd64[i].addrlow)) - di->dataoffsetlow),
1711 (BUS_SWAP32(R_SM(&di->txd64[i].ctrl2)) & D64_CTRL2_BC_MASK),
1712 DMA_TX, di->txp[i]);
1713
1714 W_SM(&di->txd64[i].addrlow, 0xdeadbeef);
1715 W_SM(&di->txd64[i].addrhigh, 0xdeadbeef);
1716
1717 txp = di->txp[i];
1718 di->txp[i] = NULL;
1719 }
1720
1721 di->txin = i;
1722
1723 /* tx flow control */
1724 di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
1725
1726 return (txp);
1727
1728 bogus:
1729 /*
1730 DMA_ERROR(("dma_getnexttxp: bogus curr: start %d end %d txout %d force %d\n",
1731 start, end, di->txout, forceall));
1732 */
1733 return (NULL);
1734 }
1735
1736 static void *
1737 dma64_getnextrxp(dma_info_t *di, bool forceall)
1738 {
1739 uint i;
1740 void *rxp;
1741
1742 /* if forcing, dma engine must be disabled */
1743 ASSERT(!forceall || !dma64_rxenabled(di));
1744
1745 i = di->rxin;
1746
1747 /* return if no packets posted */
1748 if (i == di->rxout)
1749 return (NULL);
1750
1751 /* ignore curr if forceall */
1752 if (!forceall &&
1753 (i == B2I(R_REG(di->osh, &di->d64rxregs->status0) & D64_RS0_CD_MASK, dma64dd_t)))
1754 return (NULL);
1755
1756 /* get the packet pointer that corresponds to the rx descriptor */
1757 rxp = di->rxp[i];
1758 ASSERT(rxp);
1759 di->rxp[i] = NULL;
1760
1761 /* clear this packet from the descriptor ring */
1762 DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->rxd64[i].addrlow)) - di->dataoffsetlow),
1763 di->rxbufsize, DMA_RX, rxp);
1764
1765 W_SM(&di->rxd64[i].addrlow, 0xdeadbeef);
1766 W_SM(&di->rxd64[i].addrhigh, 0xdeadbeef);
1767
1768 di->rxin = NEXTRXD(i);
1769
1770 return (rxp);
1771 }
1772
1773 static bool
1774 _dma64_addrext(osl_t *osh, dma64regs_t *dma64regs)
1775 {
1776 uint32 w;
1777 OR_REG(osh, &dma64regs->control, D64_XC_AE);
1778 w = R_REG(osh, &dma64regs->control);
1779 AND_REG(osh, &dma64regs->control, ~D64_XC_AE);
1780 return ((w & D64_XC_AE) == D64_XC_AE);
1781 }
1782
1783 /*
1784 * Rotate all active tx dma ring entries "forward" by (ActiveDescriptor - txin).
1785 */
1786 static void
1787 dma64_txrotate(dma_info_t *di)
1788 {
1789 uint ad;
1790 uint nactive;
1791 uint rot;
1792 uint old, new;
1793 uint32 w;
1794 uint first, last;
1795
1796 ASSERT(dma64_txsuspendedidle(di));
1797
1798 nactive = _dma_txactive(di);
1799 ad = B2I((R_REG(di->osh, &di->d64txregs->status1) & D64_XS1_AD_MASK), dma64dd_t);
1800 rot = TXD(ad - di->txin);
1801
1802 ASSERT(rot < di->ntxd);
1803
1804 /* full-ring case is a lot harder - don't worry about this */
1805 if (rot >= (di->ntxd - nactive)) {
1806 DMA_ERROR(("%s: dma_txrotate: ring full - punt\n", di->name));
1807 return;
1808 }
1809
1810 first = di->txin;
1811 last = PREVTXD(di->txout);
1812
1813 /* move entries starting at last and moving backwards to first */
1814 for (old = last; old != PREVTXD(first); old = PREVTXD(old)) {
1815 new = TXD(old + rot);
1816
1817 /*
1818 * Move the tx dma descriptor.
1819 * EOT is set only in the last entry in the ring.
1820 */
1821 w = BUS_SWAP32(R_SM(&di->txd64[old].ctrl1)) & ~D64_CTRL1_EOT;
1822 if (new == (di->ntxd - 1))
1823 w |= D64_CTRL1_EOT;
1824 W_SM(&di->txd64[new].ctrl1, BUS_SWAP32(w));
1825
1826 w = BUS_SWAP32(R_SM(&di->txd64[old].ctrl2));
1827 W_SM(&di->txd64[new].ctrl2, BUS_SWAP32(w));
1828
1829 W_SM(&di->txd64[new].addrlow, R_SM(&di->txd64[old].addrlow));
1830 W_SM(&di->txd64[new].addrhigh, R_SM(&di->txd64[old].addrhigh));
1831
1832 /* zap the old tx dma descriptor address field */
1833 W_SM(&di->txd64[old].addrlow, BUS_SWAP32(0xdeadbeef));
1834 W_SM(&di->txd64[old].addrhigh, BUS_SWAP32(0xdeadbeef));
1835
1836 /* move the corresponding txp[] entry */
1837 ASSERT(di->txp[new] == NULL);
1838 di->txp[new] = di->txp[old];
1839 di->txp[old] = NULL;
1840 }
1841
1842 /* update txin and txout */
1843 di->txin = ad;
1844 di->txout = TXD(di->txout + rot);
1845 di->hnddma.txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
1846
1847 /* kick the chip */
1848 W_REG(di->osh, &di->d64txregs->ptr, I2B(di->txout, dma64dd_t));
1849 }
1850
1851 #endif /* BCMDMA64 */
1852
1853 uint
1854 dma_addrwidth(sb_t *sbh, void *dmaregs)
1855 {
1856 dma32regs_t *dma32regs;
1857 osl_t *osh;
1858
1859 osh = sb_osh(sbh);
1860
1861 if (DMA64_CAP) {
1862 /* DMA engine is 64-bit capable */
1863 if (((sb_coreflagshi(sbh, 0, 0) & SBTMH_DMA64) == SBTMH_DMA64)) {
1864 /* backplane are 64 bits capable */
1865 #if 0
1866 if (sb_backplane64(sbh))
1867 /* If bus is System Backplane or PCIE then we can access 64-bits */
1868 if ((BUSTYPE(sbh->bustype) == SB_BUS) ||
1869 ((BUSTYPE(sbh->bustype) == PCI_BUS) &&
1870 sbh->buscoretype == SB_PCIE))
1871 return (DMADDRWIDTH_64);
1872 #endif
1873
1874 /* DMA64 is always 32 bits capable, AE is always TRUE */
1875 #ifdef BCMDMA64
1876 ASSERT(_dma64_addrext(osh, (dma64regs_t *)dmaregs));
1877 #endif
1878 return (DMADDRWIDTH_32);
1879 }
1880 }
1881
1882 /* Start checking for 32-bit / 30-bit addressing */
1883 dma32regs = (dma32regs_t *)dmaregs;
1884
1885 /* For System Backplane, PCIE bus or addrext feature, 32-bits ok */
1886 if ((BUSTYPE(sbh->bustype) == SB_BUS) ||
1887 ((BUSTYPE(sbh->bustype) == PCI_BUS) && sbh->buscoretype == SB_PCIE) ||
1888 (_dma32_addrext(osh, dma32regs)))
1889 return (DMADDRWIDTH_32);
1890
1891 /* Fallthru */
1892 return (DMADDRWIDTH_30);
1893 }
Personal OpenWRT clone
This page took 0.187009 seconds and 5 git commands to generate.