fwsignal.c revision 946072383b6f93839e4ff79ffe44cfffa3aeb2d0
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, 6) \ 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 fws->stats.tlv_invalid_type++; 444 break; 445 } 446 return -EINVAL; 447} 448#undef BRCMF_FWS_TLV_DEF 449 450static bool brcmf_fws_ifidx_match(struct sk_buff *skb, void *arg) 451{ 452 u32 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX); 453 return ifidx == *(int *)arg; 454} 455 456static void brcmf_fws_psq_flush(struct brcmf_fws_info *fws, struct pktq *q, 457 int ifidx) 458{ 459 bool (*matchfn)(struct sk_buff *, void *) = NULL; 460 struct sk_buff *skb; 461 int prec; 462 463 if (ifidx != -1) 464 matchfn = brcmf_fws_ifidx_match; 465 for (prec = 0; prec < q->num_prec; prec++) { 466 skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); 467 while (skb) { 468 brcmf_txfinalize(fws->drvr, skb, false); 469 skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); 470 } 471 } 472} 473 474static void brcmf_fws_hanger_init(struct brcmf_fws_hanger *hanger) 475{ 476 int i; 477 478 brcmf_dbg(TRACE, "enter\n"); 479 memset(hanger, 0, sizeof(*hanger)); 480 for (i = 0; i < ARRAY_SIZE(hanger->items); i++) 481 hanger->items[i].state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 482} 483 484static u32 brcmf_fws_hanger_get_free_slot(struct brcmf_fws_hanger *h) 485{ 486 u32 i; 487 488 brcmf_dbg(TRACE, "enter\n"); 489 i = (h->slot_pos + 1) % BRCMF_FWS_HANGER_MAXITEMS; 490 491 while (i != h->slot_pos) { 492 if (h->items[i].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 493 h->slot_pos = i; 494 return i; 495 } 496 i++; 497 if (i == BRCMF_FWS_HANGER_MAXITEMS) 498 i = 0; 499 } 500 brcmf_err("all slots occupied\n"); 501 h->failed_slotfind++; 502 return BRCMF_FWS_HANGER_MAXITEMS; 503} 504 505static int brcmf_fws_hanger_pushpkt(struct brcmf_fws_hanger *h, 506 struct sk_buff *pkt, u32 slot_id) 507{ 508 brcmf_dbg(TRACE, "enter\n"); 509 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 510 return -ENOENT; 511 512 if (h->items[slot_id].state != BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 513 brcmf_err("slot is not free\n"); 514 h->failed_to_push++; 515 return -EINVAL; 516 } 517 518 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_INUSE; 519 h->items[slot_id].pkt = pkt; 520 h->pushed++; 521 return 0; 522} 523 524static int brcmf_fws_hanger_poppkt(struct brcmf_fws_hanger *h, 525 u32 slot_id, struct sk_buff **pktout, 526 bool remove_item) 527{ 528 brcmf_dbg(TRACE, "enter\n"); 529 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 530 return -ENOENT; 531 532 if (h->items[slot_id].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 533 brcmf_err("entry not in use\n"); 534 h->failed_to_pop++; 535 return -EINVAL; 536 } 537 538 *pktout = h->items[slot_id].pkt; 539 if (remove_item) { 540 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 541 h->items[slot_id].pkt = NULL; 542 h->items[slot_id].gen = 0xff; 543 h->popped++; 544 } 545 return 0; 546} 547 548static __used int brcmf_fws_hanger_mark_suppressed(struct brcmf_fws_hanger *h, 549 u32 slot_id, u8 gen) 550{ 551 brcmf_dbg(TRACE, "enter\n"); 552 553 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 554 return -ENOENT; 555 556 h->items[slot_id].gen = gen; 557 558 if (h->items[slot_id].state != BRCMF_FWS_HANGER_ITEM_STATE_INUSE) { 559 brcmf_err("entry not in use\n"); 560 return -EINVAL; 561 } 562 563 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED; 564 return 0; 565} 566 567static int brcmf_fws_hanger_get_genbit(struct brcmf_fws_hanger *hanger, 568 struct sk_buff *pkt, u32 slot_id, 569 int *gen) 570{ 571 brcmf_dbg(TRACE, "enter\n"); 572 *gen = 0xff; 573 574 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 575 return -ENOENT; 576 577 if (hanger->items[slot_id].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 578 brcmf_err("slot not in use\n"); 579 return -EINVAL; 580 } 581 582 *gen = hanger->items[slot_id].gen; 583 return 0; 584} 585 586static void brcmf_fws_hanger_cleanup(struct brcmf_fws_hanger *h, 587 bool (*fn)(struct sk_buff *, void *), 588 int ifidx) 589{ 590 struct sk_buff *skb; 591 int i; 592 enum brcmf_fws_hanger_item_state s; 593 594 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx); 595 for (i = 0; i < ARRAY_SIZE(h->items); i++) { 596 s = h->items[i].state; 597 if (s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE || 598 s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED) { 599 skb = h->items[i].pkt; 600 if (fn == NULL || fn(skb, &ifidx)) { 601 /* suppress packets freed from psq */ 602 if (s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE) 603 brcmu_pkt_buf_free_skb(skb); 604 h->items[i].state = 605 BRCMF_FWS_HANGER_ITEM_STATE_FREE; 606 } 607 } 608 } 609} 610 611static void brcmf_fws_init_mac_descriptor(struct brcmf_fws_mac_descriptor *desc, 612 u8 *addr, u8 ifidx) 613{ 614 brcmf_dbg(TRACE, "enter: ea=%pM, ifidx=%u\n", addr, ifidx); 615 desc->occupied = 1; 616 desc->state = BRCMF_FWS_STATE_OPEN; 617 desc->requested_credit = 0; 618 /* depending on use may need ifp->bssidx instead */ 619 desc->interface_id = ifidx; 620 desc->ac_bitmap = 0xff; /* update this when handling APSD */ 621 memcpy(&desc->ea[0], addr, ETH_ALEN); 622} 623 624static 625void brcmf_fws_clear_mac_descriptor(struct brcmf_fws_mac_descriptor *desc) 626{ 627 brcmf_dbg(TRACE, 628 "enter: ea=%pM, ifidx=%u\n", desc->ea, desc->interface_id); 629 desc->occupied = 0; 630 desc->state = BRCMF_FWS_STATE_CLOSE; 631 desc->requested_credit = 0; 632} 633 634static struct brcmf_fws_mac_descriptor * 635brcmf_fws_mac_descriptor_lookup(struct brcmf_fws_info *fws, u8 *ea) 636{ 637 struct brcmf_fws_mac_descriptor *entry; 638 int i; 639 640 brcmf_dbg(TRACE, "enter: ea=%pM\n", ea); 641 if (ea == NULL) 642 return ERR_PTR(-EINVAL); 643 644 entry = &fws->nodes[0]; 645 for (i = 0; i < ARRAY_SIZE(fws->nodes); i++) { 646 if (entry->occupied && !memcmp(entry->ea, ea, ETH_ALEN)) 647 return entry; 648 entry++; 649 } 650 651 return ERR_PTR(-ENOENT); 652} 653 654static struct brcmf_fws_mac_descriptor* 655brcmf_fws_find_mac_desc(struct brcmf_fws_info *fws, int ifidx, u8 *da) 656{ 657 struct brcmf_fws_mac_descriptor *entry = &fws->other; 658 struct brcmf_if *ifp; 659 bool multicast; 660 661 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx); 662 663 multicast = is_multicast_ether_addr(da); 664 ifp = fws->drvr->iflist[ifidx ? ifidx + 1 : 0]; 665 if (WARN_ON(!ifp)) 666 goto done; 667 668 /* Multicast destination and P2P clients get the interface entry. 669 * STA gets the interface entry if there is no exact match. For 670 * example, TDLS destinations have their own entry. 671 */ 672 entry = NULL; 673 if ((/* ifp->iftype == 0 ||*/ multicast) && ifp->fws_desc) 674 entry = ifp->fws_desc; 675 676 if (entry != NULL && multicast) 677 goto done; 678 679 entry = brcmf_fws_mac_descriptor_lookup(fws, da); 680 if (IS_ERR(entry)) 681 entry = &fws->other; 682 683done: 684 brcmf_dbg(TRACE, "exit: entry=%p\n", entry); 685 return entry; 686} 687 688static void brcmf_fws_mac_desc_cleanup(struct brcmf_fws_info *fws, 689 struct brcmf_fws_mac_descriptor *entry, 690 int ifidx) 691{ 692 brcmf_dbg(TRACE, "enter: entry=(ea=%pM, ifid=%d), ifidx=%d\n", 693 entry->ea, entry->interface_id, ifidx); 694 if (entry->occupied && (ifidx == -1 || ifidx == entry->interface_id)) { 695 brcmf_dbg(TRACE, "flush psq: ifidx=%d, qlen=%d\n", 696 ifidx, entry->psq.len); 697 brcmf_fws_psq_flush(fws, &entry->psq, ifidx); 698 entry->occupied = !!(entry->psq.len); 699 } 700} 701 702static void brcmf_fws_bus_txq_cleanup(struct brcmf_fws_info *fws, 703 bool (*fn)(struct sk_buff *, void *), 704 int ifidx) 705{ 706 struct brcmf_fws_hanger_item *hi; 707 struct pktq *txq; 708 struct sk_buff *skb; 709 int prec; 710 u32 hslot; 711 712 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx); 713 txq = brcmf_bus_gettxq(fws->drvr->bus_if); 714 if (IS_ERR(txq)) { 715 brcmf_dbg(TRACE, "no txq to clean up\n"); 716 return; 717 } 718 719 for (prec = 0; prec < txq->num_prec; prec++) { 720 skb = brcmu_pktq_pdeq_match(txq, prec, fn, &ifidx); 721 while (skb) { 722 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT); 723 hi = &fws->hanger.items[hslot]; 724 WARN_ON(skb != hi->pkt); 725 hi->state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 726 brcmu_pkt_buf_free_skb(skb); 727 skb = brcmu_pktq_pdeq_match(txq, prec, fn, &ifidx); 728 } 729 } 730} 731 732static void brcmf_fws_cleanup(struct brcmf_fws_info *fws, int ifidx) 733{ 734 int i; 735 struct brcmf_fws_mac_descriptor *table; 736 bool (*matchfn)(struct sk_buff *, void *) = NULL; 737 738 brcmf_dbg(TRACE, "enter: ifidx=%d\n", ifidx); 739 if (fws == NULL) 740 return; 741 742 if (ifidx != -1) 743 matchfn = brcmf_fws_ifidx_match; 744 745 /* cleanup individual nodes */ 746 table = &fws->nodes[0]; 747 for (i = 0; i < ARRAY_SIZE(fws->nodes); i++) 748 brcmf_fws_mac_desc_cleanup(fws, &table[i], ifidx); 749 750 brcmf_fws_mac_desc_cleanup(fws, &fws->other, ifidx); 751 brcmf_fws_bus_txq_cleanup(fws, matchfn, ifidx); 752 brcmf_fws_hanger_cleanup(&fws->hanger, matchfn, ifidx); 753} 754 755static int brcmf_fws_rssi_indicate(struct brcmf_fws_info *fws, s8 rssi) 756{ 757 brcmf_dbg(CTL, "rssi %d\n", rssi); 758 return 0; 759} 760 761static 762int brcmf_fws_macdesc_indicate(struct brcmf_fws_info *fws, u8 type, u8 *data) 763{ 764 struct brcmf_fws_mac_descriptor *entry, *existing; 765 u8 mac_handle; 766 u8 ifidx; 767 u8 *addr; 768 769 mac_handle = *data++; 770 ifidx = *data++; 771 addr = data; 772 773 entry = &fws->nodes[mac_handle & 0x1F]; 774 if (type == BRCMF_FWS_TYPE_MACDESC_DEL) { 775 brcmf_dbg(TRACE, "deleting mac %pM idx %d\n", addr, ifidx); 776 if (entry->occupied) 777 brcmf_fws_clear_mac_descriptor(entry); 778 else 779 fws->stats.mac_update_failed++; 780 return 0; 781 } 782 783 brcmf_dbg(TRACE, 784 "add mac %pM handle %u idx %d\n", addr, mac_handle, ifidx); 785 existing = brcmf_fws_mac_descriptor_lookup(fws, addr); 786 if (IS_ERR(existing)) { 787 if (!entry->occupied) { 788 entry->mac_handle = mac_handle; 789 brcmf_fws_init_mac_descriptor(entry, addr, ifidx); 790 brcmu_pktq_init(&entry->psq, BRCMF_FWS_PSQ_PREC_COUNT, 791 BRCMF_FWS_PSQ_LEN); 792 } else { 793 fws->stats.mac_update_failed++; 794 } 795 } else { 796 if (entry != existing) { 797 brcmf_dbg(TRACE, "relocate mac\n"); 798 memcpy(entry, existing, 799 offsetof(struct brcmf_fws_mac_descriptor, psq)); 800 entry->mac_handle = mac_handle; 801 brcmf_fws_clear_mac_descriptor(existing); 802 } else { 803 brcmf_dbg(TRACE, "use existing\n"); 804 WARN_ON(entry->mac_handle != mac_handle); 805 /* TODO: what should we do here: continue, reinit, .. */ 806 } 807 } 808 return 0; 809} 810 811static int 812brcmf_fws_txstatus_process(struct brcmf_fws_info *fws, u8 flags, u32 hslot) 813{ 814 int ret; 815 struct sk_buff *skb; 816 struct brcmf_fws_mac_descriptor *entry = NULL; 817 818 brcmf_dbg(TRACE, "status: flags=0x%X, hslot=%d\n", 819 flags, hslot); 820 821 if (flags == BRCMF_FWS_TXSTATUS_DISCARD) 822 fws->stats.txs_discard++; 823 else if (flags == BRCMF_FWS_TXSTATUS_FW_TOSSED) 824 fws->stats.txs_tossed++; 825 else 826 brcmf_err("unexpected txstatus\n"); 827 828 ret = brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb, 829 true); 830 if (ret != 0) { 831 brcmf_err("no packet in hanger slot: hslot=%d\n", hslot); 832 return ret; 833 } 834 835 entry = brcmf_skbcb(skb)->mac; 836 if (WARN_ON(!entry)) { 837 ret = -EINVAL; 838 goto done; 839 } 840 841 entry->transit_count--; 842 843done: 844 brcmf_txfinalize(fws->drvr, skb, true); 845 return ret; 846} 847 848static int brcmf_fws_txstatus_indicate(struct brcmf_fws_info *fws, u8 *data) 849{ 850 u32 status; 851 u32 hslot; 852 u8 flags; 853 854 fws->stats.txs_indicate++; 855 status = le32_to_cpu(*(__le32 *)data); 856 flags = brcmf_txstatus_get_field(status, FLAGS); 857 hslot = brcmf_txstatus_get_field(status, HSLOT); 858 859 return brcmf_fws_txstatus_process(fws, flags, hslot); 860} 861 862static int brcmf_fws_dbg_seqnum_check(struct brcmf_fws_info *fws, u8 *data) 863{ 864 __le32 timestamp; 865 866 memcpy(×tamp, &data[2], sizeof(timestamp)); 867 brcmf_dbg(INFO, "received: seq %d, timestamp %d\n", data[1], 868 le32_to_cpu(timestamp)); 869 return 0; 870} 871 872/* using macro so sparse checking does not complain 873 * about locking imbalance. 874 */ 875#define brcmf_fws_lock(drvr, flags) \ 876do { \ 877 flags = 0; \ 878 spin_lock_irqsave(&((drvr)->fws_spinlock), (flags)); \ 879} while (0) 880 881/* using macro so sparse checking does not complain 882 * about locking imbalance. 883 */ 884#define brcmf_fws_unlock(drvr, flags) \ 885 spin_unlock_irqrestore(&((drvr)->fws_spinlock), (flags)) 886 887static int brcmf_fws_notify_credit_map(struct brcmf_if *ifp, 888 const struct brcmf_event_msg *e, 889 void *data) 890{ 891 struct brcmf_fws_info *fws = ifp->drvr->fws; 892 int i; 893 ulong flags; 894 u8 *credits = data; 895 896 brcmf_fws_lock(ifp->drvr, flags); 897 for (i = 0; i < ARRAY_SIZE(fws->fifo_credit); i++) 898 fws->fifo_credit[i] = *credits++; 899 brcmf_fws_unlock(ifp->drvr, flags); 900 return 0; 901} 902 903int brcmf_fws_init(struct brcmf_pub *drvr) 904{ 905 u32 tlv = 0; 906 int rc; 907 908 /* enable rssi signals */ 909 if (drvr->fw_signals) 910 tlv = BRCMF_FWS_FLAGS_RSSI_SIGNALS | 911 BRCMF_FWS_FLAGS_XONXOFF_SIGNALS | 912 BRCMF_FWS_FLAGS_CREDIT_STATUS_SIGNALS; 913 914 spin_lock_init(&drvr->fws_spinlock); 915 916 drvr->fws = kzalloc(sizeof(*(drvr->fws)), GFP_KERNEL); 917 if (!drvr->fws) { 918 rc = -ENOMEM; 919 goto fail; 920 } 921 922 /* set linkage back */ 923 drvr->fws->drvr = drvr; 924 drvr->fws->fcmode = fcmode; 925 926 /* enable proptxtstatus signaling by default */ 927 rc = brcmf_fil_iovar_int_set(drvr->iflist[0], "tlv", tlv); 928 if (rc < 0) { 929 brcmf_err("failed to set bdcv2 tlv signaling\n"); 930 goto fail; 931 } 932 933 if (brcmf_fweh_register(drvr, BRCMF_E_FIFO_CREDIT_MAP, 934 brcmf_fws_notify_credit_map)) { 935 brcmf_err("register credit map handler failed\n"); 936 goto fail; 937 } 938 939 brcmf_fws_hanger_init(&drvr->fws->hanger); 940 941 /* create debugfs file for statistics */ 942 brcmf_debugfs_create_fws_stats(drvr, &drvr->fws->stats); 943 944 /* TODO: remove upon feature delivery */ 945 brcmf_err("%s bdcv2 tlv signaling [%x]\n", 946 drvr->fw_signals ? "enabled" : "disabled", tlv); 947 return 0; 948 949fail: 950 /* disable flow control entirely */ 951 drvr->fw_signals = false; 952 brcmf_fws_deinit(drvr); 953 return rc; 954} 955 956void brcmf_fws_deinit(struct brcmf_pub *drvr) 957{ 958 struct brcmf_fws_info *fws = drvr->fws; 959 ulong flags; 960 961 /* cleanup */ 962 brcmf_fws_lock(drvr, flags); 963 brcmf_fws_cleanup(fws, -1); 964 drvr->fws = NULL; 965 brcmf_fws_unlock(drvr, flags); 966 967 /* free top structure */ 968 kfree(fws); 969} 970 971int brcmf_fws_hdrpull(struct brcmf_pub *drvr, int ifidx, s16 signal_len, 972 struct sk_buff *skb) 973{ 974 struct brcmf_fws_info *fws = drvr->fws; 975 ulong flags; 976 u8 *signal_data; 977 s16 data_len; 978 u8 type; 979 u8 len; 980 u8 *data; 981 982 brcmf_dbg(TRACE, "enter: ifidx %d, skblen %u, sig %d\n", 983 ifidx, skb->len, signal_len); 984 985 WARN_ON(signal_len > skb->len); 986 987 /* if flow control disabled, skip to packet data and leave */ 988 if (!signal_len || !drvr->fw_signals) { 989 skb_pull(skb, signal_len); 990 return 0; 991 } 992 993 /* lock during tlv parsing */ 994 brcmf_fws_lock(drvr, flags); 995 996 fws->stats.header_pulls++; 997 data_len = signal_len; 998 signal_data = skb->data; 999 1000 while (data_len > 0) { 1001 /* extract tlv info */ 1002 type = signal_data[0]; 1003 1004 /* FILLER type is actually not a TLV, but 1005 * a single byte that can be skipped. 1006 */ 1007 if (type == BRCMF_FWS_TYPE_FILLER) { 1008 signal_data += 1; 1009 data_len -= 1; 1010 continue; 1011 } 1012 len = signal_data[1]; 1013 data = signal_data + 2; 1014 1015 brcmf_dbg(INFO, "tlv type=%d (%s), len=%d, data[0]=%d\n", type, 1016 brcmf_fws_get_tlv_name(type), len, *data); 1017 1018 /* abort parsing when length invalid */ 1019 if (data_len < len + 2) 1020 break; 1021 1022 if (len != brcmf_fws_get_tlv_len(fws, type)) 1023 break; 1024 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