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