fwsignal.c revision 0f8b5cc5214b0c8c772d9ba0a41f5b1f07aff274
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 "fweh.h" 35#include "fwsignal.h" 36 37/** 38 * DOC: Firmware Signalling 39 * 40 * Firmware can send signals to host and vice versa, which are passed in the 41 * data packets using TLV based header. This signalling layer is on top of the 42 * BDC bus protocol layer. 43 */ 44 45/* 46 * single definition for firmware-driver flow control tlv's. 47 * 48 * each tlv is specified by BRCMF_FWS_TLV_DEF(name, ID, length). 49 * A length value 0 indicates variable length tlv. 50 */ 51#define BRCMF_FWS_TLV_DEFLIST \ 52 BRCMF_FWS_TLV_DEF(MAC_OPEN, 1, 1) \ 53 BRCMF_FWS_TLV_DEF(MAC_CLOSE, 2, 1) \ 54 BRCMF_FWS_TLV_DEF(MAC_REQUEST_CREDIT, 3, 2) \ 55 BRCMF_FWS_TLV_DEF(TXSTATUS, 4, 4) \ 56 BRCMF_FWS_TLV_DEF(PKTTAG, 5, 4) \ 57 BRCMF_FWS_TLV_DEF(MACDESC_ADD, 6, 8) \ 58 BRCMF_FWS_TLV_DEF(MACDESC_DEL, 7, 8) \ 59 BRCMF_FWS_TLV_DEF(RSSI, 8, 1) \ 60 BRCMF_FWS_TLV_DEF(INTERFACE_OPEN, 9, 1) \ 61 BRCMF_FWS_TLV_DEF(INTERFACE_CLOSE, 10, 1) \ 62 BRCMF_FWS_TLV_DEF(FIFO_CREDITBACK, 11, 8) \ 63 BRCMF_FWS_TLV_DEF(PENDING_TRAFFIC_BMP, 12, 2) \ 64 BRCMF_FWS_TLV_DEF(MAC_REQUEST_PACKET, 13, 3) \ 65 BRCMF_FWS_TLV_DEF(HOST_REORDER_RXPKTS, 14, 10) \ 66 BRCMF_FWS_TLV_DEF(TRANS_ID, 18, 6) \ 67 BRCMF_FWS_TLV_DEF(COMP_TXSTATUS, 19, 1) \ 68 BRCMF_FWS_TLV_DEF(FILLER, 255, 0) 69 70/* 71 * enum brcmf_fws_tlv_type - definition of tlv identifiers. 72 */ 73#define BRCMF_FWS_TLV_DEF(name, id, len) \ 74 BRCMF_FWS_TYPE_ ## name = id, 75enum brcmf_fws_tlv_type { 76 BRCMF_FWS_TLV_DEFLIST 77 BRCMF_FWS_TYPE_INVALID 78}; 79#undef BRCMF_FWS_TLV_DEF 80 81/* 82 * enum brcmf_fws_tlv_len - definition of tlv lengths. 83 */ 84#define BRCMF_FWS_TLV_DEF(name, id, len) \ 85 BRCMF_FWS_TYPE_ ## name ## _LEN = (len), 86enum brcmf_fws_tlv_len { 87 BRCMF_FWS_TLV_DEFLIST 88}; 89#undef BRCMF_FWS_TLV_DEF 90 91#ifdef DEBUG 92/* 93 * brcmf_fws_tlv_names - array of tlv names. 94 */ 95#define BRCMF_FWS_TLV_DEF(name, id, len) \ 96 { id, #name }, 97static struct { 98 enum brcmf_fws_tlv_type id; 99 const char *name; 100} brcmf_fws_tlv_names[] = { 101 BRCMF_FWS_TLV_DEFLIST 102}; 103#undef BRCMF_FWS_TLV_DEF 104 105static const char *brcmf_fws_get_tlv_name(enum brcmf_fws_tlv_type id) 106{ 107 int i; 108 109 for (i = 0; i < ARRAY_SIZE(brcmf_fws_tlv_names); i++) 110 if (brcmf_fws_tlv_names[i].id == id) 111 return brcmf_fws_tlv_names[i].name; 112 113 return "INVALID"; 114} 115#else 116static const char *brcmf_fws_get_tlv_name(enum brcmf_fws_tlv_type id) 117{ 118 return "NODEBUG"; 119} 120#endif /* DEBUG */ 121 122/* 123 * flags used to enable tlv signalling from firmware. 124 */ 125#define BRCMF_FWS_FLAGS_RSSI_SIGNALS 0x0001 126#define BRCMF_FWS_FLAGS_XONXOFF_SIGNALS 0x0002 127#define BRCMF_FWS_FLAGS_CREDIT_STATUS_SIGNALS 0x0004 128#define BRCMF_FWS_FLAGS_HOST_PROPTXSTATUS_ACTIVE 0x0008 129#define BRCMF_FWS_FLAGS_PSQ_GENERATIONFSM_ENABLE 0x0010 130#define BRCMF_FWS_FLAGS_PSQ_ZERO_BUFFER_ENABLE 0x0020 131#define BRCMF_FWS_FLAGS_HOST_RXREORDER_ACTIVE 0x0040 132 133#define BRCMF_FWS_STATE_OPEN 1 134#define BRCMF_FWS_STATE_CLOSE 2 135 136#define BRCMF_FWS_MAC_DESC_TABLE_SIZE 32 137#define BRCMF_FWS_MAX_IFNUM 16 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 143#define BRCMF_FWS_PSQ_PREC_COUNT ((NL80211_NUM_ACS + 1) * 2) 144#define BRCMF_FWS_PSQ_LEN 256 145 146#define BRCMF_FWS_HTOD_FLAG_PKTFROMHOST 0x01 147#define BRCMF_FWS_HTOD_FLAG_PKT_REQUESTED 0x02 148 149/** 150 * enum brcmf_fws_skb_state - indicates processing state of skb. 151 * 152 * @BRCMF_FWS_SKBSTATE_NEW: sk_buff is newly arrived in the driver. 153 * @BRCMF_FWS_SKBSTATE_DELAYED: sk_buff had to wait on queue. 154 * @BRCMF_FWS_SKBSTATE_SUPPRESSED: sk_buff has been suppressed by firmware. 155 */ 156enum brcmf_fws_skb_state { 157 BRCMF_FWS_SKBSTATE_NEW, 158 BRCMF_FWS_SKBSTATE_DELAYED, 159 BRCMF_FWS_SKBSTATE_SUPPRESSED 160}; 161 162/** 163 * struct brcmf_skbuff_cb - control buffer associated with skbuff. 164 * 165 * @if_flags: holds interface index and packet related flags. 166 * @htod: host to device packet identifier (used in PKTTAG tlv). 167 * @state: transmit state of the packet. 168 * @mac: descriptor related to destination for this packet. 169 * 170 * This information is stored in control buffer struct sk_buff::cb, which 171 * provides 48 bytes of storage so this structure should not exceed that. 172 */ 173struct brcmf_skbuff_cb { 174 u16 if_flags; 175 u32 htod; 176 enum brcmf_fws_skb_state state; 177 struct brcmf_fws_mac_descriptor *mac; 178}; 179 180/* 181 * macro casting skbuff control buffer to struct brcmf_skbuff_cb. 182 */ 183#define brcmf_skbcb(skb) ((struct brcmf_skbuff_cb *)((skb)->cb)) 184 185/* 186 * sk_buff control if flags 187 * 188 * b[11] - packet sent upon firmware request. 189 * b[10] - packet only contains signalling data. 190 * b[9] - packet is a tx packet. 191 * b[8] - packet uses FIFO credit (non-pspoll). 192 * b[7] - interface in AP mode. 193 * b[6:4] - AC FIFO number. 194 * b[3:0] - interface index. 195 */ 196#define BRCMF_SKB_IF_FLAGS_REQUESTED_MASK 0x0800 197#define BRCMF_SKB_IF_FLAGS_REQUESTED_SHIFT 11 198#define BRCMF_SKB_IF_FLAGS_SIGNAL_ONLY_MASK 0x0400 199#define BRCMF_SKB_IF_FLAGS_SIGNAL_ONLY_SHIFT 10 200#define BRCMF_SKB_IF_FLAGS_TRANSMIT_MASK 0x0200 201#define BRCMF_SKB_IF_FLAGS_TRANSMIT_SHIFT 9 202#define BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK 0x0100 203#define BRCMF_SKB_IF_FLAGS_CREDITCHECK_SHIFT 8 204#define BRCMF_SKB_IF_FLAGS_IF_AP_MASK 0x0080 205#define BRCMF_SKB_IF_FLAGS_IF_AP_SHIFT 7 206#define BRCMF_SKB_IF_FLAGS_FIFO_MASK 0x0070 207#define BRCMF_SKB_IF_FLAGS_FIFO_SHIFT 4 208#define BRCMF_SKB_IF_FLAGS_INDEX_MASK 0x000f 209#define BRCMF_SKB_IF_FLAGS_INDEX_SHIFT 0 210 211#define brcmf_skb_if_flags_set_field(skb, field, value) \ 212 brcmu_maskset16(&(brcmf_skbcb(skb)->if_flags), \ 213 BRCMF_SKB_IF_FLAGS_ ## field ## _MASK, \ 214 BRCMF_SKB_IF_FLAGS_ ## field ## _SHIFT, (value)) 215#define brcmf_skb_if_flags_get_field(skb, field) \ 216 brcmu_maskget16(brcmf_skbcb(skb)->if_flags, \ 217 BRCMF_SKB_IF_FLAGS_ ## field ## _MASK, \ 218 BRCMF_SKB_IF_FLAGS_ ## field ## _SHIFT) 219 220/* 221 * sk_buff control packet identifier 222 * 223 * 32-bit packet identifier used in PKTTAG tlv from host to dongle. 224 * 225 * - Generated at the host (e.g. dhd) 226 * - Seen as a generic sequence number by firmware except for the flags field. 227 * 228 * Generation : b[31] => generation number for this packet [host->fw] 229 * OR, current generation number [fw->host] 230 * Flags : b[30:27] => command, status flags 231 * FIFO-AC : b[26:24] => AC-FIFO id 232 * h-slot : b[23:8] => hanger-slot 233 * freerun : b[7:0] => A free running counter 234 */ 235#define BRCMF_SKB_HTOD_TAG_GENERATION_MASK 0x80000000 236#define BRCMF_SKB_HTOD_TAG_GENERATION_SHIFT 31 237#define BRCMF_SKB_HTOD_TAG_FLAGS_MASK 0x78000000 238#define BRCMF_SKB_HTOD_TAG_FLAGS_SHIFT 27 239#define BRCMF_SKB_HTOD_TAG_FIFO_MASK 0x07000000 240#define BRCMF_SKB_HTOD_TAG_FIFO_SHIFT 24 241#define BRCMF_SKB_HTOD_TAG_HSLOT_MASK 0x00ffff00 242#define BRCMF_SKB_HTOD_TAG_HSLOT_SHIFT 8 243#define BRCMF_SKB_HTOD_TAG_FREERUN_MASK 0x000000ff 244#define BRCMF_SKB_HTOD_TAG_FREERUN_SHIFT 0 245 246#define brcmf_skb_htod_tag_set_field(skb, field, value) \ 247 brcmu_maskset32(&(brcmf_skbcb(skb)->htod), \ 248 BRCMF_SKB_HTOD_TAG_ ## field ## _MASK, \ 249 BRCMF_SKB_HTOD_TAG_ ## field ## _SHIFT, (value)) 250#define brcmf_skb_htod_tag_get_field(skb, field) \ 251 brcmu_maskget32(brcmf_skbcb(skb)->htod, \ 252 BRCMF_SKB_HTOD_TAG_ ## field ## _MASK, \ 253 BRCMF_SKB_HTOD_TAG_ ## field ## _SHIFT) 254 255#define BRCMF_FWS_TXSTAT_GENERATION_MASK 0x80000000 256#define BRCMF_FWS_TXSTAT_GENERATION_SHIFT 31 257#define BRCMF_FWS_TXSTAT_FLAGS_MASK 0x78000000 258#define BRCMF_FWS_TXSTAT_FLAGS_SHIFT 27 259#define BRCMF_FWS_TXSTAT_FIFO_MASK 0x07000000 260#define BRCMF_FWS_TXSTAT_FIFO_SHIFT 24 261#define BRCMF_FWS_TXSTAT_HSLOT_MASK 0x00FFFF00 262#define BRCMF_FWS_TXSTAT_HSLOT_SHIFT 8 263#define BRCMF_FWS_TXSTAT_PKTID_MASK 0x00FFFFFF 264#define BRCMF_FWS_TXSTAT_PKTID_SHIFT 0 265 266#define brcmf_txstatus_get_field(txs, field) \ 267 brcmu_maskget32(txs, BRCMF_FWS_TXSTAT_ ## field ## _MASK, \ 268 BRCMF_FWS_TXSTAT_ ## field ## _SHIFT) 269 270/** 271 * enum brcmf_fws_fifo - fifo indices used by dongle firmware. 272 * 273 * @BRCMF_FWS_FIFO_AC_BK: fifo for background traffic. 274 * @BRCMF_FWS_FIFO_AC_BE: fifo for best-effort traffic. 275 * @BRCMF_FWS_FIFO_AC_VI: fifo for video traffic. 276 * @BRCMF_FWS_FIFO_AC_VO: fifo for voice traffic. 277 * @BRCMF_FWS_FIFO_BCMC: fifo for broadcast/multicast (AP only). 278 * @BRCMF_FWS_FIFO_ATIM: fifo for ATIM (AP only). 279 * @BRCMF_FWS_FIFO_COUNT: number of fifos. 280 */ 281enum brcmf_fws_fifo { 282 BRCMF_FWS_FIFO_AC_BK, 283 BRCMF_FWS_FIFO_AC_BE, 284 BRCMF_FWS_FIFO_AC_VI, 285 BRCMF_FWS_FIFO_AC_VO, 286 BRCMF_FWS_FIFO_BCMC, 287 BRCMF_FWS_FIFO_ATIM, 288 BRCMF_FWS_FIFO_COUNT 289}; 290 291/** 292 * enum brcmf_fws_txstatus - txstatus flag values. 293 * 294 * @BRCMF_FWS_TXSTATUS_DISCARD: 295 * host is free to discard the packet. 296 * @BRCMF_FWS_TXSTATUS_CORE_SUPPRESS: 297 * 802.11 core suppressed the packet. 298 * @BRCMF_FWS_TXSTATUS_FW_PS_SUPPRESS: 299 * firmware suppress the packet as device is already in PS mode. 300 * @BRCMF_FWS_TXSTATUS_FW_TOSSED: 301 * firmware tossed the packet. 302 */ 303enum brcmf_fws_txstatus { 304 BRCMF_FWS_TXSTATUS_DISCARD, 305 BRCMF_FWS_TXSTATUS_CORE_SUPPRESS, 306 BRCMF_FWS_TXSTATUS_FW_PS_SUPPRESS, 307 BRCMF_FWS_TXSTATUS_FW_TOSSED 308}; 309 310enum brcmf_fws_fcmode { 311 BRCMF_FWS_FCMODE_NONE, 312 BRCMF_FWS_FCMODE_IMPLIED_CREDIT, 313 BRCMF_FWS_FCMODE_EXPLICIT_CREDIT 314}; 315 316/** 317 * struct brcmf_fws_mac_descriptor - firmware signalling data per node/interface 318 * 319 * @occupied: slot is in use. 320 * @mac_handle: handle for mac entry determined by firmware. 321 * @interface_id: interface index. 322 * @state: current state. 323 * @suppressed: mac entry is suppressed. 324 * @generation: generation bit. 325 * @ac_bitmap: ac queue bitmap. 326 * @requested_credit: credits requested by firmware. 327 * @ea: ethernet address. 328 * @seq: per-node free-running sequence. 329 * @psq: power-save queue. 330 * @transit_count: packet in transit to firmware. 331 */ 332struct brcmf_fws_mac_descriptor { 333 u8 occupied; 334 u8 mac_handle; 335 u8 interface_id; 336 u8 state; 337 bool suppressed; 338 u8 generation; 339 u8 ac_bitmap; 340 u8 requested_credit; 341 u8 ea[ETH_ALEN]; 342 u8 seq[BRCMF_FWS_FIFO_COUNT]; 343 struct pktq psq; 344 int transit_count; 345}; 346 347#define BRCMF_FWS_HANGER_MAXITEMS 1024 348 349/** 350 * enum brcmf_fws_hanger_item_state - state of hanger item. 351 * 352 * @BRCMF_FWS_HANGER_ITEM_STATE_FREE: item is free for use. 353 * @BRCMF_FWS_HANGER_ITEM_STATE_INUSE: item is in use. 354 * @BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED: item was suppressed. 355 */ 356enum brcmf_fws_hanger_item_state { 357 BRCMF_FWS_HANGER_ITEM_STATE_FREE = 1, 358 BRCMF_FWS_HANGER_ITEM_STATE_INUSE, 359 BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED 360}; 361 362 363/** 364 * struct brcmf_fws_hanger_item - single entry for tx pending packet. 365 * 366 * @state: entry is either free or occupied. 367 * @gen: generation. 368 * @pkt: packet itself. 369 */ 370struct brcmf_fws_hanger_item { 371 enum brcmf_fws_hanger_item_state state; 372 u8 gen; 373 struct sk_buff *pkt; 374}; 375 376/** 377 * struct brcmf_fws_hanger - holds packets awaiting firmware txstatus. 378 * 379 * @pushed: packets pushed to await txstatus. 380 * @popped: packets popped upon handling txstatus. 381 * @failed_to_push: packets that could not be pushed. 382 * @failed_to_pop: packets that could not be popped. 383 * @failed_slotfind: packets for which failed to find an entry. 384 * @slot_pos: last returned item index for a free entry. 385 * @items: array of hanger items. 386 */ 387struct brcmf_fws_hanger { 388 u32 pushed; 389 u32 popped; 390 u32 failed_to_push; 391 u32 failed_to_pop; 392 u32 failed_slotfind; 393 u32 slot_pos; 394 struct brcmf_fws_hanger_item items[BRCMF_FWS_HANGER_MAXITEMS]; 395}; 396 397struct brcmf_fws_info { 398 struct brcmf_pub *drvr; 399 struct brcmf_fws_stats stats; 400 struct brcmf_fws_hanger hanger; 401 struct brcmf_fws_mac_descriptor nodes[BRCMF_FWS_MAC_DESC_TABLE_SIZE]; 402 struct brcmf_fws_mac_descriptor other; 403 enum brcmf_fws_fcmode fcmode; 404 int fifo_credit[BRCMF_FWS_FIFO_COUNT]; 405}; 406 407/* 408 * brcmf_fws_prio2fifo - mapping from 802.1d priority to firmware fifo index. 409 */ 410static const int brcmf_fws_prio2fifo[] = { 411 BRCMF_FWS_FIFO_AC_BE, 412 BRCMF_FWS_FIFO_AC_BK, 413 BRCMF_FWS_FIFO_AC_BK, 414 BRCMF_FWS_FIFO_AC_BE, 415 BRCMF_FWS_FIFO_AC_VI, 416 BRCMF_FWS_FIFO_AC_VI, 417 BRCMF_FWS_FIFO_AC_VO, 418 BRCMF_FWS_FIFO_AC_VO 419}; 420 421static int fcmode; 422module_param(fcmode, int, S_IRUSR); 423MODULE_PARM_DESC(fcmode, "mode of firmware signalled flow control"); 424 425#define BRCMF_FWS_TLV_DEF(name, id, len) \ 426 case BRCMF_FWS_TYPE_ ## name: \ 427 return len; 428 429/** 430 * brcmf_fws_get_tlv_len() - returns defined length for given tlv id. 431 * 432 * @fws: firmware-signalling information. 433 * @id: identifier of the TLV. 434 * 435 * Return: the specified length for the given TLV; Otherwise -EINVAL. 436 */ 437static int brcmf_fws_get_tlv_len(struct brcmf_fws_info *fws, 438 enum brcmf_fws_tlv_type id) 439{ 440 switch (id) { 441 BRCMF_FWS_TLV_DEFLIST 442 default: 443 brcmf_err("invalid tlv id: %d\n", id); 444 fws->stats.tlv_invalid_type++; 445 break; 446 } 447 return -EINVAL; 448} 449#undef BRCMF_FWS_TLV_DEF 450 451static bool brcmf_fws_ifidx_match(struct sk_buff *skb, void *arg) 452{ 453 u32 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX); 454 return ifidx == *(int *)arg; 455} 456 457static void brcmf_fws_psq_flush(struct brcmf_fws_info *fws, struct pktq *q, 458 int ifidx) 459{ 460 bool (*matchfn)(struct sk_buff *, void *) = NULL; 461 struct sk_buff *skb; 462 int prec; 463 464 if (ifidx != -1) 465 matchfn = brcmf_fws_ifidx_match; 466 for (prec = 0; prec < q->num_prec; prec++) { 467 skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); 468 while (skb) { 469 brcmf_txfinalize(fws->drvr, skb, false); 470 skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); 471 } 472 } 473} 474 475static void brcmf_fws_hanger_init(struct brcmf_fws_hanger *hanger) 476{ 477 int i; 478 479 brcmf_dbg(TRACE, "enter\n"); 480 memset(hanger, 0, sizeof(*hanger)); 481 for (i = 0; i < ARRAY_SIZE(hanger->items); i++) 482 hanger->items[i].state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 483} 484 485static u32 brcmf_fws_hanger_get_free_slot(struct brcmf_fws_hanger *h) 486{ 487 u32 i; 488 489 brcmf_dbg(TRACE, "enter\n"); 490 i = (h->slot_pos + 1) % BRCMF_FWS_HANGER_MAXITEMS; 491 492 while (i != h->slot_pos) { 493 if (h->items[i].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 494 h->slot_pos = i; 495 return i; 496 } 497 i++; 498 if (i == BRCMF_FWS_HANGER_MAXITEMS) 499 i = 0; 500 } 501 brcmf_err("all slots occupied\n"); 502 h->failed_slotfind++; 503 return BRCMF_FWS_HANGER_MAXITEMS; 504} 505 506static int brcmf_fws_hanger_pushpkt(struct brcmf_fws_hanger *h, 507 struct sk_buff *pkt, u32 slot_id) 508{ 509 brcmf_dbg(TRACE, "enter\n"); 510 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 511 return -ENOENT; 512 513 if (h->items[slot_id].state != BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 514 brcmf_err("slot is not free\n"); 515 h->failed_to_push++; 516 return -EINVAL; 517 } 518 519 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_INUSE; 520 h->items[slot_id].pkt = pkt; 521 h->pushed++; 522 return 0; 523} 524 525static int brcmf_fws_hanger_poppkt(struct brcmf_fws_hanger *h, 526 u32 slot_id, struct sk_buff **pktout, 527 bool remove_item) 528{ 529 brcmf_dbg(TRACE, "enter\n"); 530 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 531 return -ENOENT; 532 533 if (h->items[slot_id].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 534 brcmf_err("entry not in use\n"); 535 h->failed_to_pop++; 536 return -EINVAL; 537 } 538 539 *pktout = h->items[slot_id].pkt; 540 if (remove_item) { 541 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 542 h->items[slot_id].pkt = NULL; 543 h->items[slot_id].gen = 0xff; 544 h->popped++; 545 } 546 return 0; 547} 548 549static __used int brcmf_fws_hanger_mark_suppressed(struct brcmf_fws_hanger *h, 550 u32 slot_id, u8 gen) 551{ 552 brcmf_dbg(TRACE, "enter\n"); 553 554 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 555 return -ENOENT; 556 557 h->items[slot_id].gen = gen; 558 559 if (h->items[slot_id].state != BRCMF_FWS_HANGER_ITEM_STATE_INUSE) { 560 brcmf_err("entry not in use\n"); 561 return -EINVAL; 562 } 563 564 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED; 565 return 0; 566} 567 568static int brcmf_fws_hanger_get_genbit(struct brcmf_fws_hanger *hanger, 569 struct sk_buff *pkt, u32 slot_id, 570 int *gen) 571{ 572 brcmf_dbg(TRACE, "enter\n"); 573 *gen = 0xff; 574 575 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 576 return -ENOENT; 577 578 if (hanger->items[slot_id].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 579 brcmf_err("slot not in use\n"); 580 return -EINVAL; 581 } 582 583 *gen = hanger->items[slot_id].gen; 584 return 0; 585} 586 587static void brcmf_fws_hanger_cleanup(struct brcmf_fws_hanger *h, 588 bool (*fn)(struct sk_buff *, void *), 589 int ifidx) 590{ 591 struct sk_buff *skb; 592 int i; 593 enum brcmf_fws_hanger_item_state s; 594 595 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx); 596 for (i = 0; i < ARRAY_SIZE(h->items); i++) { 597 s = h->items[i].state; 598 if (s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE || 599 s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED) { 600 skb = h->items[i].pkt; 601 if (fn == NULL || fn(skb, &ifidx)) { 602 /* suppress packets freed from psq */ 603 if (s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE) 604 brcmu_pkt_buf_free_skb(skb); 605 h->items[i].state = 606 BRCMF_FWS_HANGER_ITEM_STATE_FREE; 607 } 608 } 609 } 610} 611 612static void brcmf_fws_init_mac_descriptor(struct brcmf_fws_mac_descriptor *desc, 613 u8 *addr, u8 ifidx) 614{ 615 brcmf_dbg(TRACE, "enter: ea=%pM, ifidx=%u\n", addr, ifidx); 616 desc->occupied = 1; 617 desc->state = BRCMF_FWS_STATE_OPEN; 618 desc->requested_credit = 0; 619 /* depending on use may need ifp->bssidx instead */ 620 desc->interface_id = ifidx; 621 desc->ac_bitmap = 0xff; /* update this when handling APSD */ 622 memcpy(&desc->ea[0], addr, ETH_ALEN); 623} 624 625static 626void brcmf_fws_clear_mac_descriptor(struct brcmf_fws_mac_descriptor *desc) 627{ 628 brcmf_dbg(TRACE, 629 "enter: ea=%pM, ifidx=%u\n", desc->ea, desc->interface_id); 630 desc->occupied = 0; 631 desc->state = BRCMF_FWS_STATE_CLOSE; 632 desc->requested_credit = 0; 633} 634 635static struct brcmf_fws_mac_descriptor * 636brcmf_fws_mac_descriptor_lookup(struct brcmf_fws_info *fws, u8 *ea) 637{ 638 struct brcmf_fws_mac_descriptor *entry; 639 int i; 640 641 brcmf_dbg(TRACE, "enter: ea=%pM\n", ea); 642 if (ea == NULL) 643 return ERR_PTR(-EINVAL); 644 645 entry = &fws->nodes[0]; 646 for (i = 0; i < ARRAY_SIZE(fws->nodes); i++) { 647 if (entry->occupied && !memcmp(entry->ea, ea, ETH_ALEN)) 648 return entry; 649 entry++; 650 } 651 652 return ERR_PTR(-ENOENT); 653} 654 655static struct brcmf_fws_mac_descriptor* 656brcmf_fws_find_mac_desc(struct brcmf_fws_info *fws, int ifidx, u8 *da) 657{ 658 struct brcmf_fws_mac_descriptor *entry = &fws->other; 659 struct brcmf_if *ifp; 660 bool multicast; 661 662 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx); 663 664 multicast = is_multicast_ether_addr(da); 665 ifp = fws->drvr->iflist[ifidx ? ifidx + 1 : 0]; 666 if (WARN_ON(!ifp)) 667 goto done; 668 669 /* Multicast destination and P2P clients get the interface entry. 670 * STA gets the interface entry if there is no exact match. For 671 * example, TDLS destinations have their own entry. 672 */ 673 entry = NULL; 674 if ((/* ifp->iftype == 0 ||*/ multicast) && ifp->fws_desc) 675 entry = ifp->fws_desc; 676 677 if (entry != NULL && multicast) 678 goto done; 679 680 entry = brcmf_fws_mac_descriptor_lookup(fws, da); 681 if (IS_ERR(entry)) 682 entry = &fws->other; 683 684done: 685 brcmf_dbg(TRACE, "exit: entry=%p\n", entry); 686 return entry; 687} 688 689static void brcmf_fws_mac_desc_cleanup(struct brcmf_fws_info *fws, 690 struct brcmf_fws_mac_descriptor *entry, 691 int ifidx) 692{ 693 brcmf_dbg(TRACE, "enter: entry=(ea=%pM, ifid=%d), ifidx=%d\n", 694 entry->ea, entry->interface_id, ifidx); 695 if (entry->occupied && (ifidx == -1 || ifidx == entry->interface_id)) { 696 brcmf_dbg(TRACE, "flush psq: ifidx=%d, qlen=%d\n", 697 ifidx, entry->psq.len); 698 brcmf_fws_psq_flush(fws, &entry->psq, ifidx); 699 entry->occupied = !!(entry->psq.len); 700 } 701} 702 703static void brcmf_fws_bus_txq_cleanup(struct brcmf_fws_info *fws, 704 bool (*fn)(struct sk_buff *, void *), 705 int ifidx) 706{ 707 struct brcmf_fws_hanger_item *hi; 708 struct pktq *txq; 709 struct sk_buff *skb; 710 int prec; 711 u32 hslot; 712 713 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx); 714 txq = brcmf_bus_gettxq(fws->drvr->bus_if); 715 if (IS_ERR(txq)) { 716 brcmf_dbg(TRACE, "no txq to clean up\n"); 717 return; 718 } 719 720 for (prec = 0; prec < txq->num_prec; prec++) { 721 skb = brcmu_pktq_pdeq_match(txq, prec, fn, &ifidx); 722 while (skb) { 723 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT); 724 hi = &fws->hanger.items[hslot]; 725 WARN_ON(skb != hi->pkt); 726 hi->state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 727 brcmu_pkt_buf_free_skb(skb); 728 skb = brcmu_pktq_pdeq_match(txq, prec, fn, &ifidx); 729 } 730 } 731} 732 733static void brcmf_fws_cleanup(struct brcmf_fws_info *fws, int ifidx) 734{ 735 int i; 736 struct brcmf_fws_mac_descriptor *table; 737 bool (*matchfn)(struct sk_buff *, void *) = NULL; 738 739 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx); 740 if (fws == NULL) 741 return; 742 743 if (ifidx != -1) 744 matchfn = brcmf_fws_ifidx_match; 745 746 /* cleanup individual nodes */ 747 table = &fws->nodes[0]; 748 for (i = 0; i < ARRAY_SIZE(fws->nodes); i++) 749 brcmf_fws_mac_desc_cleanup(fws, &table[i], ifidx); 750 751 brcmf_fws_mac_desc_cleanup(fws, &fws->other, ifidx); 752 brcmf_fws_bus_txq_cleanup(fws, matchfn, ifidx); 753 brcmf_fws_hanger_cleanup(&fws->hanger, matchfn, ifidx); 754} 755 756static int brcmf_fws_rssi_indicate(struct brcmf_fws_info *fws, s8 rssi) 757{ 758 brcmf_dbg(CTL, "rssi %d\n", rssi); 759 return 0; 760} 761 762static 763int brcmf_fws_macdesc_indicate(struct brcmf_fws_info *fws, u8 type, u8 *data) 764{ 765 struct brcmf_fws_mac_descriptor *entry, *existing; 766 u8 mac_handle; 767 u8 ifidx; 768 u8 *addr; 769 770 mac_handle = *data++; 771 ifidx = *data++; 772 addr = data; 773 774 entry = &fws->nodes[mac_handle & 0x1F]; 775 if (type == BRCMF_FWS_TYPE_MACDESC_DEL) { 776 brcmf_dbg(TRACE, "deleting mac %pM idx %d\n", addr, ifidx); 777 if (entry->occupied) 778 brcmf_fws_clear_mac_descriptor(entry); 779 else 780 fws->stats.mac_update_failed++; 781 return 0; 782 } 783 784 brcmf_dbg(TRACE, 785 "add mac %pM handle %u idx %d\n", addr, mac_handle, ifidx); 786 existing = brcmf_fws_mac_descriptor_lookup(fws, addr); 787 if (IS_ERR(existing)) { 788 if (!entry->occupied) { 789 entry->mac_handle = mac_handle; 790 brcmf_fws_init_mac_descriptor(entry, addr, ifidx); 791 brcmu_pktq_init(&entry->psq, BRCMF_FWS_PSQ_PREC_COUNT, 792 BRCMF_FWS_PSQ_LEN); 793 } else { 794 fws->stats.mac_update_failed++; 795 } 796 } else { 797 if (entry != existing) { 798 brcmf_dbg(TRACE, "relocate mac\n"); 799 memcpy(entry, existing, 800 offsetof(struct brcmf_fws_mac_descriptor, psq)); 801 entry->mac_handle = mac_handle; 802 brcmf_fws_clear_mac_descriptor(existing); 803 } else { 804 brcmf_dbg(TRACE, "use existing\n"); 805 WARN_ON(entry->mac_handle != mac_handle); 806 /* TODO: what should we do here: continue, reinit, .. */ 807 } 808 } 809 return 0; 810} 811 812static int 813brcmf_fws_txstatus_process(struct brcmf_fws_info *fws, u8 flags, u32 hslot) 814{ 815 int ret; 816 struct sk_buff *skb; 817 struct brcmf_fws_mac_descriptor *entry = NULL; 818 819 brcmf_dbg(TRACE, "status: flags=0x%X, hslot=%d\n", 820 flags, hslot); 821 822 if (flags == BRCMF_FWS_TXSTATUS_DISCARD) 823 fws->stats.txs_discard++; 824 else if (flags == BRCMF_FWS_TXSTATUS_FW_TOSSED) 825 fws->stats.txs_tossed++; 826 else 827 brcmf_err("unexpected txstatus\n"); 828 829 ret = brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb, 830 true); 831 if (ret != 0) { 832 brcmf_err("no packet in hanger slot: hslot=%d\n", hslot); 833 return ret; 834 } 835 836 entry = brcmf_skbcb(skb)->mac; 837 if (WARN_ON(!entry)) { 838 ret = -EINVAL; 839 goto done; 840 } 841 842 entry->transit_count--; 843 844done: 845 brcmf_txfinalize(fws->drvr, skb, true); 846 return ret; 847} 848 849static int brcmf_fws_txstatus_indicate(struct brcmf_fws_info *fws, u8 *data) 850{ 851 u32 status; 852 u32 hslot; 853 u8 flags; 854 855 fws->stats.txs_indicate++; 856 status = le32_to_cpu(*(__le32 *)data); 857 flags = brcmf_txstatus_get_field(status, FLAGS); 858 hslot = brcmf_txstatus_get_field(status, HSLOT); 859 860 return brcmf_fws_txstatus_process(fws, flags, hslot); 861} 862 863static int brcmf_fws_dbg_seqnum_check(struct brcmf_fws_info *fws, u8 *data) 864{ 865 __le32 timestamp; 866 867 memcpy(×tamp, &data[2], sizeof(timestamp)); 868 brcmf_dbg(INFO, "received: seq %d, timestamp %d\n", data[1], 869 le32_to_cpu(timestamp)); 870 return 0; 871} 872 873/* using macro so sparse checking does not complain 874 * about locking imbalance. 875 */ 876#define brcmf_fws_lock(drvr, flags) \ 877do { \ 878 flags = 0; \ 879 spin_lock_irqsave(&((drvr)->fws_spinlock), (flags)); \ 880} while (0) 881 882/* using macro so sparse checking does not complain 883 * about locking imbalance. 884 */ 885#define brcmf_fws_unlock(drvr, flags) \ 886 spin_unlock_irqrestore(&((drvr)->fws_spinlock), (flags)) 887 888static int brcmf_fws_notify_credit_map(struct brcmf_if *ifp, 889 const struct brcmf_event_msg *e, 890 void *data) 891{ 892 struct brcmf_fws_info *fws = ifp->drvr->fws; 893 int i; 894 ulong flags; 895 u8 *credits = data; 896 897 brcmf_fws_lock(ifp->drvr, flags); 898 for (i = 0; i < ARRAY_SIZE(fws->fifo_credit); i++) 899 fws->fifo_credit[i] = *credits++; 900 brcmf_fws_unlock(ifp->drvr, flags); 901 return 0; 902} 903 904int brcmf_fws_init(struct brcmf_pub *drvr) 905{ 906 u32 tlv = 0; 907 int rc; 908 909 /* enable rssi signals */ 910 if (drvr->fw_signals) 911 tlv = BRCMF_FWS_FLAGS_RSSI_SIGNALS | 912 BRCMF_FWS_FLAGS_XONXOFF_SIGNALS | 913 BRCMF_FWS_FLAGS_CREDIT_STATUS_SIGNALS; 914 915 spin_lock_init(&drvr->fws_spinlock); 916 917 drvr->fws = kzalloc(sizeof(*(drvr->fws)), GFP_KERNEL); 918 if (!drvr->fws) { 919 rc = -ENOMEM; 920 goto fail; 921 } 922 923 /* enable proptxtstatus signaling by default */ 924 rc = brcmf_fil_iovar_int_set(drvr->iflist[0], "tlv", tlv); 925 if (rc < 0) { 926 brcmf_err("failed to set bdcv2 tlv signaling\n"); 927 goto fail; 928 } 929 930 if (brcmf_fweh_register(drvr, BRCMF_E_FIFO_CREDIT_MAP, 931 brcmf_fws_notify_credit_map)) { 932 brcmf_err("register credit map handler failed\n"); 933 goto fail; 934 } 935 936 brcmf_fws_hanger_init(&drvr->fws->hanger); 937 938 /* create debugfs file for statistics */ 939 brcmf_debugfs_create_fws_stats(drvr, &drvr->fws->stats); 940 941 /* set linkage back */ 942 drvr->fws->drvr = drvr; 943 drvr->fws->fcmode = fcmode; 944 945 /* TODO: remove upon feature delivery */ 946 brcmf_err("%s bdcv2 tlv signaling [%x]\n", 947 drvr->fw_signals ? "enabled" : "disabled", tlv); 948 return 0; 949 950fail: 951 /* disable flow control entirely */ 952 drvr->fw_signals = false; 953 brcmf_fws_deinit(drvr); 954 return rc; 955} 956 957void brcmf_fws_deinit(struct brcmf_pub *drvr) 958{ 959 struct brcmf_fws_info *fws = drvr->fws; 960 ulong flags; 961 962 /* cleanup */ 963 brcmf_fws_lock(drvr, flags); 964 brcmf_fws_cleanup(fws, -1); 965 drvr->fws = NULL; 966 brcmf_fws_unlock(drvr, flags); 967 968 /* free top structure */ 969 kfree(fws); 970} 971 972int brcmf_fws_hdrpull(struct brcmf_pub *drvr, int ifidx, s16 signal_len, 973 struct sk_buff *skb) 974{ 975 struct brcmf_fws_info *fws = drvr->fws; 976 ulong flags; 977 u8 *signal_data; 978 s16 data_len; 979 u8 type; 980 u8 len; 981 u8 *data; 982 983 brcmf_dbg(TRACE, "enter: ifidx %d, skblen %u, sig %d\n", 984 ifidx, skb->len, signal_len); 985 986 WARN_ON(signal_len > skb->len); 987 988 /* if flow control disabled, skip to packet data and leave */ 989 if (!signal_len || !drvr->fw_signals) { 990 skb_pull(skb, signal_len); 991 return 0; 992 } 993 994 /* lock during tlv parsing */ 995 brcmf_fws_lock(drvr, flags); 996 997 fws->stats.header_pulls++; 998 data_len = signal_len; 999 signal_data = skb->data; 1000 1001 while (data_len > 0) { 1002 /* extract tlv info */ 1003 type = signal_data[0]; 1004 1005 /* FILLER type is actually not a TLV, but 1006 * a single byte that can be skipped. 1007 */ 1008 if (type == BRCMF_FWS_TYPE_FILLER) { 1009 signal_data += 1; 1010 data_len -= 1; 1011 continue; 1012 } 1013 len = signal_data[1]; 1014 data = signal_data + 2; 1015 1016 /* abort parsing when length invalid */ 1017 if (data_len < len + 2) 1018 break; 1019 1020 if (len != brcmf_fws_get_tlv_len(fws, type)) 1021 break; 1022 1023 brcmf_dbg(INFO, "tlv type=%d (%s), len=%d\n", type, 1024 brcmf_fws_get_tlv_name(type), len); 1025 switch (type) { 1026 case BRCMF_FWS_TYPE_MAC_OPEN: 1027 case BRCMF_FWS_TYPE_MAC_CLOSE: 1028 case BRCMF_FWS_TYPE_MAC_REQUEST_CREDIT: 1029 case BRCMF_FWS_TYPE_PKTTAG: 1030 case BRCMF_FWS_TYPE_INTERFACE_OPEN: 1031 case BRCMF_FWS_TYPE_INTERFACE_CLOSE: 1032 case BRCMF_FWS_TYPE_FIFO_CREDITBACK: 1033 case BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP: 1034 case BRCMF_FWS_TYPE_MAC_REQUEST_PACKET: 1035 case BRCMF_FWS_TYPE_HOST_REORDER_RXPKTS: 1036 case BRCMF_FWS_TYPE_COMP_TXSTATUS: 1037 break; 1038 case BRCMF_FWS_TYPE_MACDESC_ADD: 1039 case BRCMF_FWS_TYPE_MACDESC_DEL: 1040 brcmf_fws_macdesc_indicate(fws, type, data); 1041 break; 1042 case BRCMF_FWS_TYPE_TXSTATUS: 1043 brcmf_fws_txstatus_indicate(fws, data); 1044 break; 1045 case BRCMF_FWS_TYPE_RSSI: 1046 brcmf_fws_rssi_indicate(fws, *data); 1047 break; 1048 case BRCMF_FWS_TYPE_TRANS_ID: 1049 brcmf_fws_dbg_seqnum_check(fws, data); 1050 break; 1051 default: 1052 fws->stats.tlv_invalid_type++; 1053 break; 1054 } 1055 1056 signal_data += len + 2; 1057 data_len -= len + 2; 1058 } 1059 1060 if (data_len != 0) 1061 fws->stats.tlv_parse_failed++; 1062 1063 /* signalling processing result does 1064 * not affect the actual ethernet packet. 1065 */ 1066 skb_pull(skb, signal_len); 1067 1068 /* this may be a signal-only packet 1069 */ 1070 if (skb->len == 0) 1071 fws->stats.header_only_pkt++; 1072 1073 brcmf_fws_unlock(drvr, flags); 1074 return 0; 1075} 1076 1077static int brcmf_fws_hdrpush(struct brcmf_fws_info *fws, struct sk_buff *skb) 1078{ 1079 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac; 1080 u8 *wlh; 1081 u16 data_offset; 1082 u8 fillers; 1083 __le32 pkttag = cpu_to_le32(brcmf_skbcb(skb)->htod); 1084 1085 brcmf_dbg(TRACE, "enter: ea=%pM, ifidx=%u, pkttag=0x%08X\n", 1086 entry->ea, entry->interface_id, le32_to_cpu(pkttag)); 1087 /* +2 is for Type[1] and Len[1] in TLV, plus TIM signal */ 1088 data_offset = 2 + BRCMF_FWS_TYPE_PKTTAG_LEN; 1089 fillers = round_up(data_offset, 4) - data_offset; 1090 data_offset += fillers; 1091 1092 skb_push(skb, data_offset); 1093 wlh = skb->data; 1094 1095 wlh[0] = BRCMF_FWS_TYPE_PKTTAG; 1096 wlh[1] = BRCMF_FWS_TYPE_PKTTAG_LEN; 1097 memcpy(&wlh[2], &pkttag, sizeof(pkttag)); 1098 wlh += BRCMF_FWS_TYPE_PKTTAG_LEN + 2; 1099 1100 if (fillers) 1101 memset(wlh, BRCMF_FWS_TYPE_FILLER, fillers); 1102 1103 brcmf_proto_hdrpush(fws->drvr, brcmf_skb_if_flags_get_field(skb, INDEX), 1104 data_offset >> 2, skb); 1105 return 0; 1106} 1107 1108static int brcmf_fws_precommit_skb(struct brcmf_fws_info *fws, int fifo, 1109 struct sk_buff *p) 1110{ 1111 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(p); 1112 struct brcmf_fws_mac_descriptor *entry = skcb->mac; 1113 int rc = 0; 1114 bool header_needed; 1115 int hslot = BRCMF_FWS_HANGER_MAXITEMS; 1116 u8 free_ctr; 1117 u8 ifidx; 1118 u8 flags; 1119 1120 header_needed = skcb->state == BRCMF_FWS_SKBSTATE_NEW; 1121 1122 if (header_needed) { 1123 /* obtaining free slot may fail, but that will be caught 1124 * by the hanger push. This assures the packet has a BDC 1125 * header upon return. 1126 */ 1127 hslot = brcmf_fws_hanger_get_free_slot(&fws->hanger); 1128 free_ctr = entry->seq[fifo]; 1129 brcmf_skb_htod_tag_set_field(p, HSLOT, hslot); 1130 brcmf_skb_htod_tag_set_field(p, FREERUN, free_ctr); 1131 brcmf_skb_htod_tag_set_field(p, GENERATION, 1); 1132 entry->transit_count++; 1133 } 1134 brcmf_skb_if_flags_set_field(p, TRANSMIT, 1); 1135 brcmf_skb_htod_tag_set_field(p, FIFO, fifo); 1136 1137 flags = BRCMF_FWS_HTOD_FLAG_PKTFROMHOST; 1138 if (!(skcb->if_flags & BRCMF_SKB_IF_FLAGS_CREDITCHECK_MASK)) { 1139 /* 1140 Indicate that this packet is being sent in response to an 1141 explicit request from the firmware side. 1142 */ 1143 flags |= BRCMF_FWS_HTOD_FLAG_PKT_REQUESTED; 1144 } 1145 brcmf_skb_htod_tag_set_field(p, FLAGS, flags); 1146 if (header_needed) { 1147 brcmf_fws_hdrpush(fws, p); 1148 rc = brcmf_fws_hanger_pushpkt(&fws->hanger, p, hslot); 1149 if (rc) 1150 brcmf_err("hanger push failed: rc=%d\n", rc); 1151 } else { 1152 int gen; 1153 1154 /* remove old header */ 1155 rc = brcmf_proto_hdrpull(fws->drvr, false, &ifidx, p); 1156 if (rc == 0) { 1157 hslot = brcmf_skb_htod_tag_get_field(p, HSLOT); 1158 brcmf_fws_hanger_get_genbit(&fws->hanger, p, 1159 hslot, &gen); 1160 brcmf_skb_htod_tag_set_field(p, GENERATION, gen); 1161 1162 /* push new header */ 1163 brcmf_fws_hdrpush(fws, p); 1164 } 1165 } 1166 1167 return rc; 1168} 1169 1170static int brcmf_fws_commit_skb(struct brcmf_fws_info *fws, int fifo, 1171 struct sk_buff *skb) 1172{ 1173 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb); 1174 struct brcmf_fws_mac_descriptor *entry; 1175 struct brcmf_bus *bus = fws->drvr->bus_if; 1176 int rc; 1177 1178 entry = skcb->mac; 1179 if (IS_ERR(entry)) 1180 return PTR_ERR(entry); 1181 1182 rc = brcmf_fws_precommit_skb(fws, fifo, skb); 1183 if (rc < 0) { 1184 fws->stats.generic_error++; 1185 goto done; 1186 } 1187 1188 rc = brcmf_bus_txdata(bus, skb); 1189 if (rc < 0) 1190 goto done; 1191 1192 entry->seq[fifo]++; 1193 fws->stats.pkt2bus++; 1194 return rc; 1195 1196done: 1197 brcmf_txfinalize(fws->drvr, skb, false); 1198 return rc; 1199} 1200 1201int brcmf_fws_process_skb(struct brcmf_if *ifp, struct sk_buff *skb) 1202{ 1203 struct brcmf_pub *drvr = ifp->drvr; 1204 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb); 1205 struct ethhdr *eh = (struct ethhdr *)(skb->data); 1206 ulong flags; 1207 u8 ifidx = ifp->ifidx; 1208 int fifo = BRCMF_FWS_FIFO_BCMC; 1209 bool multicast = is_multicast_ether_addr(eh->h_dest); 1210 1211 /* determine the priority */ 1212 if (!skb->priority) 1213 skb->priority = cfg80211_classify8021d(skb); 1214 1215 drvr->tx_multicast += !!multicast; 1216 if (ntohs(eh->h_proto) == ETH_P_PAE) 1217 atomic_inc(&ifp->pend_8021x_cnt); 1218 1219 if (!brcmf_fws_fc_active(drvr->fws)) { 1220 /* If the protocol uses a data header, apply it */ 1221 brcmf_proto_hdrpush(drvr, ifidx, 0, skb); 1222 1223 /* Use bus module to send data frame */ 1224 return brcmf_bus_txdata(drvr->bus_if, skb); 1225 } 1226 1227 /* set control buffer information */ 1228 skcb->mac = brcmf_fws_find_mac_desc(drvr->fws, ifidx, eh->h_dest); 1229 skcb->state = BRCMF_FWS_SKBSTATE_NEW; 1230 brcmf_skb_if_flags_set_field(skb, INDEX, ifidx); 1231 if (!multicast) 1232 fifo = brcmf_fws_prio2fifo[skb->priority]; 1233 brcmf_skb_if_flags_set_field(skb, FIFO, fifo); 1234 brcmf_skb_if_flags_set_field(skb, CREDITCHECK, 0); 1235 1236 brcmf_dbg(TRACE, "ea=%pM, multi=%d, fifo=%d\n", eh->h_dest, 1237 multicast, fifo); 1238 1239 brcmf_fws_lock(drvr, flags); 1240 brcmf_fws_commit_skb(drvr->fws, fifo, skb); 1241 brcmf_fws_unlock(drvr, flags); 1242 return 0; 1243} 1244 1245void brcmf_fws_reset_interface(struct brcmf_if *ifp) 1246{ 1247 struct brcmf_fws_mac_descriptor *entry = ifp->fws_desc; 1248 1249 brcmf_dbg(TRACE, "enter: idx=%d\n", ifp->bssidx); 1250 if (!entry) 1251 return; 1252 1253 brcmf_fws_init_mac_descriptor(entry, ifp->mac_addr, ifp->ifidx); 1254} 1255 1256void brcmf_fws_add_interface(struct brcmf_if *ifp) 1257{ 1258 struct brcmf_fws_mac_descriptor *entry; 1259 1260 brcmf_dbg(TRACE, "enter: idx=%d, mac=%pM\n", 1261 ifp->bssidx, ifp->mac_addr); 1262 if (!ifp->drvr->fw_signals) 1263 return; 1264 1265 entry = kzalloc(sizeof(*entry), GFP_ATOMIC); 1266 if (entry) { 1267 ifp->fws_desc = entry; 1268 brcmf_fws_init_mac_descriptor(entry, ifp->mac_addr, ifp->ifidx); 1269 brcmu_pktq_init(&entry->psq, BRCMF_FWS_PSQ_PREC_COUNT, 1270 BRCMF_FWS_PSQ_LEN); 1271 } else { 1272 brcmf_err("no firmware signalling\n"); 1273 } 1274} 1275 1276void brcmf_fws_del_interface(struct brcmf_if *ifp) 1277{ 1278 struct brcmf_fws_mac_descriptor *entry = ifp->fws_desc; 1279 1280 brcmf_dbg(TRACE, "enter: idx=%d\n", ifp->bssidx); 1281 if (!entry) 1282 return; 1283 1284 ifp->fws_desc = NULL; 1285 brcmf_fws_clear_mac_descriptor(entry); 1286 brcmf_fws_cleanup(ifp->drvr->fws, ifp->ifidx); 1287 kfree(entry); 1288} 1289 1290bool brcmf_fws_fc_active(struct brcmf_fws_info *fws) 1291{ 1292 if (!fws) 1293 return false; 1294 1295 brcmf_dbg(TRACE, "enter: mode=%d\n", fws->fcmode); 1296 return fws->fcmode != BRCMF_FWS_FCMODE_NONE; 1297} 1298 1299void brcmf_fws_bustxfail(struct brcmf_fws_info *fws, struct sk_buff *skb) 1300{ 1301 ulong flags; 1302 1303 brcmf_fws_lock(fws->drvr, flags); 1304 brcmf_fws_txstatus_process(fws, BRCMF_FWS_TXSTATUS_FW_TOSSED, 1305 brcmf_skb_htod_tag_get_field(skb, HSLOT)); 1306 brcmf_fws_unlock(fws->drvr, flags); 1307} 1308