1 /* Copyright (c) 2014 Broadcom Corporation
3 * Permission to use, copy, modify, and/or distribute this software for any
4 * purpose with or without fee is hereby granted, provided that the above
5 * copyright notice and this permission notice appear in all copies.
7 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
10 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
12 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
13 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 /*******************************************************************************
17 * Communicates with the dongle by using dcmd codes.
18 * For certain dcmd codes, the dongle interprets string data from the host.
19 ******************************************************************************/
21 #include <linux/types.h>
22 #include <linux/netdevice.h>
24 #include <brcmu_utils.h>
25 #include <brcmu_wifi.h>
31 #include "commonring.h"
34 #include "tracepoint.h"
37 #define MSGBUF_IOCTL_RESP_TIMEOUT 2000
39 #define MSGBUF_TYPE_GEN_STATUS 0x1
40 #define MSGBUF_TYPE_RING_STATUS 0x2
41 #define MSGBUF_TYPE_FLOW_RING_CREATE 0x3
42 #define MSGBUF_TYPE_FLOW_RING_CREATE_CMPLT 0x4
43 #define MSGBUF_TYPE_FLOW_RING_DELETE 0x5
44 #define MSGBUF_TYPE_FLOW_RING_DELETE_CMPLT 0x6
45 #define MSGBUF_TYPE_FLOW_RING_FLUSH 0x7
46 #define MSGBUF_TYPE_FLOW_RING_FLUSH_CMPLT 0x8
47 #define MSGBUF_TYPE_IOCTLPTR_REQ 0x9
48 #define MSGBUF_TYPE_IOCTLPTR_REQ_ACK 0xA
49 #define MSGBUF_TYPE_IOCTLRESP_BUF_POST 0xB
50 #define MSGBUF_TYPE_IOCTL_CMPLT 0xC
51 #define MSGBUF_TYPE_EVENT_BUF_POST 0xD
52 #define MSGBUF_TYPE_WL_EVENT 0xE
53 #define MSGBUF_TYPE_TX_POST 0xF
54 #define MSGBUF_TYPE_TX_STATUS 0x10
55 #define MSGBUF_TYPE_RXBUF_POST 0x11
56 #define MSGBUF_TYPE_RX_CMPLT 0x12
57 #define MSGBUF_TYPE_LPBK_DMAXFER 0x13
58 #define MSGBUF_TYPE_LPBK_DMAXFER_CMPLT 0x14
60 #define NR_TX_PKTIDS 2048
61 #define NR_RX_PKTIDS 1024
63 #define BRCMF_IOCTL_REQ_PKTID 0xFFFE
65 #define BRCMF_MSGBUF_MAX_PKT_SIZE 2048
66 #define BRCMF_MSGBUF_RXBUFPOST_THRESHOLD 32
67 #define BRCMF_MSGBUF_MAX_IOCTLRESPBUF_POST 8
68 #define BRCMF_MSGBUF_MAX_EVENTBUF_POST 8
70 #define BRCMF_MSGBUF_PKT_FLAGS_FRAME_802_3 0x01
71 #define BRCMF_MSGBUF_PKT_FLAGS_PRIO_SHIFT 5
73 #define BRCMF_MSGBUF_TX_FLUSH_CNT1 32
74 #define BRCMF_MSGBUF_TX_FLUSH_CNT2 96
76 #define BRCMF_MSGBUF_DELAY_TXWORKER_THRS 96
77 #define BRCMF_MSGBUF_TRICKLE_TXWORKER_THRS 32
78 #define BRCMF_MSGBUF_UPDATE_RX_PTR_THRS 48
81 struct msgbuf_common_hdr
{
89 struct msgbuf_buf_addr
{
94 struct msgbuf_ioctl_req_hdr
{
95 struct msgbuf_common_hdr msg
;
99 __le16 output_buf_len
;
101 struct msgbuf_buf_addr req_buf_addr
;
105 struct msgbuf_tx_msghdr
{
106 struct msgbuf_common_hdr msg
;
110 struct msgbuf_buf_addr metadata_buf_addr
;
111 struct msgbuf_buf_addr data_buf_addr
;
112 __le16 metadata_buf_len
;
117 struct msgbuf_rx_bufpost
{
118 struct msgbuf_common_hdr msg
;
119 __le16 metadata_buf_len
;
122 struct msgbuf_buf_addr metadata_buf_addr
;
123 struct msgbuf_buf_addr data_buf_addr
;
126 struct msgbuf_rx_ioctl_resp_or_event
{
127 struct msgbuf_common_hdr msg
;
130 struct msgbuf_buf_addr host_buf_addr
;
134 struct msgbuf_completion_hdr
{
139 struct msgbuf_rx_event
{
140 struct msgbuf_common_hdr msg
;
141 struct msgbuf_completion_hdr compl_hdr
;
142 __le16 event_data_len
;
147 struct msgbuf_ioctl_resp_hdr
{
148 struct msgbuf_common_hdr msg
;
149 struct msgbuf_completion_hdr compl_hdr
;
156 struct msgbuf_tx_status
{
157 struct msgbuf_common_hdr msg
;
158 struct msgbuf_completion_hdr compl_hdr
;
163 struct msgbuf_rx_complete
{
164 struct msgbuf_common_hdr msg
;
165 struct msgbuf_completion_hdr compl_hdr
;
175 struct msgbuf_tx_flowring_create_req
{
176 struct msgbuf_common_hdr msg
;
187 struct msgbuf_buf_addr flow_ring_addr
;
190 struct msgbuf_tx_flowring_delete_req
{
191 struct msgbuf_common_hdr msg
;
197 struct msgbuf_flowring_create_resp
{
198 struct msgbuf_common_hdr msg
;
199 struct msgbuf_completion_hdr compl_hdr
;
203 struct msgbuf_flowring_delete_resp
{
204 struct msgbuf_common_hdr msg
;
205 struct msgbuf_completion_hdr compl_hdr
;
209 struct msgbuf_flowring_flush_resp
{
210 struct msgbuf_common_hdr msg
;
211 struct msgbuf_completion_hdr compl_hdr
;
215 struct brcmf_msgbuf_work_item
{
216 struct list_head queue
;
223 struct brcmf_msgbuf
{
224 struct brcmf_pub
*drvr
;
226 struct brcmf_commonring
**commonrings
;
227 struct brcmf_commonring
**flowrings
;
228 dma_addr_t
*flowring_dma_handle
;
233 u16 rx_metadata_offset
;
236 u32 max_ioctlrespbuf
;
237 u32 cur_ioctlrespbuf
;
242 dma_addr_t ioctbuf_handle
;
245 int ioctl_resp_status
;
246 u32 ioctl_resp_ret_len
;
247 u32 ioctl_resp_pktid
;
252 wait_queue_head_t ioctl_resp_wait
;
255 struct brcmf_msgbuf_pktids
*tx_pktids
;
256 struct brcmf_msgbuf_pktids
*rx_pktids
;
257 struct brcmf_flowring
*flow
;
259 struct workqueue_struct
*txflow_wq
;
260 struct work_struct txflow_work
;
261 unsigned long *flow_map
;
262 unsigned long *txstatus_done_map
;
264 struct work_struct flowring_work
;
265 spinlock_t flowring_work_lock
;
266 struct list_head work_queue
;
269 struct brcmf_msgbuf_pktid
{
276 struct brcmf_msgbuf_pktids
{
278 u32 last_allocated_idx
;
279 enum dma_data_direction direction
;
280 struct brcmf_msgbuf_pktid
*array
;
283 static void brcmf_msgbuf_rxbuf_ioctlresp_post(struct brcmf_msgbuf
*msgbuf
);
286 static struct brcmf_msgbuf_pktids
*
287 brcmf_msgbuf_init_pktids(u32 nr_array_entries
,
288 enum dma_data_direction direction
)
290 struct brcmf_msgbuf_pktid
*array
;
291 struct brcmf_msgbuf_pktids
*pktids
;
293 array
= kcalloc(nr_array_entries
, sizeof(*array
), GFP_KERNEL
);
297 pktids
= kzalloc(sizeof(*pktids
), GFP_KERNEL
);
302 pktids
->array
= array
;
303 pktids
->array_size
= nr_array_entries
;
310 brcmf_msgbuf_alloc_pktid(struct device
*dev
,
311 struct brcmf_msgbuf_pktids
*pktids
,
312 struct sk_buff
*skb
, u16 data_offset
,
313 dma_addr_t
*physaddr
, u32
*idx
)
315 struct brcmf_msgbuf_pktid
*array
;
318 array
= pktids
->array
;
320 *physaddr
= dma_map_single(dev
, skb
->data
+ data_offset
,
321 skb
->len
- data_offset
, pktids
->direction
);
323 if (dma_mapping_error(dev
, *physaddr
)) {
324 brcmf_err("dma_map_single failed !!\n");
328 *idx
= pktids
->last_allocated_idx
;
333 if (*idx
== pktids
->array_size
)
335 if (array
[*idx
].allocated
.counter
== 0)
336 if (atomic_cmpxchg(&array
[*idx
].allocated
, 0, 1) == 0)
339 } while (count
< pktids
->array_size
);
341 if (count
== pktids
->array_size
)
344 array
[*idx
].data_offset
= data_offset
;
345 array
[*idx
].physaddr
= *physaddr
;
346 array
[*idx
].skb
= skb
;
348 pktids
->last_allocated_idx
= *idx
;
354 static struct sk_buff
*
355 brcmf_msgbuf_get_pktid(struct device
*dev
, struct brcmf_msgbuf_pktids
*pktids
,
358 struct brcmf_msgbuf_pktid
*pktid
;
361 if (idx
>= pktids
->array_size
) {
362 brcmf_err("Invalid packet id %d (max %d)\n", idx
,
366 if (pktids
->array
[idx
].allocated
.counter
) {
367 pktid
= &pktids
->array
[idx
];
368 dma_unmap_single(dev
, pktid
->physaddr
,
369 pktid
->skb
->len
- pktid
->data_offset
,
372 pktid
->allocated
.counter
= 0;
375 brcmf_err("Invalid packet id %d (not in use)\n", idx
);
383 brcmf_msgbuf_release_array(struct device
*dev
,
384 struct brcmf_msgbuf_pktids
*pktids
)
386 struct brcmf_msgbuf_pktid
*array
;
387 struct brcmf_msgbuf_pktid
*pktid
;
390 array
= pktids
->array
;
393 if (array
[count
].allocated
.counter
) {
394 pktid
= &array
[count
];
395 dma_unmap_single(dev
, pktid
->physaddr
,
396 pktid
->skb
->len
- pktid
->data_offset
,
398 brcmu_pkt_buf_free_skb(pktid
->skb
);
401 } while (count
< pktids
->array_size
);
408 static void brcmf_msgbuf_release_pktids(struct brcmf_msgbuf
*msgbuf
)
410 if (msgbuf
->rx_pktids
)
411 brcmf_msgbuf_release_array(msgbuf
->drvr
->bus_if
->dev
,
413 if (msgbuf
->tx_pktids
)
414 brcmf_msgbuf_release_array(msgbuf
->drvr
->bus_if
->dev
,
419 static int brcmf_msgbuf_tx_ioctl(struct brcmf_pub
*drvr
, int ifidx
,
420 uint cmd
, void *buf
, uint len
)
422 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
423 struct brcmf_commonring
*commonring
;
424 struct msgbuf_ioctl_req_hdr
*request
;
429 commonring
= msgbuf
->commonrings
[BRCMF_H2D_MSGRING_CONTROL_SUBMIT
];
430 brcmf_commonring_lock(commonring
);
431 ret_ptr
= brcmf_commonring_reserve_for_write(commonring
);
433 brcmf_err("Failed to reserve space in commonring\n");
434 brcmf_commonring_unlock(commonring
);
440 request
= (struct msgbuf_ioctl_req_hdr
*)ret_ptr
;
441 request
->msg
.msgtype
= MSGBUF_TYPE_IOCTLPTR_REQ
;
442 request
->msg
.ifidx
= (u8
)ifidx
;
443 request
->msg
.flags
= 0;
444 request
->msg
.request_id
= cpu_to_le32(BRCMF_IOCTL_REQ_PKTID
);
445 request
->cmd
= cpu_to_le32(cmd
);
446 request
->output_buf_len
= cpu_to_le16(len
);
447 request
->trans_id
= cpu_to_le16(msgbuf
->reqid
);
449 buf_len
= min_t(u16
, len
, BRCMF_TX_IOCTL_MAX_MSG_SIZE
);
450 request
->input_buf_len
= cpu_to_le16(buf_len
);
451 request
->req_buf_addr
.high_addr
= cpu_to_le32(msgbuf
->ioctbuf_phys_hi
);
452 request
->req_buf_addr
.low_addr
= cpu_to_le32(msgbuf
->ioctbuf_phys_lo
);
454 memcpy(msgbuf
->ioctbuf
, buf
, buf_len
);
456 memset(msgbuf
->ioctbuf
, 0, buf_len
);
458 err
= brcmf_commonring_write_complete(commonring
);
459 brcmf_commonring_unlock(commonring
);
465 static int brcmf_msgbuf_ioctl_resp_wait(struct brcmf_msgbuf
*msgbuf
)
467 return wait_event_timeout(msgbuf
->ioctl_resp_wait
,
468 msgbuf
->ctl_completed
,
469 msecs_to_jiffies(MSGBUF_IOCTL_RESP_TIMEOUT
));
473 static void brcmf_msgbuf_ioctl_resp_wake(struct brcmf_msgbuf
*msgbuf
)
475 msgbuf
->ctl_completed
= true;
476 if (waitqueue_active(&msgbuf
->ioctl_resp_wait
))
477 wake_up(&msgbuf
->ioctl_resp_wait
);
481 static int brcmf_msgbuf_query_dcmd(struct brcmf_pub
*drvr
, int ifidx
,
482 uint cmd
, void *buf
, uint len
)
484 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
485 struct sk_buff
*skb
= NULL
;
489 brcmf_dbg(MSGBUF
, "ifidx=%d, cmd=%d, len=%d\n", ifidx
, cmd
, len
);
490 msgbuf
->ctl_completed
= false;
491 err
= brcmf_msgbuf_tx_ioctl(drvr
, ifidx
, cmd
, buf
, len
);
495 timeout
= brcmf_msgbuf_ioctl_resp_wait(msgbuf
);
497 brcmf_err("Timeout on response for query command\n");
501 skb
= brcmf_msgbuf_get_pktid(msgbuf
->drvr
->bus_if
->dev
,
503 msgbuf
->ioctl_resp_pktid
);
504 if (msgbuf
->ioctl_resp_ret_len
!= 0) {
508 memcpy(buf
, skb
->data
, (len
< msgbuf
->ioctl_resp_ret_len
) ?
509 len
: msgbuf
->ioctl_resp_ret_len
);
511 brcmu_pkt_buf_free_skb(skb
);
513 return msgbuf
->ioctl_resp_status
;
517 static int brcmf_msgbuf_set_dcmd(struct brcmf_pub
*drvr
, int ifidx
,
518 uint cmd
, void *buf
, uint len
)
520 return brcmf_msgbuf_query_dcmd(drvr
, ifidx
, cmd
, buf
, len
);
524 static int brcmf_msgbuf_hdrpull(struct brcmf_pub
*drvr
, bool do_fws
,
525 struct sk_buff
*skb
, struct brcmf_if
**ifp
)
532 brcmf_msgbuf_remove_flowring(struct brcmf_msgbuf
*msgbuf
, u16 flowid
)
537 brcmf_dbg(MSGBUF
, "Removing flowring %d\n", flowid
);
539 dma_sz
= BRCMF_H2D_TXFLOWRING_MAX_ITEM
* BRCMF_H2D_TXFLOWRING_ITEMSIZE
;
540 dma_buf
= msgbuf
->flowrings
[flowid
]->buf_addr
;
541 dma_free_coherent(msgbuf
->drvr
->bus_if
->dev
, dma_sz
, dma_buf
,
542 msgbuf
->flowring_dma_handle
[flowid
]);
544 brcmf_flowring_delete(msgbuf
->flow
, flowid
);
548 static struct brcmf_msgbuf_work_item
*
549 brcmf_msgbuf_dequeue_work(struct brcmf_msgbuf
*msgbuf
)
551 struct brcmf_msgbuf_work_item
*work
= NULL
;
554 spin_lock_irqsave(&msgbuf
->flowring_work_lock
, flags
);
555 if (!list_empty(&msgbuf
->work_queue
)) {
556 work
= list_first_entry(&msgbuf
->work_queue
,
557 struct brcmf_msgbuf_work_item
, queue
);
558 list_del(&work
->queue
);
560 spin_unlock_irqrestore(&msgbuf
->flowring_work_lock
, flags
);
567 brcmf_msgbuf_flowring_create_worker(struct brcmf_msgbuf
*msgbuf
,
568 struct brcmf_msgbuf_work_item
*work
)
570 struct msgbuf_tx_flowring_create_req
*create
;
571 struct brcmf_commonring
*commonring
;
579 flowid
= work
->flowid
;
580 dma_sz
= BRCMF_H2D_TXFLOWRING_MAX_ITEM
* BRCMF_H2D_TXFLOWRING_ITEMSIZE
;
581 dma_buf
= dma_alloc_coherent(msgbuf
->drvr
->bus_if
->dev
, dma_sz
,
582 &msgbuf
->flowring_dma_handle
[flowid
],
585 brcmf_err("dma_alloc_coherent failed\n");
586 brcmf_flowring_delete(msgbuf
->flow
, flowid
);
587 return BRCMF_FLOWRING_INVALID_ID
;
590 brcmf_commonring_config(msgbuf
->flowrings
[flowid
],
591 BRCMF_H2D_TXFLOWRING_MAX_ITEM
,
592 BRCMF_H2D_TXFLOWRING_ITEMSIZE
, dma_buf
);
594 commonring
= msgbuf
->commonrings
[BRCMF_H2D_MSGRING_CONTROL_SUBMIT
];
595 brcmf_commonring_lock(commonring
);
596 ret_ptr
= brcmf_commonring_reserve_for_write(commonring
);
598 brcmf_err("Failed to reserve space in commonring\n");
599 brcmf_commonring_unlock(commonring
);
600 brcmf_msgbuf_remove_flowring(msgbuf
, flowid
);
601 return BRCMF_FLOWRING_INVALID_ID
;
604 create
= (struct msgbuf_tx_flowring_create_req
*)ret_ptr
;
605 create
->msg
.msgtype
= MSGBUF_TYPE_FLOW_RING_CREATE
;
606 create
->msg
.ifidx
= work
->ifidx
;
607 create
->msg
.request_id
= 0;
608 create
->tid
= brcmf_flowring_tid(msgbuf
->flow
, flowid
);
609 create
->flow_ring_id
= cpu_to_le16(flowid
+
610 BRCMF_NROF_H2D_COMMON_MSGRINGS
);
611 memcpy(create
->sa
, work
->sa
, ETH_ALEN
);
612 memcpy(create
->da
, work
->da
, ETH_ALEN
);
613 address
= (u64
)msgbuf
->flowring_dma_handle
[flowid
];
614 create
->flow_ring_addr
.high_addr
= cpu_to_le32(address
>> 32);
615 create
->flow_ring_addr
.low_addr
= cpu_to_le32(address
& 0xffffffff);
616 create
->max_items
= cpu_to_le16(BRCMF_H2D_TXFLOWRING_MAX_ITEM
);
617 create
->len_item
= cpu_to_le16(BRCMF_H2D_TXFLOWRING_ITEMSIZE
);
619 brcmf_dbg(MSGBUF
, "Send Flow Create Req flow ID %d for peer %pM prio %d ifindex %d\n",
620 flowid
, work
->da
, create
->tid
, work
->ifidx
);
622 err
= brcmf_commonring_write_complete(commonring
);
623 brcmf_commonring_unlock(commonring
);
625 brcmf_err("Failed to write commonring\n");
626 brcmf_msgbuf_remove_flowring(msgbuf
, flowid
);
627 return BRCMF_FLOWRING_INVALID_ID
;
634 static void brcmf_msgbuf_flowring_worker(struct work_struct
*work
)
636 struct brcmf_msgbuf
*msgbuf
;
637 struct brcmf_msgbuf_work_item
*create
;
639 msgbuf
= container_of(work
, struct brcmf_msgbuf
, flowring_work
);
641 while ((create
= brcmf_msgbuf_dequeue_work(msgbuf
))) {
642 brcmf_msgbuf_flowring_create_worker(msgbuf
, create
);
648 static u32
brcmf_msgbuf_flowring_create(struct brcmf_msgbuf
*msgbuf
, int ifidx
,
651 struct brcmf_msgbuf_work_item
*create
;
652 struct ethhdr
*eh
= (struct ethhdr
*)(skb
->data
);
656 create
= kzalloc(sizeof(*create
), GFP_ATOMIC
);
658 return BRCMF_FLOWRING_INVALID_ID
;
660 flowid
= brcmf_flowring_create(msgbuf
->flow
, eh
->h_dest
,
661 skb
->priority
, ifidx
);
662 if (flowid
== BRCMF_FLOWRING_INVALID_ID
) {
667 create
->flowid
= flowid
;
668 create
->ifidx
= ifidx
;
669 memcpy(create
->sa
, eh
->h_source
, ETH_ALEN
);
670 memcpy(create
->da
, eh
->h_dest
, ETH_ALEN
);
672 spin_lock_irqsave(&msgbuf
->flowring_work_lock
, flags
);
673 list_add_tail(&create
->queue
, &msgbuf
->work_queue
);
674 spin_unlock_irqrestore(&msgbuf
->flowring_work_lock
, flags
);
675 schedule_work(&msgbuf
->flowring_work
);
681 static void brcmf_msgbuf_txflow(struct brcmf_msgbuf
*msgbuf
, u8 flowid
)
683 struct brcmf_flowring
*flow
= msgbuf
->flow
;
684 struct brcmf_commonring
*commonring
;
690 struct msgbuf_tx_msghdr
*tx_msghdr
;
693 commonring
= msgbuf
->flowrings
[flowid
];
694 if (!brcmf_commonring_write_available(commonring
))
697 brcmf_commonring_lock(commonring
);
699 count
= BRCMF_MSGBUF_TX_FLUSH_CNT2
- BRCMF_MSGBUF_TX_FLUSH_CNT1
;
700 while (brcmf_flowring_qlen(flow
, flowid
)) {
701 skb
= brcmf_flowring_dequeue(flow
, flowid
);
703 brcmf_err("No SKB, but qlen %d\n",
704 brcmf_flowring_qlen(flow
, flowid
));
708 if (brcmf_msgbuf_alloc_pktid(msgbuf
->drvr
->bus_if
->dev
,
709 msgbuf
->tx_pktids
, skb
, ETH_HLEN
,
710 &physaddr
, &pktid
)) {
711 brcmf_flowring_reinsert(flow
, flowid
, skb
);
712 brcmf_err("No PKTID available !!\n");
715 ret_ptr
= brcmf_commonring_reserve_for_write(commonring
);
717 brcmf_msgbuf_get_pktid(msgbuf
->drvr
->bus_if
->dev
,
718 msgbuf
->tx_pktids
, pktid
);
719 brcmf_flowring_reinsert(flow
, flowid
, skb
);
724 tx_msghdr
= (struct msgbuf_tx_msghdr
*)ret_ptr
;
726 tx_msghdr
->msg
.msgtype
= MSGBUF_TYPE_TX_POST
;
727 tx_msghdr
->msg
.request_id
= cpu_to_le32(pktid
);
728 tx_msghdr
->msg
.ifidx
= brcmf_flowring_ifidx_get(flow
, flowid
);
729 tx_msghdr
->flags
= BRCMF_MSGBUF_PKT_FLAGS_FRAME_802_3
;
730 tx_msghdr
->flags
|= (skb
->priority
& 0x07) <<
731 BRCMF_MSGBUF_PKT_FLAGS_PRIO_SHIFT
;
732 tx_msghdr
->seg_cnt
= 1;
733 memcpy(tx_msghdr
->txhdr
, skb
->data
, ETH_HLEN
);
734 tx_msghdr
->data_len
= cpu_to_le16(skb
->len
- ETH_HLEN
);
735 address
= (u64
)physaddr
;
736 tx_msghdr
->data_buf_addr
.high_addr
= cpu_to_le32(address
>> 32);
737 tx_msghdr
->data_buf_addr
.low_addr
=
738 cpu_to_le32(address
& 0xffffffff);
739 tx_msghdr
->metadata_buf_len
= 0;
740 tx_msghdr
->metadata_buf_addr
.high_addr
= 0;
741 tx_msghdr
->metadata_buf_addr
.low_addr
= 0;
742 atomic_inc(&commonring
->outstanding_tx
);
743 if (count
>= BRCMF_MSGBUF_TX_FLUSH_CNT2
) {
744 brcmf_commonring_write_complete(commonring
);
749 brcmf_commonring_write_complete(commonring
);
750 brcmf_commonring_unlock(commonring
);
754 static void brcmf_msgbuf_txflow_worker(struct work_struct
*worker
)
756 struct brcmf_msgbuf
*msgbuf
;
759 msgbuf
= container_of(worker
, struct brcmf_msgbuf
, txflow_work
);
760 for_each_set_bit(flowid
, msgbuf
->flow_map
, msgbuf
->nrof_flowrings
) {
761 clear_bit(flowid
, msgbuf
->flow_map
);
762 brcmf_msgbuf_txflow(msgbuf
, flowid
);
767 static int brcmf_msgbuf_schedule_txdata(struct brcmf_msgbuf
*msgbuf
, u32 flowid
,
770 struct brcmf_commonring
*commonring
;
772 set_bit(flowid
, msgbuf
->flow_map
);
773 commonring
= msgbuf
->flowrings
[flowid
];
774 if ((force
) || (atomic_read(&commonring
->outstanding_tx
) <
775 BRCMF_MSGBUF_DELAY_TXWORKER_THRS
))
776 queue_work(msgbuf
->txflow_wq
, &msgbuf
->txflow_work
);
782 static int brcmf_msgbuf_txdata(struct brcmf_pub
*drvr
, int ifidx
,
783 u8 offset
, struct sk_buff
*skb
)
785 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
786 struct brcmf_flowring
*flow
= msgbuf
->flow
;
787 struct ethhdr
*eh
= (struct ethhdr
*)(skb
->data
);
792 flowid
= brcmf_flowring_lookup(flow
, eh
->h_dest
, skb
->priority
, ifidx
);
793 if (flowid
== BRCMF_FLOWRING_INVALID_ID
) {
794 flowid
= brcmf_msgbuf_flowring_create(msgbuf
, ifidx
, skb
);
795 if (flowid
== BRCMF_FLOWRING_INVALID_ID
)
798 queue_count
= brcmf_flowring_enqueue(flow
, flowid
, skb
);
799 force
= ((queue_count
% BRCMF_MSGBUF_TRICKLE_TXWORKER_THRS
) == 0);
800 brcmf_msgbuf_schedule_txdata(msgbuf
, flowid
, force
);
807 brcmf_msgbuf_configure_addr_mode(struct brcmf_pub
*drvr
, int ifidx
,
808 enum proto_addr_mode addr_mode
)
810 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
812 brcmf_flowring_configure_addr_mode(msgbuf
->flow
, ifidx
, addr_mode
);
817 brcmf_msgbuf_delete_peer(struct brcmf_pub
*drvr
, int ifidx
, u8 peer
[ETH_ALEN
])
819 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
821 brcmf_flowring_delete_peer(msgbuf
->flow
, ifidx
, peer
);
826 brcmf_msgbuf_add_tdls_peer(struct brcmf_pub
*drvr
, int ifidx
, u8 peer
[ETH_ALEN
])
828 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
830 brcmf_flowring_add_tdls_peer(msgbuf
->flow
, ifidx
, peer
);
835 brcmf_msgbuf_process_ioctl_complete(struct brcmf_msgbuf
*msgbuf
, void *buf
)
837 struct msgbuf_ioctl_resp_hdr
*ioctl_resp
;
839 ioctl_resp
= (struct msgbuf_ioctl_resp_hdr
*)buf
;
841 msgbuf
->ioctl_resp_status
=
842 (s16
)le16_to_cpu(ioctl_resp
->compl_hdr
.status
);
843 msgbuf
->ioctl_resp_ret_len
= le16_to_cpu(ioctl_resp
->resp_len
);
844 msgbuf
->ioctl_resp_pktid
= le32_to_cpu(ioctl_resp
->msg
.request_id
);
846 brcmf_msgbuf_ioctl_resp_wake(msgbuf
);
848 if (msgbuf
->cur_ioctlrespbuf
)
849 msgbuf
->cur_ioctlrespbuf
--;
850 brcmf_msgbuf_rxbuf_ioctlresp_post(msgbuf
);
855 brcmf_msgbuf_process_txstatus(struct brcmf_msgbuf
*msgbuf
, void *buf
)
857 struct brcmf_commonring
*commonring
;
858 struct msgbuf_tx_status
*tx_status
;
863 tx_status
= (struct msgbuf_tx_status
*)buf
;
864 idx
= le32_to_cpu(tx_status
->msg
.request_id
);
865 flowid
= le16_to_cpu(tx_status
->compl_hdr
.flow_ring_id
);
866 flowid
-= BRCMF_NROF_H2D_COMMON_MSGRINGS
;
867 skb
= brcmf_msgbuf_get_pktid(msgbuf
->drvr
->bus_if
->dev
,
868 msgbuf
->tx_pktids
, idx
);
872 set_bit(flowid
, msgbuf
->txstatus_done_map
);
873 commonring
= msgbuf
->flowrings
[flowid
];
874 atomic_dec(&commonring
->outstanding_tx
);
876 /* Hante: i believe this was a bug as tx_status->msg.ifidx was used
877 * in brcmf_txfinalize as index in drvr->iflist. Can you confirm/deny?
879 brcmf_txfinalize(brcmf_get_ifp(msgbuf
->drvr
, tx_status
->msg
.ifidx
),
884 static u32
brcmf_msgbuf_rxbuf_data_post(struct brcmf_msgbuf
*msgbuf
, u32 count
)
886 struct brcmf_commonring
*commonring
;
892 struct msgbuf_rx_bufpost
*rx_bufpost
;
897 commonring
= msgbuf
->commonrings
[BRCMF_H2D_MSGRING_RXPOST_SUBMIT
];
898 ret_ptr
= brcmf_commonring_reserve_for_write_multiple(commonring
,
902 brcmf_dbg(MSGBUF
, "Failed to reserve space in commonring\n");
906 for (i
= 0; i
< alloced
; i
++) {
907 rx_bufpost
= (struct msgbuf_rx_bufpost
*)ret_ptr
;
908 memset(rx_bufpost
, 0, sizeof(*rx_bufpost
));
910 skb
= brcmu_pkt_buf_get_skb(BRCMF_MSGBUF_MAX_PKT_SIZE
);
913 brcmf_err("Failed to alloc SKB\n");
914 brcmf_commonring_write_cancel(commonring
, alloced
- i
);
919 if (brcmf_msgbuf_alloc_pktid(msgbuf
->drvr
->bus_if
->dev
,
920 msgbuf
->rx_pktids
, skb
, 0,
921 &physaddr
, &pktid
)) {
922 dev_kfree_skb_any(skb
);
923 brcmf_err("No PKTID available !!\n");
924 brcmf_commonring_write_cancel(commonring
, alloced
- i
);
928 if (msgbuf
->rx_metadata_offset
) {
929 address
= (u64
)physaddr
;
930 rx_bufpost
->metadata_buf_len
=
931 cpu_to_le16(msgbuf
->rx_metadata_offset
);
932 rx_bufpost
->metadata_buf_addr
.high_addr
=
933 cpu_to_le32(address
>> 32);
934 rx_bufpost
->metadata_buf_addr
.low_addr
=
935 cpu_to_le32(address
& 0xffffffff);
937 skb_pull(skb
, msgbuf
->rx_metadata_offset
);
939 physaddr
+= msgbuf
->rx_metadata_offset
;
941 rx_bufpost
->msg
.msgtype
= MSGBUF_TYPE_RXBUF_POST
;
942 rx_bufpost
->msg
.request_id
= cpu_to_le32(pktid
);
944 address
= (u64
)physaddr
;
945 rx_bufpost
->data_buf_len
= cpu_to_le16((u16
)pktlen
);
946 rx_bufpost
->data_buf_addr
.high_addr
=
947 cpu_to_le32(address
>> 32);
948 rx_bufpost
->data_buf_addr
.low_addr
=
949 cpu_to_le32(address
& 0xffffffff);
951 ret_ptr
+= brcmf_commonring_len_item(commonring
);
955 brcmf_commonring_write_complete(commonring
);
962 brcmf_msgbuf_rxbuf_data_fill(struct brcmf_msgbuf
*msgbuf
)
967 fillbufs
= msgbuf
->max_rxbufpost
- msgbuf
->rxbufpost
;
970 retcount
= brcmf_msgbuf_rxbuf_data_post(msgbuf
, fillbufs
);
973 msgbuf
->rxbufpost
+= retcount
;
974 fillbufs
-= retcount
;
980 brcmf_msgbuf_update_rxbufpost_count(struct brcmf_msgbuf
*msgbuf
, u16 rxcnt
)
982 msgbuf
->rxbufpost
-= rxcnt
;
983 if (msgbuf
->rxbufpost
<= (msgbuf
->max_rxbufpost
-
984 BRCMF_MSGBUF_RXBUFPOST_THRESHOLD
))
985 brcmf_msgbuf_rxbuf_data_fill(msgbuf
);
990 brcmf_msgbuf_rxbuf_ctrl_post(struct brcmf_msgbuf
*msgbuf
, bool event_buf
,
993 struct brcmf_commonring
*commonring
;
999 struct msgbuf_rx_ioctl_resp_or_event
*rx_bufpost
;
1004 commonring
= msgbuf
->commonrings
[BRCMF_H2D_MSGRING_CONTROL_SUBMIT
];
1005 brcmf_commonring_lock(commonring
);
1006 ret_ptr
= brcmf_commonring_reserve_for_write_multiple(commonring
,
1010 brcmf_err("Failed to reserve space in commonring\n");
1011 brcmf_commonring_unlock(commonring
);
1015 for (i
= 0; i
< alloced
; i
++) {
1016 rx_bufpost
= (struct msgbuf_rx_ioctl_resp_or_event
*)ret_ptr
;
1017 memset(rx_bufpost
, 0, sizeof(*rx_bufpost
));
1019 skb
= brcmu_pkt_buf_get_skb(BRCMF_MSGBUF_MAX_PKT_SIZE
);
1022 brcmf_err("Failed to alloc SKB\n");
1023 brcmf_commonring_write_cancel(commonring
, alloced
- i
);
1028 if (brcmf_msgbuf_alloc_pktid(msgbuf
->drvr
->bus_if
->dev
,
1029 msgbuf
->rx_pktids
, skb
, 0,
1030 &physaddr
, &pktid
)) {
1031 dev_kfree_skb_any(skb
);
1032 brcmf_err("No PKTID available !!\n");
1033 brcmf_commonring_write_cancel(commonring
, alloced
- i
);
1037 rx_bufpost
->msg
.msgtype
= MSGBUF_TYPE_EVENT_BUF_POST
;
1039 rx_bufpost
->msg
.msgtype
=
1040 MSGBUF_TYPE_IOCTLRESP_BUF_POST
;
1041 rx_bufpost
->msg
.request_id
= cpu_to_le32(pktid
);
1043 address
= (u64
)physaddr
;
1044 rx_bufpost
->host_buf_len
= cpu_to_le16((u16
)pktlen
);
1045 rx_bufpost
->host_buf_addr
.high_addr
=
1046 cpu_to_le32(address
>> 32);
1047 rx_bufpost
->host_buf_addr
.low_addr
=
1048 cpu_to_le32(address
& 0xffffffff);
1050 ret_ptr
+= brcmf_commonring_len_item(commonring
);
1054 brcmf_commonring_write_complete(commonring
);
1056 brcmf_commonring_unlock(commonring
);
1062 static void brcmf_msgbuf_rxbuf_ioctlresp_post(struct brcmf_msgbuf
*msgbuf
)
1066 count
= msgbuf
->max_ioctlrespbuf
- msgbuf
->cur_ioctlrespbuf
;
1067 count
= brcmf_msgbuf_rxbuf_ctrl_post(msgbuf
, false, count
);
1068 msgbuf
->cur_ioctlrespbuf
+= count
;
1072 static void brcmf_msgbuf_rxbuf_event_post(struct brcmf_msgbuf
*msgbuf
)
1076 count
= msgbuf
->max_eventbuf
- msgbuf
->cur_eventbuf
;
1077 count
= brcmf_msgbuf_rxbuf_ctrl_post(msgbuf
, true, count
);
1078 msgbuf
->cur_eventbuf
+= count
;
1083 brcmf_msgbuf_rx_skb(struct brcmf_msgbuf
*msgbuf
, struct sk_buff
*skb
,
1086 struct brcmf_if
*ifp
;
1088 ifp
= brcmf_get_ifp(msgbuf
->drvr
, ifidx
);
1089 if (!ifp
|| !ifp
->ndev
) {
1090 brcmf_err("Received pkt for invalid ifidx %d\n", ifidx
);
1091 brcmu_pkt_buf_free_skb(skb
);
1094 brcmf_netif_rx(ifp
, skb
);
1098 static void brcmf_msgbuf_process_event(struct brcmf_msgbuf
*msgbuf
, void *buf
)
1100 struct msgbuf_rx_event
*event
;
1103 struct sk_buff
*skb
;
1105 event
= (struct msgbuf_rx_event
*)buf
;
1106 idx
= le32_to_cpu(event
->msg
.request_id
);
1107 buflen
= le16_to_cpu(event
->event_data_len
);
1109 if (msgbuf
->cur_eventbuf
)
1110 msgbuf
->cur_eventbuf
--;
1111 brcmf_msgbuf_rxbuf_event_post(msgbuf
);
1113 skb
= brcmf_msgbuf_get_pktid(msgbuf
->drvr
->bus_if
->dev
,
1114 msgbuf
->rx_pktids
, idx
);
1118 if (msgbuf
->rx_dataoffset
)
1119 skb_pull(skb
, msgbuf
->rx_dataoffset
);
1121 skb_trim(skb
, buflen
);
1123 brcmf_msgbuf_rx_skb(msgbuf
, skb
, event
->msg
.ifidx
);
1128 brcmf_msgbuf_process_rx_complete(struct brcmf_msgbuf
*msgbuf
, void *buf
)
1130 struct msgbuf_rx_complete
*rx_complete
;
1131 struct sk_buff
*skb
;
1136 brcmf_msgbuf_update_rxbufpost_count(msgbuf
, 1);
1138 rx_complete
= (struct msgbuf_rx_complete
*)buf
;
1139 data_offset
= le16_to_cpu(rx_complete
->data_offset
);
1140 buflen
= le16_to_cpu(rx_complete
->data_len
);
1141 idx
= le32_to_cpu(rx_complete
->msg
.request_id
);
1143 skb
= brcmf_msgbuf_get_pktid(msgbuf
->drvr
->bus_if
->dev
,
1144 msgbuf
->rx_pktids
, idx
);
1149 skb_pull(skb
, data_offset
);
1150 else if (msgbuf
->rx_dataoffset
)
1151 skb_pull(skb
, msgbuf
->rx_dataoffset
);
1153 skb_trim(skb
, buflen
);
1155 brcmf_msgbuf_rx_skb(msgbuf
, skb
, rx_complete
->msg
.ifidx
);
1160 brcmf_msgbuf_process_flow_ring_create_response(struct brcmf_msgbuf
*msgbuf
,
1163 struct msgbuf_flowring_create_resp
*flowring_create_resp
;
1167 flowring_create_resp
= (struct msgbuf_flowring_create_resp
*)buf
;
1169 flowid
= le16_to_cpu(flowring_create_resp
->compl_hdr
.flow_ring_id
);
1170 flowid
-= BRCMF_NROF_H2D_COMMON_MSGRINGS
;
1171 status
= le16_to_cpu(flowring_create_resp
->compl_hdr
.status
);
1174 brcmf_err("Flowring creation failed, code %d\n", status
);
1175 brcmf_msgbuf_remove_flowring(msgbuf
, flowid
);
1178 brcmf_dbg(MSGBUF
, "Flowring %d Create response status %d\n", flowid
,
1181 brcmf_flowring_open(msgbuf
->flow
, flowid
);
1183 brcmf_msgbuf_schedule_txdata(msgbuf
, flowid
, true);
1188 brcmf_msgbuf_process_flow_ring_delete_response(struct brcmf_msgbuf
*msgbuf
,
1191 struct msgbuf_flowring_delete_resp
*flowring_delete_resp
;
1195 flowring_delete_resp
= (struct msgbuf_flowring_delete_resp
*)buf
;
1197 flowid
= le16_to_cpu(flowring_delete_resp
->compl_hdr
.flow_ring_id
);
1198 flowid
-= BRCMF_NROF_H2D_COMMON_MSGRINGS
;
1199 status
= le16_to_cpu(flowring_delete_resp
->compl_hdr
.status
);
1202 brcmf_err("Flowring deletion failed, code %d\n", status
);
1203 brcmf_flowring_delete(msgbuf
->flow
, flowid
);
1206 brcmf_dbg(MSGBUF
, "Flowring %d Delete response status %d\n", flowid
,
1209 brcmf_msgbuf_remove_flowring(msgbuf
, flowid
);
1213 static void brcmf_msgbuf_process_msgtype(struct brcmf_msgbuf
*msgbuf
, void *buf
)
1215 struct msgbuf_common_hdr
*msg
;
1217 msg
= (struct msgbuf_common_hdr
*)buf
;
1218 switch (msg
->msgtype
) {
1219 case MSGBUF_TYPE_FLOW_RING_CREATE_CMPLT
:
1220 brcmf_dbg(MSGBUF
, "MSGBUF_TYPE_FLOW_RING_CREATE_CMPLT\n");
1221 brcmf_msgbuf_process_flow_ring_create_response(msgbuf
, buf
);
1223 case MSGBUF_TYPE_FLOW_RING_DELETE_CMPLT
:
1224 brcmf_dbg(MSGBUF
, "MSGBUF_TYPE_FLOW_RING_DELETE_CMPLT\n");
1225 brcmf_msgbuf_process_flow_ring_delete_response(msgbuf
, buf
);
1227 case MSGBUF_TYPE_IOCTLPTR_REQ_ACK
:
1228 brcmf_dbg(MSGBUF
, "MSGBUF_TYPE_IOCTLPTR_REQ_ACK\n");
1230 case MSGBUF_TYPE_IOCTL_CMPLT
:
1231 brcmf_dbg(MSGBUF
, "MSGBUF_TYPE_IOCTL_CMPLT\n");
1232 brcmf_msgbuf_process_ioctl_complete(msgbuf
, buf
);
1234 case MSGBUF_TYPE_WL_EVENT
:
1235 brcmf_dbg(MSGBUF
, "MSGBUF_TYPE_WL_EVENT\n");
1236 brcmf_msgbuf_process_event(msgbuf
, buf
);
1238 case MSGBUF_TYPE_TX_STATUS
:
1239 brcmf_dbg(MSGBUF
, "MSGBUF_TYPE_TX_STATUS\n");
1240 brcmf_msgbuf_process_txstatus(msgbuf
, buf
);
1242 case MSGBUF_TYPE_RX_CMPLT
:
1243 brcmf_dbg(MSGBUF
, "MSGBUF_TYPE_RX_CMPLT\n");
1244 brcmf_msgbuf_process_rx_complete(msgbuf
, buf
);
1247 brcmf_err("Unsupported msgtype %d\n", msg
->msgtype
);
1253 static void brcmf_msgbuf_process_rx(struct brcmf_msgbuf
*msgbuf
,
1254 struct brcmf_commonring
*commonring
)
1261 buf
= brcmf_commonring_get_read_ptr(commonring
, &count
);
1267 brcmf_msgbuf_process_msgtype(msgbuf
,
1268 buf
+ msgbuf
->rx_dataoffset
);
1269 buf
+= brcmf_commonring_len_item(commonring
);
1271 if (processed
== BRCMF_MSGBUF_UPDATE_RX_PTR_THRS
) {
1272 brcmf_commonring_read_complete(commonring
, processed
);
1278 brcmf_commonring_read_complete(commonring
, processed
);
1280 if (commonring
->r_ptr
== 0)
1285 int brcmf_proto_msgbuf_rx_trigger(struct device
*dev
)
1287 struct brcmf_bus
*bus_if
= dev_get_drvdata(dev
);
1288 struct brcmf_pub
*drvr
= bus_if
->drvr
;
1289 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
1290 struct brcmf_commonring
*commonring
;
1295 buf
= msgbuf
->commonrings
[BRCMF_D2H_MSGRING_RX_COMPLETE
];
1296 brcmf_msgbuf_process_rx(msgbuf
, buf
);
1297 buf
= msgbuf
->commonrings
[BRCMF_D2H_MSGRING_TX_COMPLETE
];
1298 brcmf_msgbuf_process_rx(msgbuf
, buf
);
1299 buf
= msgbuf
->commonrings
[BRCMF_D2H_MSGRING_CONTROL_COMPLETE
];
1300 brcmf_msgbuf_process_rx(msgbuf
, buf
);
1302 for_each_set_bit(flowid
, msgbuf
->txstatus_done_map
,
1303 msgbuf
->nrof_flowrings
) {
1304 clear_bit(flowid
, msgbuf
->txstatus_done_map
);
1305 commonring
= msgbuf
->flowrings
[flowid
];
1306 qlen
= brcmf_flowring_qlen(msgbuf
->flow
, flowid
);
1307 if ((qlen
> BRCMF_MSGBUF_TRICKLE_TXWORKER_THRS
) ||
1308 ((qlen
) && (atomic_read(&commonring
->outstanding_tx
) <
1309 BRCMF_MSGBUF_TRICKLE_TXWORKER_THRS
)))
1310 brcmf_msgbuf_schedule_txdata(msgbuf
, flowid
, true);
1317 void brcmf_msgbuf_delete_flowring(struct brcmf_pub
*drvr
, u8 flowid
)
1319 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
1320 struct msgbuf_tx_flowring_delete_req
*delete;
1321 struct brcmf_commonring
*commonring
;
1326 commonring
= msgbuf
->commonrings
[BRCMF_H2D_MSGRING_CONTROL_SUBMIT
];
1327 brcmf_commonring_lock(commonring
);
1328 ret_ptr
= brcmf_commonring_reserve_for_write(commonring
);
1330 brcmf_err("FW unaware, flowring will be removed !!\n");
1331 brcmf_commonring_unlock(commonring
);
1332 brcmf_msgbuf_remove_flowring(msgbuf
, flowid
);
1336 delete = (struct msgbuf_tx_flowring_delete_req
*)ret_ptr
;
1338 ifidx
= brcmf_flowring_ifidx_get(msgbuf
->flow
, flowid
);
1340 delete->msg
.msgtype
= MSGBUF_TYPE_FLOW_RING_DELETE
;
1341 delete->msg
.ifidx
= ifidx
;
1342 delete->msg
.request_id
= 0;
1344 delete->flow_ring_id
= cpu_to_le16(flowid
+
1345 BRCMF_NROF_H2D_COMMON_MSGRINGS
);
1348 brcmf_dbg(MSGBUF
, "Send Flow Delete Req flow ID %d, ifindex %d\n",
1351 err
= brcmf_commonring_write_complete(commonring
);
1352 brcmf_commonring_unlock(commonring
);
1354 brcmf_err("Failed to submit RING_DELETE, flowring will be removed\n");
1355 brcmf_msgbuf_remove_flowring(msgbuf
, flowid
);
1360 static int brcmf_msgbuf_stats_read(struct seq_file
*seq
, void *data
)
1362 struct brcmf_bus
*bus_if
= dev_get_drvdata(seq
->private);
1363 struct brcmf_pub
*drvr
= bus_if
->drvr
;
1364 struct brcmf_msgbuf
*msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
1365 struct brcmf_commonring
*commonring
;
1367 struct brcmf_flowring_ring
*ring
;
1368 struct brcmf_flowring_hash
*hash
;
1370 commonring
= msgbuf
->commonrings
[BRCMF_H2D_MSGRING_CONTROL_SUBMIT
];
1371 seq_printf(seq
, "h2d_ctl_submit: rp %4u, wp %4u, depth %4u\n",
1372 commonring
->r_ptr
, commonring
->w_ptr
, commonring
->depth
);
1373 commonring
= msgbuf
->commonrings
[BRCMF_H2D_MSGRING_RXPOST_SUBMIT
];
1374 seq_printf(seq
, "h2d_rx_submit: rp %4u, wp %4u, depth %4u\n",
1375 commonring
->r_ptr
, commonring
->w_ptr
, commonring
->depth
);
1376 commonring
= msgbuf
->commonrings
[BRCMF_D2H_MSGRING_CONTROL_COMPLETE
];
1377 seq_printf(seq
, "d2h_ctl_cmplt: rp %4u, wp %4u, depth %4u\n",
1378 commonring
->r_ptr
, commonring
->w_ptr
, commonring
->depth
);
1379 commonring
= msgbuf
->commonrings
[BRCMF_D2H_MSGRING_TX_COMPLETE
];
1380 seq_printf(seq
, "d2h_tx_cmplt: rp %4u, wp %4u, depth %4u\n",
1381 commonring
->r_ptr
, commonring
->w_ptr
, commonring
->depth
);
1382 commonring
= msgbuf
->commonrings
[BRCMF_D2H_MSGRING_RX_COMPLETE
];
1383 seq_printf(seq
, "d2h_rx_cmplt: rp %4u, wp %4u, depth %4u\n",
1384 commonring
->r_ptr
, commonring
->w_ptr
, commonring
->depth
);
1386 seq_printf(seq
, "\nh2d_flowrings: depth %u\n",
1387 BRCMF_H2D_TXFLOWRING_MAX_ITEM
);
1388 seq_puts(seq
, "Active flowrings:\n");
1389 hash
= msgbuf
->flow
->hash
;
1390 for (i
= 0; i
< msgbuf
->flow
->nrofrings
; i
++) {
1391 if (!msgbuf
->flow
->rings
[i
])
1393 ring
= msgbuf
->flow
->rings
[i
];
1394 if (ring
->status
!= RING_OPEN
)
1396 commonring
= msgbuf
->flowrings
[i
];
1397 hash
= &msgbuf
->flow
->hash
[ring
->hash_id
];
1398 seq_printf(seq
, "id %3u: rp %4u, wp %4u, qlen %4u, blocked %u\n"
1399 " ifidx %u, fifo %u, da %pM\n",
1400 i
, commonring
->r_ptr
, commonring
->w_ptr
,
1401 skb_queue_len(&ring
->skblist
), ring
->blocked
,
1402 hash
->ifidx
, hash
->fifo
, hash
->mac
);
1408 static int brcmf_msgbuf_stats_read(struct seq_file
*seq
, void *data
)
1414 int brcmf_proto_msgbuf_attach(struct brcmf_pub
*drvr
)
1416 struct brcmf_bus_msgbuf
*if_msgbuf
;
1417 struct brcmf_msgbuf
*msgbuf
;
1421 if_msgbuf
= drvr
->bus_if
->msgbuf
;
1422 msgbuf
= kzalloc(sizeof(*msgbuf
), GFP_KERNEL
);
1426 msgbuf
->txflow_wq
= create_singlethread_workqueue("msgbuf_txflow");
1427 if (msgbuf
->txflow_wq
== NULL
) {
1428 brcmf_err("workqueue creation failed\n");
1431 INIT_WORK(&msgbuf
->txflow_work
, brcmf_msgbuf_txflow_worker
);
1432 count
= BITS_TO_LONGS(if_msgbuf
->nrof_flowrings
);
1433 count
= count
* sizeof(unsigned long);
1434 msgbuf
->flow_map
= kzalloc(count
, GFP_KERNEL
);
1435 if (!msgbuf
->flow_map
)
1438 msgbuf
->txstatus_done_map
= kzalloc(count
, GFP_KERNEL
);
1439 if (!msgbuf
->txstatus_done_map
)
1442 msgbuf
->drvr
= drvr
;
1443 msgbuf
->ioctbuf
= dma_alloc_coherent(drvr
->bus_if
->dev
,
1444 BRCMF_TX_IOCTL_MAX_MSG_SIZE
,
1445 &msgbuf
->ioctbuf_handle
,
1447 if (!msgbuf
->ioctbuf
)
1449 address
= (u64
)msgbuf
->ioctbuf_handle
;
1450 msgbuf
->ioctbuf_phys_hi
= address
>> 32;
1451 msgbuf
->ioctbuf_phys_lo
= address
& 0xffffffff;
1453 drvr
->proto
->hdrpull
= brcmf_msgbuf_hdrpull
;
1454 drvr
->proto
->query_dcmd
= brcmf_msgbuf_query_dcmd
;
1455 drvr
->proto
->set_dcmd
= brcmf_msgbuf_set_dcmd
;
1456 drvr
->proto
->txdata
= brcmf_msgbuf_txdata
;
1457 drvr
->proto
->configure_addr_mode
= brcmf_msgbuf_configure_addr_mode
;
1458 drvr
->proto
->delete_peer
= brcmf_msgbuf_delete_peer
;
1459 drvr
->proto
->add_tdls_peer
= brcmf_msgbuf_add_tdls_peer
;
1460 drvr
->proto
->pd
= msgbuf
;
1462 init_waitqueue_head(&msgbuf
->ioctl_resp_wait
);
1464 msgbuf
->commonrings
=
1465 (struct brcmf_commonring
**)if_msgbuf
->commonrings
;
1466 msgbuf
->flowrings
= (struct brcmf_commonring
**)if_msgbuf
->flowrings
;
1467 msgbuf
->nrof_flowrings
= if_msgbuf
->nrof_flowrings
;
1468 msgbuf
->flowring_dma_handle
= kzalloc(msgbuf
->nrof_flowrings
*
1469 sizeof(*msgbuf
->flowring_dma_handle
), GFP_KERNEL
);
1470 if (!msgbuf
->flowring_dma_handle
)
1473 msgbuf
->rx_dataoffset
= if_msgbuf
->rx_dataoffset
;
1474 msgbuf
->max_rxbufpost
= if_msgbuf
->max_rxbufpost
;
1476 msgbuf
->max_ioctlrespbuf
= BRCMF_MSGBUF_MAX_IOCTLRESPBUF_POST
;
1477 msgbuf
->max_eventbuf
= BRCMF_MSGBUF_MAX_EVENTBUF_POST
;
1479 msgbuf
->tx_pktids
= brcmf_msgbuf_init_pktids(NR_TX_PKTIDS
,
1481 if (!msgbuf
->tx_pktids
)
1483 msgbuf
->rx_pktids
= brcmf_msgbuf_init_pktids(NR_RX_PKTIDS
,
1485 if (!msgbuf
->rx_pktids
)
1488 msgbuf
->flow
= brcmf_flowring_attach(drvr
->bus_if
->dev
,
1489 if_msgbuf
->nrof_flowrings
);
1494 brcmf_dbg(MSGBUF
, "Feeding buffers, rx data %d, rx event %d, rx ioctl resp %d\n",
1495 msgbuf
->max_rxbufpost
, msgbuf
->max_eventbuf
,
1496 msgbuf
->max_ioctlrespbuf
);
1499 brcmf_msgbuf_rxbuf_data_fill(msgbuf
);
1500 if (msgbuf
->max_rxbufpost
!= msgbuf
->rxbufpost
)
1505 } while (count
< 10);
1506 brcmf_msgbuf_rxbuf_event_post(msgbuf
);
1507 brcmf_msgbuf_rxbuf_ioctlresp_post(msgbuf
);
1509 INIT_WORK(&msgbuf
->flowring_work
, brcmf_msgbuf_flowring_worker
);
1510 spin_lock_init(&msgbuf
->flowring_work_lock
);
1511 INIT_LIST_HEAD(&msgbuf
->work_queue
);
1513 brcmf_debugfs_add_entry(drvr
, "msgbuf_stats", brcmf_msgbuf_stats_read
);
1519 kfree(msgbuf
->flow_map
);
1520 kfree(msgbuf
->txstatus_done_map
);
1521 brcmf_msgbuf_release_pktids(msgbuf
);
1522 kfree(msgbuf
->flowring_dma_handle
);
1523 if (msgbuf
->ioctbuf
)
1524 dma_free_coherent(drvr
->bus_if
->dev
,
1525 BRCMF_TX_IOCTL_MAX_MSG_SIZE
,
1527 msgbuf
->ioctbuf_handle
);
1534 void brcmf_proto_msgbuf_detach(struct brcmf_pub
*drvr
)
1536 struct brcmf_msgbuf
*msgbuf
;
1537 struct brcmf_msgbuf_work_item
*work
;
1539 brcmf_dbg(TRACE
, "Enter\n");
1540 if (drvr
->proto
->pd
) {
1541 msgbuf
= (struct brcmf_msgbuf
*)drvr
->proto
->pd
;
1542 cancel_work_sync(&msgbuf
->flowring_work
);
1543 while (!list_empty(&msgbuf
->work_queue
)) {
1544 work
= list_first_entry(&msgbuf
->work_queue
,
1545 struct brcmf_msgbuf_work_item
,
1547 list_del(&work
->queue
);
1550 kfree(msgbuf
->flow_map
);
1551 kfree(msgbuf
->txstatus_done_map
);
1552 if (msgbuf
->txflow_wq
)
1553 destroy_workqueue(msgbuf
->txflow_wq
);
1555 brcmf_flowring_detach(msgbuf
->flow
);
1556 dma_free_coherent(drvr
->bus_if
->dev
,
1557 BRCMF_TX_IOCTL_MAX_MSG_SIZE
,
1558 msgbuf
->ioctbuf
, msgbuf
->ioctbuf_handle
);
1559 brcmf_msgbuf_release_pktids(msgbuf
);
1560 kfree(msgbuf
->flowring_dma_handle
);
1562 drvr
->proto
->pd
= NULL
;