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.
17 #include <linux/types.h>
18 #include <linux/netdevice.h>
19 #include <linux/etherdevice.h>
20 #include <brcmu_utils.h>
31 #define BRCMF_FLOWRING_HIGH 1024
32 #define BRCMF_FLOWRING_LOW (BRCMF_FLOWRING_HIGH - 256)
33 #define BRCMF_FLOWRING_INVALID_IFIDX 0xff
35 #define BRCMF_FLOWRING_HASH_AP(da, fifo, ifidx) (da[5] * 2 + fifo + ifidx * 16)
36 #define BRCMF_FLOWRING_HASH_STA(fifo, ifidx) (fifo + ifidx * 16)
38 static const u8 brcmf_flowring_prio2fifo[] = {
51 brcmf_flowring_is_tdls_mac(struct brcmf_flowring *flow, u8 mac[ETH_ALEN])
53 struct brcmf_flowring_tdls_entry *search;
55 search = flow->tdls_entry;
58 if (memcmp(search->mac, mac, ETH_ALEN) == 0)
60 search = search->next;
67 u32 brcmf_flowring_lookup(struct brcmf_flowring *flow, u8 da[ETH_ALEN],
70 struct brcmf_flowring_hash *hash;
78 fifo = brcmf_flowring_prio2fifo[prio];
79 sta = (flow->addr_mode[ifidx] == ADDR_INDIRECT);
81 if ((!sta) && (is_multicast_ether_addr(da))) {
85 if ((sta) && (flow->tdls_active) &&
86 (brcmf_flowring_is_tdls_mac(flow, da))) {
89 hash_idx = sta ? BRCMF_FLOWRING_HASH_STA(fifo, ifidx) :
90 BRCMF_FLOWRING_HASH_AP(mac, fifo, ifidx);
91 hash_idx &= (BRCMF_FLOWRING_HASHSIZE - 1);
94 for (i = 0; i < BRCMF_FLOWRING_HASHSIZE; i++) {
95 if ((sta || (memcmp(hash[hash_idx].mac, mac, ETH_ALEN) == 0)) &&
96 (hash[hash_idx].fifo == fifo) &&
97 (hash[hash_idx].ifidx == ifidx)) {
102 hash_idx &= (BRCMF_FLOWRING_HASHSIZE - 1);
105 return hash[hash_idx].flowid;
107 return BRCMF_FLOWRING_INVALID_ID;
111 u32 brcmf_flowring_create(struct brcmf_flowring *flow, u8 da[ETH_ALEN],
114 struct brcmf_flowring_ring *ring;
115 struct brcmf_flowring_hash *hash;
123 fifo = brcmf_flowring_prio2fifo[prio];
124 sta = (flow->addr_mode[ifidx] == ADDR_INDIRECT);
126 if ((!sta) && (is_multicast_ether_addr(da))) {
127 mac = (u8 *)ALLFFMAC;
130 if ((sta) && (flow->tdls_active) &&
131 (brcmf_flowring_is_tdls_mac(flow, da))) {
134 hash_idx = sta ? BRCMF_FLOWRING_HASH_STA(fifo, ifidx) :
135 BRCMF_FLOWRING_HASH_AP(mac, fifo, ifidx);
136 hash_idx &= (BRCMF_FLOWRING_HASHSIZE - 1);
139 for (i = 0; i < BRCMF_FLOWRING_HASHSIZE; i++) {
140 if ((hash[hash_idx].ifidx == BRCMF_FLOWRING_INVALID_IFIDX) &&
141 (is_zero_ether_addr(hash[hash_idx].mac))) {
146 hash_idx &= (BRCMF_FLOWRING_HASHSIZE - 1);
149 for (i = 0; i < flow->nrofrings; i++) {
150 if (flow->rings[i] == NULL)
153 if (i == flow->nrofrings)
156 ring = kzalloc(sizeof(*ring), GFP_ATOMIC);
160 memcpy(hash[hash_idx].mac, mac, ETH_ALEN);
161 hash[hash_idx].fifo = fifo;
162 hash[hash_idx].ifidx = ifidx;
163 hash[hash_idx].flowid = i;
165 ring->hash_id = hash_idx;
166 ring->status = RING_CLOSED;
167 skb_queue_head_init(&ring->skblist);
168 flow->rings[i] = ring;
172 return BRCMF_FLOWRING_INVALID_ID;
176 u8 brcmf_flowring_tid(struct brcmf_flowring *flow, u16 flowid)
178 struct brcmf_flowring_ring *ring;
180 ring = flow->rings[flowid];
182 return flow->hash[ring->hash_id].fifo;
186 static void brcmf_flowring_block(struct brcmf_flowring *flow, u16 flowid,
189 struct brcmf_flowring_ring *ring;
190 struct brcmf_bus *bus_if;
191 struct brcmf_pub *drvr;
192 struct brcmf_if *ifp;
193 bool currently_blocked;
198 spin_lock_irqsave(&flow->block_lock, flags);
200 ring = flow->rings[flowid];
201 if (ring->blocked == blocked) {
202 spin_unlock_irqrestore(&flow->block_lock, flags);
205 ifidx = brcmf_flowring_ifidx_get(flow, flowid);
207 currently_blocked = false;
208 for (i = 0; i < flow->nrofrings; i++) {
209 if ((flow->rings[i]) && (i != flowid)) {
210 ring = flow->rings[i];
211 if ((ring->status == RING_OPEN) &&
212 (brcmf_flowring_ifidx_get(flow, i) == ifidx)) {
214 currently_blocked = true;
220 flow->rings[flowid]->blocked = blocked;
221 if (currently_blocked) {
222 spin_unlock_irqrestore(&flow->block_lock, flags);
226 bus_if = dev_get_drvdata(flow->dev);
228 ifp = brcmf_get_ifp(drvr, ifidx);
229 brcmf_txflowblock_if(ifp, BRCMF_NETIF_STOP_REASON_FLOW, blocked);
231 spin_unlock_irqrestore(&flow->block_lock, flags);
235 void brcmf_flowring_delete(struct brcmf_flowring *flow, u16 flowid)
237 struct brcmf_flowring_ring *ring;
241 ring = flow->rings[flowid];
244 brcmf_flowring_block(flow, flowid, false);
245 hash_idx = ring->hash_id;
246 flow->hash[hash_idx].ifidx = BRCMF_FLOWRING_INVALID_IFIDX;
247 eth_zero_addr(flow->hash[hash_idx].mac);
248 flow->rings[flowid] = NULL;
250 skb = skb_dequeue(&ring->skblist);
252 brcmu_pkt_buf_free_skb(skb);
253 skb = skb_dequeue(&ring->skblist);
260 u32 brcmf_flowring_enqueue(struct brcmf_flowring *flow, u16 flowid,
263 struct brcmf_flowring_ring *ring;
265 ring = flow->rings[flowid];
267 skb_queue_tail(&ring->skblist, skb);
269 if (!ring->blocked &&
270 (skb_queue_len(&ring->skblist) > BRCMF_FLOWRING_HIGH)) {
271 brcmf_flowring_block(flow, flowid, true);
272 brcmf_dbg(MSGBUF, "Flowcontrol: BLOCK for ring %d\n", flowid);
273 /* To prevent (work around) possible race condition, check
274 * queue len again. It is also possible to use locking to
275 * protect, but that is undesirable for every enqueue and
276 * dequeue. This simple check will solve a possible race
277 * condition if it occurs.
279 if (skb_queue_len(&ring->skblist) < BRCMF_FLOWRING_LOW)
280 brcmf_flowring_block(flow, flowid, false);
282 return skb_queue_len(&ring->skblist);
286 struct sk_buff *brcmf_flowring_dequeue(struct brcmf_flowring *flow, u16 flowid)
288 struct brcmf_flowring_ring *ring;
291 ring = flow->rings[flowid];
292 if (ring->status != RING_OPEN)
295 skb = skb_dequeue(&ring->skblist);
298 (skb_queue_len(&ring->skblist) < BRCMF_FLOWRING_LOW)) {
299 brcmf_flowring_block(flow, flowid, false);
300 brcmf_dbg(MSGBUF, "Flowcontrol: OPEN for ring %d\n", flowid);
307 void brcmf_flowring_reinsert(struct brcmf_flowring *flow, u16 flowid,
310 struct brcmf_flowring_ring *ring;
312 ring = flow->rings[flowid];
314 skb_queue_head(&ring->skblist, skb);
318 u32 brcmf_flowring_qlen(struct brcmf_flowring *flow, u16 flowid)
320 struct brcmf_flowring_ring *ring;
322 ring = flow->rings[flowid];
326 if (ring->status != RING_OPEN)
329 return skb_queue_len(&ring->skblist);
333 void brcmf_flowring_open(struct brcmf_flowring *flow, u16 flowid)
335 struct brcmf_flowring_ring *ring;
337 ring = flow->rings[flowid];
339 brcmf_err("Ring NULL, for flowid %d\n", flowid);
343 ring->status = RING_OPEN;
347 u8 brcmf_flowring_ifidx_get(struct brcmf_flowring *flow, u16 flowid)
349 struct brcmf_flowring_ring *ring;
352 ring = flow->rings[flowid];
353 hash_idx = ring->hash_id;
355 return flow->hash[hash_idx].ifidx;
359 struct brcmf_flowring *brcmf_flowring_attach(struct device *dev, u16 nrofrings)
361 struct brcmf_flowring *flow;
364 flow = kzalloc(sizeof(*flow), GFP_KERNEL);
367 flow->nrofrings = nrofrings;
368 spin_lock_init(&flow->block_lock);
369 for (i = 0; i < ARRAY_SIZE(flow->addr_mode); i++)
370 flow->addr_mode[i] = ADDR_INDIRECT;
371 for (i = 0; i < ARRAY_SIZE(flow->hash); i++)
372 flow->hash[i].ifidx = BRCMF_FLOWRING_INVALID_IFIDX;
373 flow->rings = kcalloc(nrofrings, sizeof(*flow->rings),
385 void brcmf_flowring_detach(struct brcmf_flowring *flow)
387 struct brcmf_bus *bus_if = dev_get_drvdata(flow->dev);
388 struct brcmf_pub *drvr = bus_if->drvr;
389 struct brcmf_flowring_tdls_entry *search;
390 struct brcmf_flowring_tdls_entry *remove;
393 for (flowid = 0; flowid < flow->nrofrings; flowid++) {
394 if (flow->rings[flowid])
395 brcmf_msgbuf_delete_flowring(drvr, flowid);
398 search = flow->tdls_entry;
401 search = search->next;
409 void brcmf_flowring_configure_addr_mode(struct brcmf_flowring *flow, int ifidx,
410 enum proto_addr_mode addr_mode)
412 struct brcmf_bus *bus_if = dev_get_drvdata(flow->dev);
413 struct brcmf_pub *drvr = bus_if->drvr;
417 if (flow->addr_mode[ifidx] != addr_mode) {
418 for (i = 0; i < ARRAY_SIZE(flow->hash); i++) {
419 if (flow->hash[i].ifidx == ifidx) {
420 flowid = flow->hash[i].flowid;
421 if (flow->rings[flowid]->status != RING_OPEN)
423 flow->rings[flowid]->status = RING_CLOSING;
424 brcmf_msgbuf_delete_flowring(drvr, flowid);
427 flow->addr_mode[ifidx] = addr_mode;
432 void brcmf_flowring_delete_peer(struct brcmf_flowring *flow, int ifidx,
435 struct brcmf_bus *bus_if = dev_get_drvdata(flow->dev);
436 struct brcmf_pub *drvr = bus_if->drvr;
437 struct brcmf_flowring_hash *hash;
438 struct brcmf_flowring_tdls_entry *prev;
439 struct brcmf_flowring_tdls_entry *search;
444 sta = (flow->addr_mode[ifidx] == ADDR_INDIRECT);
446 search = flow->tdls_entry;
449 if (memcmp(search->mac, peer, ETH_ALEN) == 0) {
454 search = search->next;
458 for (i = 0; i < BRCMF_FLOWRING_HASHSIZE; i++) {
459 if ((sta || (memcmp(hash[i].mac, peer, ETH_ALEN) == 0)) &&
460 (hash[i].ifidx == ifidx)) {
461 flowid = flow->hash[i].flowid;
462 if (flow->rings[flowid]->status == RING_OPEN) {
463 flow->rings[flowid]->status = RING_CLOSING;
464 brcmf_msgbuf_delete_flowring(drvr, flowid);
471 prev->next = search->next;
473 flow->tdls_entry = search->next;
475 if (flow->tdls_entry == NULL)
476 flow->tdls_active = false;
481 void brcmf_flowring_add_tdls_peer(struct brcmf_flowring *flow, int ifidx,
484 struct brcmf_flowring_tdls_entry *tdls_entry;
485 struct brcmf_flowring_tdls_entry *search;
487 tdls_entry = kzalloc(sizeof(*tdls_entry), GFP_ATOMIC);
488 if (tdls_entry == NULL)
491 memcpy(tdls_entry->mac, peer, ETH_ALEN);
492 tdls_entry->next = NULL;
493 if (flow->tdls_entry == NULL) {
494 flow->tdls_entry = tdls_entry;
496 search = flow->tdls_entry;
497 if (memcmp(search->mac, peer, ETH_ALEN) == 0)
499 while (search->next) {
500 search = search->next;
501 if (memcmp(search->mac, peer, ETH_ALEN) == 0)
504 search->next = tdls_entry;
507 flow->tdls_active = true;