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