projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mwifiex: hold proper locks when accessing ra_list / bss_prio lists
[deliverable/linux.git] / drivers / net / wireless / brcm80211 / brcmfmac / fwsignal.c
CommitLineData
349e7104
AS		 1/*
2 * Copyright (c) 2010 Broadcom Corporation
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16#include <linux/types.h>
c7f34a69 17#include <linux/module.h>
349e7104
AS		 18#include <linux/if_ether.h>
19#include <linux/spinlock.h>
20#include <linux/skbuff.h>
21#include <linux/netdevice.h>
3edc1cff 22#include <linux/etherdevice.h>
349e7104
AS		 23#include <linux/err.h>
24#include <uapi/linux/nl80211.h>
3edc1cff 25#include <net/cfg80211.h>
349e7104
AS		 26
27#include <brcmu_utils.h>
28#include <brcmu_wifi.h>
29#include "dhd.h"
3edc1cff 30#include "dhd_proto.h"
349e7104 31#include "dhd_dbg.h"
e2432b67 32#include "dhd_bus.h"
349e7104
AS		 33#include "fwil.h"
34#include "fweh.h"
35#include "fwsignal.h"
36
37/**
38 * DOC: Firmware Signalling
39 *
40 * Firmware can send signals to host and vice versa, which are passed in the
41 * data packets using TLV based header. This signalling layer is on top of the
42 * BDC bus protocol layer.
43 */
44
45/*
46 * single definition for firmware-driver flow control tlv's.
47 *
48 * each tlv is specified by BRCMF_FWS_TLV_DEF(name, ID, length).
49 * A length value 0 indicates variable length tlv.
50 */
51#define BRCMF_FWS_TLV_DEFLIST \
52 BRCMF_FWS_TLV_DEF(MAC_OPEN, 1, 1) \
53 BRCMF_FWS_TLV_DEF(MAC_CLOSE, 2, 1) \
54 BRCMF_FWS_TLV_DEF(MAC_REQUEST_CREDIT, 3, 2) \
55 BRCMF_FWS_TLV_DEF(TXSTATUS, 4, 4) \
56 BRCMF_FWS_TLV_DEF(PKTTAG, 5, 4) \
57 BRCMF_FWS_TLV_DEF(MACDESC_ADD, 6, 8) \
58 BRCMF_FWS_TLV_DEF(MACDESC_DEL, 7, 8) \
59 BRCMF_FWS_TLV_DEF(RSSI, 8, 1) \
60 BRCMF_FWS_TLV_DEF(INTERFACE_OPEN, 9, 1) \
61 BRCMF_FWS_TLV_DEF(INTERFACE_CLOSE, 10, 1) \
94607238 62 BRCMF_FWS_TLV_DEF(FIFO_CREDITBACK, 11, 6) \
349e7104
AS		 63 BRCMF_FWS_TLV_DEF(PENDING_TRAFFIC_BMP, 12, 2) \
64 BRCMF_FWS_TLV_DEF(MAC_REQUEST_PACKET, 13, 3) \
65 BRCMF_FWS_TLV_DEF(HOST_REORDER_RXPKTS, 14, 10) \
66 BRCMF_FWS_TLV_DEF(TRANS_ID, 18, 6) \
67 BRCMF_FWS_TLV_DEF(COMP_TXSTATUS, 19, 1) \
68 BRCMF_FWS_TLV_DEF(FILLER, 255, 0)
69
3edc1cff 70/*
349e7104
AS		 71 * enum brcmf_fws_tlv_type - definition of tlv identifiers.
72 */
73#define BRCMF_FWS_TLV_DEF(name, id, len) \
74 BRCMF_FWS_TYPE_ ## name = id,
75enum brcmf_fws_tlv_type {
76 BRCMF_FWS_TLV_DEFLIST
77 BRCMF_FWS_TYPE_INVALID
78};
79#undef BRCMF_FWS_TLV_DEF
80
3edc1cff
AS		 81/*
82 * enum brcmf_fws_tlv_len - definition of tlv lengths.
83 */
84#define BRCMF_FWS_TLV_DEF(name, id, len) \
85 BRCMF_FWS_TYPE_ ## name ## _LEN = (len),
86enum brcmf_fws_tlv_len {
87 BRCMF_FWS_TLV_DEFLIST
88};
89#undef BRCMF_FWS_TLV_DEF
90
349e7104 91#ifdef DEBUG
3edc1cff 92/*
349e7104
AS		 93 * brcmf_fws_tlv_names - array of tlv names.
94 */
95#define BRCMF_FWS_TLV_DEF(name, id, len) \
96 { id, #name },
97static struct {
98 enum brcmf_fws_tlv_type id;
99 const char *name;
100} brcmf_fws_tlv_names[] = {
101 BRCMF_FWS_TLV_DEFLIST
102};
103#undef BRCMF_FWS_TLV_DEF
104
105static const char *brcmf_fws_get_tlv_name(enum brcmf_fws_tlv_type id)
106{
107 int i;
108
109 for (i = 0; i < ARRAY_SIZE(brcmf_fws_tlv_names); i++)
110 if (brcmf_fws_tlv_names[i].id == id)
111 return brcmf_fws_tlv_names[i].name;
112
113 return "INVALID";
114}
115#else
116static const char *brcmf_fws_get_tlv_name(enum brcmf_fws_tlv_type id)
117{
118 return "NODEBUG";
119}
120#endif /* DEBUG */
121
3edc1cff 122/*
349e7104
AS		 123 * flags used to enable tlv signalling from firmware.
124 */
bb8c8063
AS		 125#define BRCMF_FWS_FLAGS_RSSI_SIGNALS 0x0001
126#define BRCMF_FWS_FLAGS_XONXOFF_SIGNALS 0x0002
127#define BRCMF_FWS_FLAGS_CREDIT_STATUS_SIGNALS 0x0004
128#define BRCMF_FWS_FLAGS_HOST_PROPTXSTATUS_ACTIVE 0x0008
129#define BRCMF_FWS_FLAGS_PSQ_GENERATIONFSM_ENABLE 0x0010
130#define BRCMF_FWS_FLAGS_PSQ_ZERO_BUFFER_ENABLE 0x0020
131#define BRCMF_FWS_FLAGS_HOST_RXREORDER_ACTIVE 0x0040
132
349e7104 133#define BRCMF_FWS_MAC_DESC_TABLE_SIZE 32
349e7104
AS		 134#define BRCMF_FWS_MAC_DESC_ID_INVALID 0xff
135
136#define BRCMF_FWS_HOSTIF_FLOWSTATE_OFF 0
137#define BRCMF_FWS_HOSTIF_FLOWSTATE_ON 1
84bcc0c3
AS		 138#define BRCMF_FWS_FLOWCONTROL_HIWATER 128
139#define BRCMF_FWS_FLOWCONTROL_LOWATER 64
349e7104 140
bb8c8063
AS		 141#define BRCMF_FWS_PSQ_PREC_COUNT ((NL80211_NUM_ACS + 1) * 2)
142#define BRCMF_FWS_PSQ_LEN 256
143
3edc1cff
AS		 144#define BRCMF_FWS_HTOD_FLAG_PKTFROMHOST 0x01
145#define BRCMF_FWS_HTOD_FLAG_PKT_REQUESTED 0x02
146
ebb93883
AS		 147/**
148 * enum brcmf_fws_skb_state - indicates processing state of skb.
3edc1cff
AS		 149 *
150 * @BRCMF_FWS_SKBSTATE_NEW: sk_buff is newly arrived in the driver.
151 * @BRCMF_FWS_SKBSTATE_DELAYED: sk_buff had to wait on queue.
152 * @BRCMF_FWS_SKBSTATE_SUPPRESSED: sk_buff has been suppressed by firmware.
ebb93883
AS		 153 */
154enum brcmf_fws_skb_state {
3edc1cff
AS		 155 BRCMF_FWS_SKBSTATE_NEW,
156 BRCMF_FWS_SKBSTATE_DELAYED,
157 BRCMF_FWS_SKBSTATE_SUPPRESSED
ebb93883
AS		 158};
159
160/**
161 * struct brcmf_skbuff_cb - control buffer associated with skbuff.
162 *
163 * @if_flags: holds interface index and packet related flags.
ebb93883 164 * @htod: host to device packet identifier (used in PKTTAG tlv).
ebb93883
AS		 165 * @state: transmit state of the packet.
166 * @mac: descriptor related to destination for this packet.
167 *
168 * This information is stored in control buffer struct sk_buff::cb, which
169 * provides 48 bytes of storage so this structure should not exceed that.
170 */
171struct brcmf_skbuff_cb {
172 u16 if_flags;
ebb93883 173 u32 htod;
ebb93883
AS		 174 enum brcmf_fws_skb_state state;
175 struct brcmf_fws_mac_descriptor *mac;
176};
177
3edc1cff 178/*
ebb93883
AS		 179 * macro casting skbuff control buffer to struct brcmf_skbuff_cb.
180 */
181#define brcmf_skbcb(skb) ((struct brcmf_skbuff_cb *)((skb)->cb))
182
3edc1cff 183/*
ebb93883
AS		 184 * sk_buff control if flags
185 *
186 * b[11] - packet sent upon firmware request.
187 * b[10] - packet only contains signalling data.
188 * b[9] - packet is a tx packet.
189 * b[8] - packet uses FIFO credit (non-pspoll).
190 * b[7] - interface in AP mode.
191 * b[6:4] - AC FIFO number.
192 * b[3:0] - interface index.
193 */
194#define BRCMF_SKB_IF_FLAGS_REQUESTED_MASK 0x0800
195#define BRCMF_SKB_IF_FLAGS_REQUESTED_SHIFT 11
196#define BRCMF_SKB_IF_FLAGS_SIGNAL_ONLY_MASK 0x0400
197#define BRCMF_SKB_IF_FLAGS_SIGNAL_ONLY_SHIFT 10
198#define BRCMF_SKB_IF_FLAGS_TRANSMIT_MASK 0x0200
199#define BRCMF_SKB_IF_FLAGS_TRANSMIT_SHIFT 9
200#define BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK 0x0100
201#define BRCMF_SKB_IF_FLAGS_CREDITCHECK_SHIFT 8
202#define BRCMF_SKB_IF_FLAGS_IF_AP_MASK 0x0080
203#define BRCMF_SKB_IF_FLAGS_IF_AP_SHIFT 7
204#define BRCMF_SKB_IF_FLAGS_FIFO_MASK 0x0070
205#define BRCMF_SKB_IF_FLAGS_FIFO_SHIFT 4
206#define BRCMF_SKB_IF_FLAGS_INDEX_MASK 0x000f
207#define BRCMF_SKB_IF_FLAGS_INDEX_SHIFT 0
208
209#define brcmf_skb_if_flags_set_field(skb, field, value) \
210 brcmu_maskset16(&(brcmf_skbcb(skb)->if_flags), \
211 BRCMF_SKB_IF_FLAGS_ ## field ## _MASK, \
212 BRCMF_SKB_IF_FLAGS_ ## field ## _SHIFT, (value))
213#define brcmf_skb_if_flags_get_field(skb, field) \
214 brcmu_maskget16(brcmf_skbcb(skb)->if_flags, \
215 BRCMF_SKB_IF_FLAGS_ ## field ## _MASK, \
216 BRCMF_SKB_IF_FLAGS_ ## field ## _SHIFT)
217
3edc1cff 218/*
ebb93883
AS		 219 * sk_buff control packet identifier
220 *
221 * 32-bit packet identifier used in PKTTAG tlv from host to dongle.
222 *
223 * - Generated at the host (e.g. dhd)
224 * - Seen as a generic sequence number by firmware except for the flags field.
225 *
226 * Generation : b[31] => generation number for this packet [host->fw]
227 * OR, current generation number [fw->host]
228 * Flags : b[30:27] => command, status flags
229 * FIFO-AC : b[26:24] => AC-FIFO id
230 * h-slot : b[23:8] => hanger-slot
231 * freerun : b[7:0] => A free running counter
232 */
233#define BRCMF_SKB_HTOD_TAG_GENERATION_MASK 0x80000000
234#define BRCMF_SKB_HTOD_TAG_GENERATION_SHIFT 31
235#define BRCMF_SKB_HTOD_TAG_FLAGS_MASK 0x78000000
236#define BRCMF_SKB_HTOD_TAG_FLAGS_SHIFT 27
237#define BRCMF_SKB_HTOD_TAG_FIFO_MASK 0x07000000
238#define BRCMF_SKB_HTOD_TAG_FIFO_SHIFT 24
239#define BRCMF_SKB_HTOD_TAG_HSLOT_MASK 0x00ffff00
240#define BRCMF_SKB_HTOD_TAG_HSLOT_SHIFT 8
241#define BRCMF_SKB_HTOD_TAG_FREERUN_MASK 0x000000ff
242#define BRCMF_SKB_HTOD_TAG_FREERUN_SHIFT 0
243
244#define brcmf_skb_htod_tag_set_field(skb, field, value) \
e2432b67 245 brcmu_maskset32(&(brcmf_skbcb(skb)->htod), \
ebb93883
AS		 246 BRCMF_SKB_HTOD_TAG_ ## field ## _MASK, \
247 BRCMF_SKB_HTOD_TAG_ ## field ## _SHIFT, (value))
248#define brcmf_skb_htod_tag_get_field(skb, field) \
e2432b67 249 brcmu_maskget32(brcmf_skbcb(skb)->htod, \
ebb93883
AS		 250 BRCMF_SKB_HTOD_TAG_ ## field ## _MASK, \
251 BRCMF_SKB_HTOD_TAG_ ## field ## _SHIFT)
252
3edc1cff
AS		 253#define BRCMF_FWS_TXSTAT_GENERATION_MASK 0x80000000
254#define BRCMF_FWS_TXSTAT_GENERATION_SHIFT 31
255#define BRCMF_FWS_TXSTAT_FLAGS_MASK 0x78000000
256#define BRCMF_FWS_TXSTAT_FLAGS_SHIFT 27
257#define BRCMF_FWS_TXSTAT_FIFO_MASK 0x07000000
258#define BRCMF_FWS_TXSTAT_FIFO_SHIFT 24
259#define BRCMF_FWS_TXSTAT_HSLOT_MASK 0x00FFFF00
260#define BRCMF_FWS_TXSTAT_HSLOT_SHIFT 8
261#define BRCMF_FWS_TXSTAT_PKTID_MASK 0x00FFFFFF
262#define BRCMF_FWS_TXSTAT_PKTID_SHIFT 0
263
264#define brcmf_txstatus_get_field(txs, field) \
265 brcmu_maskget32(txs, BRCMF_FWS_TXSTAT_ ## field ## _MASK, \
266 BRCMF_FWS_TXSTAT_ ## field ## _SHIFT)
267
268/**
269 * enum brcmf_fws_fifo - fifo indices used by dongle firmware.
270 *
271 * @BRCMF_FWS_FIFO_AC_BK: fifo for background traffic.
272 * @BRCMF_FWS_FIFO_AC_BE: fifo for best-effort traffic.
273 * @BRCMF_FWS_FIFO_AC_VI: fifo for video traffic.
274 * @BRCMF_FWS_FIFO_AC_VO: fifo for voice traffic.
275 * @BRCMF_FWS_FIFO_BCMC: fifo for broadcast/multicast (AP only).
276 * @BRCMF_FWS_FIFO_ATIM: fifo for ATIM (AP only).
277 * @BRCMF_FWS_FIFO_COUNT: number of fifos.
278 */
279enum brcmf_fws_fifo {
280 BRCMF_FWS_FIFO_AC_BK,
281 BRCMF_FWS_FIFO_AC_BE,
282 BRCMF_FWS_FIFO_AC_VI,
283 BRCMF_FWS_FIFO_AC_VO,
284 BRCMF_FWS_FIFO_BCMC,
285 BRCMF_FWS_FIFO_ATIM,
286 BRCMF_FWS_FIFO_COUNT
287};
288
289/**
290 * enum brcmf_fws_txstatus - txstatus flag values.
291 *
292 * @BRCMF_FWS_TXSTATUS_DISCARD:
293 * host is free to discard the packet.
294 * @BRCMF_FWS_TXSTATUS_CORE_SUPPRESS:
295 * 802.11 core suppressed the packet.
296 * @BRCMF_FWS_TXSTATUS_FW_PS_SUPPRESS:
297 * firmware suppress the packet as device is already in PS mode.
298 * @BRCMF_FWS_TXSTATUS_FW_TOSSED:
299 * firmware tossed the packet.
300 */
301enum brcmf_fws_txstatus {
302 BRCMF_FWS_TXSTATUS_DISCARD,
303 BRCMF_FWS_TXSTATUS_CORE_SUPPRESS,
304 BRCMF_FWS_TXSTATUS_FW_PS_SUPPRESS,
305 BRCMF_FWS_TXSTATUS_FW_TOSSED
306};
307
c7f34a69
AS		 308enum brcmf_fws_fcmode {
309 BRCMF_FWS_FCMODE_NONE,
310 BRCMF_FWS_FCMODE_IMPLIED_CREDIT,
311 BRCMF_FWS_FCMODE_EXPLICIT_CREDIT
312};
313
84bcc0c3
AS		 314enum brcmf_fws_mac_desc_state {
315 BRCMF_FWS_STATE_OPEN = 1,
316 BRCMF_FWS_STATE_CLOSE
317};
318
bb8c8063
AS		 319/**
320 * struct brcmf_fws_mac_descriptor - firmware signalling data per node/interface
321 *
322 * @occupied: slot is in use.
ce814c1b 323 * @mac_handle: handle for mac entry determined by firmware.
bb8c8063
AS		 324 * @interface_id: interface index.
325 * @state: current state.
3edc1cff
AS		 326 * @suppressed: mac entry is suppressed.
327 * @generation: generation bit.
bb8c8063
AS		 328 * @ac_bitmap: ac queue bitmap.
329 * @requested_credit: credits requested by firmware.
330 * @ea: ethernet address.
3edc1cff 331 * @seq: per-node free-running sequence.
bb8c8063 332 * @psq: power-save queue.
3edc1cff 333 * @transit_count: packet in transit to firmware.
bb8c8063
AS		 334 */
335struct brcmf_fws_mac_descriptor {
336 u8 occupied;
ce814c1b 337 u8 mac_handle;
bb8c8063
AS		 338 u8 interface_id;
339 u8 state;
3edc1cff
AS		 340 bool suppressed;
341 u8 generation;
bb8c8063
AS		 342 u8 ac_bitmap;
343 u8 requested_credit;
84bcc0c3 344 u8 requested_packet;
bb8c8063 345 u8 ea[ETH_ALEN];
3edc1cff 346 u8 seq[BRCMF_FWS_FIFO_COUNT];
bb8c8063 347 struct pktq psq;
3edc1cff 348 int transit_count;
84bcc0c3
AS		 349 int suppress_count;
350 int suppr_transit_count;
351 bool send_tim_signal;
352 u8 traffic_pending_bmp;
353 u8 traffic_lastreported_bmp;
bb8c8063
AS		 354};
355
6971280a
AS		 356#define BRCMF_FWS_HANGER_MAXITEMS 1024
357
358/**
359 * enum brcmf_fws_hanger_item_state - state of hanger item.
360 *
3edc1cff
AS		 361 * @BRCMF_FWS_HANGER_ITEM_STATE_FREE: item is free for use.
362 * @BRCMF_FWS_HANGER_ITEM_STATE_INUSE: item is in use.
363 * @BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED: item was suppressed.
6971280a
AS		 364 */
365enum brcmf_fws_hanger_item_state {
3edc1cff
AS		 366 BRCMF_FWS_HANGER_ITEM_STATE_FREE = 1,
367 BRCMF_FWS_HANGER_ITEM_STATE_INUSE,
368 BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED
6971280a
AS		 369};
370
371
372/**
373 * struct brcmf_fws_hanger_item - single entry for tx pending packet.
374 *
375 * @state: entry is either free or occupied.
376 * @gen: generation.
6971280a
AS		 377 * @pkt: packet itself.
378 */
379struct brcmf_fws_hanger_item {
380 enum brcmf_fws_hanger_item_state state;
381 u8 gen;
6971280a
AS		 382 struct sk_buff *pkt;
383};
384
385/**
386 * struct brcmf_fws_hanger - holds packets awaiting firmware txstatus.
387 *
6971280a
AS		 388 * @pushed: packets pushed to await txstatus.
389 * @popped: packets popped upon handling txstatus.
390 * @failed_to_push: packets that could not be pushed.
391 * @failed_to_pop: packets that could not be popped.
392 * @failed_slotfind: packets for which failed to find an entry.
393 * @slot_pos: last returned item index for a free entry.
394 * @items: array of hanger items.
395 */
396struct brcmf_fws_hanger {
397 u32 pushed;
398 u32 popped;
399 u32 failed_to_push;
400 u32 failed_to_pop;
401 u32 failed_slotfind;
402 u32 slot_pos;
403 struct brcmf_fws_hanger_item items[BRCMF_FWS_HANGER_MAXITEMS];
404};
405
84bcc0c3
AS		 406struct brcmf_fws_macdesc_table {
407 struct brcmf_fws_mac_descriptor nodes[BRCMF_FWS_MAC_DESC_TABLE_SIZE];
408 struct brcmf_fws_mac_descriptor iface[BRCMF_MAX_IFS];
409 struct brcmf_fws_mac_descriptor other;
410};
411
349e7104
AS		 412struct brcmf_fws_info {
413 struct brcmf_pub *drvr;
414 struct brcmf_fws_stats stats;
6971280a 415 struct brcmf_fws_hanger hanger;
c7f34a69 416 enum brcmf_fws_fcmode fcmode;
84bcc0c3
AS		 417 struct brcmf_fws_macdesc_table desc;
418 struct workqueue_struct *fws_wq;
419 struct work_struct fws_dequeue_work;
420 u32 fifo_enqpkt[BRCMF_FWS_FIFO_COUNT];
3edc1cff 421 int fifo_credit[BRCMF_FWS_FIFO_COUNT];
84bcc0c3
AS		 422 int deq_node_pos[BRCMF_FWS_FIFO_COUNT];
423 u32 fifo_credit_map;
424 u32 fifo_delay_map;
3edc1cff
AS		 425};
426
427/*
428 * brcmf_fws_prio2fifo - mapping from 802.1d priority to firmware fifo index.
429 */
430static const int brcmf_fws_prio2fifo[] = {
431 BRCMF_FWS_FIFO_AC_BE,
432 BRCMF_FWS_FIFO_AC_BK,
433 BRCMF_FWS_FIFO_AC_BK,
434 BRCMF_FWS_FIFO_AC_BE,
435 BRCMF_FWS_FIFO_AC_VI,
436 BRCMF_FWS_FIFO_AC_VI,
437 BRCMF_FWS_FIFO_AC_VO,
438 BRCMF_FWS_FIFO_AC_VO
349e7104
AS		 439};
440
c7f34a69
AS		 441static int fcmode;
442module_param(fcmode, int, S_IRUSR);
443MODULE_PARM_DESC(fcmode, "mode of firmware signalled flow control");
444
bb8c8063
AS		 445#define BRCMF_FWS_TLV_DEF(name, id, len) \
446 case BRCMF_FWS_TYPE_ ## name: \
447 return len;
448
3edc1cff
AS		 449/**
450 * brcmf_fws_get_tlv_len() - returns defined length for given tlv id.
451 *
452 * @fws: firmware-signalling information.
453 * @id: identifier of the TLV.
454 *
455 * Return: the specified length for the given TLV; Otherwise -EINVAL.
456 */
bb8c8063
AS		 457static int brcmf_fws_get_tlv_len(struct brcmf_fws_info *fws,
458 enum brcmf_fws_tlv_type id)
459{
460 switch (id) {
461 BRCMF_FWS_TLV_DEFLIST
462 default:
bb8c8063
AS		 463 fws->stats.tlv_invalid_type++;
464 break;
465 }
466 return -EINVAL;
467}
468#undef BRCMF_FWS_TLV_DEF
469
3edc1cff
AS		 470static bool brcmf_fws_ifidx_match(struct sk_buff *skb, void *arg)
471{
472 u32 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX);
473 return ifidx == *(int *)arg;
474}
475
476static void brcmf_fws_psq_flush(struct brcmf_fws_info *fws, struct pktq *q,
477 int ifidx)
478{
479 bool (*matchfn)(struct sk_buff *, void *) = NULL;
480 struct sk_buff *skb;
481 int prec;
482
483 if (ifidx != -1)
484 matchfn = brcmf_fws_ifidx_match;
485 for (prec = 0; prec < q->num_prec; prec++) {
486 skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx);
487 while (skb) {
84bcc0c3 488 brcmu_pkt_buf_free_skb(skb);
3edc1cff
AS		 489 skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx);
490 }
491 }
492}
493
6971280a
AS		 494static void brcmf_fws_hanger_init(struct brcmf_fws_hanger *hanger)
495{
496 int i;
497
498 brcmf_dbg(TRACE, "enter\n");
499 memset(hanger, 0, sizeof(*hanger));
500 for (i = 0; i < ARRAY_SIZE(hanger->items); i++)
3edc1cff 501 hanger->items[i].state = BRCMF_FWS_HANGER_ITEM_STATE_FREE;
6971280a
AS		 502}
503
3edc1cff 504static u32 brcmf_fws_hanger_get_free_slot(struct brcmf_fws_hanger *h)
6971280a
AS		 505{
506 u32 i;
507
508 brcmf_dbg(TRACE, "enter\n");
509 i = (h->slot_pos + 1) % BRCMF_FWS_HANGER_MAXITEMS;
510
511 while (i != h->slot_pos) {
3edc1cff 512 if (h->items[i].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) {
6971280a 513 h->slot_pos = i;
84bcc0c3 514 goto done;
6971280a
AS		 515 }
516 i++;
517 if (i == BRCMF_FWS_HANGER_MAXITEMS)
518 i = 0;
519 }
520 brcmf_err("all slots occupied\n");
521 h->failed_slotfind++;
84bcc0c3
AS		 522 i = BRCMF_FWS_HANGER_MAXITEMS;
523done:
524 brcmf_dbg(TRACE, "exit: %d\n", i);
525 return i;
6971280a
AS		 526}
527
3edc1cff 528static int brcmf_fws_hanger_pushpkt(struct brcmf_fws_hanger *h,
6971280a
AS		 529 struct sk_buff *pkt, u32 slot_id)
530{
531 brcmf_dbg(TRACE, "enter\n");
532 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS)
533 return -ENOENT;
534
535 if (h->items[slot_id].state != BRCMF_FWS_HANGER_ITEM_STATE_FREE) {
536 brcmf_err("slot is not free\n");
537 h->failed_to_push++;
538 return -EINVAL;
539 }
540
541 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_INUSE;
542 h->items[slot_id].pkt = pkt;
6971280a
AS		 543 h->pushed++;
544 return 0;
545}
546
3edc1cff 547static int brcmf_fws_hanger_poppkt(struct brcmf_fws_hanger *h,
6971280a
AS		 548 u32 slot_id, struct sk_buff **pktout,
549 bool remove_item)
550{
551 brcmf_dbg(TRACE, "enter\n");
552 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS)
553 return -ENOENT;
554
555 if (h->items[slot_id].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) {
556 brcmf_err("entry not in use\n");
557 h->failed_to_pop++;
558 return -EINVAL;
559 }
560
561 *pktout = h->items[slot_id].pkt;
562 if (remove_item) {
563 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_FREE;
564 h->items[slot_id].pkt = NULL;
6971280a
AS		 565 h->items[slot_id].gen = 0xff;
566 h->popped++;
567 }
568 return 0;
569}
570
84bcc0c3 571static int brcmf_fws_hanger_mark_suppressed(struct brcmf_fws_hanger *h,
6971280a
AS		 572 u32 slot_id, u8 gen)
573{
574 brcmf_dbg(TRACE, "enter\n");
575
576 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS)
577 return -ENOENT;
578
579 h->items[slot_id].gen = gen;
580
3edc1cff 581 if (h->items[slot_id].state != BRCMF_FWS_HANGER_ITEM_STATE_INUSE) {
6971280a
AS		 582 brcmf_err("entry not in use\n");
583 return -EINVAL;
584 }
585
3edc1cff 586 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED;
6971280a
AS		 587 return 0;
588}
589
3edc1cff 590static int brcmf_fws_hanger_get_genbit(struct brcmf_fws_hanger *hanger,
6971280a
AS		 591 struct sk_buff *pkt, u32 slot_id,
592 int *gen)
593{
594 brcmf_dbg(TRACE, "enter\n");
595 *gen = 0xff;
596
597 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS)
598 return -ENOENT;
599
600 if (hanger->items[slot_id].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) {
601 brcmf_err("slot not in use\n");
602 return -EINVAL;
603 }
604
605 *gen = hanger->items[slot_id].gen;
606 return 0;
607}
608
84bcc0c3 609static void brcmf_fws_hanger_cleanup(struct brcmf_fws_info *fws,
6971280a
AS		 610 bool (*fn)(struct sk_buff *, void *),
611 int ifidx)
612{
84bcc0c3 613 struct brcmf_fws_hanger *h = &fws->hanger;
6971280a
AS		 614 struct sk_buff *skb;
615 int i;
616 enum brcmf_fws_hanger_item_state s;
617
618 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx);
619 for (i = 0; i < ARRAY_SIZE(h->items); i++) {
620 s = h->items[i].state;
621 if (s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE ||
622 s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED) {
623 skb = h->items[i].pkt;
624 if (fn == NULL || fn(skb, &ifidx)) {
625 /* suppress packets freed from psq */
626 if (s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE)
627 brcmu_pkt_buf_free_skb(skb);
628 h->items[i].state =
629 BRCMF_FWS_HANGER_ITEM_STATE_FREE;
630 }
631 }
632 }
633}
634
ce814c1b
AS		 635static void brcmf_fws_init_mac_descriptor(struct brcmf_fws_mac_descriptor *desc,
636 u8 *addr, u8 ifidx)
637{
84bcc0c3
AS		 638 brcmf_dbg(TRACE,
639 "enter: desc %p ea=%pM, ifidx=%u\n", desc, addr, ifidx);
ce814c1b
AS		 640 desc->occupied = 1;
641 desc->state = BRCMF_FWS_STATE_OPEN;
642 desc->requested_credit = 0;
643 /* depending on use may need ifp->bssidx instead */
644 desc->interface_id = ifidx;
645 desc->ac_bitmap = 0xff; /* update this when handling APSD */
84bcc0c3
AS		 646 if (addr)
647 memcpy(&desc->ea[0], addr, ETH_ALEN);
ce814c1b
AS		 648}
649
650static
651void brcmf_fws_clear_mac_descriptor(struct brcmf_fws_mac_descriptor *desc)
652{
653 brcmf_dbg(TRACE,
654 "enter: ea=%pM, ifidx=%u\n", desc->ea, desc->interface_id);
655 desc->occupied = 0;
656 desc->state = BRCMF_FWS_STATE_CLOSE;
657 desc->requested_credit = 0;
658}
659
660static struct brcmf_fws_mac_descriptor *
661brcmf_fws_mac_descriptor_lookup(struct brcmf_fws_info *fws, u8 *ea)
662{
663 struct brcmf_fws_mac_descriptor *entry;
664 int i;
665
666 brcmf_dbg(TRACE, "enter: ea=%pM\n", ea);
667 if (ea == NULL)
668 return ERR_PTR(-EINVAL);
669
84bcc0c3
AS		 670 entry = &fws->desc.nodes[0];
671 for (i = 0; i < ARRAY_SIZE(fws->desc.nodes); i++) {
ce814c1b
AS		 672 if (entry->occupied && !memcmp(entry->ea, ea, ETH_ALEN))
673 return entry;
674 entry++;
675 }
676
677 return ERR_PTR(-ENOENT);
678}
679
3edc1cff
AS		 680static struct brcmf_fws_mac_descriptor*
681brcmf_fws_find_mac_desc(struct brcmf_fws_info *fws, int ifidx, u8 *da)
682{
84bcc0c3 683 struct brcmf_fws_mac_descriptor *entry = &fws->desc.other;
3edc1cff
AS		 684 struct brcmf_if *ifp;
685 bool multicast;
686
687 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx);
688
689 multicast = is_multicast_ether_addr(da);
690 ifp = fws->drvr->iflist[ifidx ? ifidx + 1 : 0];
691 if (WARN_ON(!ifp))
692 goto done;
693
694 /* Multicast destination and P2P clients get the interface entry.
695 * STA gets the interface entry if there is no exact match. For
696 * example, TDLS destinations have their own entry.
697 */
698 entry = NULL;
84bcc0c3 699 if (multicast && ifp->fws_desc)
3edc1cff
AS		 700 entry = ifp->fws_desc;
701
702 if (entry != NULL && multicast)
703 goto done;
704
705 entry = brcmf_fws_mac_descriptor_lookup(fws, da);
706 if (IS_ERR(entry))
84bcc0c3 707 entry = &fws->desc.other;
3edc1cff
AS		 708
709done:
710 brcmf_dbg(TRACE, "exit: entry=%p\n", entry);
711 return entry;
712}
713
84bcc0c3
AS		 714static bool brcmf_fws_mac_desc_ready(struct brcmf_fws_mac_descriptor *entry,
715 int fifo)
716{
717 bool ready;
718
719 /*
720 * destination entry is ready when firmware says it is OPEN
721 * and there are no packets enqueued for it.
722 */
723 ready = entry->state == BRCMF_FWS_STATE_OPEN &&
724 !entry->suppressed &&
725 brcmu_pktq_mlen(&entry->psq, 3 << (fifo * 2)) == 0;
726
727 /*
728 * Or when the destination entry is CLOSED, but firmware has
729 * specifically requested packets for this entry.
730 */
731 ready = ready || (entry->state == BRCMF_FWS_STATE_CLOSE &&
732 (entry->requested_credit + entry->requested_packet));
733 return ready;
734}
735
3edc1cff
AS		 736static void brcmf_fws_mac_desc_cleanup(struct brcmf_fws_info *fws,
737 struct brcmf_fws_mac_descriptor *entry,
fba1400a
AS		 738 int ifidx)
739{
3edc1cff 740 brcmf_dbg(TRACE, "enter: entry=(ea=%pM, ifid=%d), ifidx=%d\n",
fba1400a 741 entry->ea, entry->interface_id, ifidx);
3edc1cff
AS		 742 if (entry->occupied && (ifidx == -1 || ifidx == entry->interface_id)) {
743 brcmf_dbg(TRACE, "flush psq: ifidx=%d, qlen=%d\n",
fba1400a 744 ifidx, entry->psq.len);
3edc1cff 745 brcmf_fws_psq_flush(fws, &entry->psq, ifidx);
fba1400a
AS		 746 entry->occupied = !!(entry->psq.len);
747 }
748}
749
e2432b67
AS		 750static void brcmf_fws_bus_txq_cleanup(struct brcmf_fws_info *fws,
751 bool (*fn)(struct sk_buff *, void *),
752 int ifidx)
753{
754 struct brcmf_fws_hanger_item *hi;
755 struct pktq *txq;
756 struct sk_buff *skb;
757 int prec;
758 u32 hslot;
759
760 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx);
761 txq = brcmf_bus_gettxq(fws->drvr->bus_if);
762 if (IS_ERR(txq)) {
763 brcmf_dbg(TRACE, "no txq to clean up\n");
764 return;
765 }
766
767 for (prec = 0; prec < txq->num_prec; prec++) {
768 skb = brcmu_pktq_pdeq_match(txq, prec, fn, &ifidx);
769 while (skb) {
770 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT);
771 hi = &fws->hanger.items[hslot];
772 WARN_ON(skb != hi->pkt);
773 hi->state = BRCMF_FWS_HANGER_ITEM_STATE_FREE;
774 brcmu_pkt_buf_free_skb(skb);
775 skb = brcmu_pktq_pdeq_match(txq, prec, fn, &ifidx);
776 }
777 }
778}
779
fba1400a
AS		 780static void brcmf_fws_cleanup(struct brcmf_fws_info *fws, int ifidx)
781{
782 int i;
783 struct brcmf_fws_mac_descriptor *table;
a3e993c7 784 bool (*matchfn)(struct sk_buff *, void *) = NULL;
fba1400a
AS		 785
786 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx);
787 if (fws == NULL)
788 return;
789
a3e993c7
AS		 790 if (ifidx != -1)
791 matchfn = brcmf_fws_ifidx_match;
792
fba1400a 793 /* cleanup individual nodes */
84bcc0c3
AS		 794 table = &fws->desc.nodes[0];
795 for (i = 0; i < ARRAY_SIZE(fws->desc.nodes); i++)
3edc1cff 796 brcmf_fws_mac_desc_cleanup(fws, &table[i], ifidx);
fba1400a 797
84bcc0c3 798 brcmf_fws_mac_desc_cleanup(fws, &fws->desc.other, ifidx);
e2432b67 799 brcmf_fws_bus_txq_cleanup(fws, matchfn, ifidx);
84bcc0c3
AS		 800 brcmf_fws_hanger_cleanup(fws, matchfn, ifidx);
801}
802
803static void brcmf_fws_tim_update(struct brcmf_fws_info *ctx,
804 struct brcmf_fws_mac_descriptor *entry,
805 int prec)
806{
807 brcmf_dbg(TRACE, "enter: ea=%pM\n", entry->ea);
808 if (entry->state == BRCMF_FWS_STATE_CLOSE) {
809 /* check delayedQ and suppressQ in one call using bitmap */
810 if (brcmu_pktq_mlen(&entry->psq, 3 << (prec * 2)) == 0)
811 entry->traffic_pending_bmp =
812 entry->traffic_pending_bmp & ~NBITVAL(prec);
813 else
814 entry->traffic_pending_bmp =
815 entry->traffic_pending_bmp | NBITVAL(prec);
816 }
817 /* request a TIM update to firmware at the next piggyback opportunity */
818 if (entry->traffic_lastreported_bmp != entry->traffic_pending_bmp)
819 entry->send_tim_signal = true;
820}
821
822static void
823brcmf_fws_flow_control_check(struct brcmf_fws_info *fws, struct pktq *pq,
824 u8 if_id)
825{
826 struct brcmf_if *ifp = fws->drvr->iflist[if_id];
827
828 brcmf_dbg(TRACE,
829 "enter: bssidx=%d, ifidx=%d\n", ifp->bssidx, ifp->ifidx);
830 if (WARN_ON(!ifp))
831 return;
832
833 if ((ifp->netif_stop & BRCMF_NETIF_STOP_REASON_FWS_FC) &&
834 pq->len <= BRCMF_FWS_FLOWCONTROL_LOWATER)
835 brcmf_txflowblock_if(ifp,
836 BRCMF_NETIF_STOP_REASON_FWS_FC, false);
837 if (!(ifp->netif_stop & BRCMF_NETIF_STOP_REASON_FWS_FC) &&
838 pq->len >= BRCMF_FWS_FLOWCONTROL_HIWATER)
839 brcmf_txflowblock_if(ifp, BRCMF_NETIF_STOP_REASON_FWS_FC, true);
840 return;
fba1400a
AS		 841}
842
349e7104
AS		 843static int brcmf_fws_rssi_indicate(struct brcmf_fws_info *fws, s8 rssi)
844{
845 brcmf_dbg(CTL, "rssi %d\n", rssi);
846 return 0;
847}
848
ce814c1b
AS		 849static
850int brcmf_fws_macdesc_indicate(struct brcmf_fws_info *fws, u8 type, u8 *data)
851{
852 struct brcmf_fws_mac_descriptor *entry, *existing;
853 u8 mac_handle;
854 u8 ifidx;
855 u8 *addr;
856
857 mac_handle = *data++;
858 ifidx = *data++;
859 addr = data;
860
84bcc0c3 861 entry = &fws->desc.nodes[mac_handle & 0x1F];
ce814c1b
AS		 862 if (type == BRCMF_FWS_TYPE_MACDESC_DEL) {
863 brcmf_dbg(TRACE, "deleting mac %pM idx %d\n", addr, ifidx);
3edc1cff
AS		 864 if (entry->occupied)
865 brcmf_fws_clear_mac_descriptor(entry);
866 else
ce814c1b 867 fws->stats.mac_update_failed++;
ce814c1b
AS		 868 return 0;
869 }
870
3edc1cff
AS		 871 brcmf_dbg(TRACE,
872 "add mac %pM handle %u idx %d\n", addr, mac_handle, ifidx);
ce814c1b
AS		 873 existing = brcmf_fws_mac_descriptor_lookup(fws, addr);
874 if (IS_ERR(existing)) {
875 if (!entry->occupied) {
876 entry->mac_handle = mac_handle;
877 brcmf_fws_init_mac_descriptor(entry, addr, ifidx);
878 brcmu_pktq_init(&entry->psq, BRCMF_FWS_PSQ_PREC_COUNT,
879 BRCMF_FWS_PSQ_LEN);
880 } else {
881 fws->stats.mac_update_failed++;
882 }
883 } else {
884 if (entry != existing) {
885 brcmf_dbg(TRACE, "relocate mac\n");
886 memcpy(entry, existing,
887 offsetof(struct brcmf_fws_mac_descriptor, psq));
888 entry->mac_handle = mac_handle;
889 brcmf_fws_clear_mac_descriptor(existing);
890 } else {
891 brcmf_dbg(TRACE, "use existing\n");
892 WARN_ON(entry->mac_handle != mac_handle);
893 /* TODO: what should we do here: continue, reinit, .. */
894 }
895 }
896 return 0;
897}
898
84bcc0c3
AS		 899static void brcmf_fws_return_credits(struct brcmf_fws_info *fws,
900 u8 fifo, u8 credits)
901{
902 if (!credits)
903 return;
904
905 fws->fifo_credit_map |= 1 << fifo;
906 fws->fifo_credit[fifo] += credits;
907}
908
909static void brcmf_fws_schedule_deq(struct brcmf_fws_info *fws)
910{
911 /* only schedule dequeue when there are credits for delayed traffic */
912 if (fws->fifo_credit_map & fws->fifo_delay_map)
913 queue_work(fws->fws_wq, &fws->fws_dequeue_work);
914}
915
916static void brcmf_skb_pick_up_credit(struct brcmf_fws_info *fws, int fifo,
917 struct sk_buff *p)
918{
919 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(p)->mac;
920
921 if (brcmf_skbcb(p)->if_flags & BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK) {
922 if (fws->fcmode != BRCMF_FWS_FCMODE_IMPLIED_CREDIT)
923 return;
924 brcmf_fws_return_credits(fws, fifo, 1);
925 } else {
926 /*
927 * if this packet did not count against FIFO credit, it
928 * must have taken a requested_credit from the destination
929 * entry (for pspoll etc.)
930 */
931 if (!brcmf_skb_if_flags_get_field(p, REQUESTED))
932 entry->requested_credit++;
933 }
934 brcmf_fws_schedule_deq(fws);
935}
936
937static int brcmf_fws_enq(struct brcmf_fws_info *fws,
938 enum brcmf_fws_skb_state state, int fifo,
939 struct sk_buff *p)
940{
941 int prec = 2 * fifo;
942 u32 *qfull_stat = &fws->stats.delayq_full_error;
943
944 struct brcmf_fws_mac_descriptor *entry;
945
946 entry = brcmf_skbcb(p)->mac;
947 if (entry == NULL) {
948 brcmf_err("no mac descriptor found for skb %p\n", p);
949 return -ENOENT;
950 }
951
952 brcmf_dbg(TRACE, "enter: ea=%pM, qlen=%d\n", entry->ea, entry->psq.len);
953 if (state == BRCMF_FWS_SKBSTATE_SUPPRESSED) {
954 prec += 1;
955 qfull_stat = &fws->stats.supprq_full_error;
956 }
957
958 if (brcmu_pktq_penq(&entry->psq, prec, p) == NULL) {
959 *qfull_stat += 1;
960 return -ENFILE;
961 }
962
963 /* increment total enqueued packet count */
964 fws->fifo_delay_map |= 1 << fifo;
965 fws->fifo_enqpkt[fifo]++;
966
967 /* update the sk_buff state */
968 brcmf_skbcb(p)->state = state;
969 if (state == BRCMF_FWS_SKBSTATE_SUPPRESSED)
970 entry->suppress_count++;
971
972 /*
973 * A packet has been pushed so update traffic
974 * availability bitmap, if applicable
975 */
976 brcmf_fws_tim_update(fws, entry, fifo);
977 brcmf_fws_flow_control_check(fws, &entry->psq,
978 brcmf_skb_if_flags_get_field(p, INDEX));
979 return 0;
980}
981
982static struct sk_buff *brcmf_fws_deq(struct brcmf_fws_info *fws, int fifo)
983{
984 struct brcmf_fws_mac_descriptor *table;
985 struct brcmf_fws_mac_descriptor *entry;
986 struct sk_buff *p;
987 int use_credit = 1;
988 int num_nodes;
989 int node_pos;
990 int prec_out;
991 int pmsk = 3;
992 int i;
993
994 table = (struct brcmf_fws_mac_descriptor *)&fws->desc;
995 num_nodes = sizeof(fws->desc) / sizeof(struct brcmf_fws_mac_descriptor);
996 node_pos = fws->deq_node_pos[fifo];
997
998 for (i = 0; i < num_nodes; i++) {
999 entry = &table[(node_pos + i) % num_nodes];
1000 if (!entry->occupied)
1001 continue;
1002
1003 if (entry->suppressed)
1004 pmsk = 2;
1005 p = brcmu_pktq_mdeq(&entry->psq, pmsk << (fifo * 2), &prec_out);
1006 if (p == NULL) {
1007 if (entry->suppressed) {
1008 if (entry->suppr_transit_count >
1009 entry->suppress_count)
1010 return NULL;
1011 entry->suppressed = false;
1012 p = brcmu_pktq_mdeq(&entry->psq,
1013 1 << (fifo * 2), &prec_out);
1014 }
1015 }
1016 if (p == NULL)
1017 continue;
1018
1019 /* did the packet come from suppress sub-queue? */
1020 if (entry->requested_credit > 0) {
1021 entry->requested_credit--;
1022 /*
1023 * if the packet was pulled out while destination is in
1024 * closed state but had a non-zero packets requested,
1025 * then this should not count against the FIFO credit.
1026 * That is due to the fact that the firmware will
1027 * most likely hold onto this packet until a suitable
1028 * time later to push it to the appropriate AC FIFO.
1029 */
1030 if (entry->state == BRCMF_FWS_STATE_CLOSE)
1031 use_credit = 0;
1032 } else if (entry->requested_packet > 0) {
1033 entry->requested_packet--;
1034 brcmf_skb_if_flags_set_field(p, REQUESTED, 1);
1035 if (entry->state == BRCMF_FWS_STATE_CLOSE)
1036 use_credit = 0;
1037 }
1038 brcmf_skb_if_flags_set_field(p, CREDITCHECK, use_credit);
1039
1040 /* move dequeue position to ensure fair round-robin */
1041 fws->deq_node_pos[fifo] = (node_pos + i + 1) % num_nodes;
1042 brcmf_fws_flow_control_check(fws, &entry->psq,
1043 brcmf_skb_if_flags_get_field(p,
1044 INDEX)
1045 );
1046 /*
1047 * A packet has been picked up, update traffic
1048 * availability bitmap, if applicable
1049 */
1050 brcmf_fws_tim_update(fws, entry, fifo);
1051
1052 /*
1053 * decrement total enqueued fifo packets and
1054 * clear delay bitmap if done.
1055 */
1056 fws->fifo_enqpkt[fifo]--;
1057 if (fws->fifo_enqpkt[fifo] == 0)
1058 fws->fifo_delay_map &= ~(1 << fifo);
1059 goto done;
1060 }
1061 p = NULL;
1062done:
1063 brcmf_dbg(TRACE, "exit: fifo %d skb %p\n", fifo, p);
1064 return p;
1065}
1066
1067static int brcmf_fws_txstatus_suppressed(struct brcmf_fws_info *fws, int fifo,
1068 struct sk_buff *skb, u32 genbit)
1069{
1070 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac;
1071 u32 hslot;
1072 int ret;
1073
1074 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT);
1075
1076 /* this packet was suppressed */
1077 if (!entry->suppressed || entry->generation != genbit) {
1078 entry->suppressed = true;
1079 entry->suppress_count = brcmu_pktq_mlen(&entry->psq,
1080 1 << (fifo * 2 + 1));
1081 entry->suppr_transit_count = entry->transit_count;
1082 }
1083
1084 entry->generation = genbit;
1085
1086 ret = brcmf_fws_enq(fws, BRCMF_FWS_SKBSTATE_SUPPRESSED, fifo, skb);
1087 if (ret != 0) {
1088 /* suppress q is full, drop this packet */
1089 brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb,
1090 true);
1091 } else {
1092 /*
1093 * Mark suppressed to avoid a double free during
1094 * wlfc cleanup
1095 */
1096 brcmf_fws_hanger_mark_suppressed(&fws->hanger, hslot,
1097 genbit);
1098 entry->suppress_count++;
1099 }
1100
1101 return ret;
1102}
1103
3edc1cff 1104static int
84bcc0c3
AS		 1105brcmf_fws_txstatus_process(struct brcmf_fws_info *fws, u8 flags, u32 hslot,
1106 u32 genbit)
3edc1cff 1107{
84bcc0c3 1108 u32 fifo;
3edc1cff 1109 int ret;
84bcc0c3 1110 bool remove_from_hanger = true;
3edc1cff
AS		 1111 struct sk_buff *skb;
1112 struct brcmf_fws_mac_descriptor *entry = NULL;
1113
84bcc0c3
AS		 1114 fws->stats.txs_indicate++;
1115
3edc1cff
AS		 1116 brcmf_dbg(TRACE, "status: flags=0x%X, hslot=%d\n",
1117 flags, hslot);
1118
1119 if (flags == BRCMF_FWS_TXSTATUS_DISCARD)
1120 fws->stats.txs_discard++;
84bcc0c3
AS		 1121 else if (flags == BRCMF_FWS_TXSTATUS_CORE_SUPPRESS) {
1122 fws->stats.txs_supp_core++;
1123 remove_from_hanger = false;
1124 } else if (flags == BRCMF_FWS_TXSTATUS_FW_PS_SUPPRESS) {
1125 fws->stats.txs_supp_ps++;
1126 remove_from_hanger = false;
1127 } else if (flags == BRCMF_FWS_TXSTATUS_FW_TOSSED)
3edc1cff
AS		 1128 fws->stats.txs_tossed++;
1129 else
1130 brcmf_err("unexpected txstatus\n");
1131
1132 ret = brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb,
84bcc0c3 1133 remove_from_hanger);
3edc1cff
AS		 1134 if (ret != 0) {
1135 brcmf_err("no packet in hanger slot: hslot=%d\n", hslot);
1136 return ret;
1137 }
1138
1139 entry = brcmf_skbcb(skb)->mac;
1140 if (WARN_ON(!entry)) {
84bcc0c3
AS		 1141 brcmu_pkt_buf_free_skb(skb);
1142 return -EINVAL;
3edc1cff
AS		 1143 }
1144
84bcc0c3
AS		 1145 /* pick up the implicit credit from this packet */
1146 fifo = brcmf_skb_htod_tag_get_field(skb, FIFO);
1147 brcmf_skb_pick_up_credit(fws, fifo, skb);
3edc1cff 1148
84bcc0c3
AS		 1149 if (!remove_from_hanger)
1150 ret = brcmf_fws_txstatus_suppressed(fws, fifo, skb, genbit);
1151
1152 if (remove_from_hanger || ret) {
1153 entry->transit_count--;
1154 if (entry->suppressed)
1155 entry->suppr_transit_count--;
1156
1157 brcmf_txfinalize(fws->drvr, skb, true);
1158 }
1159 return 0;
1160}
1161
1162static int brcmf_fws_fifocreditback_indicate(struct brcmf_fws_info *fws,
1163 u8 *data)
1164{
1165 int i;
1166
1167 if (fws->fcmode != BRCMF_FWS_FCMODE_EXPLICIT_CREDIT) {
1168 brcmf_dbg(INFO, "ignored\n");
1169 return 0;
1170 }
1171
1172 brcmf_dbg(TRACE, "enter: data %pM\n", data);
1173 for (i = 0; i < BRCMF_FWS_FIFO_COUNT; i++)
1174 brcmf_fws_return_credits(fws, i, data[i]);
1175
1176 brcmf_dbg(INFO, "map: credit %x delay %x\n", fws->fifo_credit_map,
1177 fws->fifo_delay_map);
1178 brcmf_fws_schedule_deq(fws);
1179 return 0;
3edc1cff
AS		 1180}
1181
0f8b5cc5
AS		 1182static int brcmf_fws_txstatus_indicate(struct brcmf_fws_info *fws, u8 *data)
1183{
1184 u32 status;
1185 u32 hslot;
84bcc0c3 1186 u32 genbit;
0f8b5cc5
AS		 1187 u8 flags;
1188
1189 fws->stats.txs_indicate++;
1190 status = le32_to_cpu(*(__le32 *)data);
1191 flags = brcmf_txstatus_get_field(status, FLAGS);
1192 hslot = brcmf_txstatus_get_field(status, HSLOT);
84bcc0c3 1193 genbit = brcmf_txstatus_get_field(status, GENERATION);
0f8b5cc5 1194
84bcc0c3 1195 return brcmf_fws_txstatus_process(fws, flags, hslot, genbit);
0f8b5cc5
AS		 1196}
1197
349e7104
AS		 1198static int brcmf_fws_dbg_seqnum_check(struct brcmf_fws_info *fws, u8 *data)
1199{
1200 __le32 timestamp;
1201
1202 memcpy(&timestamp, &data[2], sizeof(timestamp));
1203 brcmf_dbg(INFO, "received: seq %d, timestamp %d\n", data[1],
1204 le32_to_cpu(timestamp));
1205 return 0;
1206}
1207
1208/* using macro so sparse checking does not complain
1209 * about locking imbalance.
1210 */
1211#define brcmf_fws_lock(drvr, flags) \
1212do { \
1213 flags = 0; \
1214 spin_lock_irqsave(&((drvr)->fws_spinlock), (flags)); \
1215} while (0)
1216
1217/* using macro so sparse checking does not complain
1218 * about locking imbalance.
1219 */
1220#define brcmf_fws_unlock(drvr, flags) \
1221 spin_unlock_irqrestore(&((drvr)->fws_spinlock), (flags))
1222
43fa635e
AS		 1223static int brcmf_fws_notify_credit_map(struct brcmf_if *ifp,
1224 const struct brcmf_event_msg *e,
1225 void *data)
1226{
1227 struct brcmf_fws_info *fws = ifp->drvr->fws;
1228 int i;
1229 ulong flags;
1230 u8 *credits = data;
1231
84bcc0c3
AS		 1232 if (e->datalen < BRCMF_FWS_FIFO_COUNT) {
1233 brcmf_err("event payload too small (%d)\n", e->datalen);
1234 return -EINVAL;
1235 }
1236
1237 brcmf_dbg(TRACE, "enter: credits %pM\n", credits);
43fa635e 1238 brcmf_fws_lock(ifp->drvr, flags);
84bcc0c3
AS		 1239 for (i = 0; i < ARRAY_SIZE(fws->fifo_credit); i++) {
1240 if (*credits)
1241 fws->fifo_credit_map |= 1 << i;
1242 else
1243 fws->fifo_credit_map &= ~(1 << i);
43fa635e 1244 fws->fifo_credit[i] = *credits++;
84bcc0c3
AS		 1245 }
1246 brcmf_fws_schedule_deq(fws);
43fa635e
AS		 1247 brcmf_fws_unlock(ifp->drvr, flags);
1248 return 0;
1249}
1250
349e7104
AS		 1251int brcmf_fws_hdrpull(struct brcmf_pub *drvr, int ifidx, s16 signal_len,
1252 struct sk_buff *skb)
1253{
1254 struct brcmf_fws_info *fws = drvr->fws;
1255 ulong flags;
1256 u8 *signal_data;
1257 s16 data_len;
1258 u8 type;
1259 u8 len;
1260 u8 *data;
1261
1262 brcmf_dbg(TRACE, "enter: ifidx %d, skblen %u, sig %d\n",
1263 ifidx, skb->len, signal_len);
1264
1265 WARN_ON(signal_len > skb->len);
1266
1267 /* if flow control disabled, skip to packet data and leave */
1268 if (!signal_len || !drvr->fw_signals) {
1269 skb_pull(skb, signal_len);
1270 return 0;
1271 }
1272
1273 /* lock during tlv parsing */
1274 brcmf_fws_lock(drvr, flags);
1275
1276 fws->stats.header_pulls++;
1277 data_len = signal_len;
1278 signal_data = skb->data;
1279
1280 while (data_len > 0) {
1281 /* extract tlv info */
1282 type = signal_data[0];
1283
1284 /* FILLER type is actually not a TLV, but
1285 * a single byte that can be skipped.
1286 */
1287 if (type == BRCMF_FWS_TYPE_FILLER) {
1288 signal_data += 1;
1289 data_len -= 1;
1290 continue;
1291 }
1292 len = signal_data[1];
1293 data = signal_data + 2;
1294
2af15580
AS		 1295 brcmf_dbg(INFO, "tlv type=%d (%s), len=%d, data[0]=%d\n", type,
1296 brcmf_fws_get_tlv_name(type), len, *data);
1297
349e7104
AS		 1298 /* abort parsing when length invalid */
1299 if (data_len < len + 2)
1300 break;
1301
bb8c8063
AS		 1302 if (len != brcmf_fws_get_tlv_len(fws, type))
1303 break;
1304
349e7104
AS		 1305 switch (type) {
1306 case BRCMF_FWS_TYPE_MAC_OPEN:
1307 case BRCMF_FWS_TYPE_MAC_CLOSE:
349e7104 1308 case BRCMF_FWS_TYPE_MAC_REQUEST_CREDIT:
349e7104
AS		 1309 case BRCMF_FWS_TYPE_INTERFACE_OPEN:
1310 case BRCMF_FWS_TYPE_INTERFACE_CLOSE:
349e7104 1311 case BRCMF_FWS_TYPE_MAC_REQUEST_PACKET:
349e7104 1312 case BRCMF_FWS_TYPE_HOST_REORDER_RXPKTS:
bb8c8063 1313 case BRCMF_FWS_TYPE_COMP_TXSTATUS:
ce814c1b 1314 break;
bb8c8063
AS		 1315 case BRCMF_FWS_TYPE_MACDESC_ADD:
1316 case BRCMF_FWS_TYPE_MACDESC_DEL:
ce814c1b 1317 brcmf_fws_macdesc_indicate(fws, type, data);
bb8c8063 1318 break;
3edc1cff
AS		 1319 case BRCMF_FWS_TYPE_TXSTATUS:
1320 brcmf_fws_txstatus_indicate(fws, data);
1321 break;
84bcc0c3
AS		 1322 case BRCMF_FWS_TYPE_FIFO_CREDITBACK:
1323 brcmf_fws_fifocreditback_indicate(fws, data);
1324 break;
bb8c8063
AS		 1325 case BRCMF_FWS_TYPE_RSSI:
1326 brcmf_fws_rssi_indicate(fws, *data);
349e7104
AS		 1327 break;
1328 case BRCMF_FWS_TYPE_TRANS_ID:
349e7104
AS		 1329 brcmf_fws_dbg_seqnum_check(fws, data);
1330 break;
84bcc0c3
AS		 1331 case BRCMF_FWS_TYPE_PKTTAG:
1332 case BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP:
349e7104
AS		 1333 default:
1334 fws->stats.tlv_invalid_type++;
1335 break;
1336 }
1337
1338 signal_data += len + 2;
1339 data_len -= len + 2;
1340 }
1341
1342 if (data_len != 0)
1343 fws->stats.tlv_parse_failed++;
1344
1345 /* signalling processing result does
1346 * not affect the actual ethernet packet.
1347 */
1348 skb_pull(skb, signal_len);
1349
1350 /* this may be a signal-only packet
1351 */
1352 if (skb->len == 0)
1353 fws->stats.header_only_pkt++;
1354
1355 brcmf_fws_unlock(drvr, flags);
1356 return 0;
1357}
bb8c8063 1358
3edc1cff
AS		 1359static int brcmf_fws_hdrpush(struct brcmf_fws_info *fws, struct sk_buff *skb)
1360{
1361 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac;
1362 u8 *wlh;
84bcc0c3 1363 u16 data_offset = 0;
3edc1cff
AS		 1364 u8 fillers;
1365 __le32 pkttag = cpu_to_le32(brcmf_skbcb(skb)->htod);
1366
1367 brcmf_dbg(TRACE, "enter: ea=%pM, ifidx=%u, pkttag=0x%08X\n",
1368 entry->ea, entry->interface_id, le32_to_cpu(pkttag));
84bcc0c3
AS		 1369 if (entry->send_tim_signal)
1370 data_offset += 2 + BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP_LEN;
1371
3edc1cff 1372 /* +2 is for Type[1] and Len[1] in TLV, plus TIM signal */
84bcc0c3 1373 data_offset += 2 + BRCMF_FWS_TYPE_PKTTAG_LEN;
3edc1cff
AS		 1374 fillers = round_up(data_offset, 4) - data_offset;
1375 data_offset += fillers;
1376
1377 skb_push(skb, data_offset);
1378 wlh = skb->data;
1379
1380 wlh[0] = BRCMF_FWS_TYPE_PKTTAG;
1381 wlh[1] = BRCMF_FWS_TYPE_PKTTAG_LEN;
1382 memcpy(&wlh[2], &pkttag, sizeof(pkttag));
1383 wlh += BRCMF_FWS_TYPE_PKTTAG_LEN + 2;
1384
84bcc0c3
AS		 1385 if (entry->send_tim_signal) {
1386 entry->send_tim_signal = 0;
1387 wlh[0] = BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP;
1388 wlh[1] = BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP_LEN;
1389 wlh[2] = entry->mac_handle;
1390 wlh[3] = entry->traffic_pending_bmp;
1391 wlh += BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP_LEN + 2;
1392 entry->traffic_lastreported_bmp = entry->traffic_pending_bmp;
1393 }
3edc1cff
AS		 1394 if (fillers)
1395 memset(wlh, BRCMF_FWS_TYPE_FILLER, fillers);
1396
1397 brcmf_proto_hdrpush(fws->drvr, brcmf_skb_if_flags_get_field(skb, INDEX),
1398 data_offset >> 2, skb);
1399 return 0;
1400}
1401
1402static int brcmf_fws_precommit_skb(struct brcmf_fws_info *fws, int fifo,
1403 struct sk_buff *p)
1404{
1405 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(p);
1406 struct brcmf_fws_mac_descriptor *entry = skcb->mac;
1407 int rc = 0;
1408 bool header_needed;
1409 int hslot = BRCMF_FWS_HANGER_MAXITEMS;
1410 u8 free_ctr;
1411 u8 ifidx;
1412 u8 flags;
1413
84bcc0c3 1414 header_needed = skcb->state != BRCMF_FWS_SKBSTATE_SUPPRESSED;
3edc1cff
AS		 1415
1416 if (header_needed) {
1417 /* obtaining free slot may fail, but that will be caught
1418 * by the hanger push. This assures the packet has a BDC
1419 * header upon return.
1420 */
1421 hslot = brcmf_fws_hanger_get_free_slot(&fws->hanger);
1422 free_ctr = entry->seq[fifo];
1423 brcmf_skb_htod_tag_set_field(p, HSLOT, hslot);
1424 brcmf_skb_htod_tag_set_field(p, FREERUN, free_ctr);
1425 brcmf_skb_htod_tag_set_field(p, GENERATION, 1);
1426 entry->transit_count++;
1427 }
1428 brcmf_skb_if_flags_set_field(p, TRANSMIT, 1);
1429 brcmf_skb_htod_tag_set_field(p, FIFO, fifo);
1430
1431 flags = BRCMF_FWS_HTOD_FLAG_PKTFROMHOST;
1432 if (!(skcb->if_flags & BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK)) {
1433 /*
1434 Indicate that this packet is being sent in response to an
1435 explicit request from the firmware side.
1436 */
1437 flags |= BRCMF_FWS_HTOD_FLAG_PKT_REQUESTED;
1438 }
1439 brcmf_skb_htod_tag_set_field(p, FLAGS, flags);
1440 if (header_needed) {
1441 brcmf_fws_hdrpush(fws, p);
1442 rc = brcmf_fws_hanger_pushpkt(&fws->hanger, p, hslot);
1443 if (rc)
1444 brcmf_err("hanger push failed: rc=%d\n", rc);
1445 } else {
1446 int gen;
1447
1448 /* remove old header */
1449 rc = brcmf_proto_hdrpull(fws->drvr, false, &ifidx, p);
1450 if (rc == 0) {
1451 hslot = brcmf_skb_htod_tag_get_field(p, HSLOT);
1452 brcmf_fws_hanger_get_genbit(&fws->hanger, p,
1453 hslot, &gen);
1454 brcmf_skb_htod_tag_set_field(p, GENERATION, gen);
1455
1456 /* push new header */
1457 brcmf_fws_hdrpush(fws, p);
1458 }
1459 }
1460
1461 return rc;
1462}
1463
84bcc0c3
AS		 1464static int
1465brcmf_fws_rollback_toq(struct brcmf_fws_info *fws, struct sk_buff *skb)
1466{
1467 /*
1468 put the packet back to the head of queue
1469
1470 - suppressed packet goes back to suppress sub-queue
1471 - pull out the header, if new or delayed packet
1472
1473 Note: hslot is used only when header removal is done.
1474 */
1475 struct brcmf_fws_mac_descriptor *entry;
1476 enum brcmf_fws_skb_state state;
1477 struct sk_buff *pktout;
1478 int rc = 0;
1479 int fifo;
1480 int hslot;
1481 u8 ifidx;
1482
1483 fifo = brcmf_skb_if_flags_get_field(skb, FIFO);
1484 state = brcmf_skbcb(skb)->state;
1485 entry = brcmf_skbcb(skb)->mac;
1486
1487 if (entry != NULL) {
1488 if (state == BRCMF_FWS_SKBSTATE_SUPPRESSED) {
1489 /* wl-header is saved for suppressed packets */
1490 pktout = brcmu_pktq_penq_head(&entry->psq, 2 * fifo + 1,
1491 skb);
1492 if (pktout == NULL) {
1493 brcmf_err("suppress queue full\n");
1494 rc = -ENOSPC;
1495 }
1496 } else {
1497 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT);
1498
1499 /* remove header first */
1500 rc = brcmf_proto_hdrpull(fws->drvr, false, &ifidx, skb);
1501 if (rc) {
1502 brcmf_err("header removal failed\n");
1503 /* free the hanger slot */
1504 brcmf_fws_hanger_poppkt(&fws->hanger, hslot,
1505 &pktout, true);
1506 brcmf_txfinalize(fws->drvr, skb, false);
1507 rc = -EINVAL;
1508 goto fail;
1509 }
1510
1511 /* delay-q packets are going to delay-q */
1512 pktout = brcmu_pktq_penq_head(&entry->psq,
1513 2 * fifo, skb);
1514 if (pktout == NULL) {
1515 brcmf_err("delay queue full\n");
1516 rc = -ENOSPC;
1517 }
1518
1519 /* free the hanger slot */
1520 brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &pktout,
1521 true);
1522
1523 /* decrement sequence count */
1524 entry->seq[fifo]--;
1525 }
1526 /*
1527 if this packet did not count against FIFO credit, it must have
1528 taken a requested_credit from the firmware (for pspoll etc.)
1529 */
1530 if (!(brcmf_skbcb(skb)->if_flags &
1531 BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK))
1532 entry->requested_credit++;
1533 } else {
1534 brcmf_err("no mac entry linked\n");
1535 rc = -ENOENT;
1536 }
1537
1538
1539fail:
1540 if (rc)
1541 fws->stats.rollback_failed++;
1542 else
1543 fws->stats.rollback_success++;
1544 return rc;
1545}
1546
1547static int brcmf_fws_consume_credit(struct brcmf_fws_info *fws, int fifo,
1548 struct sk_buff *skb)
1549{
1550 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac;
1551 int *credit = &fws->fifo_credit[fifo];
1552 int use_credit = 1;
1553
1554 brcmf_dbg(TRACE, "enter: ac=%d, credits=%d\n", fifo, *credit);
1555
1556 if (entry->requested_credit > 0) {
1557 /*
1558 * if the packet was pulled out while destination is in
1559 * closed state but had a non-zero packets requested,
1560 * then this should not count against the FIFO credit.
1561 * That is due to the fact that the firmware will
1562 * most likely hold onto this packet until a suitable
1563 * time later to push it to the appropriate AC FIFO.
1564 */
1565 entry->requested_credit--;
1566 if (entry->state == BRCMF_FWS_STATE_CLOSE)
1567 use_credit = 0;
1568 } else if (entry->requested_packet > 0) {
1569 entry->requested_packet--;
1570 brcmf_skb_if_flags_set_field(skb, REQUESTED, 1);
1571 if (entry->state == BRCMF_FWS_STATE_CLOSE)
1572 use_credit = 0;
1573 }
1574 brcmf_skb_if_flags_set_field(skb, CREDITCHECK, use_credit);
1575 if (!use_credit) {
1576 brcmf_dbg(TRACE, "exit: no creditcheck set\n");
1577 return 0;
1578 }
1579
1580 if (!(*credit)) {
1581 brcmf_dbg(TRACE, "exit: credits depleted\n");
1582 return -ENAVAIL;
1583 }
1584 (*credit)--;
1585 if (!(*credit))
1586 fws->fifo_credit_map &= ~(1 << fifo);
1587 brcmf_dbg(TRACE, "exit: ac=%d, credits=%d\n", fifo, *credit);
1588 return 0;
1589}
1590
3edc1cff
AS		 1591static int brcmf_fws_commit_skb(struct brcmf_fws_info *fws, int fifo,
1592 struct sk_buff *skb)
1593{
1594 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb);
1595 struct brcmf_fws_mac_descriptor *entry;
1596 struct brcmf_bus *bus = fws->drvr->bus_if;
1597 int rc;
1598
1599 entry = skcb->mac;
1600 if (IS_ERR(entry))
1601 return PTR_ERR(entry);
1602
1603 rc = brcmf_fws_precommit_skb(fws, fifo, skb);
1604 if (rc < 0) {
1605 fws->stats.generic_error++;
84bcc0c3 1606 goto rollback;
3edc1cff
AS		 1607 }
1608
1609 rc = brcmf_bus_txdata(bus, skb);
1610 if (rc < 0)
84bcc0c3 1611 goto rollback;
3edc1cff
AS		 1612
1613 entry->seq[fifo]++;
1614 fws->stats.pkt2bus++;
84bcc0c3
AS		 1615 if (brcmf_skbcb(skb)->if_flags & BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK) {
1616 fws->stats.send_pkts[fifo]++;
1617 fws->stats.fifo_credits_sent[fifo]++;
1618 }
1619
3edc1cff
AS		 1620 return rc;
1621
84bcc0c3
AS		 1622rollback:
1623 rc = brcmf_fws_rollback_toq(fws, skb);
3edc1cff
AS		 1624 return rc;
1625}
1626
1627int brcmf_fws_process_skb(struct brcmf_if *ifp, struct sk_buff *skb)
1628{
1629 struct brcmf_pub *drvr = ifp->drvr;
1630 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb);
1631 struct ethhdr *eh = (struct ethhdr *)(skb->data);
1632 ulong flags;
1633 u8 ifidx = ifp->ifidx;
1634 int fifo = BRCMF_FWS_FIFO_BCMC;
1635 bool multicast = is_multicast_ether_addr(eh->h_dest);
1636
1637 /* determine the priority */
1638 if (!skb->priority)
1639 skb->priority = cfg80211_classify8021d(skb);
1640
1641 drvr->tx_multicast += !!multicast;
1642 if (ntohs(eh->h_proto) == ETH_P_PAE)
1643 atomic_inc(&ifp->pend_8021x_cnt);
1644
1645 if (!brcmf_fws_fc_active(drvr->fws)) {
1646 /* If the protocol uses a data header, apply it */
1647 brcmf_proto_hdrpush(drvr, ifidx, 0, skb);
1648
1649 /* Use bus module to send data frame */
1650 return brcmf_bus_txdata(drvr->bus_if, skb);
1651 }
1652
1653 /* set control buffer information */
84bcc0c3 1654 skcb->if_flags = 0;
3edc1cff
AS		 1655 skcb->mac = brcmf_fws_find_mac_desc(drvr->fws, ifidx, eh->h_dest);
1656 skcb->state = BRCMF_FWS_SKBSTATE_NEW;
1657 brcmf_skb_if_flags_set_field(skb, INDEX, ifidx);
1658 if (!multicast)
1659 fifo = brcmf_fws_prio2fifo[skb->priority];
1660 brcmf_skb_if_flags_set_field(skb, FIFO, fifo);
3edc1cff
AS		 1661
1662 brcmf_dbg(TRACE, "ea=%pM, multi=%d, fifo=%d\n", eh->h_dest,
1663 multicast, fifo);
1664
1665 brcmf_fws_lock(drvr, flags);
84bcc0c3
AS		 1666 if (!brcmf_fws_mac_desc_ready(skcb->mac, fifo) ||
1667 (!multicast &&
1668 brcmf_fws_consume_credit(drvr->fws, fifo, skb) < 0)) {
1669 /* enqueue the packet in delayQ */
1670 drvr->fws->fifo_delay_map |= 1 << fifo;
1671 brcmf_fws_enq(drvr->fws, BRCMF_FWS_SKBSTATE_DELAYED, fifo, skb);
1672 } else {
1673 brcmf_fws_commit_skb(drvr->fws, fifo, skb);
1674 }
3edc1cff
AS		 1675 brcmf_fws_unlock(drvr, flags);
1676 return 0;
1677}
1678
bb8c8063
AS		 1679void brcmf_fws_reset_interface(struct brcmf_if *ifp)
1680{
1681 struct brcmf_fws_mac_descriptor *entry = ifp->fws_desc;
1682
1683 brcmf_dbg(TRACE, "enter: idx=%d\n", ifp->bssidx);
1684 if (!entry)
1685 return;
1686
ce814c1b 1687 brcmf_fws_init_mac_descriptor(entry, ifp->mac_addr, ifp->ifidx);
bb8c8063
AS		 1688}
1689
1690void brcmf_fws_add_interface(struct brcmf_if *ifp)
1691{
84bcc0c3 1692 struct brcmf_fws_info *fws = ifp->drvr->fws;
bb8c8063
AS		 1693 struct brcmf_fws_mac_descriptor *entry;
1694
1695 brcmf_dbg(TRACE, "enter: idx=%d, mac=%pM\n",
1696 ifp->bssidx, ifp->mac_addr);
1697 if (!ifp->drvr->fw_signals)
1698 return;
1699
84bcc0c3
AS		 1700 entry = &fws->desc.iface[ifp->ifidx];
1701 ifp->fws_desc = entry;
1702 brcmf_fws_init_mac_descriptor(entry, ifp->mac_addr, ifp->ifidx);
1703 brcmu_pktq_init(&entry->psq, BRCMF_FWS_PSQ_PREC_COUNT,
1704 BRCMF_FWS_PSQ_LEN);
bb8c8063
AS		 1705}
1706
1707void brcmf_fws_del_interface(struct brcmf_if *ifp)
1708{
1709 struct brcmf_fws_mac_descriptor *entry = ifp->fws_desc;
1710
1711 brcmf_dbg(TRACE, "enter: idx=%d\n", ifp->bssidx);
1712 if (!entry)
1713 return;
1714
1715 ifp->fws_desc = NULL;
ce814c1b 1716 brcmf_fws_clear_mac_descriptor(entry);
a3e993c7 1717 brcmf_fws_cleanup(ifp->drvr->fws, ifp->ifidx);
84bcc0c3
AS		 1718}
1719
1720static void brcmf_fws_dequeue_worker(struct work_struct *worker)
1721{
1722 struct brcmf_fws_info *fws;
1723 struct sk_buff *skb;
1724 ulong flags;
1725 int fifo;
1726 int credit;
1727
1728 fws = container_of(worker, struct brcmf_fws_info, fws_dequeue_work);
1729
1730 brcmf_dbg(TRACE, "enter: fws=%p\n", fws);
1731 brcmf_fws_lock(fws->drvr, flags);
1732 for (fifo = NL80211_NUM_ACS; fifo >= 0; fifo--) {
1733 brcmf_dbg(TRACE, "fifo %d credit %d\n", fifo,
1734 fws->fifo_credit[fifo]);
1735 for (credit = 0; credit < fws->fifo_credit[fifo]; /* nop */) {
1736 skb = brcmf_fws_deq(fws, fifo);
1737 if (!skb)
1738 break;
1739 if (!brcmf_fws_commit_skb(fws, fifo, skb) &&
1740 brcmf_skbcb(skb)->if_flags &
1741 BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK)
1742 credit++;
1743 }
1744 fws->fifo_credit[fifo] -= credit;
1745 }
1746 brcmf_fws_unlock(fws->drvr, flags);
bb8c8063 1747}
c7f34a69 1748
d9337414
AS		 1749int brcmf_fws_init(struct brcmf_pub *drvr)
1750{
290fb763 1751 u32 tlv = BRCMF_FWS_FLAGS_RSSI_SIGNALS;
d9337414
AS		 1752 int rc;
1753
47829f4f
AS		 1754 if (!drvr->fw_signals)
1755 return 0;
1756
d9337414
AS		 1757 spin_lock_init(&drvr->fws_spinlock);
1758
1759 drvr->fws = kzalloc(sizeof(*(drvr->fws)), GFP_KERNEL);
1760 if (!drvr->fws) {
1761 rc = -ENOMEM;
1762 goto fail;
1763 }
1764
1765 /* set linkage back */
1766 drvr->fws->drvr = drvr;
1767 drvr->fws->fcmode = fcmode;
1768
84bcc0c3
AS		 1769 drvr->fws->fws_wq = create_singlethread_workqueue("brcmf_fws_wq");
1770 if (drvr->fws->fws_wq == NULL) {
1771 brcmf_err("workqueue creation failed\n");
1772 rc = -EBADF;
1773 goto fail;
1774 }
1775 INIT_WORK(&drvr->fws->fws_dequeue_work, brcmf_fws_dequeue_worker);
1776
290fb763
AS		 1777 /* enable firmware signalling if fcmode active */
1778 if (drvr->fws->fcmode != BRCMF_FWS_FCMODE_NONE)
1779 tlv |= BRCMF_FWS_FLAGS_XONXOFF_SIGNALS |
1780 BRCMF_FWS_FLAGS_CREDIT_STATUS_SIGNALS;
1781
d9337414
AS		 1782 rc = brcmf_fil_iovar_int_set(drvr->iflist[0], "tlv", tlv);
1783 if (rc < 0) {
1784 brcmf_err("failed to set bdcv2 tlv signaling\n");
1785 goto fail;
1786 }
1787
1788 if (brcmf_fweh_register(drvr, BRCMF_E_FIFO_CREDIT_MAP,
1789 brcmf_fws_notify_credit_map)) {
1790 brcmf_err("register credit map handler failed\n");
1791 goto fail;
1792 }
1793
1794 brcmf_fws_hanger_init(&drvr->fws->hanger);
84bcc0c3
AS		 1795 brcmf_fws_init_mac_descriptor(&drvr->fws->desc.other, NULL, 0);
1796 brcmu_pktq_init(&drvr->fws->desc.other.psq, BRCMF_FWS_PSQ_PREC_COUNT,
1797 BRCMF_FWS_PSQ_LEN);
d9337414
AS		 1798
1799 /* create debugfs file for statistics */
1800 brcmf_debugfs_create_fws_stats(drvr, &drvr->fws->stats);
1801
1802 /* TODO: remove upon feature delivery */
1803 brcmf_err("%s bdcv2 tlv signaling [%x]\n",
1804 drvr->fw_signals ? "enabled" : "disabled", tlv);
1805 return 0;
1806
1807fail:
1808 /* disable flow control entirely */
1809 drvr->fw_signals = false;
1810 brcmf_fws_deinit(drvr);
1811 return rc;
1812}
1813
1814void brcmf_fws_deinit(struct brcmf_pub *drvr)
1815{
1816 struct brcmf_fws_info *fws = drvr->fws;
1817 ulong flags;
1818
47829f4f
AS		 1819 if (!fws)
1820 return;
1821
d9337414
AS		 1822 /* cleanup */
1823 brcmf_fws_lock(drvr, flags);
1824 brcmf_fws_cleanup(fws, -1);
1825 drvr->fws = NULL;
1826 brcmf_fws_unlock(drvr, flags);
1827
1828 /* free top structure */
1829 kfree(fws);
1830}
1831
c7f34a69
AS		 1832bool brcmf_fws_fc_active(struct brcmf_fws_info *fws)
1833{
1834 if (!fws)
1835 return false;
1836
1837 brcmf_dbg(TRACE, "enter: mode=%d\n", fws->fcmode);
1838 return fws->fcmode != BRCMF_FWS_FCMODE_NONE;
1839}
0f8b5cc5
AS		 1840
1841void brcmf_fws_bustxfail(struct brcmf_fws_info *fws, struct sk_buff *skb)
1842{
1843 ulong flags;
1844
1845 brcmf_fws_lock(fws->drvr, flags);
1846 brcmf_fws_txstatus_process(fws, BRCMF_FWS_TXSTATUS_FW_TOSSED,
84bcc0c3
AS		 1847 brcmf_skb_htod_tag_get_field(skb, HSLOT), 0);
1848 /* the packet never reached firmware so reclaim credit */
1849 if (fws->fcmode == BRCMF_FWS_FCMODE_EXPLICIT_CREDIT &&
1850 brcmf_skbcb(skb)->if_flags & BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK) {
1851 brcmf_fws_return_credits(fws,
1852 brcmf_skb_htod_tag_get_field(skb,
1853 FIFO),
1854 1);
1855 brcmf_fws_schedule_deq(fws);
1856 }
0f8b5cc5
AS		 1857 brcmf_fws_unlock(fws->drvr, flags);
1858}
Linux kernel - Deliverables
This page took 0.116141 seconds and 5 git commands to generate.