Pileus Git - ~andy/linux/blob - drivers/net/wireless/brcm80211/brcmfmac/fwsignal.c

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