3 Broadcom BCM43xx wireless driver
5 DMA ringbuffer and descriptor allocation/management
7 Copyright (c) 2005 Michael Buesch <mbuesch@freenet.de>
9 Some code in this file is derived from the b44.c driver
10 Copyright (C) 2002 David S. Miller
11 Copyright (C) Pekka Pietikainen
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; see the file COPYING. If not, write to
25 the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
26 Boston, MA 02110-1301, USA.
31 #include "bcm43xx_dma.h"
32 #include "bcm43xx_main.h"
33 #include "bcm43xx_debugfs.h"
34 #include "bcm43xx_power.h"
35 #include "bcm43xx_xmit.h"
37 #include <linux/dma-mapping.h>
38 #include <linux/pci.h>
39 #include <linux/delay.h>
40 #include <linux/skbuff.h>
43 static inline int free_slots(struct bcm43xx_dmaring
*ring
)
45 return (ring
->nr_slots
- ring
->used_slots
);
48 static inline int next_slot(struct bcm43xx_dmaring
*ring
, int slot
)
50 assert(slot
>= -1 && slot
<= ring
->nr_slots
- 1);
51 if (slot
== ring
->nr_slots
- 1)
56 static inline int prev_slot(struct bcm43xx_dmaring
*ring
, int slot
)
58 assert(slot
>= 0 && slot
<= ring
->nr_slots
- 1);
60 return ring
->nr_slots
- 1;
64 /* Request a slot for usage. */
66 int request_slot(struct bcm43xx_dmaring
*ring
)
71 assert(!ring
->suspended
);
72 assert(free_slots(ring
) != 0);
74 slot
= next_slot(ring
, ring
->current_slot
);
75 ring
->current_slot
= slot
;
78 /* Check the number of available slots and suspend TX,
79 * if we are running low on free slots.
81 if (unlikely(free_slots(ring
) < ring
->suspend_mark
)) {
82 netif_stop_queue(ring
->bcm
->net_dev
);
85 #ifdef CONFIG_BCM43XX_DEBUG
86 if (ring
->used_slots
> ring
->max_used_slots
)
87 ring
->max_used_slots
= ring
->used_slots
;
88 #endif /* CONFIG_BCM43XX_DEBUG*/
93 /* Return a slot to the free slots. */
95 void return_slot(struct bcm43xx_dmaring
*ring
, int slot
)
101 /* Check if TX is suspended and check if we have
102 * enough free slots to resume it again.
104 if (unlikely(ring
->suspended
)) {
105 if (free_slots(ring
) >= ring
->resume_mark
) {
107 netif_wake_queue(ring
->bcm
->net_dev
);
113 dma_addr_t
map_descbuffer(struct bcm43xx_dmaring
*ring
,
121 dmaaddr
= dma_map_single(&ring
->bcm
->pci_dev
->dev
,
125 dmaaddr
= dma_map_single(&ring
->bcm
->pci_dev
->dev
,
134 void unmap_descbuffer(struct bcm43xx_dmaring
*ring
,
140 dma_unmap_single(&ring
->bcm
->pci_dev
->dev
,
144 dma_unmap_single(&ring
->bcm
->pci_dev
->dev
,
151 void sync_descbuffer_for_cpu(struct bcm43xx_dmaring
*ring
,
157 dma_sync_single_for_cpu(&ring
->bcm
->pci_dev
->dev
,
158 addr
, len
, DMA_FROM_DEVICE
);
162 void sync_descbuffer_for_device(struct bcm43xx_dmaring
*ring
,
168 dma_sync_single_for_device(&ring
->bcm
->pci_dev
->dev
,
169 addr
, len
, DMA_FROM_DEVICE
);
172 /* Unmap and free a descriptor buffer. */
174 void free_descriptor_buffer(struct bcm43xx_dmaring
*ring
,
175 struct bcm43xx_dmadesc
*desc
,
176 struct bcm43xx_dmadesc_meta
*meta
,
181 dev_kfree_skb_irq(meta
->skb
);
183 dev_kfree_skb(meta
->skb
);
187 static int alloc_ringmemory(struct bcm43xx_dmaring
*ring
)
189 struct device
*dev
= &(ring
->bcm
->pci_dev
->dev
);
191 ring
->vbase
= dma_alloc_coherent(dev
, BCM43xx_DMA_RINGMEMSIZE
,
192 &(ring
->dmabase
), GFP_KERNEL
);
194 printk(KERN_ERR PFX
"DMA ringmemory allocation failed\n");
197 if (ring
->dmabase
+ BCM43xx_DMA_RINGMEMSIZE
> BCM43xx_DMA_BUSADDRMAX
) {
198 printk(KERN_ERR PFX
">>>FATAL ERROR<<< DMA RINGMEMORY >1G "
199 "(0x%08x, len: %lu)\n",
200 ring
->dmabase
, BCM43xx_DMA_RINGMEMSIZE
);
201 dma_free_coherent(dev
, BCM43xx_DMA_RINGMEMSIZE
,
202 ring
->vbase
, ring
->dmabase
);
205 assert(!(ring
->dmabase
& 0x000003FF));
206 memset(ring
->vbase
, 0, BCM43xx_DMA_RINGMEMSIZE
);
211 static void free_ringmemory(struct bcm43xx_dmaring
*ring
)
213 struct device
*dev
= &(ring
->bcm
->pci_dev
->dev
);
215 dma_free_coherent(dev
, BCM43xx_DMA_RINGMEMSIZE
,
216 ring
->vbase
, ring
->dmabase
);
219 /* Reset the RX DMA channel */
220 int bcm43xx_dmacontroller_rx_reset(struct bcm43xx_private
*bcm
,
227 mmio_base
+ BCM43xx_DMA_RX_CONTROL
,
229 for (i
= 0; i
< 1000; i
++) {
230 value
= bcm43xx_read32(bcm
,
231 mmio_base
+ BCM43xx_DMA_RX_STATUS
);
232 value
&= BCM43xx_DMA_RXSTAT_STAT_MASK
;
233 if (value
== BCM43xx_DMA_RXSTAT_STAT_DISABLED
) {
240 printk(KERN_ERR PFX
"Error: Wait on DMA RX status timed out.\n");
247 /* Reset the RX DMA channel */
248 int bcm43xx_dmacontroller_tx_reset(struct bcm43xx_private
*bcm
,
254 for (i
= 0; i
< 1000; i
++) {
255 value
= bcm43xx_read32(bcm
,
256 mmio_base
+ BCM43xx_DMA_TX_STATUS
);
257 value
&= BCM43xx_DMA_TXSTAT_STAT_MASK
;
258 if (value
== BCM43xx_DMA_TXSTAT_STAT_DISABLED
||
259 value
== BCM43xx_DMA_TXSTAT_STAT_IDLEWAIT
||
260 value
== BCM43xx_DMA_TXSTAT_STAT_STOPPED
)
265 mmio_base
+ BCM43xx_DMA_TX_CONTROL
,
267 for (i
= 0; i
< 1000; i
++) {
268 value
= bcm43xx_read32(bcm
,
269 mmio_base
+ BCM43xx_DMA_TX_STATUS
);
270 value
&= BCM43xx_DMA_TXSTAT_STAT_MASK
;
271 if (value
== BCM43xx_DMA_TXSTAT_STAT_DISABLED
) {
278 printk(KERN_ERR PFX
"Error: Wait on DMA TX status timed out.\n");
281 /* ensure the reset is completed. */
287 static int setup_rx_descbuffer(struct bcm43xx_dmaring
*ring
,
288 struct bcm43xx_dmadesc
*desc
,
289 struct bcm43xx_dmadesc_meta
*meta
,
292 struct bcm43xx_rxhdr
*rxhdr
;
296 const int slot
= (int)(desc
- ring
->vbase
);
299 assert(slot
>= 0 && slot
< ring
->nr_slots
);
302 skb
= __dev_alloc_skb(ring
->rx_buffersize
, gfp_flags
);
305 dmaaddr
= map_descbuffer(ring
, skb
->data
, ring
->rx_buffersize
, 0);
306 if (unlikely(dmaaddr
+ ring
->rx_buffersize
> BCM43xx_DMA_BUSADDRMAX
)) {
307 unmap_descbuffer(ring
, dmaaddr
, ring
->rx_buffersize
, 0);
308 dev_kfree_skb_any(skb
);
309 printk(KERN_ERR PFX
">>>FATAL ERROR<<< DMA RX SKB >1G "
310 "(0x%08x, len: %u)\n",
311 dmaaddr
, ring
->rx_buffersize
);
315 meta
->dmaaddr
= dmaaddr
;
316 skb
->dev
= ring
->bcm
->net_dev
;
317 desc_addr
= (u32
)(dmaaddr
+ ring
->memoffset
);
318 desc_ctl
= (BCM43xx_DMADTOR_BYTECNT_MASK
&
319 (u32
)(ring
->rx_buffersize
- ring
->frameoffset
));
320 if (slot
== ring
->nr_slots
- 1)
321 desc_ctl
|= BCM43xx_DMADTOR_DTABLEEND
;
322 set_desc_addr(desc
, desc_addr
);
323 set_desc_ctl(desc
, desc_ctl
);
325 rxhdr
= (struct bcm43xx_rxhdr
*)(skb
->data
);
326 rxhdr
->frame_length
= 0;
332 /* Allocate the initial descbuffers.
333 * This is used for an RX ring only.
335 static int alloc_initial_descbuffers(struct bcm43xx_dmaring
*ring
)
337 int i
, err
= -ENOMEM
;
338 struct bcm43xx_dmadesc
*desc
;
339 struct bcm43xx_dmadesc_meta
*meta
;
341 for (i
= 0; i
< ring
->nr_slots
; i
++) {
342 desc
= ring
->vbase
+ i
;
343 meta
= ring
->meta
+ i
;
345 err
= setup_rx_descbuffer(ring
, desc
, meta
, GFP_KERNEL
);
349 ring
->used_slots
= ring
->nr_slots
;
355 for (i
--; i
>= 0; i
--) {
356 desc
= ring
->vbase
+ i
;
357 meta
= ring
->meta
+ i
;
359 unmap_descbuffer(ring
, meta
->dmaaddr
, ring
->rx_buffersize
, 0);
360 dev_kfree_skb(meta
->skb
);
365 /* Do initial setup of the DMA controller.
366 * Reset the controller, write the ring busaddress
367 * and switch the "enable" bit on.
369 static int dmacontroller_setup(struct bcm43xx_dmaring
*ring
)
375 /* Set Transmit Control register to "transmit enable" */
376 bcm43xx_dma_write(ring
, BCM43xx_DMA_TX_CONTROL
,
377 BCM43xx_DMA_TXCTRL_ENABLE
);
378 /* Set Transmit Descriptor ring address. */
379 bcm43xx_dma_write(ring
, BCM43xx_DMA_TX_DESC_RING
,
380 ring
->dmabase
+ ring
->memoffset
);
382 err
= alloc_initial_descbuffers(ring
);
385 /* Set Receive Control "receive enable" and frame offset */
386 value
= (ring
->frameoffset
<< BCM43xx_DMA_RXCTRL_FRAMEOFF_SHIFT
);
387 value
|= BCM43xx_DMA_RXCTRL_ENABLE
;
388 bcm43xx_dma_write(ring
, BCM43xx_DMA_RX_CONTROL
, value
);
389 /* Set Receive Descriptor ring address. */
390 bcm43xx_dma_write(ring
, BCM43xx_DMA_RX_DESC_RING
,
391 ring
->dmabase
+ ring
->memoffset
);
392 /* Init the descriptor pointer. */
393 bcm43xx_dma_write(ring
, BCM43xx_DMA_RX_DESC_INDEX
, 200);
400 /* Shutdown the DMA controller. */
401 static void dmacontroller_cleanup(struct bcm43xx_dmaring
*ring
)
404 bcm43xx_dmacontroller_tx_reset(ring
->bcm
, ring
->mmio_base
);
405 /* Zero out Transmit Descriptor ring address. */
406 bcm43xx_dma_write(ring
, BCM43xx_DMA_TX_DESC_RING
, 0);
408 bcm43xx_dmacontroller_rx_reset(ring
->bcm
, ring
->mmio_base
);
409 /* Zero out Receive Descriptor ring address. */
410 bcm43xx_dma_write(ring
, BCM43xx_DMA_RX_DESC_RING
, 0);
414 static void free_all_descbuffers(struct bcm43xx_dmaring
*ring
)
416 struct bcm43xx_dmadesc
*desc
;
417 struct bcm43xx_dmadesc_meta
*meta
;
420 if (!ring
->used_slots
)
422 for (i
= 0; i
< ring
->nr_slots
; i
++) {
423 desc
= ring
->vbase
+ i
;
424 meta
= ring
->meta
+ i
;
431 unmap_descbuffer(ring
, meta
->dmaaddr
,
434 unmap_descbuffer(ring
, meta
->dmaaddr
,
435 ring
->rx_buffersize
, 0);
437 free_descriptor_buffer(ring
, desc
, meta
, 0);
441 /* Main initialization function. */
443 struct bcm43xx_dmaring
* bcm43xx_setup_dmaring(struct bcm43xx_private
*bcm
,
444 u16 dma_controller_base
,
445 int nr_descriptor_slots
,
448 struct bcm43xx_dmaring
*ring
;
451 ring
= kzalloc(sizeof(*ring
), GFP_KERNEL
);
455 ring
->meta
= kzalloc(sizeof(*ring
->meta
) * nr_descriptor_slots
,
460 ring
->memoffset
= BCM43xx_DMA_DMABUSADDROFFSET
;
461 #ifdef CONFIG_BCM947XX
462 if (bcm
->pci_dev
->bus
->number
== 0)
467 ring
->nr_slots
= nr_descriptor_slots
;
468 ring
->suspend_mark
= ring
->nr_slots
* BCM43xx_TXSUSPEND_PERCENT
/ 100;
469 ring
->resume_mark
= ring
->nr_slots
* BCM43xx_TXRESUME_PERCENT
/ 100;
470 assert(ring
->suspend_mark
< ring
->resume_mark
);
471 ring
->mmio_base
= dma_controller_base
;
474 ring
->current_slot
= -1;
476 switch (dma_controller_base
) {
477 case BCM43xx_MMIO_DMA1_BASE
:
478 ring
->rx_buffersize
= BCM43xx_DMA1_RXBUFFERSIZE
;
479 ring
->frameoffset
= BCM43xx_DMA1_RX_FRAMEOFFSET
;
481 case BCM43xx_MMIO_DMA4_BASE
:
482 ring
->rx_buffersize
= BCM43xx_DMA4_RXBUFFERSIZE
;
483 ring
->frameoffset
= BCM43xx_DMA4_RX_FRAMEOFFSET
;
490 err
= alloc_ringmemory(ring
);
493 err
= dmacontroller_setup(ring
);
495 goto err_free_ringmemory
;
501 free_ringmemory(ring
);
510 /* Main cleanup function. */
511 static void bcm43xx_destroy_dmaring(struct bcm43xx_dmaring
*ring
)
516 dprintk(KERN_INFO PFX
"DMA 0x%04x (%s) max used slots: %d/%d\n",
518 (ring
->tx
) ? "TX" : "RX",
519 ring
->max_used_slots
, ring
->nr_slots
);
520 /* Device IRQs are disabled prior entering this function,
521 * so no need to take care of concurrency with rx handler stuff.
523 dmacontroller_cleanup(ring
);
524 free_all_descbuffers(ring
);
525 free_ringmemory(ring
);
531 void bcm43xx_dma_free(struct bcm43xx_private
*bcm
)
533 struct bcm43xx_dma
*dma
;
535 if (bcm43xx_using_pio(bcm
))
537 dma
= bcm43xx_current_dma(bcm
);
539 bcm43xx_destroy_dmaring(dma
->rx_ring1
);
540 dma
->rx_ring1
= NULL
;
541 bcm43xx_destroy_dmaring(dma
->rx_ring0
);
542 dma
->rx_ring0
= NULL
;
543 bcm43xx_destroy_dmaring(dma
->tx_ring3
);
544 dma
->tx_ring3
= NULL
;
545 bcm43xx_destroy_dmaring(dma
->tx_ring2
);
546 dma
->tx_ring2
= NULL
;
547 bcm43xx_destroy_dmaring(dma
->tx_ring1
);
548 dma
->tx_ring1
= NULL
;
549 bcm43xx_destroy_dmaring(dma
->tx_ring0
);
550 dma
->tx_ring0
= NULL
;
553 int bcm43xx_dma_init(struct bcm43xx_private
*bcm
)
555 struct bcm43xx_dma
*dma
= bcm43xx_current_dma(bcm
);
556 struct bcm43xx_dmaring
*ring
;
559 /* setup TX DMA channels. */
560 ring
= bcm43xx_setup_dmaring(bcm
, BCM43xx_MMIO_DMA1_BASE
,
561 BCM43xx_TXRING_SLOTS
, 1);
564 dma
->tx_ring0
= ring
;
566 ring
= bcm43xx_setup_dmaring(bcm
, BCM43xx_MMIO_DMA2_BASE
,
567 BCM43xx_TXRING_SLOTS
, 1);
569 goto err_destroy_tx0
;
570 dma
->tx_ring1
= ring
;
572 ring
= bcm43xx_setup_dmaring(bcm
, BCM43xx_MMIO_DMA3_BASE
,
573 BCM43xx_TXRING_SLOTS
, 1);
575 goto err_destroy_tx1
;
576 dma
->tx_ring2
= ring
;
578 ring
= bcm43xx_setup_dmaring(bcm
, BCM43xx_MMIO_DMA4_BASE
,
579 BCM43xx_TXRING_SLOTS
, 1);
581 goto err_destroy_tx2
;
582 dma
->tx_ring3
= ring
;
584 /* setup RX DMA channels. */
585 ring
= bcm43xx_setup_dmaring(bcm
, BCM43xx_MMIO_DMA1_BASE
,
586 BCM43xx_RXRING_SLOTS
, 0);
588 goto err_destroy_tx3
;
589 dma
->rx_ring0
= ring
;
591 if (bcm
->current_core
->rev
< 5) {
592 ring
= bcm43xx_setup_dmaring(bcm
, BCM43xx_MMIO_DMA4_BASE
,
593 BCM43xx_RXRING_SLOTS
, 0);
595 goto err_destroy_rx0
;
596 dma
->rx_ring1
= ring
;
599 dprintk(KERN_INFO PFX
"DMA initialized\n");
605 bcm43xx_destroy_dmaring(dma
->rx_ring0
);
606 dma
->rx_ring0
= NULL
;
608 bcm43xx_destroy_dmaring(dma
->tx_ring3
);
609 dma
->tx_ring3
= NULL
;
611 bcm43xx_destroy_dmaring(dma
->tx_ring2
);
612 dma
->tx_ring2
= NULL
;
614 bcm43xx_destroy_dmaring(dma
->tx_ring1
);
615 dma
->tx_ring1
= NULL
;
617 bcm43xx_destroy_dmaring(dma
->tx_ring0
);
618 dma
->tx_ring0
= NULL
;
622 /* Generate a cookie for the TX header. */
623 static u16
generate_cookie(struct bcm43xx_dmaring
*ring
,
628 /* Use the upper 4 bits of the cookie as
629 * DMA controller ID and store the slot number
630 * in the lower 12 bits
632 switch (ring
->mmio_base
) {
635 case BCM43xx_MMIO_DMA1_BASE
:
637 case BCM43xx_MMIO_DMA2_BASE
:
640 case BCM43xx_MMIO_DMA3_BASE
:
643 case BCM43xx_MMIO_DMA4_BASE
:
647 assert(((u16
)slot
& 0xF000) == 0x0000);
653 /* Inspect a cookie and find out to which controller/slot it belongs. */
655 struct bcm43xx_dmaring
* parse_cookie(struct bcm43xx_private
*bcm
,
656 u16 cookie
, int *slot
)
658 struct bcm43xx_dma
*dma
= bcm43xx_current_dma(bcm
);
659 struct bcm43xx_dmaring
*ring
= NULL
;
661 switch (cookie
& 0xF000) {
663 ring
= dma
->tx_ring0
;
666 ring
= dma
->tx_ring1
;
669 ring
= dma
->tx_ring2
;
672 ring
= dma
->tx_ring3
;
677 *slot
= (cookie
& 0x0FFF);
678 assert(*slot
>= 0 && *slot
< ring
->nr_slots
);
683 static void dmacontroller_poke_tx(struct bcm43xx_dmaring
*ring
,
686 /* Everything is ready to start. Buffers are DMA mapped and
687 * associated with slots.
688 * "slot" is the last slot of the new frame we want to transmit.
689 * Close your seat belts now, please.
692 slot
= next_slot(ring
, slot
);
693 bcm43xx_dma_write(ring
, BCM43xx_DMA_TX_DESC_INDEX
,
694 (u32
)(slot
* sizeof(struct bcm43xx_dmadesc
)));
697 static int dma_tx_fragment(struct bcm43xx_dmaring
*ring
,
702 struct bcm43xx_dmadesc
*desc
;
703 struct bcm43xx_dmadesc_meta
*meta
;
707 assert(skb_shinfo(skb
)->nr_frags
== 0);
709 slot
= request_slot(ring
);
710 desc
= ring
->vbase
+ slot
;
711 meta
= ring
->meta
+ slot
;
713 /* Add a device specific TX header. */
714 assert(skb_headroom(skb
) >= sizeof(struct bcm43xx_txhdr
));
715 /* Reserve enough headroom for the device tx header. */
716 __skb_push(skb
, sizeof(struct bcm43xx_txhdr
));
717 /* Now calculate and add the tx header.
718 * The tx header includes the PLCP header.
720 bcm43xx_generate_txhdr(ring
->bcm
,
721 (struct bcm43xx_txhdr
*)skb
->data
,
722 skb
->data
+ sizeof(struct bcm43xx_txhdr
),
723 skb
->len
- sizeof(struct bcm43xx_txhdr
),
725 generate_cookie(ring
, slot
));
728 meta
->dmaaddr
= map_descbuffer(ring
, skb
->data
, skb
->len
, 1);
729 if (unlikely(meta
->dmaaddr
+ skb
->len
> BCM43xx_DMA_BUSADDRMAX
)) {
730 return_slot(ring
, slot
);
731 printk(KERN_ERR PFX
">>>FATAL ERROR<<< DMA TX SKB >1G "
732 "(0x%08x, len: %u)\n",
733 meta
->dmaaddr
, skb
->len
);
737 desc_addr
= (u32
)(meta
->dmaaddr
+ ring
->memoffset
);
738 desc_ctl
= BCM43xx_DMADTOR_FRAMESTART
| BCM43xx_DMADTOR_FRAMEEND
;
739 desc_ctl
|= BCM43xx_DMADTOR_COMPIRQ
;
740 desc_ctl
|= (BCM43xx_DMADTOR_BYTECNT_MASK
&
741 (u32
)(meta
->skb
->len
- ring
->frameoffset
));
742 if (slot
== ring
->nr_slots
- 1)
743 desc_ctl
|= BCM43xx_DMADTOR_DTABLEEND
;
745 set_desc_ctl(desc
, desc_ctl
);
746 set_desc_addr(desc
, desc_addr
);
747 /* Now transfer the whole frame. */
748 dmacontroller_poke_tx(ring
, slot
);
753 int bcm43xx_dma_tx(struct bcm43xx_private
*bcm
,
754 struct ieee80211_txb
*txb
)
756 /* We just received a packet from the kernel network subsystem.
757 * Add headers and DMA map the memory. Poke
758 * the device to send the stuff.
759 * Note that this is called from atomic context.
761 struct bcm43xx_dmaring
*ring
= bcm43xx_current_dma(bcm
)->tx_ring1
;
766 if (unlikely(free_slots(ring
) < txb
->nr_frags
)) {
767 /* The queue should be stopped,
768 * if we are low on free slots.
769 * If this ever triggers, we have to lower the suspend_mark.
771 dprintkl(KERN_ERR PFX
"Out of DMA descriptor slots!\n");
775 for (i
= 0; i
< txb
->nr_frags
; i
++) {
776 skb
= txb
->fragments
[i
];
777 /* Take skb from ieee80211_txb_free */
778 txb
->fragments
[i
] = NULL
;
779 dma_tx_fragment(ring
, skb
, i
);
780 //TODO: handle failure of dma_tx_fragment
782 ieee80211_txb_free(txb
);
787 void bcm43xx_dma_handle_xmitstatus(struct bcm43xx_private
*bcm
,
788 struct bcm43xx_xmitstatus
*status
)
790 struct bcm43xx_dmaring
*ring
;
791 struct bcm43xx_dmadesc
*desc
;
792 struct bcm43xx_dmadesc_meta
*meta
;
793 int is_last_fragment
;
796 ring
= parse_cookie(bcm
, status
->cookie
, &slot
);
799 assert(get_desc_ctl(ring
->vbase
+ slot
) & BCM43xx_DMADTOR_FRAMESTART
);
801 assert(slot
>= 0 && slot
< ring
->nr_slots
);
802 desc
= ring
->vbase
+ slot
;
803 meta
= ring
->meta
+ slot
;
805 is_last_fragment
= !!(get_desc_ctl(desc
) & BCM43xx_DMADTOR_FRAMEEND
);
806 unmap_descbuffer(ring
, meta
->dmaaddr
, meta
->skb
->len
, 1);
807 free_descriptor_buffer(ring
, desc
, meta
, 1);
808 /* Everything belonging to the slot is unmapped
809 * and freed, so we can return it.
811 return_slot(ring
, slot
);
813 if (is_last_fragment
)
815 slot
= next_slot(ring
, slot
);
817 bcm
->stats
.last_tx
= jiffies
;
820 static void dma_rx(struct bcm43xx_dmaring
*ring
,
823 struct bcm43xx_dmadesc
*desc
;
824 struct bcm43xx_dmadesc_meta
*meta
;
825 struct bcm43xx_rxhdr
*rxhdr
;
831 desc
= ring
->vbase
+ *slot
;
832 meta
= ring
->meta
+ *slot
;
834 sync_descbuffer_for_cpu(ring
, meta
->dmaaddr
, ring
->rx_buffersize
);
837 if (ring
->mmio_base
== BCM43xx_MMIO_DMA4_BASE
) {
838 /* We received an xmit status. */
839 struct bcm43xx_hwxmitstatus
*hw
= (struct bcm43xx_hwxmitstatus
*)skb
->data
;
840 struct bcm43xx_xmitstatus stat
;
842 stat
.cookie
= le16_to_cpu(hw
->cookie
);
843 stat
.flags
= hw
->flags
;
844 stat
.cnt1
= hw
->cnt1
;
845 stat
.cnt2
= hw
->cnt2
;
846 stat
.seq
= le16_to_cpu(hw
->seq
);
847 stat
.unknown
= le16_to_cpu(hw
->unknown
);
849 bcm43xx_debugfs_log_txstat(ring
->bcm
, &stat
);
850 bcm43xx_dma_handle_xmitstatus(ring
->bcm
, &stat
);
851 /* recycle the descriptor buffer. */
852 sync_descbuffer_for_device(ring
, meta
->dmaaddr
, ring
->rx_buffersize
);
856 rxhdr
= (struct bcm43xx_rxhdr
*)skb
->data
;
857 len
= le16_to_cpu(rxhdr
->frame_length
);
864 len
= le16_to_cpu(rxhdr
->frame_length
);
865 } while (len
== 0 && i
++ < 5);
866 if (unlikely(len
== 0)) {
867 /* recycle the descriptor buffer. */
868 sync_descbuffer_for_device(ring
, meta
->dmaaddr
,
869 ring
->rx_buffersize
);
873 if (unlikely(len
> ring
->rx_buffersize
)) {
874 /* The data did not fit into one descriptor buffer
875 * and is split over multiple buffers.
876 * This should never happen, as we try to allocate buffers
877 * big enough. So simply ignore this packet.
883 desc
= ring
->vbase
+ *slot
;
884 meta
= ring
->meta
+ *slot
;
885 /* recycle the descriptor buffer. */
886 sync_descbuffer_for_device(ring
, meta
->dmaaddr
,
887 ring
->rx_buffersize
);
888 *slot
= next_slot(ring
, *slot
);
890 tmp
-= ring
->rx_buffersize
;
894 printkl(KERN_ERR PFX
"DMA RX buffer too small "
895 "(len: %u, buffer: %u, nr-dropped: %d)\n",
896 len
, ring
->rx_buffersize
, cnt
);
899 len
-= IEEE80211_FCS_LEN
;
901 dmaaddr
= meta
->dmaaddr
;
902 err
= setup_rx_descbuffer(ring
, desc
, meta
, GFP_ATOMIC
);
904 dprintkl(KERN_ERR PFX
"DMA RX: setup_rx_descbuffer() failed\n");
905 sync_descbuffer_for_device(ring
, dmaaddr
,
906 ring
->rx_buffersize
);
910 unmap_descbuffer(ring
, dmaaddr
, ring
->rx_buffersize
, 0);
911 skb_put(skb
, len
+ ring
->frameoffset
);
912 skb_pull(skb
, ring
->frameoffset
);
914 err
= bcm43xx_rx(ring
->bcm
, skb
, rxhdr
);
916 dev_kfree_skb_irq(skb
);
924 void bcm43xx_dma_rx(struct bcm43xx_dmaring
*ring
)
928 int slot
, current_slot
;
929 #ifdef CONFIG_BCM43XX_DEBUG
934 status
= bcm43xx_dma_read(ring
, BCM43xx_DMA_RX_STATUS
);
935 descptr
= (status
& BCM43xx_DMA_RXSTAT_DPTR_MASK
);
936 current_slot
= descptr
/ sizeof(struct bcm43xx_dmadesc
);
937 assert(current_slot
>= 0 && current_slot
< ring
->nr_slots
);
939 slot
= ring
->current_slot
;
940 for ( ; slot
!= current_slot
; slot
= next_slot(ring
, slot
)) {
942 #ifdef CONFIG_BCM43XX_DEBUG
943 if (++used_slots
> ring
->max_used_slots
)
944 ring
->max_used_slots
= used_slots
;
947 bcm43xx_dma_write(ring
, BCM43xx_DMA_RX_DESC_INDEX
,
948 (u32
)(slot
* sizeof(struct bcm43xx_dmadesc
)));
949 ring
->current_slot
= slot
;
952 void bcm43xx_dma_tx_suspend(struct bcm43xx_dmaring
*ring
)
955 bcm43xx_power_saving_ctl_bits(ring
->bcm
, -1, 1);
956 bcm43xx_dma_write(ring
, BCM43xx_DMA_TX_CONTROL
,
957 bcm43xx_dma_read(ring
, BCM43xx_DMA_TX_CONTROL
)
958 | BCM43xx_DMA_TXCTRL_SUSPEND
);
961 void bcm43xx_dma_tx_resume(struct bcm43xx_dmaring
*ring
)
964 bcm43xx_dma_write(ring
, BCM43xx_DMA_TX_CONTROL
,
965 bcm43xx_dma_read(ring
, BCM43xx_DMA_TX_CONTROL
)
966 & ~BCM43xx_DMA_TXCTRL_SUSPEND
);
967 bcm43xx_power_saving_ctl_bits(ring
->bcm
, -1, -1);