projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
upgrade kernel, quagga and openvpn, add licensing info to diag module, fix up jffs2
[openwrt.git] / package / linux / kernel-source / drivers / net / hnd / hnddma.c
1 /*
2 * Generic Broadcom Home Networking Division (HND) DMA module.
3 * This supports the following chips: BCM42xx, 44xx, 47xx .
4 *
5 * Copyright 2004, 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$
14 */
15
16 #include <typedefs.h>
17 #include <osl.h>
18 #include <bcmendian.h>
19 #include <bcmutils.h>
20
21 struct dma_info; /* forward declaration */
22 #define di_t struct dma_info
23 #include <hnddma.h>
24
25 /* debug/trace */
26 #define DMA_ERROR(args)
27 #define DMA_TRACE(args)
28
29 /* default dma message level(if input msg_level pointer is null in dma_attach()) */
30 static uint dma_msg_level = 0;
31
32 #define MAXNAMEL 8
33 #define MAXDD (DMAMAXRINGSZ / sizeof (dmadd_t))
34
35 /* dma engine software state */
36 typedef struct dma_info {
37 hnddma_t hnddma; /* exported structure */
38 uint *msg_level; /* message level pointer */
39
40 char name[MAXNAMEL]; /* callers name for diag msgs */
41 void *drv; /* driver handle */
42 void *dev; /* device handle */
43 dmaregs_t *regs; /* dma engine registers */
44
45 dmadd_t *txd; /* pointer to chip-specific tx descriptor ring */
46 uint txin; /* index of next descriptor to reclaim */
47 uint txout; /* index of next descriptor to post */
48 uint txavail; /* # free tx descriptors */
49 void *txp[MAXDD]; /* parallel array of pointers to packets */
50 ulong txdpa; /* physical address of descriptor ring */
51 uint txdalign; /* #bytes added to alloc'd mem to align txd */
52
53 dmadd_t *rxd; /* pointer to chip-specific rx descriptor ring */
54 uint rxin; /* index of next descriptor to reclaim */
55 uint rxout; /* index of next descriptor to post */
56 void *rxp[MAXDD]; /* parallel array of pointers to packets */
57 ulong rxdpa; /* physical address of descriptor ring */
58 uint rxdalign; /* #bytes added to alloc'd mem to align rxd */
59
60 /* tunables */
61 uint ntxd; /* # tx descriptors */
62 uint nrxd; /* # rx descriptors */
63 uint rxbufsize; /* rx buffer size in bytes */
64 uint nrxpost; /* # rx buffers to keep posted */
65 uint rxoffset; /* rxcontrol offset */
66 uint ddoffset; /* add to get dma address of descriptor ring */
67 uint dataoffset; /* add to get dma address of data buffer */
68 } dma_info_t;
69
70 /* descriptor bumping macros */
71 #define TXD(x) ((x) & (di->ntxd - 1))
72 #define RXD(x) ((x) & (di->nrxd - 1))
73 #define NEXTTXD(i) TXD(i + 1)
74 #define PREVTXD(i) TXD(i - 1)
75 #define NEXTRXD(i) RXD(i + 1)
76 #define NTXDACTIVE(h, t) TXD(t - h)
77 #define NRXDACTIVE(h, t) RXD(t - h)
78
79 /* macros to convert between byte offsets and indexes */
80 #define B2I(bytes) ((bytes) / sizeof (dmadd_t))
81 #define I2B(index) ((index) * sizeof (dmadd_t))
82
83 void*
84 dma_attach(void *drv, void *dev, char *name, dmaregs_t *regs, uint ntxd, uint nrxd,
85 uint rxbufsize, uint nrxpost, uint rxoffset, uint ddoffset, uint dataoffset, uint *msg_level)
86 {
87 dma_info_t *di;
88 void *va;
89
90 ASSERT(ntxd <= MAXDD);
91 ASSERT(nrxd <= MAXDD);
92
93 /* allocate private info structure */
94 if ((di = MALLOC(sizeof (dma_info_t))) == NULL)
95 return (NULL);
96 bzero((char*)di, sizeof (dma_info_t));
97
98 /* set message level */
99 di->msg_level = msg_level ? msg_level : &dma_msg_level;
100
101 DMA_TRACE(("%s: dma_attach: drv 0x%x dev 0x%x regs 0x%x ntxd %d nrxd %d rxbufsize %d nrxpost %d rxoffset %d ddoffset 0x%x dataoffset 0x%x\n", name, (uint)drv, (uint)dev, (uint)regs, ntxd, nrxd, rxbufsize, nrxpost, rxoffset, ddoffset, dataoffset));
102
103 /* make a private copy of our callers name */
104 strncpy(di->name, name, MAXNAMEL);
105 di->name[MAXNAMEL-1] = '\0';
106
107 di->drv = drv;
108 di->dev = dev;
109 di->regs = regs;
110
111 /* allocate transmit descriptor ring */
112 if (ntxd) {
113 if ((va = DMA_ALLOC_CONSISTENT(dev, (DMAMAXRINGSZ + DMARINGALIGN), &di->txdpa)) == NULL)
114 goto fail;
115 di->txd = (dmadd_t*) ROUNDUP(va, DMARINGALIGN);
116 di->txdalign = ((uint)di->txd - (uint)va);
117 di->txdpa = di->txdpa + di->txdalign;
118 ASSERT(ISALIGNED(di->txd, DMARINGALIGN));
119 }
120
121 /* allocate receive descriptor ring */
122 if (nrxd) {
123 if ((va = DMA_ALLOC_CONSISTENT(dev, (DMAMAXRINGSZ + DMARINGALIGN), &di->rxdpa)) == NULL)
124 goto fail;
125 di->rxd = (dmadd_t*) ROUNDUP(va, DMARINGALIGN);
126 di->rxdalign = ((uint)di->rxd - (uint)va);
127 di->rxdpa = di->rxdpa + di->rxdalign;
128 ASSERT(ISALIGNED(di->rxd, DMARINGALIGN));
129 }
130
131 /* save tunables */
132 di->ntxd = ntxd;
133 di->nrxd = nrxd;
134 di->rxbufsize = rxbufsize;
135 di->nrxpost = nrxpost;
136 di->rxoffset = rxoffset;
137 di->ddoffset = ddoffset;
138 di->dataoffset = dataoffset;
139
140 return ((void*)di);
141
142 fail:
143 dma_detach((void*)di);
144 return (NULL);
145 }
146
147 /* may be called with core in reset */
148 void
149 dma_detach(dma_info_t *di)
150 {
151 if (di == NULL)
152 return;
153
154 DMA_TRACE(("%s: dma_detach\n", di->name));
155
156 /* shouldn't be here if descriptors are unreclaimed */
157 ASSERT(di->txin == di->txout);
158 ASSERT(di->rxin == di->rxout);
159
160 /* free dma descriptor rings */
161 if (di->txd)
162 DMA_FREE_CONSISTENT(di->dev, (void *)((uint)di->txd - di->txdalign), (DMAMAXRINGSZ + DMARINGALIGN), di->txdpa);
163 if (di->rxd)
164 DMA_FREE_CONSISTENT(di->dev, (void *)((uint)di->rxd - di->rxdalign), (DMAMAXRINGSZ + DMARINGALIGN), di->rxdpa);
165
166 /* free our private info structure */
167 MFREE((void*)di, sizeof (dma_info_t));
168 }
169
170
171 void
172 dma_txreset(dma_info_t *di)
173 {
174 uint32 status;
175
176 DMA_TRACE(("%s: dma_txreset\n", di->name));
177
178 /* suspend tx DMA first */
179 W_REG(&di->regs->xmtcontrol, XC_SE);
180 SPINWAIT((status = (R_REG(&di->regs->xmtstatus) & XS_XS_MASK)) != XS_XS_DISABLED &&
181 status != XS_XS_IDLE &&
182 status != XS_XS_STOPPED,
183 10000);
184
185 W_REG(&di->regs->xmtcontrol, 0);
186 SPINWAIT((status = (R_REG(&di->regs->xmtstatus) & XS_XS_MASK)) != XS_XS_DISABLED,
187 10000);
188
189 if (status != XS_XS_DISABLED) {
190 DMA_ERROR(("%s: dma_txreset: dma cannot be stopped\n", di->name));
191 }
192
193 /* wait for the last transaction to complete */
194 OSL_DELAY(300);
195 }
196
197 void
198 dma_rxreset(dma_info_t *di)
199 {
200 uint32 status;
201
202 DMA_TRACE(("%s: dma_rxreset\n", di->name));
203
204 W_REG(&di->regs->rcvcontrol, 0);
205 SPINWAIT((status = (R_REG(&di->regs->rcvstatus) & RS_RS_MASK)) != RS_RS_DISABLED,
206 10000);
207
208 if (status != RS_RS_DISABLED) {
209 DMA_ERROR(("%s: dma_rxreset: dma cannot be stopped\n", di->name));
210 }
211 }
212
213 void
214 dma_txinit(dma_info_t *di)
215 {
216 DMA_TRACE(("%s: dma_txinit\n", di->name));
217
218 di->txin = di->txout = 0;
219 di->txavail = di->ntxd - 1;
220
221 /* clear tx descriptor ring */
222 BZERO_SM((void*)di->txd, (di->ntxd * sizeof (dmadd_t)));
223
224 W_REG(&di->regs->xmtcontrol, XC_XE);
225 W_REG(&di->regs->xmtaddr, (di->txdpa + di->ddoffset));
226 }
227
228 bool
229 dma_txenabled(dma_info_t *di)
230 {
231 uint32 xc;
232
233 /* If the chip is dead, it is not enabled :-) */
234 xc = R_REG(&di->regs->xmtcontrol);
235 return ((xc != 0xffffffff) && (xc & XC_XE));
236 }
237
238 void
239 dma_txsuspend(dma_info_t *di)
240 {
241 DMA_TRACE(("%s: dma_txsuspend\n", di->name));
242 OR_REG(&di->regs->xmtcontrol, XC_SE);
243 }
244
245 void
246 dma_txresume(dma_info_t *di)
247 {
248 DMA_TRACE(("%s: dma_txresume\n", di->name));
249 AND_REG(&di->regs->xmtcontrol, ~XC_SE);
250 }
251
252 bool
253 dma_txsuspended(dma_info_t *di)
254 {
255 if (!(R_REG(&di->regs->xmtcontrol) & XC_SE))
256 return 0;
257
258 if ((R_REG(&di->regs->xmtstatus) & XS_XS_MASK) != XS_XS_IDLE)
259 return 0;
260
261 OSL_DELAY(2);
262 return ((R_REG(&di->regs->xmtstatus) & XS_XS_MASK) == XS_XS_IDLE);
263 }
264
265 bool
266 dma_txstopped(dma_info_t *di)
267 {
268 return ((R_REG(&di->regs->xmtstatus) & XS_XS_MASK) == XS_XS_STOPPED);
269 }
270
271 bool
272 dma_rxstopped(dma_info_t *di)
273 {
274 return ((R_REG(&di->regs->rcvstatus) & RS_RS_MASK) == RS_RS_STOPPED);
275 }
276
277 void
278 dma_fifoloopbackenable(dma_info_t *di)
279 {
280 DMA_TRACE(("%s: dma_fifoloopbackenable\n", di->name));
281 OR_REG(&di->regs->xmtcontrol, XC_LE);
282 }
283
284 void
285 dma_rxinit(dma_info_t *di)
286 {
287 DMA_TRACE(("%s: dma_rxinit\n", di->name));
288
289 di->rxin = di->rxout = 0;
290
291 /* clear rx descriptor ring */
292 BZERO_SM((void*)di->rxd, (di->nrxd * sizeof (dmadd_t)));
293
294 dma_rxenable(di);
295 W_REG(&di->regs->rcvaddr, (di->rxdpa + di->ddoffset));
296 }
297
298 void
299 dma_rxenable(dma_info_t *di)
300 {
301 DMA_TRACE(("%s: dma_rxenable\n", di->name));
302 W_REG(&di->regs->rcvcontrol, ((di->rxoffset << RC_RO_SHIFT) | RC_RE));
303 }
304
305 bool
306 dma_rxenabled(dma_info_t *di)
307 {
308 uint32 rc;
309
310 rc = R_REG(&di->regs->rcvcontrol);
311 return ((rc != 0xffffffff) && (rc & RC_RE));
312 }
313
314 /*
315 * The BCM47XX family supports full 32bit dma engine buffer addressing so
316 * dma buffers can cross 4 Kbyte page boundaries.
317 */
318 int
319 dma_txfast(dma_info_t *di, void *p0, uint32 coreflags)
320 {
321 void *p, *next;
322 uchar *data;
323 uint len;
324 uint txout;
325 uint32 ctrl;
326 uint32 pa;
327
328 DMA_TRACE(("%s: dma_txfast\n", di->name));
329
330 txout = di->txout;
331 ctrl = 0;
332
333 /*
334 * Walk the chain of packet buffers
335 * allocating and initializing transmit descriptor entries.
336 */
337 for (p = p0; p; p = next) {
338 data = PKTDATA(di->drv, p);
339 len = PKTLEN(di->drv, p);
340 next = PKTNEXT(di->drv, p);
341
342 /* return nonzero if out of tx descriptors */
343 if (NEXTTXD(txout) == di->txin)
344 goto outoftxd;
345
346 if (len == 0)
347 continue;
348
349 /* get physical address of buffer start */
350 pa = (uint32) DMA_MAP(di->dev, data, len, DMA_TX, p);
351
352 /* build the descriptor control value */
353 ctrl = len & CTRL_BC_MASK;
354
355 ctrl |= coreflags;
356
357 if (p == p0)
358 ctrl |= CTRL_SOF;
359 if (next == NULL)
360 ctrl |= (CTRL_IOC | CTRL_EOF);
361 if (txout == (di->ntxd - 1))
362 ctrl |= CTRL_EOT;
363
364 /* init the tx descriptor */
365 W_SM(&di->txd[txout].ctrl, BUS_SWAP32(ctrl));
366 W_SM(&di->txd[txout].addr, BUS_SWAP32(pa + di->dataoffset));
367
368 ASSERT(di->txp[txout] == NULL);
369
370 txout = NEXTTXD(txout);
371 }
372
373 /* if last txd eof not set, fix it */
374 if (!(ctrl & CTRL_EOF))
375 W_SM(&di->txd[PREVTXD(txout)].ctrl, BUS_SWAP32(ctrl | CTRL_IOC | CTRL_EOF));
376
377 /* save the packet */
378 di->txp[PREVTXD(txout)] = p0;
379
380 /* bump the tx descriptor index */
381 di->txout = txout;
382
383 /* kick the chip */
384 W_REG(&di->regs->xmtptr, I2B(txout));
385
386 /* tx flow control */
387 di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
388
389 return (0);
390
391 outoftxd:
392 DMA_ERROR(("%s: dma_txfast: out of txds\n", di->name));
393 PKTFREE(di->drv, p0, TRUE);
394 di->txavail = 0;
395 di->hnddma.txnobuf++;
396 return (-1);
397 }
398
399 #define PAGESZ 4096
400 #define PAGEBASE(x) ((uint)(x) & ~4095)
401
402 /*
403 * Just like above except go through the extra effort of splitting
404 * buffers that cross 4Kbyte boundaries into multiple tx descriptors.
405 */
406 int
407 dma_tx(dma_info_t *di, void *p0, uint32 coreflags)
408 {
409 void *p, *next;
410 uchar *data;
411 uint plen, len;
412 uchar *page, *start, *end;
413 uint txout;
414 uint32 ctrl;
415 uint32 pa;
416
417 DMA_TRACE(("%s: dma_tx\n", di->name));
418
419 txout = di->txout;
420 ctrl = 0;
421
422 /*
423 * Walk the chain of packet buffers
424 * splitting those that cross 4 Kbyte boundaries
425 * allocating and initializing transmit descriptor entries.
426 */
427 for (p = p0; p; p = next) {
428 data = PKTDATA(di->drv, p);
429 plen = PKTLEN(di->drv, p);
430 next = PKTNEXT(di->drv, p);
431
432 if (plen == 0)
433 continue;
434
435 for (page = (uchar*)PAGEBASE(data);
436 page <= (uchar*)PAGEBASE(data + plen - 1);
437 page += PAGESZ) {
438
439 /* return nonzero if out of tx descriptors */
440 if (NEXTTXD(txout) == di->txin)
441 goto outoftxd;
442
443 start = (page == (uchar*)PAGEBASE(data))? data: page;
444 end = (page == (uchar*)PAGEBASE(data + plen))?
445 (data + plen): (page + PAGESZ);
446 len = end - start;
447
448 /* build the descriptor control value */
449 ctrl = len & CTRL_BC_MASK;
450
451 ctrl |= coreflags;
452
453 if ((p == p0) && (start == data))
454 ctrl |= CTRL_SOF;
455 if ((next == NULL) && (end == (data + plen)))
456 ctrl |= (CTRL_IOC | CTRL_EOF);
457 if (txout == (di->ntxd - 1))
458 ctrl |= CTRL_EOT;
459
460 /* get physical address of buffer start */
461 pa = (uint32) DMA_MAP(di->dev, start, len, DMA_TX, p);
462
463 /* init the tx descriptor */
464 W_SM(&di->txd[txout].ctrl, BUS_SWAP32(ctrl));
465 W_SM(&di->txd[txout].addr, BUS_SWAP32(pa + di->dataoffset));
466
467 ASSERT(di->txp[txout] == NULL);
468
469 txout = NEXTTXD(txout);
470 }
471 }
472
473 /* if last txd eof not set, fix it */
474 if (!(ctrl & CTRL_EOF))
475 W_SM(&di->txd[PREVTXD(txout)].ctrl, BUS_SWAP32(ctrl | CTRL_IOC | CTRL_EOF));
476
477 /* save the packet */
478 di->txp[PREVTXD(txout)] = p0;
479
480 /* bump the tx descriptor index */
481 di->txout = txout;
482
483 /* kick the chip */
484 W_REG(&di->regs->xmtptr, I2B(txout));
485
486 /* tx flow control */
487 di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
488
489 return (0);
490
491 outoftxd:
492 DMA_ERROR(("%s: dma_tx: out of txds\n", di->name));
493 PKTFREE(di->drv, p0, TRUE);
494 di->txavail = 0;
495 di->hnddma.txnobuf++;
496 return (-1);
497 }
498
499 /* returns a pointer to the next frame received, or NULL if there are no more */
500 void*
501 dma_rx(dma_info_t *di)
502 {
503 void *p;
504 uint len;
505 int skiplen = 0;
506
507 while ((p = dma_getnextrxp(di, FALSE))) {
508 /* skip giant packets which span multiple rx descriptors */
509 if (skiplen > 0) {
510 skiplen -= di->rxbufsize;
511 if (skiplen < 0)
512 skiplen = 0;
513 PKTFREE(di->drv, p, FALSE);
514 continue;
515 }
516
517 len = ltoh16(*(uint16*)(PKTDATA(di->drv, p)));
518 DMA_TRACE(("%s: dma_rx len %d\n", di->name, len));
519
520 /* bad frame length check */
521 if (len > (di->rxbufsize - di->rxoffset)) {
522 DMA_ERROR(("%s: dma_rx: bad frame length (%d)\n", di->name, len));
523 if (len > 0)
524 skiplen = len - (di->rxbufsize - di->rxoffset);
525 PKTFREE(di->drv, p, FALSE);
526 di->hnddma.rxgiants++;
527 continue;
528 }
529
530 /* set actual length */
531 PKTSETLEN(di->drv, p, (di->rxoffset + len));
532
533 break;
534 }
535
536 return (p);
537 }
538
539 /* post receive buffers */
540 void
541 dma_rxfill(dma_info_t *di)
542 {
543 void *p;
544 uint rxin, rxout;
545 uint ctrl;
546 uint n;
547 uint i;
548 uint32 pa;
549 uint rxbufsize;
550
551 /*
552 * Determine how many receive buffers we're lacking
553 * from the full complement, allocate, initialize,
554 * and post them, then update the chip rx lastdscr.
555 */
556
557 rxin = di->rxin;
558 rxout = di->rxout;
559 rxbufsize = di->rxbufsize;
560
561 n = di->nrxpost - NRXDACTIVE(rxin, rxout);
562
563 DMA_TRACE(("%s: dma_rxfill: post %d\n", di->name, n));
564
565 for (i = 0; i < n; i++) {
566 if ((p = PKTGET(di->drv, rxbufsize, FALSE)) == NULL) {
567 DMA_ERROR(("%s: dma_rxfill: out of rxbufs\n", di->name));
568 di->hnddma.rxnobuf++;
569 break;
570 }
571
572 *(uint32*)(OSL_UNCACHED(PKTDATA(di->drv, p))) = 0;
573
574 pa = (uint32) DMA_MAP(di->dev, PKTDATA(di->drv, p), rxbufsize, DMA_RX, p);
575 ASSERT(ISALIGNED(pa, 4));
576
577 /* save the free packet pointer */
578 ASSERT(di->rxp[rxout] == NULL);
579 di->rxp[rxout] = p;
580
581 /* prep the descriptor control value */
582 ctrl = rxbufsize;
583 if (rxout == (di->nrxd - 1))
584 ctrl |= CTRL_EOT;
585
586 /* init the rx descriptor */
587 W_SM(&di->rxd[rxout].ctrl, BUS_SWAP32(ctrl));
588 W_SM(&di->rxd[rxout].addr, BUS_SWAP32(pa + di->dataoffset));
589
590 rxout = NEXTRXD(rxout);
591 }
592
593 di->rxout = rxout;
594
595 /* update the chip lastdscr pointer */
596 W_REG(&di->regs->rcvptr, I2B(rxout));
597 }
598
599 void
600 dma_txreclaim(dma_info_t *di, bool forceall)
601 {
602 void *p;
603
604 DMA_TRACE(("%s: dma_txreclaim %s\n", di->name, forceall ? "all" : ""));
605
606 while ((p = dma_getnexttxp(di, forceall)))
607 PKTFREE(di->drv, p, TRUE);
608 }
609
610 /*
611 * Reclaim next completed txd (txds if using chained buffers) and
612 * return associated packet.
613 * If 'force' is true, reclaim txd(s) and return associated packet
614 * regardless of the value of the hardware "curr" pointer.
615 */
616 void*
617 dma_getnexttxp(dma_info_t *di, bool forceall)
618 {
619 uint start, end, i;
620 void *txp;
621
622 DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
623
624 txp = NULL;
625
626 start = di->txin;
627 if (forceall)
628 end = di->txout;
629 else
630 end = B2I(R_REG(&di->regs->xmtstatus) & XS_CD_MASK);
631
632 if ((start == 0) && (end > di->txout))
633 goto bogus;
634
635 for (i = start; i != end && !txp; i = NEXTTXD(i)) {
636 DMA_UNMAP(di->dev, (BUS_SWAP32(R_SM(&di->txd[i].addr)) - di->dataoffset),
637 (BUS_SWAP32(R_SM(&di->txd[i].ctrl)) & CTRL_BC_MASK), DMA_TX, di->txp[i]);
638 W_SM(&di->txd[i].addr, 0xdeadbeef);
639 txp = di->txp[i];
640 di->txp[i] = NULL;
641 }
642
643 di->txin = i;
644
645 /* tx flow control */
646 di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
647
648 return (txp);
649
650 bogus:
651 /*
652 DMA_ERROR(("dma_getnexttxp: bogus curr: start %d end %d txout %d force %d\n",
653 start, end, di->txout, forceall));
654 */
655 return (NULL);
656 }
657
658 /* like getnexttxp but no reclaim */
659 void*
660 dma_peeknexttxp(dma_info_t *di)
661 {
662 uint end, i;
663
664 end = B2I(R_REG(&di->regs->xmtstatus) & XS_CD_MASK);
665
666 for (i = di->txin; i != end; i = NEXTTXD(i))
667 if (di->txp[i])
668 return (di->txp[i]);
669
670 return (NULL);
671 }
672
673 void
674 dma_rxreclaim(dma_info_t *di)
675 {
676 void *p;
677
678 DMA_TRACE(("%s: dma_rxreclaim\n", di->name));
679
680 while ((p = dma_getnextrxp(di, TRUE)))
681 PKTFREE(di->drv, p, FALSE);
682 }
683
684 void *
685 dma_getnextrxp(dma_info_t *di, bool forceall)
686 {
687 uint i;
688 void *rxp;
689
690 /* if forcing, dma engine must be disabled */
691 ASSERT(!forceall || !dma_rxenabled(di));
692
693 i = di->rxin;
694
695 /* return if no packets posted */
696 if (i == di->rxout)
697 return (NULL);
698
699 /* ignore curr if forceall */
700 if (!forceall && (i == B2I(R_REG(&di->regs->rcvstatus) & RS_CD_MASK)))
701 return (NULL);
702
703 /* get the packet pointer that corresponds to the rx descriptor */
704 rxp = di->rxp[i];
705 ASSERT(rxp);
706 di->rxp[i] = NULL;
707
708 /* clear this packet from the descriptor ring */
709 DMA_UNMAP(di->dev, (BUS_SWAP32(R_SM(&di->rxd[i].addr)) - di->dataoffset),
710 di->rxbufsize, DMA_RX, rxp);
711 W_SM(&di->rxd[i].addr, 0xdeadbeef);
712
713 di->rxin = NEXTRXD(i);
714
715 return (rxp);
716 }
717
718 char*
719 dma_dumptx(dma_info_t *di, char *buf)
720 {
721 buf += sprintf(buf, "txd 0x%lx txdpa 0x%lx txp 0x%lx txin %d txout %d txavail %d\n",
722 (ulong)di->txd, di->txdpa, (ulong)di->txp, di->txin, di->txout, di->txavail);
723 buf += sprintf(buf, "xmtcontrol 0x%x xmtaddr 0x%x xmtptr 0x%x xmtstatus 0x%x\n",
724 R_REG(&di->regs->xmtcontrol),
725 R_REG(&di->regs->xmtaddr),
726 R_REG(&di->regs->xmtptr),
727 R_REG(&di->regs->xmtstatus));
728 return (buf);
729 }
730
731 char*
732 dma_dumprx(dma_info_t *di, char *buf)
733 {
734 buf += sprintf(buf, "rxd 0x%lx rxdpa 0x%lx rxp 0x%lx rxin %d rxout %d\n",
735 (ulong)di->rxd, di->rxdpa, (ulong)di->rxp, di->rxin, di->rxout);
736 buf += sprintf(buf, "rcvcontrol 0x%x rcvaddr 0x%x rcvptr 0x%x rcvstatus 0x%x\n",
737 R_REG(&di->regs->rcvcontrol),
738 R_REG(&di->regs->rcvaddr),
739 R_REG(&di->regs->rcvptr),
740 R_REG(&di->regs->rcvstatus));
741 return (buf);
742 }
743
744 char*
745 dma_dump(dma_info_t *di, char *buf)
746 {
747 buf = dma_dumptx(di, buf);
748 buf = dma_dumprx(di, buf);
749 return (buf);
750 }
751
752 uint
753 dma_getvar(dma_info_t *di, char *name)
754 {
755 if (!strcmp(name, "&txavail"))
756 return ((uint) &di->txavail);
757 else {
758 ASSERT(0);
759 }
760 return (0);
761 }
762
763 void
764 dma_txblock(dma_info_t *di)
765 {
766 di->txavail = 0;
767 }
768
769 void
770 dma_txunblock(dma_info_t *di)
771 {
772 di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
773 }
774
775 uint
776 dma_txactive(dma_info_t *di)
777 {
778 return (NTXDACTIVE(di->txin, di->txout));
779 }
780
781 /*
782 * Rotate all active tx dma ring entries "forward" by (ActiveDescriptor - txin).
783 */
784 void
785 dma_txrotate(di_t *di)
786 {
787 uint ad;
788 uint nactive;
789 uint rot;
790 uint old, new;
791 uint32 w;
792 uint first, last;
793
794 ASSERT(dma_txsuspended(di));
795
796 nactive = dma_txactive(di);
797 ad = B2I((R_REG(&di->regs->xmtstatus) & XS_AD_MASK) >> XS_AD_SHIFT);
798 rot = TXD(ad - di->txin);
799
800 ASSERT(rot < di->ntxd);
801
802 /* full-ring case is a lot harder - don't worry about this */
803 if (rot >= (di->ntxd - nactive)) {
804 DMA_ERROR(("%s: dma_txrotate: ring full - punt\n", di->name));
805 return;
806 }
807
808 first = di->txin;
809 last = PREVTXD(di->txout);
810
811 /* move entries starting at last and moving backwards to first */
812 for (old = last; old != PREVTXD(first); old = PREVTXD(old)) {
813 new = TXD(old + rot);
814
815 /*
816 * Move the tx dma descriptor.
817 * EOT is set only in the last entry in the ring.
818 */
819 w = R_SM(&di->txd[old].ctrl) & ~CTRL_EOT;
820 if (new == (di->ntxd - 1))
821 w |= CTRL_EOT;
822 W_SM(&di->txd[new].ctrl, w);
823 W_SM(&di->txd[new].addr, R_SM(&di->txd[old].addr));
824
825 /* zap the old tx dma descriptor address field */
826 W_SM(&di->txd[old].addr, 0xdeadbeef);
827
828 /* move the corresponding txp[] entry */
829 ASSERT(di->txp[new] == NULL);
830 di->txp[new] = di->txp[old];
831 di->txp[old] = NULL;
832 }
833
834 /* update txin and txout */
835 di->txin = ad;
836 di->txout = TXD(di->txout + rot);
837 di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
838
839 /* kick the chip */
840 W_REG(&di->regs->xmtptr, I2B(di->txout));
841 }
Personal OpenWRT clone
This page took 0.111551 seconds and 5 git commands to generate.