1
2
3
4
5
6
7
8
9
10
11#include <linux/types.h>
12#include <linux/netdevice.h>
13#include <linux/etherdevice.h>
14
15#include <brcmu_utils.h>
16#include <brcmu_wifi.h>
17
18#include "core.h"
19#include "debug.h"
20#include "proto.h"
21#include "msgbuf.h"
22#include "commonring.h"
23#include "flowring.h"
24#include "bus.h"
25#include "tracepoint.h"
26
27
28#define MSGBUF_IOCTL_RESP_TIMEOUT msecs_to_jiffies(2000)
29
30#define MSGBUF_TYPE_GEN_STATUS 0x1
31#define MSGBUF_TYPE_RING_STATUS 0x2
32#define MSGBUF_TYPE_FLOW_RING_CREATE 0x3
33#define MSGBUF_TYPE_FLOW_RING_CREATE_CMPLT 0x4
34#define MSGBUF_TYPE_FLOW_RING_DELETE 0x5
35#define MSGBUF_TYPE_FLOW_RING_DELETE_CMPLT 0x6
36#define MSGBUF_TYPE_FLOW_RING_FLUSH 0x7
37#define MSGBUF_TYPE_FLOW_RING_FLUSH_CMPLT 0x8
38#define MSGBUF_TYPE_IOCTLPTR_REQ 0x9
39#define MSGBUF_TYPE_IOCTLPTR_REQ_ACK 0xA
40#define MSGBUF_TYPE_IOCTLRESP_BUF_POST 0xB
41#define MSGBUF_TYPE_IOCTL_CMPLT 0xC
42#define MSGBUF_TYPE_EVENT_BUF_POST 0xD
43#define MSGBUF_TYPE_WL_EVENT 0xE
44#define MSGBUF_TYPE_TX_POST 0xF
45#define MSGBUF_TYPE_TX_STATUS 0x10
46#define MSGBUF_TYPE_RXBUF_POST 0x11
47#define MSGBUF_TYPE_RX_CMPLT 0x12
48#define MSGBUF_TYPE_LPBK_DMAXFER 0x13
49#define MSGBUF_TYPE_LPBK_DMAXFER_CMPLT 0x14
50
51#define NR_TX_PKTIDS 2048
52#define NR_RX_PKTIDS 1024
53
54#define BRCMF_IOCTL_REQ_PKTID 0xFFFE
55
56#define BRCMF_MSGBUF_MAX_PKT_SIZE 2048
57#define BRCMF_MSGBUF_MAX_CTL_PKT_SIZE 8192
58#define BRCMF_MSGBUF_RXBUFPOST_THRESHOLD 32
59#define BRCMF_MSGBUF_MAX_IOCTLRESPBUF_POST 8
60#define BRCMF_MSGBUF_MAX_EVENTBUF_POST 8
61
62#define BRCMF_MSGBUF_PKT_FLAGS_FRAME_802_3 0x01
63#define BRCMF_MSGBUF_PKT_FLAGS_FRAME_802_11 0x02
64#define BRCMF_MSGBUF_PKT_FLAGS_FRAME_MASK 0x07
65#define BRCMF_MSGBUF_PKT_FLAGS_PRIO_SHIFT 5
66
67#define BRCMF_MSGBUF_TX_FLUSH_CNT1 32
68#define BRCMF_MSGBUF_TX_FLUSH_CNT2 96
69
70#define BRCMF_MSGBUF_DELAY_TXWORKER_THRS 96
71#define BRCMF_MSGBUF_TRICKLE_TXWORKER_THRS 32
72#define BRCMF_MSGBUF_UPDATE_RX_PTR_THRS 48
73
74
75struct msgbuf_common_hdr {
76 u8 msgtype;
77 u8 ifidx;
78 u8 flags;
79 u8 rsvd0;
80 __le32 request_id;
81};
82
83struct msgbuf_ioctl_req_hdr {
84 struct msgbuf_common_hdr msg;
85 __le32 cmd;
86 __le16 trans_id;
87 __le16 input_buf_len;
88 __le16 output_buf_len;
89 __le16 rsvd0[3];
90 struct msgbuf_buf_addr req_buf_addr;
91 __le32 rsvd1[2];
92};
93
94struct msgbuf_tx_msghdr {
95 struct msgbuf_common_hdr msg;
96 u8 txhdr[ETH_HLEN];
97 u8 flags;
98 u8 seg_cnt;
99 struct msgbuf_buf_addr metadata_buf_addr;
100 struct msgbuf_buf_addr data_buf_addr;
101 __le16 metadata_buf_len;
102 __le16 data_len;
103 __le32 rsvd0;
104};
105
106struct msgbuf_rx_bufpost {
107 struct msgbuf_common_hdr msg;
108 __le16 metadata_buf_len;
109 __le16 data_buf_len;
110 __le32 rsvd0;
111 struct msgbuf_buf_addr metadata_buf_addr;
112 struct msgbuf_buf_addr data_buf_addr;
113};
114
115struct msgbuf_rx_ioctl_resp_or_event {
116 struct msgbuf_common_hdr msg;
117 __le16 host_buf_len;
118 __le16 rsvd0[3];
119 struct msgbuf_buf_addr host_buf_addr;
120 __le32 rsvd1[4];
121};
122
123struct msgbuf_completion_hdr {
124 __le16 status;
125 __le16 flow_ring_id;
126};
127
128
129struct msgbuf_gen_status {
130 struct msgbuf_common_hdr msg;
131 struct msgbuf_completion_hdr compl_hdr;
132 __le16 write_idx;
133 __le32 rsvd0[3];
134};
135
136
137struct msgbuf_ring_status {
138 struct msgbuf_common_hdr msg;
139 struct msgbuf_completion_hdr compl_hdr;
140 __le16 write_idx;
141 __le16 rsvd0[5];
142};
143
144struct msgbuf_rx_event {
145 struct msgbuf_common_hdr msg;
146 struct msgbuf_completion_hdr compl_hdr;
147 __le16 event_data_len;
148 __le16 seqnum;
149 __le16 rsvd0[4];
150};
151
152struct msgbuf_ioctl_resp_hdr {
153 struct msgbuf_common_hdr msg;
154 struct msgbuf_completion_hdr compl_hdr;
155 __le16 resp_len;
156 __le16 trans_id;
157 __le32 cmd;
158 __le32 rsvd0;
159};
160
161struct msgbuf_tx_status {
162 struct msgbuf_common_hdr msg;
163 struct msgbuf_completion_hdr compl_hdr;
164 __le16 metadata_len;
165 __le16 tx_status;
166};
167
168struct msgbuf_rx_complete {
169 struct msgbuf_common_hdr msg;
170 struct msgbuf_completion_hdr compl_hdr;
171 __le16 metadata_len;
172 __le16 data_len;
173 __le16 data_offset;
174 __le16 flags;
175 __le32 rx_status_0;
176 __le32 rx_status_1;
177 __le32 rsvd0;
178};
179
180struct msgbuf_tx_flowring_create_req {
181 struct msgbuf_common_hdr msg;
182 u8 da[ETH_ALEN];
183 u8 sa[ETH_ALEN];
184 u8 tid;
185 u8 if_flags;
186 __le16 flow_ring_id;
187 u8 tc;
188 u8 priority;
189 __le16 int_vector;
190 __le16 max_items;
191 __le16 len_item;
192 struct msgbuf_buf_addr flow_ring_addr;
193};
194
195struct msgbuf_tx_flowring_delete_req {
196 struct msgbuf_common_hdr msg;
197 __le16 flow_ring_id;
198 __le16 reason;
199 __le32 rsvd0[7];
200};
201
202struct msgbuf_flowring_create_resp {
203 struct msgbuf_common_hdr msg;
204 struct msgbuf_completion_hdr compl_hdr;
205 __le32 rsvd0[3];
206};
207
208struct msgbuf_flowring_delete_resp {
209 struct msgbuf_common_hdr msg;
210 struct msgbuf_completion_hdr compl_hdr;
211 __le32 rsvd0[3];
212};
213
214struct msgbuf_flowring_flush_resp {
215 struct msgbuf_common_hdr msg;
216 struct msgbuf_completion_hdr compl_hdr;
217 __le32 rsvd0[3];
218};
219
220struct brcmf_msgbuf_work_item {
221 struct list_head queue;
222 u32 flowid;
223 int ifidx;
224 u8 sa[ETH_ALEN];
225 u8 da[ETH_ALEN];
226};
227
228struct brcmf_msgbuf {
229 struct brcmf_pub *drvr;
230
231 struct brcmf_commonring **commonrings;
232 struct brcmf_commonring **flowrings;
233 dma_addr_t *flowring_dma_handle;
234
235 u16 max_flowrings;
236 u16 max_submissionrings;
237 u16 max_completionrings;
238
239 u16 rx_dataoffset;
240 u32 max_rxbufpost;
241 u16 rx_metadata_offset;
242 u32 rxbufpost;
243
244 u32 max_ioctlrespbuf;
245 u32 cur_ioctlrespbuf;
246 u32 max_eventbuf;
247 u32 cur_eventbuf;
248
249 void *ioctbuf;
250 dma_addr_t ioctbuf_handle;
251 u32 ioctbuf_phys_hi;
252 u32 ioctbuf_phys_lo;
253 int ioctl_resp_status;
254 u32 ioctl_resp_ret_len;
255 u32 ioctl_resp_pktid;
256
257 u16 data_seq_no;
258 u16 ioctl_seq_no;
259 u32 reqid;
260 wait_queue_head_t ioctl_resp_wait;
261 bool ctl_completed;
262
263 struct brcmf_msgbuf_pktids *tx_pktids;
264 struct brcmf_msgbuf_pktids *rx_pktids;
265 struct brcmf_flowring *flow;
266
267 struct workqueue_struct *txflow_wq;
268 struct work_struct txflow_work;
269 unsigned long *flow_map;
270 unsigned long *txstatus_done_map;
271
272 struct work_struct flowring_work;
273 spinlock_t flowring_work_lock;
274 struct list_head work_queue;
275};
276
277struct brcmf_msgbuf_pktid {
278 atomic_t allocated;
279 u16 data_offset;
280 struct sk_buff *skb;
281 dma_addr_t physaddr;
282};
283
284struct brcmf_msgbuf_pktids {
285 u32 array_size;
286 u32 last_allocated_idx;
287 enum dma_data_direction direction;
288 struct brcmf_msgbuf_pktid *array;
289};
290
291static void brcmf_msgbuf_rxbuf_ioctlresp_post(struct brcmf_msgbuf *msgbuf);
292
293
294static struct brcmf_msgbuf_pktids *
295brcmf_msgbuf_init_pktids(u32 nr_array_entries,
296 enum dma_data_direction direction)
297{
298 struct brcmf_msgbuf_pktid *array;
299 struct brcmf_msgbuf_pktids *pktids;
300
301 array = kcalloc(nr_array_entries, sizeof(*array), GFP_KERNEL);
302 if (!array)
303 return NULL;
304
305 pktids = kzalloc(sizeof(*pktids), GFP_KERNEL);
306 if (!pktids) {
307 kfree(array);
308 return NULL;
309 }
310 pktids->array = array;
311 pktids->array_size = nr_array_entries;
312
313 return pktids;
314}
315
316
317static int
318brcmf_msgbuf_alloc_pktid(struct device *dev,
319 struct brcmf_msgbuf_pktids *pktids,
320 struct sk_buff *skb, u16 data_offset,
321 dma_addr_t *physaddr, u32 *idx)
322{
323 struct brcmf_msgbuf_pktid *array;
324 u32 count;
325
326 array = pktids->array;
327
328 *physaddr = dma_map_single(dev, skb->data + data_offset,
329 skb->len - data_offset, pktids->direction);
330
331 if (dma_mapping_error(dev, *physaddr)) {
332 brcmf_err("dma_map_single failed !!\n");
333 return -ENOMEM;
334 }
335
336 *idx = pktids->last_allocated_idx;
337
338 count = 0;
339 do {
340 (*idx)++;
341 if (*idx == pktids->array_size)
342 *idx = 0;
343 if (array[*idx].allocated.counter == 0)
344 if (atomic_cmpxchg(&array[*idx].allocated, 0, 1) == 0)
345 break;
346 count++;
347 } while (count < pktids->array_size);
348
349 if (count == pktids->array_size)
350 return -ENOMEM;
351
352 array[*idx].data_offset = data_offset;
353 array[*idx].physaddr = *physaddr;
354 array[*idx].skb = skb;
355
356 pktids->last_allocated_idx = *idx;
357
358 return 0;
359}
360
361
362static struct sk_buff *
363brcmf_msgbuf_get_pktid(struct device *dev, struct brcmf_msgbuf_pktids *pktids,
364 u32 idx)
365{
366 struct brcmf_msgbuf_pktid *pktid;
367 struct sk_buff *skb;
368
369 if (idx >= pktids->array_size) {
370 brcmf_err("Invalid packet id %d (max %d)\n", idx,
371 pktids->array_size);
372 return NULL;
373 }
374 if (pktids->array[idx].allocated.counter) {
375 pktid = &pktids->array[idx];
376 dma_unmap_single(dev, pktid->physaddr,
377 pktid->skb->len - pktid->data_offset,
378 pktids->direction);
379 skb = pktid->skb;
380 pktid->allocated.counter = 0;
381 return skb;
382 } else {
383 brcmf_err("Invalid packet id %d (not in use)\n", idx);
384 }
385
386 return NULL;
387}
388
389
390static void
391brcmf_msgbuf_release_array(struct device *dev,
392 struct brcmf_msgbuf_pktids *pktids)
393{
394 struct brcmf_msgbuf_pktid *array;
395 struct brcmf_msgbuf_pktid *pktid;
396 u32 count;
397
398 array = pktids->array;
399 count = 0;
400 do {
401 if (array[count].allocated.counter) {
402 pktid = &array[count];
403 dma_unmap_single(dev, pktid->physaddr,
404 pktid->skb->len - pktid->data_offset,
405 pktids->direction);
406 brcmu_pkt_buf_free_skb(pktid->skb);
407 }
408 count++;
409 } while (count < pktids->array_size);
410
411 kfree(array);
412 kfree(pktids);
413}
414
415
416static void brcmf_msgbuf_release_pktids(struct brcmf_msgbuf *msgbuf)
417{
418 if (msgbuf->rx_pktids)
419 brcmf_msgbuf_release_array(msgbuf->drvr->bus_if->dev,
420 msgbuf->rx_pktids);
421 if (msgbuf->tx_pktids)
422 brcmf_msgbuf_release_array(msgbuf->drvr->bus_if->dev,
423 msgbuf->tx_pktids);
424}
425
426
427static int brcmf_msgbuf_tx_ioctl(struct brcmf_pub *drvr, int ifidx,
428 uint cmd, void *buf, uint len)
429{
430 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
431 struct brcmf_commonring *commonring;
432 struct msgbuf_ioctl_req_hdr *request;
433 u16 buf_len;
434 void *ret_ptr;
435 int err;
436
437 commonring = msgbuf->commonrings[BRCMF_H2D_MSGRING_CONTROL_SUBMIT];
438 brcmf_commonring_lock(commonring);
439 ret_ptr = brcmf_commonring_reserve_for_write(commonring);
440 if (!ret_ptr) {
441 bphy_err(drvr, "Failed to reserve space in commonring\n");
442 brcmf_commonring_unlock(commonring);
443 return -ENOMEM;
444 }
445
446 msgbuf->reqid++;
447
448 request = (struct msgbuf_ioctl_req_hdr *)ret_ptr;
449 request->msg.msgtype = MSGBUF_TYPE_IOCTLPTR_REQ;
450 request->msg.ifidx = (u8)ifidx;
451 request->msg.flags = 0;
452 request->msg.request_id = cpu_to_le32(BRCMF_IOCTL_REQ_PKTID);
453 request->cmd = cpu_to_le32(cmd);
454 request->output_buf_len = cpu_to_le16(len);
455 request->trans_id = cpu_to_le16(msgbuf->reqid);
456
457 buf_len = min_t(u16, len, BRCMF_TX_IOCTL_MAX_MSG_SIZE);
458 request->input_buf_len = cpu_to_le16(buf_len);
459 request->req_buf_addr.high_addr = cpu_to_le32(msgbuf->ioctbuf_phys_hi);
460 request->req_buf_addr.low_addr = cpu_to_le32(msgbuf->ioctbuf_phys_lo);
461 if (buf)
462 memcpy(msgbuf->ioctbuf, buf, buf_len);
463 else
464 memset(msgbuf->ioctbuf, 0, buf_len);
465
466 err = brcmf_commonring_write_complete(commonring);
467 brcmf_commonring_unlock(commonring);
468
469 return err;
470}
471
472
473static int brcmf_msgbuf_ioctl_resp_wait(struct brcmf_msgbuf *msgbuf)
474{
475 return wait_event_timeout(msgbuf->ioctl_resp_wait,
476 msgbuf->ctl_completed,
477 MSGBUF_IOCTL_RESP_TIMEOUT);
478}
479
480
481static void brcmf_msgbuf_ioctl_resp_wake(struct brcmf_msgbuf *msgbuf)
482{
483 msgbuf->ctl_completed = true;
484 wake_up(&msgbuf->ioctl_resp_wait);
485}
486
487
488static int brcmf_msgbuf_query_dcmd(struct brcmf_pub *drvr, int ifidx,
489 uint cmd, void *buf, uint len, int *fwerr)
490{
491 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
492 struct sk_buff *skb = NULL;
493 int timeout;
494 int err;
495
496 brcmf_dbg(MSGBUF, "ifidx=%d, cmd=%d, len=%d\n", ifidx, cmd, len);
497 *fwerr = 0;
498 msgbuf->ctl_completed = false;
499 err = brcmf_msgbuf_tx_ioctl(drvr, ifidx, cmd, buf, len);
500 if (err)
501 return err;
502
503 timeout = brcmf_msgbuf_ioctl_resp_wait(msgbuf);
504 if (!timeout) {
505 bphy_err(drvr, "Timeout on response for query command\n");
506 return -EIO;
507 }
508
509 skb = brcmf_msgbuf_get_pktid(msgbuf->drvr->bus_if->dev,
510 msgbuf->rx_pktids,
511 msgbuf->ioctl_resp_pktid);
512 if (msgbuf->ioctl_resp_ret_len != 0) {
513 if (!skb)
514 return -EBADF;
515
516 memcpy(buf, skb->data, (len < msgbuf->ioctl_resp_ret_len) ?
517 len : msgbuf->ioctl_resp_ret_len);
518 }
519 brcmu_pkt_buf_free_skb(skb);
520
521 *fwerr = msgbuf->ioctl_resp_status;
522 return 0;
523}
524
525
526static int brcmf_msgbuf_set_dcmd(struct brcmf_pub *drvr, int ifidx,
527 uint cmd, void *buf, uint len, int *fwerr)
528{
529 return brcmf_msgbuf_query_dcmd(drvr, ifidx, cmd, buf, len, fwerr);
530}
531
532
533static int brcmf_msgbuf_hdrpull(struct brcmf_pub *drvr, bool do_fws,
534 struct sk_buff *skb, struct brcmf_if **ifp)
535{
536 return -ENODEV;
537}
538
539static void brcmf_msgbuf_rxreorder(struct brcmf_if *ifp, struct sk_buff *skb)
540{
541}
542
543static void
544brcmf_msgbuf_remove_flowring(struct brcmf_msgbuf *msgbuf, u16 flowid)
545{
546 u32 dma_sz;
547 void *dma_buf;
548
549 brcmf_dbg(MSGBUF, "Removing flowring %d\n", flowid);
550
551 dma_sz = BRCMF_H2D_TXFLOWRING_MAX_ITEM * BRCMF_H2D_TXFLOWRING_ITEMSIZE;
552 dma_buf = msgbuf->flowrings[flowid]->buf_addr;
553 dma_free_coherent(msgbuf->drvr->bus_if->dev, dma_sz, dma_buf,
554 msgbuf->flowring_dma_handle[flowid]);
555
556 brcmf_flowring_delete(msgbuf->flow, flowid);
557}
558
559
560static struct brcmf_msgbuf_work_item *
561brcmf_msgbuf_dequeue_work(struct brcmf_msgbuf *msgbuf)
562{
563 struct brcmf_msgbuf_work_item *work = NULL;
564 ulong flags;
565
566 spin_lock_irqsave(&msgbuf->flowring_work_lock, flags);
567 if (!list_empty(&msgbuf->work_queue)) {
568 work = list_first_entry(&msgbuf->work_queue,
569 struct brcmf_msgbuf_work_item, queue);
570 list_del(&work->queue);
571 }
572 spin_unlock_irqrestore(&msgbuf->flowring_work_lock, flags);
573
574 return work;
575}
576
577
578static u32
579brcmf_msgbuf_flowring_create_worker(struct brcmf_msgbuf *msgbuf,
580 struct brcmf_msgbuf_work_item *work)
581{
582 struct brcmf_pub *drvr = msgbuf->drvr;
583 struct msgbuf_tx_flowring_create_req *create;
584 struct brcmf_commonring *commonring;
585 void *ret_ptr;
586 u32 flowid;
587 void *dma_buf;
588 u32 dma_sz;
589 u64 address;
590 int err;
591
592 flowid = work->flowid;
593 dma_sz = BRCMF_H2D_TXFLOWRING_MAX_ITEM * BRCMF_H2D_TXFLOWRING_ITEMSIZE;
594 dma_buf = dma_alloc_coherent(msgbuf->drvr->bus_if->dev, dma_sz,
595 &msgbuf->flowring_dma_handle[flowid],
596 GFP_KERNEL);
597 if (!dma_buf) {
598 bphy_err(drvr, "dma_alloc_coherent failed\n");
599 brcmf_flowring_delete(msgbuf->flow, flowid);
600 return BRCMF_FLOWRING_INVALID_ID;
601 }
602
603 brcmf_commonring_config(msgbuf->flowrings[flowid],
604 BRCMF_H2D_TXFLOWRING_MAX_ITEM,
605 BRCMF_H2D_TXFLOWRING_ITEMSIZE, dma_buf);
606
607 commonring = msgbuf->commonrings[BRCMF_H2D_MSGRING_CONTROL_SUBMIT];
608 brcmf_commonring_lock(commonring);
609 ret_ptr = brcmf_commonring_reserve_for_write(commonring);
610 if (!ret_ptr) {
611 bphy_err(drvr, "Failed to reserve space in commonring\n");
612 brcmf_commonring_unlock(commonring);
613 brcmf_msgbuf_remove_flowring(msgbuf, flowid);
614 return BRCMF_FLOWRING_INVALID_ID;
615 }
616
617 create = (struct msgbuf_tx_flowring_create_req *)ret_ptr;
618 create->msg.msgtype = MSGBUF_TYPE_FLOW_RING_CREATE;
619 create->msg.ifidx = work->ifidx;
620 create->msg.request_id = 0;
621 create->tid = brcmf_flowring_tid(msgbuf->flow, flowid);
622 create->flow_ring_id = cpu_to_le16(flowid +
623 BRCMF_H2D_MSGRING_FLOWRING_IDSTART);
624 memcpy(create->sa, work->sa, ETH_ALEN);
625 memcpy(create->da, work->da, ETH_ALEN);
626 address = (u64)msgbuf->flowring_dma_handle[flowid];
627 create->flow_ring_addr.high_addr = cpu_to_le32(address >> 32);
628 create->flow_ring_addr.low_addr = cpu_to_le32(address & 0xffffffff);
629 create->max_items = cpu_to_le16(BRCMF_H2D_TXFLOWRING_MAX_ITEM);
630 create->len_item = cpu_to_le16(BRCMF_H2D_TXFLOWRING_ITEMSIZE);
631
632 brcmf_dbg(MSGBUF, "Send Flow Create Req flow ID %d for peer %pM prio %d ifindex %d\n",
633 flowid, work->da, create->tid, work->ifidx);
634
635 err = brcmf_commonring_write_complete(commonring);
636 brcmf_commonring_unlock(commonring);
637 if (err) {
638 bphy_err(drvr, "Failed to write commonring\n");
639 brcmf_msgbuf_remove_flowring(msgbuf, flowid);
640 return BRCMF_FLOWRING_INVALID_ID;
641 }
642
643 return flowid;
644}
645
646
647static void brcmf_msgbuf_flowring_worker(struct work_struct *work)
648{
649 struct brcmf_msgbuf *msgbuf;
650 struct brcmf_msgbuf_work_item *create;
651
652 msgbuf = container_of(work, struct brcmf_msgbuf, flowring_work);
653
654 while ((create = brcmf_msgbuf_dequeue_work(msgbuf))) {
655 brcmf_msgbuf_flowring_create_worker(msgbuf, create);
656 kfree(create);
657 }
658}
659
660
661static u32 brcmf_msgbuf_flowring_create(struct brcmf_msgbuf *msgbuf, int ifidx,
662 struct sk_buff *skb)
663{
664 struct brcmf_msgbuf_work_item *create;
665 struct ethhdr *eh = (struct ethhdr *)(skb->data);
666 u32 flowid;
667 ulong flags;
668
669 create = kzalloc(sizeof(*create), GFP_ATOMIC);
670 if (create == NULL)
671 return BRCMF_FLOWRING_INVALID_ID;
672
673 flowid = brcmf_flowring_create(msgbuf->flow, eh->h_dest,
674 skb->priority, ifidx);
675 if (flowid == BRCMF_FLOWRING_INVALID_ID) {
676 kfree(create);
677 return flowid;
678 }
679
680 create->flowid = flowid;
681 create->ifidx = ifidx;
682 memcpy(create->sa, eh->h_source, ETH_ALEN);
683 memcpy(create->da, eh->h_dest, ETH_ALEN);
684
685 spin_lock_irqsave(&msgbuf->flowring_work_lock, flags);
686 list_add_tail(&create->queue, &msgbuf->work_queue);
687 spin_unlock_irqrestore(&msgbuf->flowring_work_lock, flags);
688 schedule_work(&msgbuf->flowring_work);
689
690 return flowid;
691}
692
693
694static void brcmf_msgbuf_txflow(struct brcmf_msgbuf *msgbuf, u16 flowid)
695{
696 struct brcmf_flowring *flow = msgbuf->flow;
697 struct brcmf_pub *drvr = msgbuf->drvr;
698 struct brcmf_commonring *commonring;
699 void *ret_ptr;
700 u32 count;
701 struct sk_buff *skb;
702 dma_addr_t physaddr;
703 u32 pktid;
704 struct msgbuf_tx_msghdr *tx_msghdr;
705 u64 address;
706
707 commonring = msgbuf->flowrings[flowid];
708 if (!brcmf_commonring_write_available(commonring))
709 return;
710
711 brcmf_commonring_lock(commonring);
712
713 count = BRCMF_MSGBUF_TX_FLUSH_CNT2 - BRCMF_MSGBUF_TX_FLUSH_CNT1;
714 while (brcmf_flowring_qlen(flow, flowid)) {
715 skb = brcmf_flowring_dequeue(flow, flowid);
716 if (skb == NULL) {
717 bphy_err(drvr, "No SKB, but qlen %d\n",
718 brcmf_flowring_qlen(flow, flowid));
719 break;
720 }
721 skb_orphan(skb);
722 if (brcmf_msgbuf_alloc_pktid(msgbuf->drvr->bus_if->dev,
723 msgbuf->tx_pktids, skb, ETH_HLEN,
724 &physaddr, &pktid)) {
725 brcmf_flowring_reinsert(flow, flowid, skb);
726 bphy_err(drvr, "No PKTID available !!\n");
727 break;
728 }
729 ret_ptr = brcmf_commonring_reserve_for_write(commonring);
730 if (!ret_ptr) {
731 brcmf_msgbuf_get_pktid(msgbuf->drvr->bus_if->dev,
732 msgbuf->tx_pktids, pktid);
733 brcmf_flowring_reinsert(flow, flowid, skb);
734 break;
735 }
736 count++;
737
738 tx_msghdr = (struct msgbuf_tx_msghdr *)ret_ptr;
739
740 tx_msghdr->msg.msgtype = MSGBUF_TYPE_TX_POST;
741 tx_msghdr->msg.request_id = cpu_to_le32(pktid + 1);
742 tx_msghdr->msg.ifidx = brcmf_flowring_ifidx_get(flow, flowid);
743 tx_msghdr->flags = BRCMF_MSGBUF_PKT_FLAGS_FRAME_802_3;
744 tx_msghdr->flags |= (skb->priority & 0x07) <<
745 BRCMF_MSGBUF_PKT_FLAGS_PRIO_SHIFT;
746 tx_msghdr->seg_cnt = 1;
747 memcpy(tx_msghdr->txhdr, skb->data, ETH_HLEN);
748 tx_msghdr->data_len = cpu_to_le16(skb->len - ETH_HLEN);
749 address = (u64)physaddr;
750 tx_msghdr->data_buf_addr.high_addr = cpu_to_le32(address >> 32);
751 tx_msghdr->data_buf_addr.low_addr =
752 cpu_to_le32(address & 0xffffffff);
753 tx_msghdr->metadata_buf_len = 0;
754 tx_msghdr->metadata_buf_addr.high_addr = 0;
755 tx_msghdr->metadata_buf_addr.low_addr = 0;
756 atomic_inc(&commonring->outstanding_tx);
757 if (count >= BRCMF_MSGBUF_TX_FLUSH_CNT2) {
758 brcmf_commonring_write_complete(commonring);
759 count = 0;
760 }
761 }
762 if (count)
763 brcmf_commonring_write_complete(commonring);
764 brcmf_commonring_unlock(commonring);
765}
766
767
768static void brcmf_msgbuf_txflow_worker(struct work_struct *worker)
769{
770 struct brcmf_msgbuf *msgbuf;
771 u32 flowid;
772
773 msgbuf = container_of(worker, struct brcmf_msgbuf, txflow_work);
774 for_each_set_bit(flowid, msgbuf->flow_map, msgbuf->max_flowrings) {
775 clear_bit(flowid, msgbuf->flow_map);
776 brcmf_msgbuf_txflow(msgbuf, flowid);
777 }
778}
779
780
781static int brcmf_msgbuf_schedule_txdata(struct brcmf_msgbuf *msgbuf, u32 flowid,
782 bool force)
783{
784 struct brcmf_commonring *commonring;
785
786 set_bit(flowid, msgbuf->flow_map);
787 commonring = msgbuf->flowrings[flowid];
788 if ((force) || (atomic_read(&commonring->outstanding_tx) <
789 BRCMF_MSGBUF_DELAY_TXWORKER_THRS))
790 queue_work(msgbuf->txflow_wq, &msgbuf->txflow_work);
791
792 return 0;
793}
794
795
796static int brcmf_msgbuf_tx_queue_data(struct brcmf_pub *drvr, int ifidx,
797 struct sk_buff *skb)
798{
799 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
800 struct brcmf_flowring *flow = msgbuf->flow;
801 struct ethhdr *eh = (struct ethhdr *)(skb->data);
802 u32 flowid;
803 u32 queue_count;
804 bool force;
805
806 flowid = brcmf_flowring_lookup(flow, eh->h_dest, skb->priority, ifidx);
807 if (flowid == BRCMF_FLOWRING_INVALID_ID) {
808 flowid = brcmf_msgbuf_flowring_create(msgbuf, ifidx, skb);
809 if (flowid == BRCMF_FLOWRING_INVALID_ID)
810 return -ENOMEM;
811 }
812 queue_count = brcmf_flowring_enqueue(flow, flowid, skb);
813 force = ((queue_count % BRCMF_MSGBUF_TRICKLE_TXWORKER_THRS) == 0);
814 brcmf_msgbuf_schedule_txdata(msgbuf, flowid, force);
815
816 return 0;
817}
818
819
820static void
821brcmf_msgbuf_configure_addr_mode(struct brcmf_pub *drvr, int ifidx,
822 enum proto_addr_mode addr_mode)
823{
824 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
825
826 brcmf_flowring_configure_addr_mode(msgbuf->flow, ifidx, addr_mode);
827}
828
829
830static void
831brcmf_msgbuf_delete_peer(struct brcmf_pub *drvr, int ifidx, u8 peer[ETH_ALEN])
832{
833 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
834
835 brcmf_flowring_delete_peer(msgbuf->flow, ifidx, peer);
836}
837
838
839static void
840brcmf_msgbuf_add_tdls_peer(struct brcmf_pub *drvr, int ifidx, u8 peer[ETH_ALEN])
841{
842 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
843
844 brcmf_flowring_add_tdls_peer(msgbuf->flow, ifidx, peer);
845}
846
847
848static void
849brcmf_msgbuf_process_ioctl_complete(struct brcmf_msgbuf *msgbuf, void *buf)
850{
851 struct msgbuf_ioctl_resp_hdr *ioctl_resp;
852
853 ioctl_resp = (struct msgbuf_ioctl_resp_hdr *)buf;
854
855 msgbuf->ioctl_resp_status =
856 (s16)le16_to_cpu(ioctl_resp->compl_hdr.status);
857 msgbuf->ioctl_resp_ret_len = le16_to_cpu(ioctl_resp->resp_len);
858 msgbuf->ioctl_resp_pktid = le32_to_cpu(ioctl_resp->msg.request_id);
859
860 brcmf_msgbuf_ioctl_resp_wake(msgbuf);
861
862 if (msgbuf->cur_ioctlrespbuf)
863 msgbuf->cur_ioctlrespbuf--;
864 brcmf_msgbuf_rxbuf_ioctlresp_post(msgbuf);
865}
866
867
868static void
869brcmf_msgbuf_process_txstatus(struct brcmf_msgbuf *msgbuf, void *buf)
870{
871 struct brcmf_commonring *commonring;
872 struct msgbuf_tx_status *tx_status;
873 u32 idx;
874 struct sk_buff *skb;
875 u16 flowid;
876
877 tx_status = (struct msgbuf_tx_status *)buf;
878 idx = le32_to_cpu(tx_status->msg.request_id) - 1;
879 flowid = le16_to_cpu(tx_status->compl_hdr.flow_ring_id);
880 flowid -= BRCMF_H2D_MSGRING_FLOWRING_IDSTART;
881 skb = brcmf_msgbuf_get_pktid(msgbuf->drvr->bus_if->dev,
882 msgbuf->tx_pktids, idx);
883 if (!skb)
884 return;
885
886 set_bit(flowid, msgbuf->txstatus_done_map);
887 commonring = msgbuf->flowrings[flowid];
888 atomic_dec(&commonring->outstanding_tx);
889
890 brcmf_txfinalize(brcmf_get_ifp(msgbuf->drvr, tx_status->msg.ifidx),
891 skb, true);
892}
893
894
895static u32 brcmf_msgbuf_rxbuf_data_post(struct brcmf_msgbuf *msgbuf, u32 count)
896{
897 struct brcmf_pub *drvr = msgbuf->drvr;
898 struct brcmf_commonring *commonring;
899 void *ret_ptr;
900 struct sk_buff *skb;
901 u16 alloced;
902 u32 pktlen;
903 dma_addr_t physaddr;
904 struct msgbuf_rx_bufpost *rx_bufpost;
905 u64 address;
906 u32 pktid;
907 u32 i;
908
909 commonring = msgbuf->commonrings[BRCMF_H2D_MSGRING_RXPOST_SUBMIT];
910 ret_ptr = brcmf_commonring_reserve_for_write_multiple(commonring,
911 count,
912 &alloced);
913 if (!ret_ptr) {
914 brcmf_dbg(MSGBUF, "Failed to reserve space in commonring\n");
915 return 0;
916 }
917
918 for (i = 0; i < alloced; i++) {
919 rx_bufpost = (struct msgbuf_rx_bufpost *)ret_ptr;
920 memset(rx_bufpost, 0, sizeof(*rx_bufpost));
921
922 skb = brcmu_pkt_buf_get_skb(BRCMF_MSGBUF_MAX_PKT_SIZE);
923
924 if (skb == NULL) {
925 bphy_err(drvr, "Failed to alloc SKB\n");
926 brcmf_commonring_write_cancel(commonring, alloced - i);
927 break;
928 }
929
930 pktlen = skb->len;
931 if (brcmf_msgbuf_alloc_pktid(msgbuf->drvr->bus_if->dev,
932 msgbuf->rx_pktids, skb, 0,
933 &physaddr, &pktid)) {
934 dev_kfree_skb_any(skb);
935 bphy_err(drvr, "No PKTID available !!\n");
936 brcmf_commonring_write_cancel(commonring, alloced - i);
937 break;
938 }
939
940 if (msgbuf->rx_metadata_offset) {
941 address = (u64)physaddr;
942 rx_bufpost->metadata_buf_len =
943 cpu_to_le16(msgbuf->rx_metadata_offset);
944 rx_bufpost->metadata_buf_addr.high_addr =
945 cpu_to_le32(address >> 32);
946 rx_bufpost->metadata_buf_addr.low_addr =
947 cpu_to_le32(address & 0xffffffff);
948
949 skb_pull(skb, msgbuf->rx_metadata_offset);
950 pktlen = skb->len;
951 physaddr += msgbuf->rx_metadata_offset;
952 }
953 rx_bufpost->msg.msgtype = MSGBUF_TYPE_RXBUF_POST;
954 rx_bufpost->msg.request_id = cpu_to_le32(pktid);
955
956 address = (u64)physaddr;
957 rx_bufpost->data_buf_len = cpu_to_le16((u16)pktlen);
958 rx_bufpost->data_buf_addr.high_addr =
959 cpu_to_le32(address >> 32);
960 rx_bufpost->data_buf_addr.low_addr =
961 cpu_to_le32(address & 0xffffffff);
962
963 ret_ptr += brcmf_commonring_len_item(commonring);
964 }
965
966 if (i)
967 brcmf_commonring_write_complete(commonring);
968
969 return i;
970}
971
972
973static void
974brcmf_msgbuf_rxbuf_data_fill(struct brcmf_msgbuf *msgbuf)
975{
976 u32 fillbufs;
977 u32 retcount;
978
979 fillbufs = msgbuf->max_rxbufpost - msgbuf->rxbufpost;
980
981 while (fillbufs) {
982 retcount = brcmf_msgbuf_rxbuf_data_post(msgbuf, fillbufs);
983 if (!retcount)
984 break;
985 msgbuf->rxbufpost += retcount;
986 fillbufs -= retcount;
987 }
988}
989
990
991static void
992brcmf_msgbuf_update_rxbufpost_count(struct brcmf_msgbuf *msgbuf, u16 rxcnt)
993{
994 msgbuf->rxbufpost -= rxcnt;
995 if (msgbuf->rxbufpost <= (msgbuf->max_rxbufpost -
996 BRCMF_MSGBUF_RXBUFPOST_THRESHOLD))
997 brcmf_msgbuf_rxbuf_data_fill(msgbuf);
998}
999
1000
1001static u32
1002brcmf_msgbuf_rxbuf_ctrl_post(struct brcmf_msgbuf *msgbuf, bool event_buf,
1003 u32 count)
1004{
1005 struct brcmf_pub *drvr = msgbuf->drvr;
1006 struct brcmf_commonring *commonring;
1007 void *ret_ptr;
1008 struct sk_buff *skb;
1009 u16 alloced;
1010 u32 pktlen;
1011 dma_addr_t physaddr;
1012 struct msgbuf_rx_ioctl_resp_or_event *rx_bufpost;
1013 u64 address;
1014 u32 pktid;
1015 u32 i;
1016
1017 commonring = msgbuf->commonrings[BRCMF_H2D_MSGRING_CONTROL_SUBMIT];
1018 brcmf_commonring_lock(commonring);
1019 ret_ptr = brcmf_commonring_reserve_for_write_multiple(commonring,
1020 count,
1021 &alloced);
1022 if (!ret_ptr) {
1023 bphy_err(drvr, "Failed to reserve space in commonring\n");
1024 brcmf_commonring_unlock(commonring);
1025 return 0;
1026 }
1027
1028 for (i = 0; i < alloced; i++) {
1029 rx_bufpost = (struct msgbuf_rx_ioctl_resp_or_event *)ret_ptr;
1030 memset(rx_bufpost, 0, sizeof(*rx_bufpost));
1031
1032 skb = brcmu_pkt_buf_get_skb(BRCMF_MSGBUF_MAX_CTL_PKT_SIZE);
1033
1034 if (skb == NULL) {
1035 bphy_err(drvr, "Failed to alloc SKB\n");
1036 brcmf_commonring_write_cancel(commonring, alloced - i);
1037 break;
1038 }
1039
1040 pktlen = skb->len;
1041 if (brcmf_msgbuf_alloc_pktid(msgbuf->drvr->bus_if->dev,
1042 msgbuf->rx_pktids, skb, 0,
1043 &physaddr, &pktid)) {
1044 dev_kfree_skb_any(skb);
1045 bphy_err(drvr, "No PKTID available !!\n");
1046 brcmf_commonring_write_cancel(commonring, alloced - i);
1047 break;
1048 }
1049 if (event_buf)
1050 rx_bufpost->msg.msgtype = MSGBUF_TYPE_EVENT_BUF_POST;
1051 else
1052 rx_bufpost->msg.msgtype =
1053 MSGBUF_TYPE_IOCTLRESP_BUF_POST;
1054 rx_bufpost->msg.request_id = cpu_to_le32(pktid);
1055
1056 address = (u64)physaddr;
1057 rx_bufpost->host_buf_len = cpu_to_le16((u16)pktlen);
1058 rx_bufpost->host_buf_addr.high_addr =
1059 cpu_to_le32(address >> 32);
1060 rx_bufpost->host_buf_addr.low_addr =
1061 cpu_to_le32(address & 0xffffffff);
1062
1063 ret_ptr += brcmf_commonring_len_item(commonring);
1064 }
1065
1066 if (i)
1067 brcmf_commonring_write_complete(commonring);
1068
1069 brcmf_commonring_unlock(commonring);
1070
1071 return i;
1072}
1073
1074
1075static void brcmf_msgbuf_rxbuf_ioctlresp_post(struct brcmf_msgbuf *msgbuf)
1076{
1077 u32 count;
1078
1079 count = msgbuf->max_ioctlrespbuf - msgbuf->cur_ioctlrespbuf;
1080 count = brcmf_msgbuf_rxbuf_ctrl_post(msgbuf, false, count);
1081 msgbuf->cur_ioctlrespbuf += count;
1082}
1083
1084
1085static void brcmf_msgbuf_rxbuf_event_post(struct brcmf_msgbuf *msgbuf)
1086{
1087 u32 count;
1088
1089 count = msgbuf->max_eventbuf - msgbuf->cur_eventbuf;
1090 count = brcmf_msgbuf_rxbuf_ctrl_post(msgbuf, true, count);
1091 msgbuf->cur_eventbuf += count;
1092}
1093
1094
1095static void brcmf_msgbuf_process_event(struct brcmf_msgbuf *msgbuf, void *buf)
1096{
1097 struct brcmf_pub *drvr = msgbuf->drvr;
1098 struct msgbuf_rx_event *event;
1099 u32 idx;
1100 u16 buflen;
1101 struct sk_buff *skb;
1102 struct brcmf_if *ifp;
1103
1104 event = (struct msgbuf_rx_event *)buf;
1105 idx = le32_to_cpu(event->msg.request_id);
1106 buflen = le16_to_cpu(event->event_data_len);
1107
1108 if (msgbuf->cur_eventbuf)
1109 msgbuf->cur_eventbuf--;
1110 brcmf_msgbuf_rxbuf_event_post(msgbuf);
1111
1112 skb = brcmf_msgbuf_get_pktid(msgbuf->drvr->bus_if->dev,
1113 msgbuf->rx_pktids, idx);
1114 if (!skb)
1115 return;
1116
1117 if (msgbuf->rx_dataoffset)
1118 skb_pull(skb, msgbuf->rx_dataoffset);
1119
1120 skb_trim(skb, buflen);
1121
1122 ifp = brcmf_get_ifp(msgbuf->drvr, event->msg.ifidx);
1123 if (!ifp || !ifp->ndev) {
1124 bphy_err(drvr, "Received pkt for invalid ifidx %d\n",
1125 event->msg.ifidx);
1126 goto exit;
1127 }
1128
1129 skb->protocol = eth_type_trans(skb, ifp->ndev);
1130
1131 brcmf_fweh_process_skb(ifp->drvr, skb, 0, GFP_KERNEL);
1132
1133exit:
1134 brcmu_pkt_buf_free_skb(skb);
1135}
1136
1137
1138static void
1139brcmf_msgbuf_process_rx_complete(struct brcmf_msgbuf *msgbuf, void *buf)
1140{
1141 struct brcmf_pub *drvr = msgbuf->drvr;
1142 struct msgbuf_rx_complete *rx_complete;
1143 struct sk_buff *skb;
1144 u16 data_offset;
1145 u16 buflen;
1146 u16 flags;
1147 u32 idx;
1148 struct brcmf_if *ifp;
1149
1150 brcmf_msgbuf_update_rxbufpost_count(msgbuf, 1);
1151
1152 rx_complete = (struct msgbuf_rx_complete *)buf;
1153 data_offset = le16_to_cpu(rx_complete->data_offset);
1154 buflen = le16_to_cpu(rx_complete->data_len);
1155 idx = le32_to_cpu(rx_complete->msg.request_id);
1156 flags = le16_to_cpu(rx_complete->flags);
1157
1158 skb = brcmf_msgbuf_get_pktid(msgbuf->drvr->bus_if->dev,
1159 msgbuf->rx_pktids, idx);
1160 if (!skb)
1161 return;
1162
1163 if (data_offset)
1164 skb_pull(skb, data_offset);
1165 else if (msgbuf->rx_dataoffset)
1166 skb_pull(skb, msgbuf->rx_dataoffset);
1167
1168 skb_trim(skb, buflen);
1169
1170 if ((flags & BRCMF_MSGBUF_PKT_FLAGS_FRAME_MASK) ==
1171 BRCMF_MSGBUF_PKT_FLAGS_FRAME_802_11) {
1172 ifp = msgbuf->drvr->mon_if;
1173
1174 if (!ifp) {
1175 bphy_err(drvr, "Received unexpected monitor pkt\n");
1176 brcmu_pkt_buf_free_skb(skb);
1177 return;
1178 }
1179
1180 brcmf_netif_mon_rx(ifp, skb);
1181 return;
1182 }
1183
1184 ifp = brcmf_get_ifp(msgbuf->drvr, rx_complete->msg.ifidx);
1185 if (!ifp || !ifp->ndev) {
1186 bphy_err(drvr, "Received pkt for invalid ifidx %d\n",
1187 rx_complete->msg.ifidx);
1188 brcmu_pkt_buf_free_skb(skb);
1189 return;
1190 }
1191
1192 skb->protocol = eth_type_trans(skb, ifp->ndev);
1193 brcmf_netif_rx(ifp, skb);
1194}
1195
1196static void brcmf_msgbuf_process_gen_status(struct brcmf_msgbuf *msgbuf,
1197 void *buf)
1198{
1199 struct msgbuf_gen_status *gen_status = buf;
1200 struct brcmf_pub *drvr = msgbuf->drvr;
1201 int err;
1202
1203 err = le16_to_cpu(gen_status->compl_hdr.status);
1204 if (err)
1205 bphy_err(drvr, "Firmware reported general error: %d\n", err);
1206}
1207
1208static void brcmf_msgbuf_process_ring_status(struct brcmf_msgbuf *msgbuf,
1209 void *buf)
1210{
1211 struct msgbuf_ring_status *ring_status = buf;
1212 struct brcmf_pub *drvr = msgbuf->drvr;
1213 int err;
1214
1215 err = le16_to_cpu(ring_status->compl_hdr.status);
1216 if (err) {
1217 int ring = le16_to_cpu(ring_status->compl_hdr.flow_ring_id);
1218
1219 bphy_err(drvr, "Firmware reported ring %d error: %d\n", ring,
1220 err);
1221 }
1222}
1223
1224static void
1225brcmf_msgbuf_process_flow_ring_create_response(struct brcmf_msgbuf *msgbuf,
1226 void *buf)
1227{
1228 struct brcmf_pub *drvr = msgbuf->drvr;
1229 struct msgbuf_flowring_create_resp *flowring_create_resp;
1230 u16 status;
1231 u16 flowid;
1232
1233 flowring_create_resp = (struct msgbuf_flowring_create_resp *)buf;
1234
1235 flowid = le16_to_cpu(flowring_create_resp->compl_hdr.flow_ring_id);
1236 flowid -= BRCMF_H2D_MSGRING_FLOWRING_IDSTART;
1237 status = le16_to_cpu(flowring_create_resp->compl_hdr.status);
1238
1239 if (status) {
1240 bphy_err(drvr, "Flowring creation failed, code %d\n", status);
1241 brcmf_msgbuf_remove_flowring(msgbuf, flowid);
1242 return;
1243 }
1244 brcmf_dbg(MSGBUF, "Flowring %d Create response status %d\n", flowid,
1245 status);
1246
1247 brcmf_flowring_open(msgbuf->flow, flowid);
1248
1249 brcmf_msgbuf_schedule_txdata(msgbuf, flowid, true);
1250}
1251
1252
1253static void
1254brcmf_msgbuf_process_flow_ring_delete_response(struct brcmf_msgbuf *msgbuf,
1255 void *buf)
1256{
1257 struct brcmf_pub *drvr = msgbuf->drvr;
1258 struct msgbuf_flowring_delete_resp *flowring_delete_resp;
1259 u16 status;
1260 u16 flowid;
1261
1262 flowring_delete_resp = (struct msgbuf_flowring_delete_resp *)buf;
1263
1264 flowid = le16_to_cpu(flowring_delete_resp->compl_hdr.flow_ring_id);
1265 flowid -= BRCMF_H2D_MSGRING_FLOWRING_IDSTART;
1266 status = le16_to_cpu(flowring_delete_resp->compl_hdr.status);
1267
1268 if (status) {
1269 bphy_err(drvr, "Flowring deletion failed, code %d\n", status);
1270 brcmf_flowring_delete(msgbuf->flow, flowid);
1271 return;
1272 }
1273 brcmf_dbg(MSGBUF, "Flowring %d Delete response status %d\n", flowid,
1274 status);
1275
1276 brcmf_msgbuf_remove_flowring(msgbuf, flowid);
1277}
1278
1279
1280static void brcmf_msgbuf_process_msgtype(struct brcmf_msgbuf *msgbuf, void *buf)
1281{
1282 struct brcmf_pub *drvr = msgbuf->drvr;
1283 struct msgbuf_common_hdr *msg;
1284
1285 msg = (struct msgbuf_common_hdr *)buf;
1286 switch (msg->msgtype) {
1287 case MSGBUF_TYPE_GEN_STATUS:
1288 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_GEN_STATUS\n");
1289 brcmf_msgbuf_process_gen_status(msgbuf, buf);
1290 break;
1291 case MSGBUF_TYPE_RING_STATUS:
1292 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_RING_STATUS\n");
1293 brcmf_msgbuf_process_ring_status(msgbuf, buf);
1294 break;
1295 case MSGBUF_TYPE_FLOW_RING_CREATE_CMPLT:
1296 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_FLOW_RING_CREATE_CMPLT\n");
1297 brcmf_msgbuf_process_flow_ring_create_response(msgbuf, buf);
1298 break;
1299 case MSGBUF_TYPE_FLOW_RING_DELETE_CMPLT:
1300 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_FLOW_RING_DELETE_CMPLT\n");
1301 brcmf_msgbuf_process_flow_ring_delete_response(msgbuf, buf);
1302 break;
1303 case MSGBUF_TYPE_IOCTLPTR_REQ_ACK:
1304 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_IOCTLPTR_REQ_ACK\n");
1305 break;
1306 case MSGBUF_TYPE_IOCTL_CMPLT:
1307 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_IOCTL_CMPLT\n");
1308 brcmf_msgbuf_process_ioctl_complete(msgbuf, buf);
1309 break;
1310 case MSGBUF_TYPE_WL_EVENT:
1311 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_WL_EVENT\n");
1312 brcmf_msgbuf_process_event(msgbuf, buf);
1313 break;
1314 case MSGBUF_TYPE_TX_STATUS:
1315 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_TX_STATUS\n");
1316 brcmf_msgbuf_process_txstatus(msgbuf, buf);
1317 break;
1318 case MSGBUF_TYPE_RX_CMPLT:
1319 brcmf_dbg(MSGBUF, "MSGBUF_TYPE_RX_CMPLT\n");
1320 brcmf_msgbuf_process_rx_complete(msgbuf, buf);
1321 break;
1322 default:
1323 bphy_err(drvr, "Unsupported msgtype %d\n", msg->msgtype);
1324 break;
1325 }
1326}
1327
1328
1329static void brcmf_msgbuf_process_rx(struct brcmf_msgbuf *msgbuf,
1330 struct brcmf_commonring *commonring)
1331{
1332 void *buf;
1333 u16 count;
1334 u16 processed;
1335
1336again:
1337 buf = brcmf_commonring_get_read_ptr(commonring, &count);
1338 if (buf == NULL)
1339 return;
1340
1341 processed = 0;
1342 while (count) {
1343 brcmf_msgbuf_process_msgtype(msgbuf,
1344 buf + msgbuf->rx_dataoffset);
1345 buf += brcmf_commonring_len_item(commonring);
1346 processed++;
1347 if (processed == BRCMF_MSGBUF_UPDATE_RX_PTR_THRS) {
1348 brcmf_commonring_read_complete(commonring, processed);
1349 processed = 0;
1350 }
1351 count--;
1352 }
1353 if (processed)
1354 brcmf_commonring_read_complete(commonring, processed);
1355
1356 if (commonring->r_ptr == 0)
1357 goto again;
1358}
1359
1360
1361int brcmf_proto_msgbuf_rx_trigger(struct device *dev)
1362{
1363 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1364 struct brcmf_pub *drvr = bus_if->drvr;
1365 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
1366 struct brcmf_commonring *commonring;
1367 void *buf;
1368 u32 flowid;
1369 int qlen;
1370
1371 buf = msgbuf->commonrings[BRCMF_D2H_MSGRING_RX_COMPLETE];
1372 brcmf_msgbuf_process_rx(msgbuf, buf);
1373 buf = msgbuf->commonrings[BRCMF_D2H_MSGRING_TX_COMPLETE];
1374 brcmf_msgbuf_process_rx(msgbuf, buf);
1375 buf = msgbuf->commonrings[BRCMF_D2H_MSGRING_CONTROL_COMPLETE];
1376 brcmf_msgbuf_process_rx(msgbuf, buf);
1377
1378 for_each_set_bit(flowid, msgbuf->txstatus_done_map,
1379 msgbuf->max_flowrings) {
1380 clear_bit(flowid, msgbuf->txstatus_done_map);
1381 commonring = msgbuf->flowrings[flowid];
1382 qlen = brcmf_flowring_qlen(msgbuf->flow, flowid);
1383 if ((qlen > BRCMF_MSGBUF_TRICKLE_TXWORKER_THRS) ||
1384 ((qlen) && (atomic_read(&commonring->outstanding_tx) <
1385 BRCMF_MSGBUF_TRICKLE_TXWORKER_THRS)))
1386 brcmf_msgbuf_schedule_txdata(msgbuf, flowid, true);
1387 }
1388
1389 return 0;
1390}
1391
1392
1393void brcmf_msgbuf_delete_flowring(struct brcmf_pub *drvr, u16 flowid)
1394{
1395 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
1396 struct msgbuf_tx_flowring_delete_req *delete;
1397 struct brcmf_commonring *commonring;
1398 void *ret_ptr;
1399 u8 ifidx;
1400 int err;
1401
1402
1403 if (drvr->bus_if->state != BRCMF_BUS_UP) {
1404 brcmf_dbg(MSGBUF, "bus down, flowring will be removed\n");
1405 brcmf_msgbuf_remove_flowring(msgbuf, flowid);
1406 return;
1407 }
1408
1409 commonring = msgbuf->commonrings[BRCMF_H2D_MSGRING_CONTROL_SUBMIT];
1410 brcmf_commonring_lock(commonring);
1411 ret_ptr = brcmf_commonring_reserve_for_write(commonring);
1412 if (!ret_ptr) {
1413 bphy_err(drvr, "FW unaware, flowring will be removed !!\n");
1414 brcmf_commonring_unlock(commonring);
1415 brcmf_msgbuf_remove_flowring(msgbuf, flowid);
1416 return;
1417 }
1418
1419 delete = (struct msgbuf_tx_flowring_delete_req *)ret_ptr;
1420
1421 ifidx = brcmf_flowring_ifidx_get(msgbuf->flow, flowid);
1422
1423 delete->msg.msgtype = MSGBUF_TYPE_FLOW_RING_DELETE;
1424 delete->msg.ifidx = ifidx;
1425 delete->msg.request_id = 0;
1426
1427 delete->flow_ring_id = cpu_to_le16(flowid +
1428 BRCMF_H2D_MSGRING_FLOWRING_IDSTART);
1429 delete->reason = 0;
1430
1431 brcmf_dbg(MSGBUF, "Send Flow Delete Req flow ID %d, ifindex %d\n",
1432 flowid, ifidx);
1433
1434 err = brcmf_commonring_write_complete(commonring);
1435 brcmf_commonring_unlock(commonring);
1436 if (err) {
1437 bphy_err(drvr, "Failed to submit RING_DELETE, flowring will be removed\n");
1438 brcmf_msgbuf_remove_flowring(msgbuf, flowid);
1439 }
1440}
1441
1442#ifdef DEBUG
1443static int brcmf_msgbuf_stats_read(struct seq_file *seq, void *data)
1444{
1445 struct brcmf_bus *bus_if = dev_get_drvdata(seq->private);
1446 struct brcmf_pub *drvr = bus_if->drvr;
1447 struct brcmf_msgbuf *msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
1448 struct brcmf_commonring *commonring;
1449 u16 i;
1450 struct brcmf_flowring_ring *ring;
1451 struct brcmf_flowring_hash *hash;
1452
1453 commonring = msgbuf->commonrings[BRCMF_H2D_MSGRING_CONTROL_SUBMIT];
1454 seq_printf(seq, "h2d_ctl_submit: rp %4u, wp %4u, depth %4u\n",
1455 commonring->r_ptr, commonring->w_ptr, commonring->depth);
1456 commonring = msgbuf->commonrings[BRCMF_H2D_MSGRING_RXPOST_SUBMIT];
1457 seq_printf(seq, "h2d_rx_submit: rp %4u, wp %4u, depth %4u\n",
1458 commonring->r_ptr, commonring->w_ptr, commonring->depth);
1459 commonring = msgbuf->commonrings[BRCMF_D2H_MSGRING_CONTROL_COMPLETE];
1460 seq_printf(seq, "d2h_ctl_cmplt: rp %4u, wp %4u, depth %4u\n",
1461 commonring->r_ptr, commonring->w_ptr, commonring->depth);
1462 commonring = msgbuf->commonrings[BRCMF_D2H_MSGRING_TX_COMPLETE];
1463 seq_printf(seq, "d2h_tx_cmplt: rp %4u, wp %4u, depth %4u\n",
1464 commonring->r_ptr, commonring->w_ptr, commonring->depth);
1465 commonring = msgbuf->commonrings[BRCMF_D2H_MSGRING_RX_COMPLETE];
1466 seq_printf(seq, "d2h_rx_cmplt: rp %4u, wp %4u, depth %4u\n",
1467 commonring->r_ptr, commonring->w_ptr, commonring->depth);
1468
1469 seq_printf(seq, "\nh2d_flowrings: depth %u\n",
1470 BRCMF_H2D_TXFLOWRING_MAX_ITEM);
1471 seq_puts(seq, "Active flowrings:\n");
1472 for (i = 0; i < msgbuf->flow->nrofrings; i++) {
1473 if (!msgbuf->flow->rings[i])
1474 continue;
1475 ring = msgbuf->flow->rings[i];
1476 if (ring->status != RING_OPEN)
1477 continue;
1478 commonring = msgbuf->flowrings[i];
1479 hash = &msgbuf->flow->hash[ring->hash_id];
1480 seq_printf(seq, "id %3u: rp %4u, wp %4u, qlen %4u, blocked %u\n"
1481 " ifidx %u, fifo %u, da %pM\n",
1482 i, commonring->r_ptr, commonring->w_ptr,
1483 skb_queue_len(&ring->skblist), ring->blocked,
1484 hash->ifidx, hash->fifo, hash->mac);
1485 }
1486
1487 return 0;
1488}
1489#else
1490static int brcmf_msgbuf_stats_read(struct seq_file *seq, void *data)
1491{
1492 return 0;
1493}
1494#endif
1495
1496static void brcmf_msgbuf_debugfs_create(struct brcmf_pub *drvr)
1497{
1498 brcmf_debugfs_add_entry(drvr, "msgbuf_stats", brcmf_msgbuf_stats_read);
1499}
1500
1501int brcmf_proto_msgbuf_attach(struct brcmf_pub *drvr)
1502{
1503 struct brcmf_bus_msgbuf *if_msgbuf;
1504 struct brcmf_msgbuf *msgbuf;
1505 u64 address;
1506 u32 count;
1507
1508 if_msgbuf = drvr->bus_if->msgbuf;
1509
1510 if (if_msgbuf->max_flowrings >= BRCMF_FLOWRING_HASHSIZE) {
1511 bphy_err(drvr, "driver not configured for this many flowrings %d\n",
1512 if_msgbuf->max_flowrings);
1513 if_msgbuf->max_flowrings = BRCMF_FLOWRING_HASHSIZE - 1;
1514 }
1515
1516 msgbuf = kzalloc(sizeof(*msgbuf), GFP_KERNEL);
1517 if (!msgbuf)
1518 goto fail;
1519
1520 msgbuf->txflow_wq = create_singlethread_workqueue("msgbuf_txflow");
1521 if (msgbuf->txflow_wq == NULL) {
1522 bphy_err(drvr, "workqueue creation failed\n");
1523 goto fail;
1524 }
1525 INIT_WORK(&msgbuf->txflow_work, brcmf_msgbuf_txflow_worker);
1526 count = BITS_TO_LONGS(if_msgbuf->max_flowrings);
1527 count = count * sizeof(unsigned long);
1528 msgbuf->flow_map = kzalloc(count, GFP_KERNEL);
1529 if (!msgbuf->flow_map)
1530 goto fail;
1531
1532 msgbuf->txstatus_done_map = kzalloc(count, GFP_KERNEL);
1533 if (!msgbuf->txstatus_done_map)
1534 goto fail;
1535
1536 msgbuf->drvr = drvr;
1537 msgbuf->ioctbuf = dma_alloc_coherent(drvr->bus_if->dev,
1538 BRCMF_TX_IOCTL_MAX_MSG_SIZE,
1539 &msgbuf->ioctbuf_handle,
1540 GFP_KERNEL);
1541 if (!msgbuf->ioctbuf)
1542 goto fail;
1543 address = (u64)msgbuf->ioctbuf_handle;
1544 msgbuf->ioctbuf_phys_hi = address >> 32;
1545 msgbuf->ioctbuf_phys_lo = address & 0xffffffff;
1546
1547 drvr->proto->hdrpull = brcmf_msgbuf_hdrpull;
1548 drvr->proto->query_dcmd = brcmf_msgbuf_query_dcmd;
1549 drvr->proto->set_dcmd = brcmf_msgbuf_set_dcmd;
1550 drvr->proto->tx_queue_data = brcmf_msgbuf_tx_queue_data;
1551 drvr->proto->configure_addr_mode = brcmf_msgbuf_configure_addr_mode;
1552 drvr->proto->delete_peer = brcmf_msgbuf_delete_peer;
1553 drvr->proto->add_tdls_peer = brcmf_msgbuf_add_tdls_peer;
1554 drvr->proto->rxreorder = brcmf_msgbuf_rxreorder;
1555 drvr->proto->debugfs_create = brcmf_msgbuf_debugfs_create;
1556 drvr->proto->pd = msgbuf;
1557
1558 init_waitqueue_head(&msgbuf->ioctl_resp_wait);
1559
1560 msgbuf->commonrings =
1561 (struct brcmf_commonring **)if_msgbuf->commonrings;
1562 msgbuf->flowrings = (struct brcmf_commonring **)if_msgbuf->flowrings;
1563 msgbuf->max_flowrings = if_msgbuf->max_flowrings;
1564 msgbuf->flowring_dma_handle =
1565 kcalloc(msgbuf->max_flowrings,
1566 sizeof(*msgbuf->flowring_dma_handle), GFP_KERNEL);
1567 if (!msgbuf->flowring_dma_handle)
1568 goto fail;
1569
1570 msgbuf->rx_dataoffset = if_msgbuf->rx_dataoffset;
1571 msgbuf->max_rxbufpost = if_msgbuf->max_rxbufpost;
1572
1573 msgbuf->max_ioctlrespbuf = BRCMF_MSGBUF_MAX_IOCTLRESPBUF_POST;
1574 msgbuf->max_eventbuf = BRCMF_MSGBUF_MAX_EVENTBUF_POST;
1575
1576 msgbuf->tx_pktids = brcmf_msgbuf_init_pktids(NR_TX_PKTIDS,
1577 DMA_TO_DEVICE);
1578 if (!msgbuf->tx_pktids)
1579 goto fail;
1580 msgbuf->rx_pktids = brcmf_msgbuf_init_pktids(NR_RX_PKTIDS,
1581 DMA_FROM_DEVICE);
1582 if (!msgbuf->rx_pktids)
1583 goto fail;
1584
1585 msgbuf->flow = brcmf_flowring_attach(drvr->bus_if->dev,
1586 if_msgbuf->max_flowrings);
1587 if (!msgbuf->flow)
1588 goto fail;
1589
1590
1591 brcmf_dbg(MSGBUF, "Feeding buffers, rx data %d, rx event %d, rx ioctl resp %d\n",
1592 msgbuf->max_rxbufpost, msgbuf->max_eventbuf,
1593 msgbuf->max_ioctlrespbuf);
1594 count = 0;
1595 do {
1596 brcmf_msgbuf_rxbuf_data_fill(msgbuf);
1597 if (msgbuf->max_rxbufpost != msgbuf->rxbufpost)
1598 msleep(10);
1599 else
1600 break;
1601 count++;
1602 } while (count < 10);
1603 brcmf_msgbuf_rxbuf_event_post(msgbuf);
1604 brcmf_msgbuf_rxbuf_ioctlresp_post(msgbuf);
1605
1606 INIT_WORK(&msgbuf->flowring_work, brcmf_msgbuf_flowring_worker);
1607 spin_lock_init(&msgbuf->flowring_work_lock);
1608 INIT_LIST_HEAD(&msgbuf->work_queue);
1609
1610 return 0;
1611
1612fail:
1613 if (msgbuf) {
1614 kfree(msgbuf->flow_map);
1615 kfree(msgbuf->txstatus_done_map);
1616 brcmf_msgbuf_release_pktids(msgbuf);
1617 kfree(msgbuf->flowring_dma_handle);
1618 if (msgbuf->ioctbuf)
1619 dma_free_coherent(drvr->bus_if->dev,
1620 BRCMF_TX_IOCTL_MAX_MSG_SIZE,
1621 msgbuf->ioctbuf,
1622 msgbuf->ioctbuf_handle);
1623 if (msgbuf->txflow_wq)
1624 destroy_workqueue(msgbuf->txflow_wq);
1625 kfree(msgbuf);
1626 }
1627 return -ENOMEM;
1628}
1629
1630
1631void brcmf_proto_msgbuf_detach(struct brcmf_pub *drvr)
1632{
1633 struct brcmf_msgbuf *msgbuf;
1634 struct brcmf_msgbuf_work_item *work;
1635
1636 brcmf_dbg(TRACE, "Enter\n");
1637 if (drvr->proto->pd) {
1638 msgbuf = (struct brcmf_msgbuf *)drvr->proto->pd;
1639 cancel_work_sync(&msgbuf->flowring_work);
1640 while (!list_empty(&msgbuf->work_queue)) {
1641 work = list_first_entry(&msgbuf->work_queue,
1642 struct brcmf_msgbuf_work_item,
1643 queue);
1644 list_del(&work->queue);
1645 kfree(work);
1646 }
1647 kfree(msgbuf->flow_map);
1648 kfree(msgbuf->txstatus_done_map);
1649 if (msgbuf->txflow_wq)
1650 destroy_workqueue(msgbuf->txflow_wq);
1651
1652 brcmf_flowring_detach(msgbuf->flow);
1653 dma_free_coherent(drvr->bus_if->dev,
1654 BRCMF_TX_IOCTL_MAX_MSG_SIZE,
1655 msgbuf->ioctbuf, msgbuf->ioctbuf_handle);
1656 brcmf_msgbuf_release_pktids(msgbuf);
1657 kfree(msgbuf->flowring_dma_handle);
1658 kfree(msgbuf);
1659 drvr->proto->pd = NULL;
1660 }
1661}
1662
