1 // SPDX-License-Identifier: ISC 2 /* 3 * Copyright (c) 2010 Broadcom Corporation 4 */ 5 #include <linux/types.h> 6 #include <linux/module.h> 7 #include <linux/if_ether.h> 8 #include <linux/spinlock.h> 9 #include <linux/skbuff.h> 10 #include <linux/netdevice.h> 11 #include <linux/etherdevice.h> 12 #include <linux/err.h> 13 #include <linux/jiffies.h> 14 #include <net/cfg80211.h> 15 16 #include <brcmu_utils.h> 17 #include <brcmu_wifi.h> 18 #include "core.h" 19 #include "debug.h" 20 #include "bus.h" 21 #include "fwil.h" 22 #include "fwil_types.h" 23 #include "fweh.h" 24 #include "fwsignal.h" 25 #include "p2p.h" 26 #include "cfg80211.h" 27 #include "proto.h" 28 #include "bcdc.h" 29 #include "common.h" 30 31 /** 32 * DOC: Firmware Signalling 33 * 34 * Firmware can send signals to host and vice versa, which are passed in the 35 * data packets using TLV based header. This signalling layer is on top of the 36 * BDC bus protocol layer. 37 */ 38 39 /* 40 * single definition for firmware-driver flow control tlv's. 41 * 42 * each tlv is specified by BRCMF_FWS_TLV_DEF(name, ID, length). 43 * A length value 0 indicates variable length tlv. 44 */ 45 #define BRCMF_FWS_TLV_DEFLIST \ 46 BRCMF_FWS_TLV_DEF(MAC_OPEN, 1, 1) \ 47 BRCMF_FWS_TLV_DEF(MAC_CLOSE, 2, 1) \ 48 BRCMF_FWS_TLV_DEF(MAC_REQUEST_CREDIT, 3, 2) \ 49 BRCMF_FWS_TLV_DEF(TXSTATUS, 4, 4) \ 50 BRCMF_FWS_TLV_DEF(PKTTAG, 5, 4) \ 51 BRCMF_FWS_TLV_DEF(MACDESC_ADD, 6, 8) \ 52 BRCMF_FWS_TLV_DEF(MACDESC_DEL, 7, 8) \ 53 BRCMF_FWS_TLV_DEF(RSSI, 8, 1) \ 54 BRCMF_FWS_TLV_DEF(INTERFACE_OPEN, 9, 1) \ 55 BRCMF_FWS_TLV_DEF(INTERFACE_CLOSE, 10, 1) \ 56 BRCMF_FWS_TLV_DEF(FIFO_CREDITBACK, 11, 6) \ 57 BRCMF_FWS_TLV_DEF(PENDING_TRAFFIC_BMP, 12, 2) \ 58 BRCMF_FWS_TLV_DEF(MAC_REQUEST_PACKET, 13, 3) \ 59 BRCMF_FWS_TLV_DEF(HOST_REORDER_RXPKTS, 14, 10) \ 60 BRCMF_FWS_TLV_DEF(TRANS_ID, 18, 6) \ 61 BRCMF_FWS_TLV_DEF(COMP_TXSTATUS, 19, 1) \ 62 BRCMF_FWS_TLV_DEF(FILLER, 255, 0) 63 64 /* 65 * enum brcmf_fws_tlv_type - definition of tlv identifiers. 66 */ 67 #define BRCMF_FWS_TLV_DEF(name, id, len) \ 68 BRCMF_FWS_TYPE_ ## name = id, 69 enum brcmf_fws_tlv_type { 70 BRCMF_FWS_TLV_DEFLIST 71 BRCMF_FWS_TYPE_INVALID 72 }; 73 #undef BRCMF_FWS_TLV_DEF 74 75 /* 76 * enum brcmf_fws_tlv_len - definition of tlv lengths. 77 */ 78 #define BRCMF_FWS_TLV_DEF(name, id, len) \ 79 BRCMF_FWS_TYPE_ ## name ## _LEN = (len), 80 enum brcmf_fws_tlv_len { 81 BRCMF_FWS_TLV_DEFLIST 82 }; 83 #undef BRCMF_FWS_TLV_DEF 84 85 /* AMPDU rx reordering definitions */ 86 #define BRCMF_RXREORDER_FLOWID_OFFSET 0 87 #define BRCMF_RXREORDER_MAXIDX_OFFSET 2 88 #define BRCMF_RXREORDER_FLAGS_OFFSET 4 89 #define BRCMF_RXREORDER_CURIDX_OFFSET 6 90 #define BRCMF_RXREORDER_EXPIDX_OFFSET 8 91 92 #define BRCMF_RXREORDER_DEL_FLOW 0x01 93 #define BRCMF_RXREORDER_FLUSH_ALL 0x02 94 #define BRCMF_RXREORDER_CURIDX_VALID 0x04 95 #define BRCMF_RXREORDER_EXPIDX_VALID 0x08 96 #define BRCMF_RXREORDER_NEW_HOLE 0x10 97 98 #ifdef DEBUG 99 /* 100 * brcmf_fws_tlv_names - array of tlv names. 101 */ 102 #define BRCMF_FWS_TLV_DEF(name, id, len) \ 103 { id, #name }, 104 static struct { 105 enum brcmf_fws_tlv_type id; 106 const char *name; 107 } brcmf_fws_tlv_names[] = { 108 BRCMF_FWS_TLV_DEFLIST 109 }; 110 #undef BRCMF_FWS_TLV_DEF 111 112 113 static const char *brcmf_fws_get_tlv_name(enum brcmf_fws_tlv_type id) 114 { 115 int i; 116 117 for (i = 0; i < ARRAY_SIZE(brcmf_fws_tlv_names); i++) 118 if (brcmf_fws_tlv_names[i].id == id) 119 return brcmf_fws_tlv_names[i].name; 120 121 return "INVALID"; 122 } 123 #else 124 static const char *brcmf_fws_get_tlv_name(enum brcmf_fws_tlv_type id) 125 { 126 return "NODEBUG"; 127 } 128 #endif /* DEBUG */ 129 130 /* 131 * The PKTTAG tlv has additional bytes when firmware-signalling 132 * mode has REUSESEQ flag set. 133 */ 134 #define BRCMF_FWS_TYPE_SEQ_LEN 2 135 136 /* 137 * flags used to enable tlv signalling from firmware. 138 */ 139 #define BRCMF_FWS_FLAGS_RSSI_SIGNALS 0x0001 140 #define BRCMF_FWS_FLAGS_XONXOFF_SIGNALS 0x0002 141 #define BRCMF_FWS_FLAGS_CREDIT_STATUS_SIGNALS 0x0004 142 #define BRCMF_FWS_FLAGS_HOST_PROPTXSTATUS_ACTIVE 0x0008 143 #define BRCMF_FWS_FLAGS_PSQ_GENERATIONFSM_ENABLE 0x0010 144 #define BRCMF_FWS_FLAGS_PSQ_ZERO_BUFFER_ENABLE 0x0020 145 #define BRCMF_FWS_FLAGS_HOST_RXREORDER_ACTIVE 0x0040 146 147 #define BRCMF_FWS_MAC_DESC_TABLE_SIZE 32 148 #define BRCMF_FWS_MAC_DESC_ID_INVALID 0xff 149 150 #define BRCMF_FWS_HOSTIF_FLOWSTATE_OFF 0 151 #define BRCMF_FWS_HOSTIF_FLOWSTATE_ON 1 152 #define BRCMF_FWS_FLOWCONTROL_HIWATER 128 153 #define BRCMF_FWS_FLOWCONTROL_LOWATER 64 154 155 #define BRCMF_FWS_PSQ_PREC_COUNT ((BRCMF_FWS_FIFO_COUNT + 1) * 2) 156 #define BRCMF_FWS_PSQ_LEN 256 157 158 #define BRCMF_FWS_HTOD_FLAG_PKTFROMHOST 0x01 159 #define BRCMF_FWS_HTOD_FLAG_PKT_REQUESTED 0x02 160 161 #define BRCMF_FWS_RET_OK_NOSCHEDULE 0 162 #define BRCMF_FWS_RET_OK_SCHEDULE 1 163 164 #define BRCMF_FWS_MODE_REUSESEQ_SHIFT 3 /* seq reuse */ 165 #define BRCMF_FWS_MODE_SET_REUSESEQ(x, val) ((x) = \ 166 ((x) & ~(1 << BRCMF_FWS_MODE_REUSESEQ_SHIFT)) | \ 167 (((val) & 1) << BRCMF_FWS_MODE_REUSESEQ_SHIFT)) 168 #define BRCMF_FWS_MODE_GET_REUSESEQ(x) \ 169 (((x) >> BRCMF_FWS_MODE_REUSESEQ_SHIFT) & 1) 170 171 /** 172 * enum brcmf_fws_skb_state - indicates processing state of skb. 173 * 174 * @BRCMF_FWS_SKBSTATE_NEW: sk_buff is newly arrived in the driver. 175 * @BRCMF_FWS_SKBSTATE_DELAYED: sk_buff had to wait on queue. 176 * @BRCMF_FWS_SKBSTATE_SUPPRESSED: sk_buff has been suppressed by firmware. 177 * @BRCMF_FWS_SKBSTATE_TIM: allocated for TIM update info. 178 */ 179 enum brcmf_fws_skb_state { 180 BRCMF_FWS_SKBSTATE_NEW, 181 BRCMF_FWS_SKBSTATE_DELAYED, 182 BRCMF_FWS_SKBSTATE_SUPPRESSED, 183 BRCMF_FWS_SKBSTATE_TIM 184 }; 185 186 /** 187 * struct brcmf_skbuff_cb - control buffer associated with skbuff. 188 * 189 * @bus_flags: 2 bytes reserved for bus specific parameters 190 * @if_flags: holds interface index and packet related flags. 191 * @htod: host to device packet identifier (used in PKTTAG tlv). 192 * @htod_seq: this 16-bit is original seq number for every suppress packet. 193 * @state: transmit state of the packet. 194 * @mac: descriptor related to destination for this packet. 195 * 196 * This information is stored in control buffer struct sk_buff::cb, which 197 * provides 48 bytes of storage so this structure should not exceed that. 198 */ 199 struct brcmf_skbuff_cb { 200 u16 bus_flags; 201 u16 if_flags; 202 u32 htod; 203 u16 htod_seq; 204 enum brcmf_fws_skb_state state; 205 struct brcmf_fws_mac_descriptor *mac; 206 }; 207 208 /* 209 * macro casting skbuff control buffer to struct brcmf_skbuff_cb. 210 */ 211 #define brcmf_skbcb(skb) ((struct brcmf_skbuff_cb *)((skb)->cb)) 212 213 /* 214 * sk_buff control if flags 215 * 216 * b[11] - packet sent upon firmware request. 217 * b[10] - packet only contains signalling data. 218 * b[9] - packet is a tx packet. 219 * b[8] - packet used requested credit 220 * b[7] - interface in AP mode. 221 * b[3:0] - interface index. 222 */ 223 #define BRCMF_SKB_IF_FLAGS_REQUESTED_MASK 0x0800 224 #define BRCMF_SKB_IF_FLAGS_REQUESTED_SHIFT 11 225 #define BRCMF_SKB_IF_FLAGS_SIGNAL_ONLY_MASK 0x0400 226 #define BRCMF_SKB_IF_FLAGS_SIGNAL_ONLY_SHIFT 10 227 #define BRCMF_SKB_IF_FLAGS_TRANSMIT_MASK 0x0200 228 #define BRCMF_SKB_IF_FLAGS_TRANSMIT_SHIFT 9 229 #define BRCMF_SKB_IF_FLAGS_REQ_CREDIT_MASK 0x0100 230 #define BRCMF_SKB_IF_FLAGS_REQ_CREDIT_SHIFT 8 231 #define BRCMF_SKB_IF_FLAGS_IF_AP_MASK 0x0080 232 #define BRCMF_SKB_IF_FLAGS_IF_AP_SHIFT 7 233 #define BRCMF_SKB_IF_FLAGS_INDEX_MASK 0x000f 234 #define BRCMF_SKB_IF_FLAGS_INDEX_SHIFT 0 235 236 #define brcmf_skb_if_flags_set_field(skb, field, value) \ 237 brcmu_maskset16(&(brcmf_skbcb(skb)->if_flags), \ 238 BRCMF_SKB_IF_FLAGS_ ## field ## _MASK, \ 239 BRCMF_SKB_IF_FLAGS_ ## field ## _SHIFT, (value)) 240 #define brcmf_skb_if_flags_get_field(skb, field) \ 241 brcmu_maskget16(brcmf_skbcb(skb)->if_flags, \ 242 BRCMF_SKB_IF_FLAGS_ ## field ## _MASK, \ 243 BRCMF_SKB_IF_FLAGS_ ## field ## _SHIFT) 244 245 /* 246 * sk_buff control packet identifier 247 * 248 * 32-bit packet identifier used in PKTTAG tlv from host to dongle. 249 * 250 * - Generated at the host (e.g. dhd) 251 * - Seen as a generic sequence number by firmware except for the flags field. 252 * 253 * Generation : b[31] => generation number for this packet [host->fw] 254 * OR, current generation number [fw->host] 255 * Flags : b[30:27] => command, status flags 256 * FIFO-AC : b[26:24] => AC-FIFO id 257 * h-slot : b[23:8] => hanger-slot 258 * freerun : b[7:0] => A free running counter 259 */ 260 #define BRCMF_SKB_HTOD_TAG_GENERATION_MASK 0x80000000 261 #define BRCMF_SKB_HTOD_TAG_GENERATION_SHIFT 31 262 #define BRCMF_SKB_HTOD_TAG_FLAGS_MASK 0x78000000 263 #define BRCMF_SKB_HTOD_TAG_FLAGS_SHIFT 27 264 #define BRCMF_SKB_HTOD_TAG_FIFO_MASK 0x07000000 265 #define BRCMF_SKB_HTOD_TAG_FIFO_SHIFT 24 266 #define BRCMF_SKB_HTOD_TAG_HSLOT_MASK 0x00ffff00 267 #define BRCMF_SKB_HTOD_TAG_HSLOT_SHIFT 8 268 #define BRCMF_SKB_HTOD_TAG_FREERUN_MASK 0x000000ff 269 #define BRCMF_SKB_HTOD_TAG_FREERUN_SHIFT 0 270 271 #define brcmf_skb_htod_tag_set_field(skb, field, value) \ 272 brcmu_maskset32(&(brcmf_skbcb(skb)->htod), \ 273 BRCMF_SKB_HTOD_TAG_ ## field ## _MASK, \ 274 BRCMF_SKB_HTOD_TAG_ ## field ## _SHIFT, (value)) 275 #define brcmf_skb_htod_tag_get_field(skb, field) \ 276 brcmu_maskget32(brcmf_skbcb(skb)->htod, \ 277 BRCMF_SKB_HTOD_TAG_ ## field ## _MASK, \ 278 BRCMF_SKB_HTOD_TAG_ ## field ## _SHIFT) 279 280 #define BRCMF_SKB_HTOD_SEQ_FROMFW_MASK 0x2000 281 #define BRCMF_SKB_HTOD_SEQ_FROMFW_SHIFT 13 282 #define BRCMF_SKB_HTOD_SEQ_FROMDRV_MASK 0x1000 283 #define BRCMF_SKB_HTOD_SEQ_FROMDRV_SHIFT 12 284 #define BRCMF_SKB_HTOD_SEQ_NR_MASK 0x0fff 285 #define BRCMF_SKB_HTOD_SEQ_NR_SHIFT 0 286 287 #define brcmf_skb_htod_seq_set_field(skb, field, value) \ 288 brcmu_maskset16(&(brcmf_skbcb(skb)->htod_seq), \ 289 BRCMF_SKB_HTOD_SEQ_ ## field ## _MASK, \ 290 BRCMF_SKB_HTOD_SEQ_ ## field ## _SHIFT, (value)) 291 #define brcmf_skb_htod_seq_get_field(skb, field) \ 292 brcmu_maskget16(brcmf_skbcb(skb)->htod_seq, \ 293 BRCMF_SKB_HTOD_SEQ_ ## field ## _MASK, \ 294 BRCMF_SKB_HTOD_SEQ_ ## field ## _SHIFT) 295 296 #define BRCMF_FWS_TXSTAT_GENERATION_MASK 0x80000000 297 #define BRCMF_FWS_TXSTAT_GENERATION_SHIFT 31 298 #define BRCMF_FWS_TXSTAT_FLAGS_MASK 0x78000000 299 #define BRCMF_FWS_TXSTAT_FLAGS_SHIFT 27 300 #define BRCMF_FWS_TXSTAT_FIFO_MASK 0x07000000 301 #define BRCMF_FWS_TXSTAT_FIFO_SHIFT 24 302 #define BRCMF_FWS_TXSTAT_HSLOT_MASK 0x00FFFF00 303 #define BRCMF_FWS_TXSTAT_HSLOT_SHIFT 8 304 #define BRCMF_FWS_TXSTAT_FREERUN_MASK 0x000000FF 305 #define BRCMF_FWS_TXSTAT_FREERUN_SHIFT 0 306 307 #define brcmf_txstatus_get_field(txs, field) \ 308 brcmu_maskget32(txs, BRCMF_FWS_TXSTAT_ ## field ## _MASK, \ 309 BRCMF_FWS_TXSTAT_ ## field ## _SHIFT) 310 311 /* How long to defer borrowing in jiffies */ 312 #define BRCMF_FWS_BORROW_DEFER_PERIOD (HZ / 10) 313 314 315 /** 316 * enum brcmf_fws_txstatus - txstatus flag values. 317 * 318 * @BRCMF_FWS_TXSTATUS_DISCARD: 319 * host is free to discard the packet. 320 * @BRCMF_FWS_TXSTATUS_CORE_SUPPRESS: 321 * 802.11 core suppressed the packet. 322 * @BRCMF_FWS_TXSTATUS_FW_PS_SUPPRESS: 323 * firmware suppress the packet as device is already in PS mode. 324 * @BRCMF_FWS_TXSTATUS_FW_TOSSED: 325 * firmware tossed the packet. 326 * @BRCMF_FWS_TXSTATUS_FW_DISCARD_NOACK: 327 * firmware tossed the packet after retries. 328 * @BRCMF_FWS_TXSTATUS_FW_SUPPRESS_ACKED: 329 * firmware wrongly reported suppressed previously, now fixing to acked. 330 * @BRCMF_FWS_TXSTATUS_HOST_TOSSED: 331 * host tossed the packet. 332 */ 333 enum brcmf_fws_txstatus { 334 BRCMF_FWS_TXSTATUS_DISCARD, 335 BRCMF_FWS_TXSTATUS_CORE_SUPPRESS, 336 BRCMF_FWS_TXSTATUS_FW_PS_SUPPRESS, 337 BRCMF_FWS_TXSTATUS_FW_TOSSED, 338 BRCMF_FWS_TXSTATUS_FW_DISCARD_NOACK, 339 BRCMF_FWS_TXSTATUS_FW_SUPPRESS_ACKED, 340 BRCMF_FWS_TXSTATUS_HOST_TOSSED 341 }; 342 343 enum brcmf_fws_fcmode { 344 BRCMF_FWS_FCMODE_NONE, 345 BRCMF_FWS_FCMODE_IMPLIED_CREDIT, 346 BRCMF_FWS_FCMODE_EXPLICIT_CREDIT 347 }; 348 349 enum brcmf_fws_mac_desc_state { 350 BRCMF_FWS_STATE_OPEN = 1, 351 BRCMF_FWS_STATE_CLOSE 352 }; 353 354 /** 355 * struct brcmf_fws_mac_descriptor - firmware signalling data per node/interface 356 * 357 * @occupied: slot is in use. 358 * @mac_handle: handle for mac entry determined by firmware. 359 * @interface_id: interface index. 360 * @state: current state. 361 * @suppressed: mac entry is suppressed. 362 * @generation: generation bit. 363 * @ac_bitmap: ac queue bitmap. 364 * @requested_credit: credits requested by firmware. 365 * @ea: ethernet address. 366 * @seq: per-node free-running sequence. 367 * @psq: power-save queue. 368 * @transit_count: packet in transit to firmware. 369 */ 370 struct brcmf_fws_mac_descriptor { 371 char name[16]; 372 u8 occupied; 373 u8 mac_handle; 374 u8 interface_id; 375 u8 state; 376 bool suppressed; 377 u8 generation; 378 u8 ac_bitmap; 379 u8 requested_credit; 380 u8 requested_packet; 381 u8 ea[ETH_ALEN]; 382 u8 seq[BRCMF_FWS_FIFO_COUNT]; 383 struct pktq psq; 384 int transit_count; 385 int suppr_transit_count; 386 bool send_tim_signal; 387 u8 traffic_pending_bmp; 388 u8 traffic_lastreported_bmp; 389 }; 390 391 #define BRCMF_FWS_HANGER_MAXITEMS 3072 392 #define BRCMF_BORROW_RATIO 3 393 394 /** 395 * enum brcmf_fws_hanger_item_state - state of hanger item. 396 * 397 * @BRCMF_FWS_HANGER_ITEM_STATE_FREE: item is free for use. 398 * @BRCMF_FWS_HANGER_ITEM_STATE_INUSE: item is in use. 399 * @BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED: item was suppressed. 400 */ 401 enum brcmf_fws_hanger_item_state { 402 BRCMF_FWS_HANGER_ITEM_STATE_FREE = 1, 403 BRCMF_FWS_HANGER_ITEM_STATE_INUSE, 404 BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED 405 }; 406 407 408 /** 409 * struct brcmf_fws_hanger_item - single entry for tx pending packet. 410 * 411 * @state: entry is either free or occupied. 412 * @pkt: packet itself. 413 */ 414 struct brcmf_fws_hanger_item { 415 enum brcmf_fws_hanger_item_state state; 416 struct sk_buff *pkt; 417 }; 418 419 /** 420 * struct brcmf_fws_hanger - holds packets awaiting firmware txstatus. 421 * 422 * @pushed: packets pushed to await txstatus. 423 * @popped: packets popped upon handling txstatus. 424 * @failed_to_push: packets that could not be pushed. 425 * @failed_to_pop: packets that could not be popped. 426 * @failed_slotfind: packets for which failed to find an entry. 427 * @slot_pos: last returned item index for a free entry. 428 * @items: array of hanger items. 429 */ 430 struct brcmf_fws_hanger { 431 u32 pushed; 432 u32 popped; 433 u32 failed_to_push; 434 u32 failed_to_pop; 435 u32 failed_slotfind; 436 u32 slot_pos; 437 struct brcmf_fws_hanger_item items[BRCMF_FWS_HANGER_MAXITEMS]; 438 }; 439 440 struct brcmf_fws_macdesc_table { 441 struct brcmf_fws_mac_descriptor nodes[BRCMF_FWS_MAC_DESC_TABLE_SIZE]; 442 struct brcmf_fws_mac_descriptor iface[BRCMF_MAX_IFS]; 443 struct brcmf_fws_mac_descriptor other; 444 }; 445 446 struct brcmf_fws_stats { 447 u32 tlv_parse_failed; 448 u32 tlv_invalid_type; 449 u32 header_only_pkt; 450 u32 header_pulls; 451 u32 pkt2bus; 452 u32 send_pkts[5]; 453 u32 requested_sent[5]; 454 u32 generic_error; 455 u32 mac_update_failed; 456 u32 mac_ps_update_failed; 457 u32 if_update_failed; 458 u32 packet_request_failed; 459 u32 credit_request_failed; 460 u32 rollback_success; 461 u32 rollback_failed; 462 u32 delayq_full_error; 463 u32 supprq_full_error; 464 u32 txs_indicate; 465 u32 txs_discard; 466 u32 txs_supp_core; 467 u32 txs_supp_ps; 468 u32 txs_tossed; 469 u32 txs_host_tossed; 470 u32 bus_flow_block; 471 u32 fws_flow_block; 472 }; 473 474 struct brcmf_fws_info { 475 struct brcmf_pub *drvr; 476 spinlock_t spinlock; 477 ulong flags; 478 struct brcmf_fws_stats stats; 479 struct brcmf_fws_hanger hanger; 480 enum brcmf_fws_fcmode fcmode; 481 bool fw_signals; 482 bool bcmc_credit_check; 483 struct brcmf_fws_macdesc_table desc; 484 struct workqueue_struct *fws_wq; 485 struct work_struct fws_dequeue_work; 486 u32 fifo_enqpkt[BRCMF_FWS_FIFO_COUNT]; 487 int fifo_credit[BRCMF_FWS_FIFO_COUNT]; 488 int init_fifo_credit[BRCMF_FWS_FIFO_COUNT]; 489 int credits_borrowed[BRCMF_FWS_FIFO_AC_VO + 1] 490 [BRCMF_FWS_FIFO_AC_VO + 1]; 491 int deq_node_pos[BRCMF_FWS_FIFO_COUNT]; 492 u32 fifo_credit_map; 493 u32 fifo_delay_map; 494 unsigned long borrow_defer_timestamp; 495 bool bus_flow_blocked; 496 bool creditmap_received; 497 u8 mode; 498 bool avoid_queueing; 499 }; 500 501 #define BRCMF_FWS_TLV_DEF(name, id, len) \ 502 case BRCMF_FWS_TYPE_ ## name: \ 503 return len; 504 505 /** 506 * brcmf_fws_get_tlv_len() - returns defined length for given tlv id. 507 * 508 * @fws: firmware-signalling information. 509 * @id: identifier of the TLV. 510 * 511 * Return: the specified length for the given TLV; Otherwise -EINVAL. 512 */ 513 static int brcmf_fws_get_tlv_len(struct brcmf_fws_info *fws, 514 enum brcmf_fws_tlv_type id) 515 { 516 switch (id) { 517 BRCMF_FWS_TLV_DEFLIST 518 default: 519 fws->stats.tlv_invalid_type++; 520 break; 521 } 522 return -EINVAL; 523 } 524 #undef BRCMF_FWS_TLV_DEF 525 526 static void brcmf_fws_lock(struct brcmf_fws_info *fws) 527 __acquires(&fws->spinlock) 528 { 529 spin_lock_irqsave(&fws->spinlock, fws->flags); 530 } 531 532 static void brcmf_fws_unlock(struct brcmf_fws_info *fws) 533 __releases(&fws->spinlock) 534 { 535 spin_unlock_irqrestore(&fws->spinlock, fws->flags); 536 } 537 538 static bool brcmf_fws_ifidx_match(struct sk_buff *skb, void *arg) 539 { 540 u32 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX); 541 return ifidx == *(int *)arg; 542 } 543 544 static void brcmf_fws_hanger_init(struct brcmf_fws_hanger *hanger) 545 { 546 int i; 547 548 memset(hanger, 0, sizeof(*hanger)); 549 for (i = 0; i < ARRAY_SIZE(hanger->items); i++) 550 hanger->items[i].state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 551 } 552 553 static u32 brcmf_fws_hanger_get_free_slot(struct brcmf_fws_hanger *h) 554 { 555 u32 i; 556 557 i = (h->slot_pos + 1) % BRCMF_FWS_HANGER_MAXITEMS; 558 559 while (i != h->slot_pos) { 560 if (h->items[i].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 561 h->slot_pos = i; 562 goto done; 563 } 564 i++; 565 if (i == BRCMF_FWS_HANGER_MAXITEMS) 566 i = 0; 567 } 568 brcmf_err("all slots occupied\n"); 569 h->failed_slotfind++; 570 i = BRCMF_FWS_HANGER_MAXITEMS; 571 done: 572 return i; 573 } 574 575 static int brcmf_fws_hanger_pushpkt(struct brcmf_fws_hanger *h, 576 struct sk_buff *pkt, u32 slot_id) 577 { 578 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 579 return -ENOENT; 580 581 if (h->items[slot_id].state != BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 582 brcmf_err("slot is not free\n"); 583 h->failed_to_push++; 584 return -EINVAL; 585 } 586 587 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_INUSE; 588 h->items[slot_id].pkt = pkt; 589 h->pushed++; 590 return 0; 591 } 592 593 static inline int brcmf_fws_hanger_poppkt(struct brcmf_fws_hanger *h, 594 u32 slot_id, struct sk_buff **pktout, 595 bool remove_item) 596 { 597 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 598 return -ENOENT; 599 600 if (h->items[slot_id].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 601 brcmf_err("entry not in use\n"); 602 h->failed_to_pop++; 603 return -EINVAL; 604 } 605 606 *pktout = h->items[slot_id].pkt; 607 if (remove_item) { 608 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 609 h->items[slot_id].pkt = NULL; 610 h->popped++; 611 } 612 return 0; 613 } 614 615 static void brcmf_fws_psq_flush(struct brcmf_fws_info *fws, struct pktq *q, 616 int ifidx) 617 { 618 struct brcmf_fws_hanger_item *hi; 619 bool (*matchfn)(struct sk_buff *, void *) = NULL; 620 struct sk_buff *skb; 621 int prec; 622 u32 hslot; 623 624 if (ifidx != -1) 625 matchfn = brcmf_fws_ifidx_match; 626 for (prec = 0; prec < q->num_prec; prec++) { 627 skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); 628 while (skb) { 629 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT); 630 hi = &fws->hanger.items[hslot]; 631 WARN_ON(skb != hi->pkt); 632 hi->state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 633 brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb, 634 true); 635 brcmu_pkt_buf_free_skb(skb); 636 skb = brcmu_pktq_pdeq_match(q, prec, matchfn, &ifidx); 637 } 638 } 639 } 640 641 static int brcmf_fws_hanger_mark_suppressed(struct brcmf_fws_hanger *h, 642 u32 slot_id) 643 { 644 if (slot_id >= BRCMF_FWS_HANGER_MAXITEMS) 645 return -ENOENT; 646 647 if (h->items[slot_id].state == BRCMF_FWS_HANGER_ITEM_STATE_FREE) { 648 brcmf_err("entry not in use\n"); 649 return -EINVAL; 650 } 651 652 h->items[slot_id].state = BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED; 653 return 0; 654 } 655 656 static void brcmf_fws_hanger_cleanup(struct brcmf_fws_info *fws, 657 bool (*fn)(struct sk_buff *, void *), 658 int ifidx) 659 { 660 struct brcmf_fws_hanger *h = &fws->hanger; 661 struct sk_buff *skb; 662 int i; 663 enum brcmf_fws_hanger_item_state s; 664 665 for (i = 0; i < ARRAY_SIZE(h->items); i++) { 666 s = h->items[i].state; 667 if (s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE || 668 s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE_SUPPRESSED) { 669 skb = h->items[i].pkt; 670 if (fn == NULL || fn(skb, &ifidx)) { 671 /* suppress packets freed from psq */ 672 if (s == BRCMF_FWS_HANGER_ITEM_STATE_INUSE) 673 brcmu_pkt_buf_free_skb(skb); 674 h->items[i].state = 675 BRCMF_FWS_HANGER_ITEM_STATE_FREE; 676 } 677 } 678 } 679 } 680 681 static void brcmf_fws_macdesc_set_name(struct brcmf_fws_info *fws, 682 struct brcmf_fws_mac_descriptor *desc) 683 { 684 if (desc == &fws->desc.other) 685 strlcpy(desc->name, "MAC-OTHER", sizeof(desc->name)); 686 else if (desc->mac_handle) 687 scnprintf(desc->name, sizeof(desc->name), "MAC-%d:%d", 688 desc->mac_handle, desc->interface_id); 689 else 690 scnprintf(desc->name, sizeof(desc->name), "MACIF:%d", 691 desc->interface_id); 692 } 693 694 static void brcmf_fws_macdesc_init(struct brcmf_fws_mac_descriptor *desc, 695 u8 *addr, u8 ifidx) 696 { 697 brcmf_dbg(TRACE, 698 "enter: desc %p ea=%pM, ifidx=%u\n", desc, addr, ifidx); 699 desc->occupied = 1; 700 desc->state = BRCMF_FWS_STATE_OPEN; 701 desc->requested_credit = 0; 702 desc->requested_packet = 0; 703 /* depending on use may need ifp->bsscfgidx instead */ 704 desc->interface_id = ifidx; 705 desc->ac_bitmap = 0xff; /* update this when handling APSD */ 706 if (addr) 707 memcpy(&desc->ea[0], addr, ETH_ALEN); 708 } 709 710 static 711 void brcmf_fws_macdesc_deinit(struct brcmf_fws_mac_descriptor *desc) 712 { 713 brcmf_dbg(TRACE, 714 "enter: ea=%pM, ifidx=%u\n", desc->ea, desc->interface_id); 715 desc->occupied = 0; 716 desc->state = BRCMF_FWS_STATE_CLOSE; 717 desc->requested_credit = 0; 718 desc->requested_packet = 0; 719 } 720 721 static struct brcmf_fws_mac_descriptor * 722 brcmf_fws_macdesc_lookup(struct brcmf_fws_info *fws, u8 *ea) 723 { 724 struct brcmf_fws_mac_descriptor *entry; 725 int i; 726 727 if (ea == NULL) 728 return ERR_PTR(-EINVAL); 729 730 entry = &fws->desc.nodes[0]; 731 for (i = 0; i < ARRAY_SIZE(fws->desc.nodes); i++) { 732 if (entry->occupied && !memcmp(entry->ea, ea, ETH_ALEN)) 733 return entry; 734 entry++; 735 } 736 737 return ERR_PTR(-ENOENT); 738 } 739 740 static struct brcmf_fws_mac_descriptor* 741 brcmf_fws_macdesc_find(struct brcmf_fws_info *fws, struct brcmf_if *ifp, u8 *da) 742 { 743 struct brcmf_fws_mac_descriptor *entry = &fws->desc.other; 744 bool multicast; 745 746 multicast = is_multicast_ether_addr(da); 747 748 /* Multicast destination, STA and P2P clients get the interface entry. 749 * STA/GC gets the Mac Entry for TDLS destinations, TDLS destinations 750 * have their own entry. 751 */ 752 if (multicast && ifp->fws_desc) { 753 entry = ifp->fws_desc; 754 goto done; 755 } 756 757 entry = brcmf_fws_macdesc_lookup(fws, da); 758 if (IS_ERR(entry)) 759 entry = ifp->fws_desc; 760 761 done: 762 return entry; 763 } 764 765 static bool brcmf_fws_macdesc_closed(struct brcmf_fws_info *fws, 766 struct brcmf_fws_mac_descriptor *entry, 767 int fifo) 768 { 769 struct brcmf_fws_mac_descriptor *if_entry; 770 bool closed; 771 772 /* for unique destination entries the related interface 773 * may be closed. 774 */ 775 if (entry->mac_handle) { 776 if_entry = &fws->desc.iface[entry->interface_id]; 777 if (if_entry->state == BRCMF_FWS_STATE_CLOSE) 778 return true; 779 } 780 /* an entry is closed when the state is closed and 781 * the firmware did not request anything. 782 */ 783 closed = entry->state == BRCMF_FWS_STATE_CLOSE && 784 !entry->requested_credit && !entry->requested_packet; 785 786 /* Or firmware does not allow traffic for given fifo */ 787 return closed || !(entry->ac_bitmap & BIT(fifo)); 788 } 789 790 static void brcmf_fws_macdesc_cleanup(struct brcmf_fws_info *fws, 791 struct brcmf_fws_mac_descriptor *entry, 792 int ifidx) 793 { 794 if (entry->occupied && (ifidx == -1 || ifidx == entry->interface_id)) { 795 brcmf_fws_psq_flush(fws, &entry->psq, ifidx); 796 entry->occupied = !!(entry->psq.len); 797 } 798 } 799 800 static void brcmf_fws_bus_txq_cleanup(struct brcmf_fws_info *fws, 801 bool (*fn)(struct sk_buff *, void *), 802 int ifidx) 803 { 804 struct brcmf_fws_hanger_item *hi; 805 struct pktq *txq; 806 struct sk_buff *skb; 807 int prec; 808 u32 hslot; 809 810 txq = brcmf_bus_gettxq(fws->drvr->bus_if); 811 if (IS_ERR(txq)) { 812 brcmf_dbg(TRACE, "no txq to clean up\n"); 813 return; 814 } 815 816 for (prec = 0; prec < txq->num_prec; prec++) { 817 skb = brcmu_pktq_pdeq_match(txq, prec, fn, &ifidx); 818 while (skb) { 819 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT); 820 hi = &fws->hanger.items[hslot]; 821 WARN_ON(skb != hi->pkt); 822 hi->state = BRCMF_FWS_HANGER_ITEM_STATE_FREE; 823 brcmu_pkt_buf_free_skb(skb); 824 skb = brcmu_pktq_pdeq_match(txq, prec, fn, &ifidx); 825 } 826 } 827 } 828 829 static void brcmf_fws_cleanup(struct brcmf_fws_info *fws, int ifidx) 830 { 831 int i; 832 struct brcmf_fws_mac_descriptor *table; 833 bool (*matchfn)(struct sk_buff *, void *) = NULL; 834 835 if (fws == NULL) 836 return; 837 838 if (ifidx != -1) 839 matchfn = brcmf_fws_ifidx_match; 840 841 /* cleanup individual nodes */ 842 table = &fws->desc.nodes[0]; 843 for (i = 0; i < ARRAY_SIZE(fws->desc.nodes); i++) 844 brcmf_fws_macdesc_cleanup(fws, &table[i], ifidx); 845 846 brcmf_fws_macdesc_cleanup(fws, &fws->desc.other, ifidx); 847 brcmf_fws_bus_txq_cleanup(fws, matchfn, ifidx); 848 brcmf_fws_hanger_cleanup(fws, matchfn, ifidx); 849 } 850 851 static u8 brcmf_fws_hdrpush(struct brcmf_fws_info *fws, struct sk_buff *skb) 852 { 853 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac; 854 u8 *wlh; 855 u16 data_offset = 0; 856 u8 fillers; 857 __le32 pkttag = cpu_to_le32(brcmf_skbcb(skb)->htod); 858 __le16 pktseq = cpu_to_le16(brcmf_skbcb(skb)->htod_seq); 859 860 brcmf_dbg(TRACE, "enter: %s, idx=%d hslot=%d htod %X seq %X\n", 861 entry->name, brcmf_skb_if_flags_get_field(skb, INDEX), 862 (le32_to_cpu(pkttag) >> 8) & 0xffff, 863 brcmf_skbcb(skb)->htod, brcmf_skbcb(skb)->htod_seq); 864 if (entry->send_tim_signal) 865 data_offset += 2 + BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP_LEN; 866 if (BRCMF_FWS_MODE_GET_REUSESEQ(fws->mode)) 867 data_offset += BRCMF_FWS_TYPE_SEQ_LEN; 868 /* +2 is for Type[1] and Len[1] in TLV, plus TIM signal */ 869 data_offset += 2 + BRCMF_FWS_TYPE_PKTTAG_LEN; 870 fillers = round_up(data_offset, 4) - data_offset; 871 data_offset += fillers; 872 873 skb_push(skb, data_offset); 874 wlh = skb->data; 875 876 wlh[0] = BRCMF_FWS_TYPE_PKTTAG; 877 wlh[1] = BRCMF_FWS_TYPE_PKTTAG_LEN; 878 memcpy(&wlh[2], &pkttag, sizeof(pkttag)); 879 if (BRCMF_FWS_MODE_GET_REUSESEQ(fws->mode)) { 880 wlh[1] += BRCMF_FWS_TYPE_SEQ_LEN; 881 memcpy(&wlh[2 + BRCMF_FWS_TYPE_PKTTAG_LEN], &pktseq, 882 sizeof(pktseq)); 883 } 884 wlh += wlh[1] + 2; 885 886 if (entry->send_tim_signal) { 887 entry->send_tim_signal = false; 888 wlh[0] = BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP; 889 wlh[1] = BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP_LEN; 890 wlh[2] = entry->mac_handle; 891 wlh[3] = entry->traffic_pending_bmp; 892 brcmf_dbg(TRACE, "adding TIM info: handle %d bmp 0x%X\n", 893 entry->mac_handle, entry->traffic_pending_bmp); 894 wlh += BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP_LEN + 2; 895 entry->traffic_lastreported_bmp = entry->traffic_pending_bmp; 896 } 897 if (fillers) 898 memset(wlh, BRCMF_FWS_TYPE_FILLER, fillers); 899 900 return (u8)(data_offset >> 2); 901 } 902 903 static bool brcmf_fws_tim_update(struct brcmf_fws_info *fws, 904 struct brcmf_fws_mac_descriptor *entry, 905 int fifo, bool send_immediately) 906 { 907 struct sk_buff *skb; 908 struct brcmf_skbuff_cb *skcb; 909 s32 err; 910 u32 len; 911 u8 data_offset; 912 int ifidx; 913 914 /* check delayedQ and suppressQ in one call using bitmap */ 915 if (brcmu_pktq_mlen(&entry->psq, 3 << (fifo * 2)) == 0) 916 entry->traffic_pending_bmp &= ~NBITVAL(fifo); 917 else 918 entry->traffic_pending_bmp |= NBITVAL(fifo); 919 920 entry->send_tim_signal = false; 921 if (entry->traffic_lastreported_bmp != entry->traffic_pending_bmp) 922 entry->send_tim_signal = true; 923 if (send_immediately && entry->send_tim_signal && 924 entry->state == BRCMF_FWS_STATE_CLOSE) { 925 /* create a dummy packet and sent that. The traffic */ 926 /* bitmap info will automatically be attached to that packet */ 927 len = BRCMF_FWS_TYPE_PKTTAG_LEN + 2 + 928 BRCMF_FWS_TYPE_SEQ_LEN + 929 BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP_LEN + 2 + 930 4 + fws->drvr->hdrlen; 931 skb = brcmu_pkt_buf_get_skb(len); 932 if (skb == NULL) 933 return false; 934 skb_pull(skb, len); 935 skcb = brcmf_skbcb(skb); 936 skcb->mac = entry; 937 skcb->state = BRCMF_FWS_SKBSTATE_TIM; 938 skcb->htod = 0; 939 skcb->htod_seq = 0; 940 data_offset = brcmf_fws_hdrpush(fws, skb); 941 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX); 942 brcmf_fws_unlock(fws); 943 err = brcmf_proto_txdata(fws->drvr, ifidx, data_offset, skb); 944 brcmf_fws_lock(fws); 945 if (err) 946 brcmu_pkt_buf_free_skb(skb); 947 return true; 948 } 949 return false; 950 } 951 952 static void 953 brcmf_fws_flow_control_check(struct brcmf_fws_info *fws, struct pktq *pq, 954 u8 if_id) 955 { 956 struct brcmf_if *ifp = brcmf_get_ifp(fws->drvr, if_id); 957 958 if (WARN_ON(!ifp)) 959 return; 960 961 if ((ifp->netif_stop & BRCMF_NETIF_STOP_REASON_FWS_FC) && 962 pq->len <= BRCMF_FWS_FLOWCONTROL_LOWATER) 963 brcmf_txflowblock_if(ifp, 964 BRCMF_NETIF_STOP_REASON_FWS_FC, false); 965 if (!(ifp->netif_stop & BRCMF_NETIF_STOP_REASON_FWS_FC) && 966 pq->len >= BRCMF_FWS_FLOWCONTROL_HIWATER) { 967 fws->stats.fws_flow_block++; 968 brcmf_txflowblock_if(ifp, BRCMF_NETIF_STOP_REASON_FWS_FC, true); 969 } 970 return; 971 } 972 973 static int brcmf_fws_rssi_indicate(struct brcmf_fws_info *fws, s8 rssi) 974 { 975 brcmf_dbg(CTL, "rssi %d\n", rssi); 976 return 0; 977 } 978 979 static 980 int brcmf_fws_macdesc_indicate(struct brcmf_fws_info *fws, u8 type, u8 *data) 981 { 982 struct brcmf_fws_mac_descriptor *entry, *existing; 983 u8 mac_handle; 984 u8 ifidx; 985 u8 *addr; 986 987 mac_handle = *data++; 988 ifidx = *data++; 989 addr = data; 990 991 entry = &fws->desc.nodes[mac_handle & 0x1F]; 992 if (type == BRCMF_FWS_TYPE_MACDESC_DEL) { 993 if (entry->occupied) { 994 brcmf_dbg(TRACE, "deleting %s mac %pM\n", 995 entry->name, addr); 996 brcmf_fws_lock(fws); 997 brcmf_fws_macdesc_cleanup(fws, entry, -1); 998 brcmf_fws_macdesc_deinit(entry); 999 brcmf_fws_unlock(fws); 1000 } else 1001 fws->stats.mac_update_failed++; 1002 return 0; 1003 } 1004 1005 existing = brcmf_fws_macdesc_lookup(fws, addr); 1006 if (IS_ERR(existing)) { 1007 if (!entry->occupied) { 1008 brcmf_fws_lock(fws); 1009 entry->mac_handle = mac_handle; 1010 brcmf_fws_macdesc_init(entry, addr, ifidx); 1011 brcmf_fws_macdesc_set_name(fws, entry); 1012 brcmu_pktq_init(&entry->psq, BRCMF_FWS_PSQ_PREC_COUNT, 1013 BRCMF_FWS_PSQ_LEN); 1014 brcmf_fws_unlock(fws); 1015 brcmf_dbg(TRACE, "add %s mac %pM\n", entry->name, addr); 1016 } else { 1017 fws->stats.mac_update_failed++; 1018 } 1019 } else { 1020 if (entry != existing) { 1021 brcmf_dbg(TRACE, "copy mac %s\n", existing->name); 1022 brcmf_fws_lock(fws); 1023 memcpy(entry, existing, 1024 offsetof(struct brcmf_fws_mac_descriptor, psq)); 1025 entry->mac_handle = mac_handle; 1026 brcmf_fws_macdesc_deinit(existing); 1027 brcmf_fws_macdesc_set_name(fws, entry); 1028 brcmf_fws_unlock(fws); 1029 brcmf_dbg(TRACE, "relocate %s mac %pM\n", entry->name, 1030 addr); 1031 } else { 1032 brcmf_dbg(TRACE, "use existing\n"); 1033 WARN_ON(entry->mac_handle != mac_handle); 1034 /* TODO: what should we do here: continue, reinit, .. */ 1035 } 1036 } 1037 return 0; 1038 } 1039 1040 static int brcmf_fws_macdesc_state_indicate(struct brcmf_fws_info *fws, 1041 u8 type, u8 *data) 1042 { 1043 struct brcmf_fws_mac_descriptor *entry; 1044 u8 mac_handle; 1045 int ret; 1046 1047 mac_handle = data[0]; 1048 entry = &fws->desc.nodes[mac_handle & 0x1F]; 1049 if (!entry->occupied) { 1050 fws->stats.mac_ps_update_failed++; 1051 return -ESRCH; 1052 } 1053 brcmf_fws_lock(fws); 1054 /* a state update should wipe old credits */ 1055 entry->requested_credit = 0; 1056 entry->requested_packet = 0; 1057 if (type == BRCMF_FWS_TYPE_MAC_OPEN) { 1058 entry->state = BRCMF_FWS_STATE_OPEN; 1059 ret = BRCMF_FWS_RET_OK_SCHEDULE; 1060 } else { 1061 entry->state = BRCMF_FWS_STATE_CLOSE; 1062 brcmf_fws_tim_update(fws, entry, BRCMF_FWS_FIFO_AC_BK, false); 1063 brcmf_fws_tim_update(fws, entry, BRCMF_FWS_FIFO_AC_BE, false); 1064 brcmf_fws_tim_update(fws, entry, BRCMF_FWS_FIFO_AC_VI, false); 1065 brcmf_fws_tim_update(fws, entry, BRCMF_FWS_FIFO_AC_VO, true); 1066 ret = BRCMF_FWS_RET_OK_NOSCHEDULE; 1067 } 1068 brcmf_fws_unlock(fws); 1069 return ret; 1070 } 1071 1072 static int brcmf_fws_interface_state_indicate(struct brcmf_fws_info *fws, 1073 u8 type, u8 *data) 1074 { 1075 struct brcmf_fws_mac_descriptor *entry; 1076 u8 ifidx; 1077 int ret; 1078 1079 ifidx = data[0]; 1080 1081 if (ifidx >= BRCMF_MAX_IFS) { 1082 ret = -ERANGE; 1083 goto fail; 1084 } 1085 1086 entry = &fws->desc.iface[ifidx]; 1087 if (!entry->occupied) { 1088 ret = -ESRCH; 1089 goto fail; 1090 } 1091 1092 brcmf_dbg(TRACE, "%s (%d): %s\n", brcmf_fws_get_tlv_name(type), type, 1093 entry->name); 1094 brcmf_fws_lock(fws); 1095 switch (type) { 1096 case BRCMF_FWS_TYPE_INTERFACE_OPEN: 1097 entry->state = BRCMF_FWS_STATE_OPEN; 1098 ret = BRCMF_FWS_RET_OK_SCHEDULE; 1099 break; 1100 case BRCMF_FWS_TYPE_INTERFACE_CLOSE: 1101 entry->state = BRCMF_FWS_STATE_CLOSE; 1102 ret = BRCMF_FWS_RET_OK_NOSCHEDULE; 1103 break; 1104 default: 1105 ret = -EINVAL; 1106 brcmf_fws_unlock(fws); 1107 goto fail; 1108 } 1109 brcmf_fws_unlock(fws); 1110 return ret; 1111 1112 fail: 1113 fws->stats.if_update_failed++; 1114 return ret; 1115 } 1116 1117 static int brcmf_fws_request_indicate(struct brcmf_fws_info *fws, u8 type, 1118 u8 *data) 1119 { 1120 struct brcmf_fws_mac_descriptor *entry; 1121 1122 entry = &fws->desc.nodes[data[1] & 0x1F]; 1123 if (!entry->occupied) { 1124 if (type == BRCMF_FWS_TYPE_MAC_REQUEST_CREDIT) 1125 fws->stats.credit_request_failed++; 1126 else 1127 fws->stats.packet_request_failed++; 1128 return -ESRCH; 1129 } 1130 1131 brcmf_dbg(TRACE, "%s (%d): %s cnt %d bmp %d\n", 1132 brcmf_fws_get_tlv_name(type), type, entry->name, 1133 data[0], data[2]); 1134 brcmf_fws_lock(fws); 1135 if (type == BRCMF_FWS_TYPE_MAC_REQUEST_CREDIT) 1136 entry->requested_credit = data[0]; 1137 else 1138 entry->requested_packet = data[0]; 1139 1140 entry->ac_bitmap = data[2]; 1141 brcmf_fws_unlock(fws); 1142 return BRCMF_FWS_RET_OK_SCHEDULE; 1143 } 1144 1145 static void 1146 brcmf_fws_macdesc_use_req_credit(struct brcmf_fws_mac_descriptor *entry, 1147 struct sk_buff *skb) 1148 { 1149 if (entry->requested_credit > 0) { 1150 entry->requested_credit--; 1151 brcmf_skb_if_flags_set_field(skb, REQUESTED, 1); 1152 brcmf_skb_if_flags_set_field(skb, REQ_CREDIT, 1); 1153 if (entry->state != BRCMF_FWS_STATE_CLOSE) 1154 brcmf_err("requested credit set while mac not closed!\n"); 1155 } else if (entry->requested_packet > 0) { 1156 entry->requested_packet--; 1157 brcmf_skb_if_flags_set_field(skb, REQUESTED, 1); 1158 brcmf_skb_if_flags_set_field(skb, REQ_CREDIT, 0); 1159 if (entry->state != BRCMF_FWS_STATE_CLOSE) 1160 brcmf_err("requested packet set while mac not closed!\n"); 1161 } else { 1162 brcmf_skb_if_flags_set_field(skb, REQUESTED, 0); 1163 brcmf_skb_if_flags_set_field(skb, REQ_CREDIT, 0); 1164 } 1165 } 1166 1167 static void brcmf_fws_macdesc_return_req_credit(struct sk_buff *skb) 1168 { 1169 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac; 1170 1171 if ((brcmf_skb_if_flags_get_field(skb, REQ_CREDIT)) && 1172 (entry->state == BRCMF_FWS_STATE_CLOSE)) 1173 entry->requested_credit++; 1174 } 1175 1176 static void brcmf_fws_return_credits(struct brcmf_fws_info *fws, 1177 u8 fifo, u8 credits) 1178 { 1179 int lender_ac; 1180 int *borrowed; 1181 int *fifo_credit; 1182 1183 if (!credits) 1184 return; 1185 1186 fws->fifo_credit_map |= 1 << fifo; 1187 1188 if (fifo > BRCMF_FWS_FIFO_AC_BK && 1189 fifo <= BRCMF_FWS_FIFO_AC_VO) { 1190 for (lender_ac = BRCMF_FWS_FIFO_AC_VO; lender_ac >= 0; 1191 lender_ac--) { 1192 borrowed = &fws->credits_borrowed[fifo][lender_ac]; 1193 if (*borrowed) { 1194 fws->fifo_credit_map |= (1 << lender_ac); 1195 fifo_credit = &fws->fifo_credit[lender_ac]; 1196 if (*borrowed >= credits) { 1197 *borrowed -= credits; 1198 *fifo_credit += credits; 1199 return; 1200 } else { 1201 credits -= *borrowed; 1202 *fifo_credit += *borrowed; 1203 *borrowed = 0; 1204 } 1205 } 1206 } 1207 } 1208 1209 if (credits) { 1210 fws->fifo_credit[fifo] += credits; 1211 } 1212 1213 if (fws->fifo_credit[fifo] > fws->init_fifo_credit[fifo]) 1214 fws->fifo_credit[fifo] = fws->init_fifo_credit[fifo]; 1215 1216 } 1217 1218 static void brcmf_fws_schedule_deq(struct brcmf_fws_info *fws) 1219 { 1220 /* only schedule dequeue when there are credits for delayed traffic */ 1221 if ((fws->fifo_credit_map & fws->fifo_delay_map) || 1222 (!brcmf_fws_fc_active(fws) && fws->fifo_delay_map)) 1223 queue_work(fws->fws_wq, &fws->fws_dequeue_work); 1224 } 1225 1226 static int brcmf_fws_enq(struct brcmf_fws_info *fws, 1227 enum brcmf_fws_skb_state state, int fifo, 1228 struct sk_buff *p) 1229 { 1230 struct brcmf_pub *drvr = fws->drvr; 1231 int prec = 2 * fifo; 1232 u32 *qfull_stat = &fws->stats.delayq_full_error; 1233 struct brcmf_fws_mac_descriptor *entry; 1234 struct pktq *pq; 1235 struct sk_buff_head *queue; 1236 struct sk_buff *p_head; 1237 struct sk_buff *p_tail; 1238 u32 fr_new; 1239 u32 fr_compare; 1240 1241 entry = brcmf_skbcb(p)->mac; 1242 if (entry == NULL) { 1243 bphy_err(drvr, "no mac descriptor found for skb %p\n", p); 1244 return -ENOENT; 1245 } 1246 1247 brcmf_dbg(DATA, "enter: fifo %d skb %p\n", fifo, p); 1248 if (state == BRCMF_FWS_SKBSTATE_SUPPRESSED) { 1249 prec += 1; 1250 qfull_stat = &fws->stats.supprq_full_error; 1251 1252 /* Fix out of order delivery of frames. Dont assume frame */ 1253 /* can be inserted at the end, but look for correct position */ 1254 pq = &entry->psq; 1255 if (pktq_full(pq) || pktq_pfull(pq, prec)) { 1256 *qfull_stat += 1; 1257 return -ENFILE; 1258 } 1259 queue = &pq->q[prec].skblist; 1260 1261 p_head = skb_peek(queue); 1262 p_tail = skb_peek_tail(queue); 1263 fr_new = brcmf_skb_htod_tag_get_field(p, FREERUN); 1264 1265 while (p_head != p_tail) { 1266 fr_compare = brcmf_skb_htod_tag_get_field(p_tail, 1267 FREERUN); 1268 /* be sure to handle wrap of 256 */ 1269 if (((fr_new > fr_compare) && 1270 ((fr_new - fr_compare) < 128)) || 1271 ((fr_new < fr_compare) && 1272 ((fr_compare - fr_new) > 128))) 1273 break; 1274 p_tail = skb_queue_prev(queue, p_tail); 1275 } 1276 /* Position found. Determine what to do */ 1277 if (p_tail == NULL) { 1278 /* empty list */ 1279 __skb_queue_tail(queue, p); 1280 } else { 1281 fr_compare = brcmf_skb_htod_tag_get_field(p_tail, 1282 FREERUN); 1283 if (((fr_new > fr_compare) && 1284 ((fr_new - fr_compare) < 128)) || 1285 ((fr_new < fr_compare) && 1286 ((fr_compare - fr_new) > 128))) { 1287 /* After tail */ 1288 __skb_queue_after(queue, p_tail, p); 1289 } else { 1290 /* Before tail */ 1291 __skb_insert(p, p_tail->prev, p_tail, queue); 1292 } 1293 } 1294 1295 /* Complete the counters and statistics */ 1296 pq->len++; 1297 if (pq->hi_prec < prec) 1298 pq->hi_prec = (u8) prec; 1299 } else if (brcmu_pktq_penq(&entry->psq, prec, p) == NULL) { 1300 *qfull_stat += 1; 1301 return -ENFILE; 1302 } 1303 1304 /* increment total enqueued packet count */ 1305 fws->fifo_delay_map |= 1 << fifo; 1306 fws->fifo_enqpkt[fifo]++; 1307 1308 /* update the sk_buff state */ 1309 brcmf_skbcb(p)->state = state; 1310 1311 /* 1312 * A packet has been pushed so update traffic 1313 * availability bitmap, if applicable 1314 */ 1315 brcmf_fws_tim_update(fws, entry, fifo, true); 1316 brcmf_fws_flow_control_check(fws, &entry->psq, 1317 brcmf_skb_if_flags_get_field(p, INDEX)); 1318 return 0; 1319 } 1320 1321 static struct sk_buff *brcmf_fws_deq(struct brcmf_fws_info *fws, int fifo) 1322 { 1323 struct brcmf_fws_mac_descriptor *table; 1324 struct brcmf_fws_mac_descriptor *entry; 1325 struct sk_buff *p; 1326 int num_nodes; 1327 int node_pos; 1328 int prec_out; 1329 int pmsk; 1330 int i; 1331 1332 table = (struct brcmf_fws_mac_descriptor *)&fws->desc; 1333 num_nodes = sizeof(fws->desc) / sizeof(struct brcmf_fws_mac_descriptor); 1334 node_pos = fws->deq_node_pos[fifo]; 1335 1336 for (i = 0; i < num_nodes; i++) { 1337 entry = &table[(node_pos + i) % num_nodes]; 1338 if (!entry->occupied || 1339 brcmf_fws_macdesc_closed(fws, entry, fifo)) 1340 continue; 1341 1342 if (entry->suppressed) 1343 pmsk = 2; 1344 else 1345 pmsk = 3; 1346 p = brcmu_pktq_mdeq(&entry->psq, pmsk << (fifo * 2), &prec_out); 1347 if (p == NULL) { 1348 if (entry->suppressed) { 1349 if (entry->suppr_transit_count) 1350 continue; 1351 entry->suppressed = false; 1352 p = brcmu_pktq_mdeq(&entry->psq, 1353 1 << (fifo * 2), &prec_out); 1354 } 1355 } 1356 if (p == NULL) 1357 continue; 1358 1359 brcmf_fws_macdesc_use_req_credit(entry, p); 1360 1361 /* move dequeue position to ensure fair round-robin */ 1362 fws->deq_node_pos[fifo] = (node_pos + i + 1) % num_nodes; 1363 brcmf_fws_flow_control_check(fws, &entry->psq, 1364 brcmf_skb_if_flags_get_field(p, 1365 INDEX) 1366 ); 1367 /* 1368 * A packet has been picked up, update traffic 1369 * availability bitmap, if applicable 1370 */ 1371 brcmf_fws_tim_update(fws, entry, fifo, false); 1372 1373 /* 1374 * decrement total enqueued fifo packets and 1375 * clear delay bitmap if done. 1376 */ 1377 fws->fifo_enqpkt[fifo]--; 1378 if (fws->fifo_enqpkt[fifo] == 0) 1379 fws->fifo_delay_map &= ~(1 << fifo); 1380 goto done; 1381 } 1382 p = NULL; 1383 done: 1384 brcmf_dbg(DATA, "exit: fifo %d skb %p\n", fifo, p); 1385 return p; 1386 } 1387 1388 static int brcmf_fws_txstatus_suppressed(struct brcmf_fws_info *fws, int fifo, 1389 struct sk_buff *skb, 1390 u32 genbit, u16 seq) 1391 { 1392 struct brcmf_fws_mac_descriptor *entry = brcmf_skbcb(skb)->mac; 1393 u32 hslot; 1394 int ret; 1395 1396 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT); 1397 1398 /* this packet was suppressed */ 1399 if (!entry->suppressed) { 1400 entry->suppressed = true; 1401 entry->suppr_transit_count = entry->transit_count; 1402 brcmf_dbg(DATA, "suppress %s: transit %d\n", 1403 entry->name, entry->transit_count); 1404 } 1405 1406 entry->generation = genbit; 1407 1408 brcmf_skb_htod_tag_set_field(skb, GENERATION, genbit); 1409 brcmf_skbcb(skb)->htod_seq = seq; 1410 if (brcmf_skb_htod_seq_get_field(skb, FROMFW)) { 1411 brcmf_skb_htod_seq_set_field(skb, FROMDRV, 1); 1412 brcmf_skb_htod_seq_set_field(skb, FROMFW, 0); 1413 } else { 1414 brcmf_skb_htod_seq_set_field(skb, FROMDRV, 0); 1415 } 1416 ret = brcmf_fws_enq(fws, BRCMF_FWS_SKBSTATE_SUPPRESSED, fifo, skb); 1417 1418 if (ret != 0) { 1419 /* suppress q is full drop this packet */ 1420 brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb, true); 1421 } else { 1422 /* Mark suppressed to avoid a double free during wlfc cleanup */ 1423 brcmf_fws_hanger_mark_suppressed(&fws->hanger, hslot); 1424 } 1425 1426 return ret; 1427 } 1428 1429 static int 1430 brcmf_fws_txs_process(struct brcmf_fws_info *fws, u8 flags, u32 hslot, 1431 u32 genbit, u16 seq, u8 compcnt) 1432 { 1433 struct brcmf_pub *drvr = fws->drvr; 1434 u32 fifo; 1435 u8 cnt = 0; 1436 int ret; 1437 bool remove_from_hanger = true; 1438 struct sk_buff *skb; 1439 struct brcmf_skbuff_cb *skcb; 1440 struct brcmf_fws_mac_descriptor *entry = NULL; 1441 struct brcmf_if *ifp; 1442 1443 brcmf_dbg(DATA, "flags %d\n", flags); 1444 1445 if (flags == BRCMF_FWS_TXSTATUS_DISCARD) 1446 fws->stats.txs_discard += compcnt; 1447 else if (flags == BRCMF_FWS_TXSTATUS_CORE_SUPPRESS) { 1448 fws->stats.txs_supp_core += compcnt; 1449 remove_from_hanger = false; 1450 } else if (flags == BRCMF_FWS_TXSTATUS_FW_PS_SUPPRESS) { 1451 fws->stats.txs_supp_ps += compcnt; 1452 remove_from_hanger = false; 1453 } else if (flags == BRCMF_FWS_TXSTATUS_FW_TOSSED) 1454 fws->stats.txs_tossed += compcnt; 1455 else if (flags == BRCMF_FWS_TXSTATUS_FW_DISCARD_NOACK) 1456 fws->stats.txs_discard += compcnt; 1457 else if (flags == BRCMF_FWS_TXSTATUS_FW_SUPPRESS_ACKED) 1458 fws->stats.txs_discard += compcnt; 1459 else if (flags == BRCMF_FWS_TXSTATUS_HOST_TOSSED) 1460 fws->stats.txs_host_tossed += compcnt; 1461 else 1462 bphy_err(drvr, "unexpected txstatus\n"); 1463 1464 while (cnt < compcnt) { 1465 ret = brcmf_fws_hanger_poppkt(&fws->hanger, hslot, &skb, 1466 remove_from_hanger); 1467 if (ret != 0) { 1468 bphy_err(drvr, "no packet in hanger slot: hslot=%d\n", 1469 hslot); 1470 goto cont; 1471 } 1472 1473 skcb = brcmf_skbcb(skb); 1474 entry = skcb->mac; 1475 if (WARN_ON(!entry)) { 1476 brcmu_pkt_buf_free_skb(skb); 1477 goto cont; 1478 } 1479 entry->transit_count--; 1480 if (entry->suppressed && entry->suppr_transit_count) 1481 entry->suppr_transit_count--; 1482 1483 brcmf_dbg(DATA, "%s flags %d htod %X seq %X\n", entry->name, 1484 flags, skcb->htod, seq); 1485 1486 /* pick up the implicit credit from this packet */ 1487 fifo = brcmf_skb_htod_tag_get_field(skb, FIFO); 1488 if (fws->fcmode == BRCMF_FWS_FCMODE_IMPLIED_CREDIT || 1489 (brcmf_skb_if_flags_get_field(skb, REQ_CREDIT)) || 1490 flags == BRCMF_FWS_TXSTATUS_HOST_TOSSED) { 1491 brcmf_fws_return_credits(fws, fifo, 1); 1492 brcmf_fws_schedule_deq(fws); 1493 } 1494 brcmf_fws_macdesc_return_req_credit(skb); 1495 1496 ret = brcmf_proto_hdrpull(fws->drvr, false, skb, &ifp); 1497 if (ret) { 1498 brcmu_pkt_buf_free_skb(skb); 1499 goto cont; 1500 } 1501 if (!remove_from_hanger) 1502 ret = brcmf_fws_txstatus_suppressed(fws, fifo, skb, 1503 genbit, seq); 1504 if (remove_from_hanger || ret) 1505 brcmf_txfinalize(ifp, skb, true); 1506 1507 cont: 1508 hslot = (hslot + 1) & (BRCMF_FWS_TXSTAT_HSLOT_MASK >> 1509 BRCMF_FWS_TXSTAT_HSLOT_SHIFT); 1510 if (BRCMF_FWS_MODE_GET_REUSESEQ(fws->mode)) 1511 seq = (seq + 1) & BRCMF_SKB_HTOD_SEQ_NR_MASK; 1512 1513 cnt++; 1514 } 1515 1516 return 0; 1517 } 1518 1519 static int brcmf_fws_fifocreditback_indicate(struct brcmf_fws_info *fws, 1520 u8 *data) 1521 { 1522 int i; 1523 1524 if (fws->fcmode != BRCMF_FWS_FCMODE_EXPLICIT_CREDIT) { 1525 brcmf_dbg(INFO, "ignored\n"); 1526 return BRCMF_FWS_RET_OK_NOSCHEDULE; 1527 } 1528 1529 brcmf_dbg(DATA, "enter: data %pM\n", data); 1530 brcmf_fws_lock(fws); 1531 for (i = 0; i < BRCMF_FWS_FIFO_COUNT; i++) 1532 brcmf_fws_return_credits(fws, i, data[i]); 1533 1534 brcmf_dbg(DATA, "map: credit %x delay %x\n", fws->fifo_credit_map, 1535 fws->fifo_delay_map); 1536 brcmf_fws_unlock(fws); 1537 return BRCMF_FWS_RET_OK_SCHEDULE; 1538 } 1539 1540 static int brcmf_fws_txstatus_indicate(struct brcmf_fws_info *fws, u8 type, 1541 u8 *data) 1542 { 1543 __le32 status_le; 1544 __le16 seq_le; 1545 u32 status; 1546 u32 hslot; 1547 u32 genbit; 1548 u8 flags; 1549 u16 seq; 1550 u8 compcnt; 1551 u8 compcnt_offset = BRCMF_FWS_TYPE_TXSTATUS_LEN; 1552 1553 memcpy(&status_le, data, sizeof(status_le)); 1554 status = le32_to_cpu(status_le); 1555 flags = brcmf_txstatus_get_field(status, FLAGS); 1556 hslot = brcmf_txstatus_get_field(status, HSLOT); 1557 genbit = brcmf_txstatus_get_field(status, GENERATION); 1558 if (BRCMF_FWS_MODE_GET_REUSESEQ(fws->mode)) { 1559 memcpy(&seq_le, &data[BRCMF_FWS_TYPE_TXSTATUS_LEN], 1560 sizeof(seq_le)); 1561 seq = le16_to_cpu(seq_le); 1562 compcnt_offset += BRCMF_FWS_TYPE_SEQ_LEN; 1563 } else { 1564 seq = 0; 1565 } 1566 1567 if (type == BRCMF_FWS_TYPE_COMP_TXSTATUS) 1568 compcnt = data[compcnt_offset]; 1569 else 1570 compcnt = 1; 1571 fws->stats.txs_indicate += compcnt; 1572 1573 brcmf_fws_lock(fws); 1574 brcmf_fws_txs_process(fws, flags, hslot, genbit, seq, compcnt); 1575 brcmf_fws_unlock(fws); 1576 return BRCMF_FWS_RET_OK_NOSCHEDULE; 1577 } 1578 1579 static int brcmf_fws_dbg_seqnum_check(struct brcmf_fws_info *fws, u8 *data) 1580 { 1581 __le32 timestamp; 1582 1583 memcpy(×tamp, &data[2], sizeof(timestamp)); 1584 brcmf_dbg(CTL, "received: seq %d, timestamp %d\n", data[1], 1585 le32_to_cpu(timestamp)); 1586 return 0; 1587 } 1588 1589 static int brcmf_fws_notify_credit_map(struct brcmf_if *ifp, 1590 const struct brcmf_event_msg *e, 1591 void *data) 1592 { 1593 struct brcmf_pub *drvr = ifp->drvr; 1594 struct brcmf_fws_info *fws = drvr_to_fws(drvr); 1595 int i; 1596 u8 *credits = data; 1597 1598 if (e->datalen < BRCMF_FWS_FIFO_COUNT) { 1599 bphy_err(drvr, "event payload too small (%d)\n", e->datalen); 1600 return -EINVAL; 1601 } 1602 1603 fws->creditmap_received = true; 1604 1605 brcmf_dbg(TRACE, "enter: credits %pM\n", credits); 1606 brcmf_fws_lock(fws); 1607 for (i = 0; i < ARRAY_SIZE(fws->fifo_credit); i++) { 1608 fws->fifo_credit[i] += credits[i] - fws->init_fifo_credit[i]; 1609 fws->init_fifo_credit[i] = credits[i]; 1610 if (fws->fifo_credit[i] > 0) 1611 fws->fifo_credit_map |= 1 << i; 1612 else 1613 fws->fifo_credit_map &= ~(1 << i); 1614 WARN_ONCE(fws->fifo_credit[i] < 0, 1615 "fifo_credit[%d] is negative(%d)\n", i, 1616 fws->fifo_credit[i]); 1617 } 1618 brcmf_fws_schedule_deq(fws); 1619 brcmf_fws_unlock(fws); 1620 return 0; 1621 } 1622 1623 static int brcmf_fws_notify_bcmc_credit_support(struct brcmf_if *ifp, 1624 const struct brcmf_event_msg *e, 1625 void *data) 1626 { 1627 struct brcmf_fws_info *fws = drvr_to_fws(ifp->drvr); 1628 1629 if (fws) { 1630 brcmf_fws_lock(fws); 1631 fws->bcmc_credit_check = true; 1632 brcmf_fws_unlock(fws); 1633 } 1634 return 0; 1635 } 1636 1637 static void brcmf_rxreorder_get_skb_list(struct brcmf_ampdu_rx_reorder *rfi, 1638 u8 start, u8 end, 1639 struct sk_buff_head *skb_list) 1640 { 1641 /* initialize return list */ 1642 __skb_queue_head_init(skb_list); 1643 1644 if (rfi->pend_pkts == 0) { 1645 brcmf_dbg(INFO, "no packets in reorder queue\n"); 1646 return; 1647 } 1648 1649 do { 1650 if (rfi->pktslots[start]) { 1651 __skb_queue_tail(skb_list, rfi->pktslots[start]); 1652 rfi->pktslots[start] = NULL; 1653 } 1654 start++; 1655 if (start > rfi->max_idx) 1656 start = 0; 1657 } while (start != end); 1658 rfi->pend_pkts -= skb_queue_len(skb_list); 1659 } 1660 1661 void brcmf_fws_rxreorder(struct brcmf_if *ifp, struct sk_buff *pkt) 1662 { 1663 struct brcmf_pub *drvr = ifp->drvr; 1664 u8 *reorder_data; 1665 u8 flow_id, max_idx, cur_idx, exp_idx, end_idx; 1666 struct brcmf_ampdu_rx_reorder *rfi; 1667 struct sk_buff_head reorder_list; 1668 struct sk_buff *pnext; 1669 u8 flags; 1670 u32 buf_size; 1671 1672 reorder_data = ((struct brcmf_skb_reorder_data *)pkt->cb)->reorder; 1673 flow_id = reorder_data[BRCMF_RXREORDER_FLOWID_OFFSET]; 1674 flags = reorder_data[BRCMF_RXREORDER_FLAGS_OFFSET]; 1675 1676 /* validate flags and flow id */ 1677 if (flags == 0xFF) { 1678 bphy_err(drvr, "invalid flags...so ignore this packet\n"); 1679 brcmf_netif_rx(ifp, pkt); 1680 return; 1681 } 1682 1683 rfi = ifp->drvr->reorder_flows[flow_id]; 1684 if (flags & BRCMF_RXREORDER_DEL_FLOW) { 1685 brcmf_dbg(INFO, "flow-%d: delete\n", 1686 flow_id); 1687 1688 if (rfi == NULL) { 1689 brcmf_dbg(INFO, "received flags to cleanup, but no flow (%d) yet\n", 1690 flow_id); 1691 brcmf_netif_rx(ifp, pkt); 1692 return; 1693 } 1694 1695 brcmf_rxreorder_get_skb_list(rfi, rfi->exp_idx, rfi->exp_idx, 1696 &reorder_list); 1697 /* add the last packet */ 1698 __skb_queue_tail(&reorder_list, pkt); 1699 kfree(rfi); 1700 ifp->drvr->reorder_flows[flow_id] = NULL; 1701 goto netif_rx; 1702 } 1703 /* from here on we need a flow reorder instance */ 1704 if (rfi == NULL) { 1705 buf_size = sizeof(*rfi); 1706 max_idx = reorder_data[BRCMF_RXREORDER_MAXIDX_OFFSET]; 1707 1708 buf_size += (max_idx + 1) * sizeof(pkt); 1709 1710 /* allocate space for flow reorder info */ 1711 brcmf_dbg(INFO, "flow-%d: start, maxidx %d\n", 1712 flow_id, max_idx); 1713 rfi = kzalloc(buf_size, GFP_ATOMIC); 1714 if (rfi == NULL) { 1715 bphy_err(drvr, "failed to alloc buffer\n"); 1716 brcmf_netif_rx(ifp, pkt); 1717 return; 1718 } 1719 1720 ifp->drvr->reorder_flows[flow_id] = rfi; 1721 rfi->pktslots = (struct sk_buff **)(rfi + 1); 1722 rfi->max_idx = max_idx; 1723 } 1724 if (flags & BRCMF_RXREORDER_NEW_HOLE) { 1725 if (rfi->pend_pkts) { 1726 brcmf_rxreorder_get_skb_list(rfi, rfi->exp_idx, 1727 rfi->exp_idx, 1728 &reorder_list); 1729 WARN_ON(rfi->pend_pkts); 1730 } else { 1731 __skb_queue_head_init(&reorder_list); 1732 } 1733 rfi->cur_idx = reorder_data[BRCMF_RXREORDER_CURIDX_OFFSET]; 1734 rfi->exp_idx = reorder_data[BRCMF_RXREORDER_EXPIDX_OFFSET]; 1735 rfi->max_idx = reorder_data[BRCMF_RXREORDER_MAXIDX_OFFSET]; 1736 rfi->pktslots[rfi->cur_idx] = pkt; 1737 rfi->pend_pkts++; 1738 brcmf_dbg(DATA, "flow-%d: new hole %d (%d), pending %d\n", 1739 flow_id, rfi->cur_idx, rfi->exp_idx, rfi->pend_pkts); 1740 } else if (flags & BRCMF_RXREORDER_CURIDX_VALID) { 1741 cur_idx = reorder_data[BRCMF_RXREORDER_CURIDX_OFFSET]; 1742 exp_idx = reorder_data[BRCMF_RXREORDER_EXPIDX_OFFSET]; 1743 1744 if ((exp_idx == rfi->exp_idx) && (cur_idx != rfi->exp_idx)) { 1745 /* still in the current hole */ 1746 /* enqueue the current on the buffer chain */ 1747 if (rfi->pktslots[cur_idx] != NULL) { 1748 brcmf_dbg(INFO, "HOLE: ERROR buffer pending..free it\n"); 1749 brcmu_pkt_buf_free_skb(rfi->pktslots[cur_idx]); 1750 rfi->pktslots[cur_idx] = NULL; 1751 } 1752 rfi->pktslots[cur_idx] = pkt; 1753 rfi->pend_pkts++; 1754 rfi->cur_idx = cur_idx; 1755 brcmf_dbg(DATA, "flow-%d: store pkt %d (%d), pending %d\n", 1756 flow_id, cur_idx, exp_idx, rfi->pend_pkts); 1757 1758 /* can return now as there is no reorder 1759 * list to process. 1760 */ 1761 return; 1762 } 1763 if (rfi->exp_idx == cur_idx) { 1764 if (rfi->pktslots[cur_idx] != NULL) { 1765 brcmf_dbg(INFO, "error buffer pending..free it\n"); 1766 brcmu_pkt_buf_free_skb(rfi->pktslots[cur_idx]); 1767 rfi->pktslots[cur_idx] = NULL; 1768 } 1769 rfi->pktslots[cur_idx] = pkt; 1770 rfi->pend_pkts++; 1771 1772 /* got the expected one. flush from current to expected 1773 * and update expected 1774 */ 1775 brcmf_dbg(DATA, "flow-%d: expected %d (%d), pending %d\n", 1776 flow_id, cur_idx, exp_idx, rfi->pend_pkts); 1777 1778 rfi->cur_idx = cur_idx; 1779 rfi->exp_idx = exp_idx; 1780 1781 brcmf_rxreorder_get_skb_list(rfi, cur_idx, exp_idx, 1782 &reorder_list); 1783 brcmf_dbg(DATA, "flow-%d: freeing buffers %d, pending %d\n", 1784 flow_id, skb_queue_len(&reorder_list), 1785 rfi->pend_pkts); 1786 } else { 1787 u8 end_idx; 1788 1789 brcmf_dbg(DATA, "flow-%d (0x%x): both moved, old %d/%d, new %d/%d\n", 1790 flow_id, flags, rfi->cur_idx, rfi->exp_idx, 1791 cur_idx, exp_idx); 1792 if (flags & BRCMF_RXREORDER_FLUSH_ALL) 1793 end_idx = rfi->exp_idx; 1794 else 1795 end_idx = exp_idx; 1796 1797 /* flush pkts first */ 1798 brcmf_rxreorder_get_skb_list(rfi, rfi->exp_idx, end_idx, 1799 &reorder_list); 1800 1801 if (exp_idx == ((cur_idx + 1) % (rfi->max_idx + 1))) { 1802 __skb_queue_tail(&reorder_list, pkt); 1803 } else { 1804 rfi->pktslots[cur_idx] = pkt; 1805 rfi->pend_pkts++; 1806 } 1807 rfi->exp_idx = exp_idx; 1808 rfi->cur_idx = cur_idx; 1809 } 1810 } else { 1811 /* explicity window move updating the expected index */ 1812 exp_idx = reorder_data[BRCMF_RXREORDER_EXPIDX_OFFSET]; 1813 1814 brcmf_dbg(DATA, "flow-%d (0x%x): change expected: %d -> %d\n", 1815 flow_id, flags, rfi->exp_idx, exp_idx); 1816 if (flags & BRCMF_RXREORDER_FLUSH_ALL) 1817 end_idx = rfi->exp_idx; 1818 else 1819 end_idx = exp_idx; 1820 1821 brcmf_rxreorder_get_skb_list(rfi, rfi->exp_idx, end_idx, 1822 &reorder_list); 1823 __skb_queue_tail(&reorder_list, pkt); 1824 /* set the new expected idx */ 1825 rfi->exp_idx = exp_idx; 1826 } 1827 netif_rx: 1828 skb_queue_walk_safe(&reorder_list, pkt, pnext) { 1829 __skb_unlink(pkt, &reorder_list); 1830 brcmf_netif_rx(ifp, pkt); 1831 } 1832 } 1833 1834 void brcmf_fws_hdrpull(struct brcmf_if *ifp, s16 siglen, struct sk_buff *skb) 1835 { 1836 struct brcmf_skb_reorder_data *rd; 1837 struct brcmf_fws_info *fws = drvr_to_fws(ifp->drvr); 1838 u8 *signal_data; 1839 s16 data_len; 1840 u8 type; 1841 u8 len; 1842 u8 *data; 1843 s32 status; 1844 s32 err; 1845 1846 brcmf_dbg(HDRS, "enter: ifidx %d, skblen %u, sig %d\n", 1847 ifp->ifidx, skb->len, siglen); 1848 1849 WARN_ON(siglen > skb->len); 1850 1851 if (siglen > skb->len) 1852 siglen = skb->len; 1853 1854 if (!siglen) 1855 return; 1856 /* if flow control disabled, skip to packet data and leave */ 1857 if ((!fws) || (!fws->fw_signals)) { 1858 skb_pull(skb, siglen); 1859 return; 1860 } 1861 1862 fws->stats.header_pulls++; 1863 data_len = siglen; 1864 signal_data = skb->data; 1865 1866 status = BRCMF_FWS_RET_OK_NOSCHEDULE; 1867 while (data_len > 0) { 1868 /* extract tlv info */ 1869 type = signal_data[0]; 1870 1871 /* FILLER type is actually not a TLV, but 1872 * a single byte that can be skipped. 1873 */ 1874 if (type == BRCMF_FWS_TYPE_FILLER) { 1875 signal_data += 1; 1876 data_len -= 1; 1877 continue; 1878 } 1879 len = signal_data[1]; 1880 data = signal_data + 2; 1881 1882 brcmf_dbg(HDRS, "tlv type=%s (%d), len=%d (%d)\n", 1883 brcmf_fws_get_tlv_name(type), type, len, 1884 brcmf_fws_get_tlv_len(fws, type)); 1885 1886 /* abort parsing when length invalid */ 1887 if (data_len < len + 2) 1888 break; 1889 1890 if (len < brcmf_fws_get_tlv_len(fws, type)) 1891 break; 1892 1893 err = BRCMF_FWS_RET_OK_NOSCHEDULE; 1894 switch (type) { 1895 case BRCMF_FWS_TYPE_HOST_REORDER_RXPKTS: 1896 rd = (struct brcmf_skb_reorder_data *)skb->cb; 1897 rd->reorder = data; 1898 break; 1899 case BRCMF_FWS_TYPE_MACDESC_ADD: 1900 case BRCMF_FWS_TYPE_MACDESC_DEL: 1901 brcmf_fws_macdesc_indicate(fws, type, data); 1902 break; 1903 case BRCMF_FWS_TYPE_MAC_OPEN: 1904 case BRCMF_FWS_TYPE_MAC_CLOSE: 1905 err = brcmf_fws_macdesc_state_indicate(fws, type, data); 1906 break; 1907 case BRCMF_FWS_TYPE_INTERFACE_OPEN: 1908 case BRCMF_FWS_TYPE_INTERFACE_CLOSE: 1909 err = brcmf_fws_interface_state_indicate(fws, type, 1910 data); 1911 break; 1912 case BRCMF_FWS_TYPE_MAC_REQUEST_CREDIT: 1913 case BRCMF_FWS_TYPE_MAC_REQUEST_PACKET: 1914 err = brcmf_fws_request_indicate(fws, type, data); 1915 break; 1916 case BRCMF_FWS_TYPE_TXSTATUS: 1917 case BRCMF_FWS_TYPE_COMP_TXSTATUS: 1918 brcmf_fws_txstatus_indicate(fws, type, data); 1919 break; 1920 case BRCMF_FWS_TYPE_FIFO_CREDITBACK: 1921 err = brcmf_fws_fifocreditback_indicate(fws, data); 1922 break; 1923 case BRCMF_FWS_TYPE_RSSI: 1924 brcmf_fws_rssi_indicate(fws, *data); 1925 break; 1926 case BRCMF_FWS_TYPE_TRANS_ID: 1927 brcmf_fws_dbg_seqnum_check(fws, data); 1928 break; 1929 case BRCMF_FWS_TYPE_PKTTAG: 1930 case BRCMF_FWS_TYPE_PENDING_TRAFFIC_BMP: 1931 default: 1932 fws->stats.tlv_invalid_type++; 1933 break; 1934 } 1935 if (err == BRCMF_FWS_RET_OK_SCHEDULE) 1936 status = BRCMF_FWS_RET_OK_SCHEDULE; 1937 signal_data += len + 2; 1938 data_len -= len + 2; 1939 } 1940 1941 if (data_len != 0) 1942 fws->stats.tlv_parse_failed++; 1943 1944 if (status == BRCMF_FWS_RET_OK_SCHEDULE) 1945 brcmf_fws_schedule_deq(fws); 1946 1947 /* signalling processing result does 1948 * not affect the actual ethernet packet. 1949 */ 1950 skb_pull(skb, siglen); 1951 1952 /* this may be a signal-only packet 1953 */ 1954 if (skb->len == 0) 1955 fws->stats.header_only_pkt++; 1956 } 1957 1958 static u8 brcmf_fws_precommit_skb(struct brcmf_fws_info *fws, int fifo, 1959 struct sk_buff *p) 1960 { 1961 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(p); 1962 struct brcmf_fws_mac_descriptor *entry = skcb->mac; 1963 u8 flags; 1964 1965 if (skcb->state != BRCMF_FWS_SKBSTATE_SUPPRESSED) 1966 brcmf_skb_htod_tag_set_field(p, GENERATION, entry->generation); 1967 flags = BRCMF_FWS_HTOD_FLAG_PKTFROMHOST; 1968 if (brcmf_skb_if_flags_get_field(p, REQUESTED)) { 1969 /* 1970 * Indicate that this packet is being sent in response to an 1971 * explicit request from the firmware side. 1972 */ 1973 flags |= BRCMF_FWS_HTOD_FLAG_PKT_REQUESTED; 1974 } 1975 brcmf_skb_htod_tag_set_field(p, FLAGS, flags); 1976 return brcmf_fws_hdrpush(fws, p); 1977 } 1978 1979 static void brcmf_fws_rollback_toq(struct brcmf_fws_info *fws, 1980 struct sk_buff *skb, int fifo) 1981 { 1982 struct brcmf_pub *drvr = fws->drvr; 1983 struct brcmf_fws_mac_descriptor *entry; 1984 struct sk_buff *pktout; 1985 int qidx, hslot; 1986 int rc = 0; 1987 1988 entry = brcmf_skbcb(skb)->mac; 1989 if (entry->occupied) { 1990 qidx = 2 * fifo; 1991 if (brcmf_skbcb(skb)->state == BRCMF_FWS_SKBSTATE_SUPPRESSED) 1992 qidx++; 1993 1994 pktout = brcmu_pktq_penq_head(&entry->psq, qidx, skb); 1995 if (pktout == NULL) { 1996 bphy_err(drvr, "%s queue %d full\n", entry->name, qidx); 1997 rc = -ENOSPC; 1998 } 1999 } else { 2000 bphy_err(drvr, "%s entry removed\n", entry->name); 2001 rc = -ENOENT; 2002 } 2003 2004 if (rc) { 2005 fws->stats.rollback_failed++; 2006 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT); 2007 brcmf_fws_txs_process(fws, BRCMF_FWS_TXSTATUS_HOST_TOSSED, 2008 hslot, 0, 0, 1); 2009 } else { 2010 fws->stats.rollback_success++; 2011 brcmf_fws_return_credits(fws, fifo, 1); 2012 brcmf_fws_macdesc_return_req_credit(skb); 2013 } 2014 } 2015 2016 static int brcmf_fws_borrow_credit(struct brcmf_fws_info *fws, 2017 int highest_lender_ac, int borrower_ac, 2018 bool borrow_all) 2019 { 2020 int lender_ac, borrow_limit = 0; 2021 2022 for (lender_ac = 0; lender_ac <= highest_lender_ac; lender_ac++) { 2023 2024 if (!borrow_all) 2025 borrow_limit = 2026 fws->init_fifo_credit[lender_ac] / BRCMF_BORROW_RATIO; 2027 else 2028 borrow_limit = 0; 2029 2030 if (fws->fifo_credit[lender_ac] > borrow_limit) { 2031 fws->credits_borrowed[borrower_ac][lender_ac]++; 2032 fws->fifo_credit[lender_ac]--; 2033 if (fws->fifo_credit[lender_ac] == 0) 2034 fws->fifo_credit_map &= ~(1 << lender_ac); 2035 fws->fifo_credit_map |= (1 << borrower_ac); 2036 brcmf_dbg(DATA, "borrow credit from: %d\n", lender_ac); 2037 return 0; 2038 } 2039 } 2040 fws->fifo_credit_map &= ~(1 << borrower_ac); 2041 return -ENAVAIL; 2042 } 2043 2044 static int brcmf_fws_commit_skb(struct brcmf_fws_info *fws, int fifo, 2045 struct sk_buff *skb) 2046 { 2047 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb); 2048 struct brcmf_fws_mac_descriptor *entry; 2049 int rc; 2050 u8 ifidx; 2051 u8 data_offset; 2052 2053 entry = skcb->mac; 2054 if (IS_ERR(entry)) 2055 return PTR_ERR(entry); 2056 2057 data_offset = brcmf_fws_precommit_skb(fws, fifo, skb); 2058 entry->transit_count++; 2059 if (entry->suppressed) 2060 entry->suppr_transit_count++; 2061 ifidx = brcmf_skb_if_flags_get_field(skb, INDEX); 2062 brcmf_fws_unlock(fws); 2063 rc = brcmf_proto_txdata(fws->drvr, ifidx, data_offset, skb); 2064 brcmf_fws_lock(fws); 2065 brcmf_dbg(DATA, "%s flags %X htod %X bus_tx %d\n", entry->name, 2066 skcb->if_flags, skcb->htod, rc); 2067 if (rc < 0) { 2068 entry->transit_count--; 2069 if (entry->suppressed) 2070 entry->suppr_transit_count--; 2071 (void)brcmf_proto_hdrpull(fws->drvr, false, skb, NULL); 2072 goto rollback; 2073 } 2074 2075 fws->stats.pkt2bus++; 2076 fws->stats.send_pkts[fifo]++; 2077 if (brcmf_skb_if_flags_get_field(skb, REQUESTED)) 2078 fws->stats.requested_sent[fifo]++; 2079 2080 return rc; 2081 2082 rollback: 2083 brcmf_fws_rollback_toq(fws, skb, fifo); 2084 return rc; 2085 } 2086 2087 static int brcmf_fws_assign_htod(struct brcmf_fws_info *fws, struct sk_buff *p, 2088 int fifo) 2089 { 2090 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(p); 2091 int rc, hslot; 2092 2093 skcb->htod = 0; 2094 skcb->htod_seq = 0; 2095 hslot = brcmf_fws_hanger_get_free_slot(&fws->hanger); 2096 brcmf_skb_htod_tag_set_field(p, HSLOT, hslot); 2097 brcmf_skb_htod_tag_set_field(p, FREERUN, skcb->mac->seq[fifo]); 2098 brcmf_skb_htod_tag_set_field(p, FIFO, fifo); 2099 rc = brcmf_fws_hanger_pushpkt(&fws->hanger, p, hslot); 2100 if (!rc) 2101 skcb->mac->seq[fifo]++; 2102 else 2103 fws->stats.generic_error++; 2104 return rc; 2105 } 2106 2107 int brcmf_fws_process_skb(struct brcmf_if *ifp, struct sk_buff *skb) 2108 { 2109 struct brcmf_pub *drvr = ifp->drvr; 2110 struct brcmf_fws_info *fws = drvr_to_fws(drvr); 2111 struct brcmf_skbuff_cb *skcb = brcmf_skbcb(skb); 2112 struct ethhdr *eh = (struct ethhdr *)(skb->data); 2113 int fifo = BRCMF_FWS_FIFO_BCMC; 2114 bool multicast = is_multicast_ether_addr(eh->h_dest); 2115 int rc = 0; 2116 2117 brcmf_dbg(DATA, "tx proto=0x%X\n", ntohs(eh->h_proto)); 2118 2119 /* set control buffer information */ 2120 skcb->if_flags = 0; 2121 skcb->state = BRCMF_FWS_SKBSTATE_NEW; 2122 brcmf_skb_if_flags_set_field(skb, INDEX, ifp->ifidx); 2123 2124 /* mapping from 802.1d priority to firmware fifo index */ 2125 if (!multicast) 2126 fifo = brcmf_map_prio_to_aci(drvr->config, skb->priority); 2127 2128 brcmf_fws_lock(fws); 2129 if (fifo != BRCMF_FWS_FIFO_AC_BE && fifo < BRCMF_FWS_FIFO_BCMC) 2130 fws->borrow_defer_timestamp = jiffies + 2131 BRCMF_FWS_BORROW_DEFER_PERIOD; 2132 2133 skcb->mac = brcmf_fws_macdesc_find(fws, ifp, eh->h_dest); 2134 brcmf_dbg(DATA, "%s mac %pM multi %d fifo %d\n", skcb->mac->name, 2135 eh->h_dest, multicast, fifo); 2136 if (!brcmf_fws_assign_htod(fws, skb, fifo)) { 2137 brcmf_fws_enq(fws, BRCMF_FWS_SKBSTATE_DELAYED, fifo, skb); 2138 brcmf_fws_schedule_deq(fws); 2139 } else { 2140 bphy_err(drvr, "no hanger slot available\n"); 2141 rc = -ENOMEM; 2142 } 2143 brcmf_fws_unlock(fws); 2144 2145 return rc; 2146 } 2147 2148 void brcmf_fws_reset_interface(struct brcmf_if *ifp) 2149 { 2150 struct brcmf_fws_mac_descriptor *entry = ifp->fws_desc; 2151 2152 brcmf_dbg(TRACE, "enter: bsscfgidx=%d\n", ifp->bsscfgidx); 2153 if (!entry) 2154 return; 2155 2156 brcmf_fws_macdesc_init(entry, ifp->mac_addr, ifp->ifidx); 2157 } 2158 2159 void brcmf_fws_add_interface(struct brcmf_if *ifp) 2160 { 2161 struct brcmf_fws_info *fws = drvr_to_fws(ifp->drvr); 2162 struct brcmf_fws_mac_descriptor *entry; 2163 2164 if (!ifp->ndev || !brcmf_fws_queue_skbs(fws)) 2165 return; 2166 2167 entry = &fws->desc.iface[ifp->ifidx]; 2168 ifp->fws_desc = entry; 2169 brcmf_fws_macdesc_init(entry, ifp->mac_addr, ifp->ifidx); 2170 brcmf_fws_macdesc_set_name(fws, entry); 2171 brcmu_pktq_init(&entry->psq, BRCMF_FWS_PSQ_PREC_COUNT, 2172 BRCMF_FWS_PSQ_LEN); 2173 brcmf_dbg(TRACE, "added %s\n", entry->name); 2174 } 2175 2176 void brcmf_fws_del_interface(struct brcmf_if *ifp) 2177 { 2178 struct brcmf_fws_mac_descriptor *entry = ifp->fws_desc; 2179 struct brcmf_fws_info *fws = drvr_to_fws(ifp->drvr); 2180 2181 if (!entry) 2182 return; 2183 2184 brcmf_fws_lock(fws); 2185 ifp->fws_desc = NULL; 2186 brcmf_dbg(TRACE, "deleting %s\n", entry->name); 2187 brcmf_fws_macdesc_cleanup(fws, &fws->desc.iface[ifp->ifidx], 2188 ifp->ifidx); 2189 brcmf_fws_macdesc_deinit(entry); 2190 brcmf_fws_cleanup(fws, ifp->ifidx); 2191 brcmf_fws_unlock(fws); 2192 } 2193 2194 static void brcmf_fws_dequeue_worker(struct work_struct *worker) 2195 { 2196 struct brcmf_fws_info *fws; 2197 struct brcmf_pub *drvr; 2198 struct sk_buff *skb; 2199 int fifo; 2200 u32 hslot; 2201 u32 ifidx; 2202 int ret; 2203 2204 fws = container_of(worker, struct brcmf_fws_info, fws_dequeue_work); 2205 drvr = fws->drvr; 2206 2207 brcmf_fws_lock(fws); 2208 for (fifo = BRCMF_FWS_FIFO_BCMC; fifo >= 0 && !fws->bus_flow_blocked; 2209 fifo--) { 2210 if (!brcmf_fws_fc_active(fws)) { 2211 while ((skb = brcmf_fws_deq(fws, fifo)) != NULL) { 2212 hslot = brcmf_skb_htod_tag_get_field(skb, 2213 HSLOT); 2214 brcmf_fws_hanger_poppkt(&fws->hanger, hslot, 2215 &skb, true); 2216 ifidx = brcmf_skb_if_flags_get_field(skb, 2217 INDEX); 2218 /* Use proto layer to send data frame */ 2219 brcmf_fws_unlock(fws); 2220 ret = brcmf_proto_txdata(drvr, ifidx, 0, skb); 2221 brcmf_fws_lock(fws); 2222 if (ret < 0) 2223 brcmf_txfinalize(brcmf_get_ifp(drvr, 2224 ifidx), 2225 skb, false); 2226 if (fws->bus_flow_blocked) 2227 break; 2228 } 2229 continue; 2230 } 2231 2232 while ((fws->fifo_credit[fifo]) || 2233 ((!fws->bcmc_credit_check) && 2234 (fifo == BRCMF_FWS_FIFO_BCMC))) { 2235 skb = brcmf_fws_deq(fws, fifo); 2236 if (!skb) 2237 break; 2238 fws->fifo_credit[fifo]--; 2239 if (brcmf_fws_commit_skb(fws, fifo, skb)) 2240 break; 2241 if (fws->bus_flow_blocked) 2242 break; 2243 } 2244 2245 if (fifo >= BRCMF_FWS_FIFO_AC_BE && 2246 fifo <= BRCMF_FWS_FIFO_AC_VO && 2247 fws->fifo_credit[fifo] == 0 && 2248 !fws->bus_flow_blocked) { 2249 while (brcmf_fws_borrow_credit(fws, 2250 fifo - 1, fifo, 2251 true) == 0) { 2252 skb = brcmf_fws_deq(fws, fifo); 2253 if (!skb) { 2254 brcmf_fws_return_credits(fws, fifo, 1); 2255 break; 2256 } 2257 if (brcmf_fws_commit_skb(fws, fifo, skb)) 2258 break; 2259 if (fws->bus_flow_blocked) 2260 break; 2261 } 2262 } 2263 } 2264 brcmf_fws_unlock(fws); 2265 } 2266 2267 #ifdef DEBUG 2268 static int brcmf_debugfs_fws_stats_read(struct seq_file *seq, void *data) 2269 { 2270 struct brcmf_bus *bus_if = dev_get_drvdata(seq->private); 2271 struct brcmf_fws_stats *fwstats = &(drvr_to_fws(bus_if->drvr)->stats); 2272 2273 seq_printf(seq, 2274 "header_pulls: %u\n" 2275 "header_only_pkt: %u\n" 2276 "tlv_parse_failed: %u\n" 2277 "tlv_invalid_type: %u\n" 2278 "mac_update_fails: %u\n" 2279 "ps_update_fails: %u\n" 2280 "if_update_fails: %u\n" 2281 "pkt2bus: %u\n" 2282 "generic_error: %u\n" 2283 "rollback_success: %u\n" 2284 "rollback_failed: %u\n" 2285 "delayq_full: %u\n" 2286 "supprq_full: %u\n" 2287 "txs_indicate: %u\n" 2288 "txs_discard: %u\n" 2289 "txs_suppr_core: %u\n" 2290 "txs_suppr_ps: %u\n" 2291 "txs_tossed: %u\n" 2292 "txs_host_tossed: %u\n" 2293 "bus_flow_block: %u\n" 2294 "fws_flow_block: %u\n" 2295 "send_pkts: BK:%u BE:%u VO:%u VI:%u BCMC:%u\n" 2296 "requested_sent: BK:%u BE:%u VO:%u VI:%u BCMC:%u\n", 2297 fwstats->header_pulls, 2298 fwstats->header_only_pkt, 2299 fwstats->tlv_parse_failed, 2300 fwstats->tlv_invalid_type, 2301 fwstats->mac_update_failed, 2302 fwstats->mac_ps_update_failed, 2303 fwstats->if_update_failed, 2304 fwstats->pkt2bus, 2305 fwstats->generic_error, 2306 fwstats->rollback_success, 2307 fwstats->rollback_failed, 2308 fwstats->delayq_full_error, 2309 fwstats->supprq_full_error, 2310 fwstats->txs_indicate, 2311 fwstats->txs_discard, 2312 fwstats->txs_supp_core, 2313 fwstats->txs_supp_ps, 2314 fwstats->txs_tossed, 2315 fwstats->txs_host_tossed, 2316 fwstats->bus_flow_block, 2317 fwstats->fws_flow_block, 2318 fwstats->send_pkts[0], fwstats->send_pkts[1], 2319 fwstats->send_pkts[2], fwstats->send_pkts[3], 2320 fwstats->send_pkts[4], 2321 fwstats->requested_sent[0], 2322 fwstats->requested_sent[1], 2323 fwstats->requested_sent[2], 2324 fwstats->requested_sent[3], 2325 fwstats->requested_sent[4]); 2326 2327 return 0; 2328 } 2329 #else 2330 static int brcmf_debugfs_fws_stats_read(struct seq_file *seq, void *data) 2331 { 2332 return 0; 2333 } 2334 #endif 2335 2336 struct brcmf_fws_info *brcmf_fws_attach(struct brcmf_pub *drvr) 2337 { 2338 struct brcmf_fws_info *fws; 2339 struct brcmf_if *ifp; 2340 u32 tlv = BRCMF_FWS_FLAGS_RSSI_SIGNALS; 2341 int rc; 2342 u32 mode; 2343 2344 fws = kzalloc(sizeof(*fws), GFP_KERNEL); 2345 if (!fws) { 2346 rc = -ENOMEM; 2347 goto fail; 2348 } 2349 2350 spin_lock_init(&fws->spinlock); 2351 2352 /* store drvr reference */ 2353 fws->drvr = drvr; 2354 fws->fcmode = drvr->settings->fcmode; 2355 2356 if (!drvr->bus_if->always_use_fws_queue && 2357 (fws->fcmode == BRCMF_FWS_FCMODE_NONE)) { 2358 fws->avoid_queueing = true; 2359 brcmf_dbg(INFO, "FWS queueing will be avoided\n"); 2360 return fws; 2361 } 2362 2363 fws->fws_wq = create_singlethread_workqueue("brcmf_fws_wq"); 2364 if (fws->fws_wq == NULL) { 2365 bphy_err(drvr, "workqueue creation failed\n"); 2366 rc = -EBADF; 2367 goto fail; 2368 } 2369 INIT_WORK(&fws->fws_dequeue_work, brcmf_fws_dequeue_worker); 2370 2371 /* enable firmware signalling if fcmode active */ 2372 if (fws->fcmode != BRCMF_FWS_FCMODE_NONE) 2373 tlv |= BRCMF_FWS_FLAGS_XONXOFF_SIGNALS | 2374 BRCMF_FWS_FLAGS_CREDIT_STATUS_SIGNALS | 2375 BRCMF_FWS_FLAGS_HOST_PROPTXSTATUS_ACTIVE | 2376 BRCMF_FWS_FLAGS_HOST_RXREORDER_ACTIVE; 2377 2378 rc = brcmf_fweh_register(drvr, BRCMF_E_FIFO_CREDIT_MAP, 2379 brcmf_fws_notify_credit_map); 2380 if (rc < 0) { 2381 bphy_err(drvr, "register credit map handler failed\n"); 2382 goto fail; 2383 } 2384 rc = brcmf_fweh_register(drvr, BRCMF_E_BCMC_CREDIT_SUPPORT, 2385 brcmf_fws_notify_bcmc_credit_support); 2386 if (rc < 0) { 2387 bphy_err(drvr, "register bcmc credit handler failed\n"); 2388 brcmf_fweh_unregister(drvr, BRCMF_E_FIFO_CREDIT_MAP); 2389 goto fail; 2390 } 2391 2392 /* Setting the iovar may fail if feature is unsupported 2393 * so leave the rc as is so driver initialization can 2394 * continue. Set mode back to none indicating not enabled. 2395 */ 2396 fws->fw_signals = true; 2397 ifp = brcmf_get_ifp(drvr, 0); 2398 if (brcmf_fil_iovar_int_set(ifp, "tlv", tlv)) { 2399 bphy_err(drvr, "failed to set bdcv2 tlv signaling\n"); 2400 fws->fcmode = BRCMF_FWS_FCMODE_NONE; 2401 fws->fw_signals = false; 2402 } 2403 2404 if (brcmf_fil_iovar_int_set(ifp, "ampdu_hostreorder", 1)) 2405 brcmf_dbg(INFO, "enabling AMPDU host-reorder failed\n"); 2406 2407 /* Enable seq number reuse, if supported */ 2408 if (brcmf_fil_iovar_int_get(ifp, "wlfc_mode", &mode) == 0) { 2409 if (BRCMF_FWS_MODE_GET_REUSESEQ(mode)) { 2410 mode = 0; 2411 BRCMF_FWS_MODE_SET_REUSESEQ(mode, 1); 2412 if (brcmf_fil_iovar_int_set(ifp, 2413 "wlfc_mode", mode) == 0) { 2414 BRCMF_FWS_MODE_SET_REUSESEQ(fws->mode, 1); 2415 } 2416 } 2417 } 2418 2419 brcmf_fws_hanger_init(&fws->hanger); 2420 brcmf_fws_macdesc_init(&fws->desc.other, NULL, 0); 2421 brcmf_fws_macdesc_set_name(fws, &fws->desc.other); 2422 brcmf_dbg(INFO, "added %s\n", fws->desc.other.name); 2423 brcmu_pktq_init(&fws->desc.other.psq, BRCMF_FWS_PSQ_PREC_COUNT, 2424 BRCMF_FWS_PSQ_LEN); 2425 2426 brcmf_dbg(INFO, "%s bdcv2 tlv signaling [%x]\n", 2427 fws->fw_signals ? "enabled" : "disabled", tlv); 2428 return fws; 2429 2430 fail: 2431 brcmf_fws_detach(fws); 2432 return ERR_PTR(rc); 2433 } 2434 2435 void brcmf_fws_detach(struct brcmf_fws_info *fws) 2436 { 2437 if (!fws) 2438 return; 2439 2440 if (fws->fws_wq) 2441 destroy_workqueue(fws->fws_wq); 2442 2443 /* cleanup */ 2444 brcmf_fws_lock(fws); 2445 brcmf_fws_cleanup(fws, -1); 2446 brcmf_fws_unlock(fws); 2447 2448 /* free top structure */ 2449 kfree(fws); 2450 } 2451 2452 void brcmf_fws_debugfs_create(struct brcmf_pub *drvr) 2453 { 2454 /* create debugfs file for statistics */ 2455 brcmf_debugfs_add_entry(drvr, "fws_stats", 2456 brcmf_debugfs_fws_stats_read); 2457 } 2458 2459 bool brcmf_fws_queue_skbs(struct brcmf_fws_info *fws) 2460 { 2461 return !fws->avoid_queueing; 2462 } 2463 2464 bool brcmf_fws_fc_active(struct brcmf_fws_info *fws) 2465 { 2466 if (!fws->creditmap_received) 2467 return false; 2468 2469 return fws->fcmode != BRCMF_FWS_FCMODE_NONE; 2470 } 2471 2472 void brcmf_fws_bustxfail(struct brcmf_fws_info *fws, struct sk_buff *skb) 2473 { 2474 u32 hslot; 2475 2476 if (brcmf_skbcb(skb)->state == BRCMF_FWS_SKBSTATE_TIM) { 2477 brcmu_pkt_buf_free_skb(skb); 2478 return; 2479 } 2480 brcmf_fws_lock(fws); 2481 hslot = brcmf_skb_htod_tag_get_field(skb, HSLOT); 2482 brcmf_fws_txs_process(fws, BRCMF_FWS_TXSTATUS_HOST_TOSSED, hslot, 0, 0, 2483 1); 2484 brcmf_fws_unlock(fws); 2485 } 2486 2487 void brcmf_fws_bus_blocked(struct brcmf_pub *drvr, bool flow_blocked) 2488 { 2489 struct brcmf_fws_info *fws = drvr_to_fws(drvr); 2490 struct brcmf_if *ifp; 2491 int i; 2492 2493 if (fws->avoid_queueing) { 2494 for (i = 0; i < BRCMF_MAX_IFS; i++) { 2495 ifp = drvr->iflist[i]; 2496 if (!ifp || !ifp->ndev) 2497 continue; 2498 brcmf_txflowblock_if(ifp, BRCMF_NETIF_STOP_REASON_FLOW, 2499 flow_blocked); 2500 } 2501 } else { 2502 fws->bus_flow_blocked = flow_blocked; 2503 if (!flow_blocked) 2504 brcmf_fws_schedule_deq(fws); 2505 else 2506 fws->stats.bus_flow_block++; 2507 } 2508 } 2509