]>
Commit | Line | Data |
---|---|---|
f5fc0f86 LC |
1 | /* |
2 | * This file is part of wl1271 | |
3 | * | |
4 | * Copyright (C) 1998-2009 Texas Instruments. All rights reserved. | |
5 | * Copyright (C) 2008-2009 Nokia Corporation | |
6 | * | |
7 | * Contact: Luciano Coelho <luciano.coelho@nokia.com> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU General Public License | |
11 | * version 2 as published by the Free Software Foundation. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 | * General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | |
21 | * 02110-1301 USA | |
22 | * | |
23 | */ | |
24 | ||
8388569a LC |
25 | #ifndef __WLCORE_I_H__ |
26 | #define __WLCORE_I_H__ | |
f5fc0f86 LC |
27 | |
28 | #include <linux/mutex.h> | |
29 | #include <linux/completion.h> | |
30 | #include <linux/spinlock.h> | |
31 | #include <linux/list.h> | |
32 | #include <linux/bitops.h> | |
33 | #include <net/mac80211.h> | |
34 | ||
00d20100 SL |
35 | #include "conf.h" |
36 | #include "ini.h" | |
2b60100b | 37 | |
5aa42346 SL |
38 | /* |
39 | * wl127x and wl128x are using the same NVS file name. However, the | |
40 | * ini parameters between them are different. The driver validates | |
41 | * the correct NVS size in wl1271_boot_upload_nvs(). | |
42 | */ | |
43 | #define WL12XX_NVS_NAME "ti-connectivity/wl1271-nvs.bin" | |
152ee6e0 | 44 | |
04e36fc5 JO |
45 | #define WL1271_TX_SECURITY_LO16(s) ((u16)((s) & 0xffff)) |
46 | #define WL1271_TX_SECURITY_HI32(s) ((u32)(((s) >> 16) & 0xffffffff)) | |
b992c682 | 47 | #define WL1271_TX_SQN_POST_RECOVERY_PADDING 0xff |
04e36fc5 | 48 | |
7a55724e JO |
49 | #define WL1271_CIPHER_SUITE_GEM 0x00147201 |
50 | ||
259da430 | 51 | #define WL1271_BUSY_WORD_CNT 1 |
545f1da8 | 52 | #define WL1271_BUSY_WORD_LEN (WL1271_BUSY_WORD_CNT * sizeof(u32)) |
f5fc0f86 LC |
53 | |
54 | #define WL1271_ELP_HW_STATE_ASLEEP 0 | |
55 | #define WL1271_ELP_HW_STATE_IRQ 1 | |
56 | ||
d94cd297 JO |
57 | #define WL1271_DEFAULT_BEACON_INT 100 |
58 | #define WL1271_DEFAULT_DTIM_PERIOD 1 | |
59 | ||
c690ec81 | 60 | #define WL12XX_MAX_ROLES 4 |
f80c2d12 | 61 | #define WL12XX_MAX_LINKS 12 |
7f097988 EP |
62 | #define WL12XX_INVALID_ROLE_ID 0xff |
63 | #define WL12XX_INVALID_LINK_ID 0xff | |
e51ae9be | 64 | |
091185d6 AN |
65 | /* the driver supports the 2.4Ghz and 5Ghz bands */ |
66 | #define WLCORE_NUM_BANDS 2 | |
67 | ||
e5a359f8 | 68 | #define WL12XX_MAX_RATE_POLICIES 16 |
001e39a8 | 69 | #define WLCORE_MAX_KLV_TEMPLATES 4 |
e5a359f8 | 70 | |
e51ae9be | 71 | /* Defined by FW as 0. Will not be freed or allocated. */ |
f4df1bd5 | 72 | #define WL12XX_SYSTEM_HLID 0 |
e51ae9be | 73 | |
b622d992 | 74 | /* |
9b17f1b3 | 75 | * When in AP-mode, we allow (at least) this number of packets |
b622d992 AN |
76 | * to be transmitted to FW for a STA in PS-mode. Only when packets are |
77 | * present in the FW buffers it will wake the sleeping STA. We want to put | |
78 | * enough packets for the driver to transmit all of its buffered data before | |
9b17f1b3 | 79 | * the STA goes to sleep again. But we don't want to take too much memory |
b622d992 | 80 | * as it might hurt the throughput of active STAs. |
b622d992 | 81 | */ |
9b17f1b3 | 82 | #define WL1271_PS_STA_MAX_PACKETS 2 |
b622d992 | 83 | |
98bdaabb | 84 | #define WL1271_AP_BSS_INDEX 0 |
98bdaabb AN |
85 | #define WL1271_AP_DEF_BEACON_EXP 20 |
86 | ||
4cc53383 IY |
87 | enum wlcore_state { |
88 | WLCORE_STATE_OFF, | |
89 | WLCORE_STATE_RESTARTING, | |
90 | WLCORE_STATE_ON, | |
3fcdab70 EP |
91 | }; |
92 | ||
93 | enum wl12xx_fw_type { | |
94 | WL12XX_FW_TYPE_NONE, | |
95 | WL12XX_FW_TYPE_NORMAL, | |
4549d09c | 96 | WL12XX_FW_TYPE_MULTI, |
3fcdab70 | 97 | WL12XX_FW_TYPE_PLT, |
f5fc0f86 LC |
98 | }; |
99 | ||
f5fc0f86 LC |
100 | struct wl1271; |
101 | ||
e7ddf549 LC |
102 | enum { |
103 | FW_VER_CHIP, | |
104 | FW_VER_IF_TYPE, | |
105 | FW_VER_MAJOR, | |
106 | FW_VER_SUBTYPE, | |
107 | FW_VER_MINOR, | |
108 | ||
109 | NUM_FW_VER | |
110 | }; | |
111 | ||
112 | #define FW_VER_CHIP_WL127X 6 | |
113 | #define FW_VER_CHIP_WL128X 7 | |
114 | ||
115 | #define FW_VER_IF_TYPE_STA 1 | |
116 | #define FW_VER_IF_TYPE_AP 2 | |
117 | ||
118 | #define FW_VER_MINOR_1_SPARE_STA_MIN 58 | |
119 | #define FW_VER_MINOR_1_SPARE_AP_MIN 47 | |
4b7fac77 | 120 | |
95dac04f IY |
121 | #define FW_VER_MINOR_FWLOG_STA_MIN 70 |
122 | ||
f5fc0f86 LC |
123 | struct wl1271_chip { |
124 | u32 id; | |
81135548 | 125 | char fw_ver_str[ETHTOOL_FWVERS_LEN]; |
e7ddf549 | 126 | unsigned int fw_ver[NUM_FW_VER]; |
81135548 | 127 | char phy_fw_ver_str[ETHTOOL_FWVERS_LEN]; |
f5fc0f86 LC |
128 | }; |
129 | ||
f5fc0f86 | 130 | #define NUM_TX_QUEUES 4 |
f5fc0f86 | 131 | |
c47e8229 | 132 | #define AP_MAX_STATIONS 8 |
beb6c880 | 133 | |
6bac40a6 AN |
134 | struct wl_fw_packet_counters { |
135 | /* Cumulative counter of released packets per AC */ | |
136 | u8 tx_released_pkts[NUM_TX_QUEUES]; | |
137 | ||
138 | /* Cumulative counter of freed packets per HLID */ | |
139 | u8 tx_lnk_free_pkts[WL12XX_MAX_LINKS]; | |
140 | ||
141 | /* Cumulative counter of released Voice memory blocks */ | |
142 | u8 tx_voice_released_blks; | |
143 | ||
144 | u8 padding[3]; | |
145 | } __packed; | |
146 | ||
4d56ad9c | 147 | /* FW status registers */ |
0afd04e5 | 148 | struct wl_fw_status_1 { |
d0f63b20 | 149 | __le32 intr; |
f5fc0f86 LC |
150 | u8 fw_rx_counter; |
151 | u8 drv_rx_counter; | |
152 | u8 reserved; | |
153 | u8 tx_results_counter; | |
0afd04e5 AN |
154 | __le32 rx_pkt_descs[0]; |
155 | } __packed; | |
156 | ||
157 | /* | |
158 | * Each HW arch has a different number of Rx descriptors. | |
159 | * The length of the status depends on it, since it holds an array | |
160 | * of descriptors. | |
161 | */ | |
162 | #define WLCORE_FW_STATUS_1_LEN(num_rx_desc) \ | |
163 | (sizeof(struct wl_fw_status_1) + \ | |
164 | (sizeof(((struct wl_fw_status_1 *)0)->rx_pkt_descs[0])) * \ | |
165 | num_rx_desc) | |
166 | ||
167 | struct wl_fw_status_2 { | |
d0f63b20 | 168 | __le32 fw_localtime; |
beb6c880 AN |
169 | |
170 | /* | |
171 | * A bitmap (where each bit represents a single HLID) | |
172 | * to indicate if the station is in PS mode. | |
173 | */ | |
174 | __le32 link_ps_bitmap; | |
175 | ||
4d56ad9c EP |
176 | /* |
177 | * A bitmap (where each bit represents a single HLID) to indicate | |
178 | * if the station is in Fast mode | |
179 | */ | |
180 | __le32 link_fast_bitmap; | |
f5fc0f86 | 181 | |
4d56ad9c EP |
182 | /* Cumulative counter of total released mem blocks since FW-reset */ |
183 | __le32 total_released_blks; | |
c8bde243 | 184 | |
4d56ad9c EP |
185 | /* Size (in Memory Blocks) of TX pool */ |
186 | __le32 tx_total; | |
c8bde243 | 187 | |
6bac40a6 | 188 | struct wl_fw_packet_counters counters; |
c8bde243 | 189 | |
4d56ad9c | 190 | __le32 log_start_addr; |
6bac40a6 AN |
191 | |
192 | /* Private status to be used by the lower drivers */ | |
193 | u8 priv[0]; | |
4d56ad9c | 194 | } __packed; |
c8bde243 | 195 | |
4a31c11c | 196 | #define WL1271_MAX_CHANNELS 64 |
abb0b3bf | 197 | struct wl1271_scan { |
4fb26fa9 | 198 | struct cfg80211_scan_request *req; |
4a31c11c | 199 | unsigned long scanned_ch[BITS_TO_LONGS(WL1271_MAX_CHANNELS)]; |
78abd320 | 200 | bool failed; |
abb0b3bf | 201 | u8 state; |
3b40c040 | 202 | u8 ssid[IEEE80211_MAX_SSID_LEN+1]; |
abb0b3bf | 203 | size_t ssid_len; |
abb0b3bf TP |
204 | }; |
205 | ||
8197b711 | 206 | struct wl1271_if_operations { |
f1a26e63 IY |
207 | int __must_check (*read)(struct device *child, int addr, void *buf, |
208 | size_t len, bool fixed); | |
209 | int __must_check (*write)(struct device *child, int addr, void *buf, | |
210 | size_t len, bool fixed); | |
a390e85c FB |
211 | void (*reset)(struct device *child); |
212 | void (*init)(struct device *child); | |
213 | int (*power)(struct device *child, bool enable); | |
214 | void (*set_block_size) (struct device *child, unsigned int blksz); | |
8197b711 TP |
215 | }; |
216 | ||
7f179b46 AN |
217 | #define MAX_NUM_KEYS 14 |
218 | #define MAX_KEY_SIZE 32 | |
219 | ||
220 | struct wl1271_ap_key { | |
221 | u8 id; | |
222 | u8 key_type; | |
223 | u8 key_size; | |
224 | u8 key[MAX_KEY_SIZE]; | |
225 | u8 hlid; | |
226 | u32 tx_seq_32; | |
227 | u16 tx_seq_16; | |
228 | }; | |
229 | ||
72c2d9e5 | 230 | enum wl12xx_flags { |
72c2d9e5 EP |
231 | WL1271_FLAG_GPIO_POWER, |
232 | WL1271_FLAG_TX_QUEUE_STOPPED, | |
b07d4037 | 233 | WL1271_FLAG_TX_PENDING, |
72c2d9e5 | 234 | WL1271_FLAG_IN_ELP, |
a665d6e2 | 235 | WL1271_FLAG_ELP_REQUESTED, |
72c2d9e5 | 236 | WL1271_FLAG_IRQ_RUNNING, |
72c2d9e5 | 237 | WL1271_FLAG_FW_TX_BUSY, |
990f5de7 | 238 | WL1271_FLAG_DUMMY_PACKET_PENDING, |
f44e5868 EP |
239 | WL1271_FLAG_SUSPENDED, |
240 | WL1271_FLAG_PENDING_WORK, | |
77ddaa10 | 241 | WL1271_FLAG_SOFT_GEMINI, |
baacb9ae | 242 | WL1271_FLAG_RECOVERY_IN_PROGRESS, |
4549d09c | 243 | WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, |
e9ba7152 | 244 | WL1271_FLAG_INTENDED_FW_RECOVERY, |
4455556d | 245 | WL1271_FLAG_IO_FAILED, |
72c2d9e5 EP |
246 | }; |
247 | ||
ba8447f6 | 248 | enum wl12xx_vif_flags { |
10c8cd01 | 249 | WLVIF_FLAG_INITIALIZED, |
ba8447f6 | 250 | WLVIF_FLAG_STA_ASSOCIATED, |
9fd6f21b | 251 | WLVIF_FLAG_STA_AUTHORIZED, |
eee514e3 | 252 | WLVIF_FLAG_IBSS_JOINED, |
53d40d0b | 253 | WLVIF_FLAG_AP_STARTED, |
5c0dc2fc | 254 | WLVIF_FLAG_IN_PS, |
8181aecc | 255 | WLVIF_FLAG_STA_STATE_SENT, |
0744bdb6 | 256 | WLVIF_FLAG_RX_STREAMING_STARTED, |
836d6600 | 257 | WLVIF_FLAG_PSPOLL_FAILURE, |
52630c5d | 258 | WLVIF_FLAG_CS_PROGRESS, |
560f0024 | 259 | WLVIF_FLAG_AP_PROBE_RESP_SET, |
a0c7b782 | 260 | WLVIF_FLAG_IN_USE, |
ba8447f6 EP |
261 | }; |
262 | ||
a8c0ddb5 AN |
263 | struct wl1271_link { |
264 | /* AP-mode - TX queue per AC in link */ | |
265 | struct sk_buff_head tx_queue[NUM_TX_QUEUES]; | |
09039f42 | 266 | |
9b17f1b3 AN |
267 | /* accounting for allocated / freed packets in FW */ |
268 | u8 allocated_pkts; | |
269 | u8 prev_freed_pkts; | |
b622d992 AN |
270 | |
271 | u8 addr[ETH_ALEN]; | |
0f9c8250 AN |
272 | |
273 | /* bitmap of TIDs where RX BA sessions are active for this link */ | |
274 | u8 ba_bitmap; | |
a8c0ddb5 AN |
275 | }; |
276 | ||
c21eebb5 | 277 | #define WL1271_MAX_RX_FILTERS 5 |
a6eab0c8 | 278 | #define WL1271_RX_FILTER_MAX_FIELDS 8 |
b95d7cef ES |
279 | |
280 | #define WL1271_RX_FILTER_ETH_HEADER_SIZE 14 | |
281 | #define WL1271_RX_FILTER_MAX_FIELDS_SIZE 95 | |
282 | #define RX_FILTER_FIELD_OVERHEAD \ | |
283 | (sizeof(struct wl12xx_rx_filter_field) - sizeof(u8 *)) | |
284 | #define WL1271_RX_FILTER_MAX_PATTERN_SIZE \ | |
285 | (WL1271_RX_FILTER_MAX_FIELDS_SIZE - RX_FILTER_FIELD_OVERHEAD) | |
286 | ||
287 | #define WL1271_RX_FILTER_FLAG_MASK BIT(0) | |
288 | #define WL1271_RX_FILTER_FLAG_IP_HEADER 0 | |
289 | #define WL1271_RX_FILTER_FLAG_ETHERNET_HEADER BIT(1) | |
290 | ||
a6eab0c8 ES |
291 | enum rx_filter_action { |
292 | FILTER_DROP = 0, | |
293 | FILTER_SIGNAL = 1, | |
294 | FILTER_FW_HANDLE = 2 | |
295 | }; | |
296 | ||
7019c80e YS |
297 | enum plt_mode { |
298 | PLT_OFF = 0, | |
299 | PLT_ON = 1, | |
300 | PLT_FEM_DETECT = 2, | |
301 | }; | |
302 | ||
a6eab0c8 ES |
303 | struct wl12xx_rx_filter_field { |
304 | __le16 offset; | |
305 | u8 len; | |
306 | u8 flags; | |
307 | u8 *pattern; | |
308 | } __packed; | |
309 | ||
310 | struct wl12xx_rx_filter { | |
311 | u8 action; | |
312 | int num_fields; | |
313 | struct wl12xx_rx_filter_field fields[WL1271_RX_FILTER_MAX_FIELDS]; | |
314 | }; | |
315 | ||
f84f7d78 AN |
316 | struct wl1271_station { |
317 | u8 hlid; | |
f5fc0f86 LC |
318 | }; |
319 | ||
87fbcb0f | 320 | struct wl12xx_vif { |
252efa4f | 321 | struct wl1271 *wl; |
87627214 | 322 | struct list_head list; |
ba8447f6 | 323 | unsigned long flags; |
536129c8 | 324 | u8 bss_type; |
fb0e707c | 325 | u8 p2p; /* we are using p2p role */ |
0603d891 | 326 | u8 role_id; |
536129c8 | 327 | |
7edebf56 EP |
328 | /* sta/ibss specific */ |
329 | u8 dev_role_id; | |
afaf8bdb | 330 | u8 dev_hlid; |
7edebf56 | 331 | |
154da67c EP |
332 | union { |
333 | struct { | |
334 | u8 hlid; | |
d0802abd | 335 | u8 ba_rx_bitmap; |
e5a359f8 EP |
336 | |
337 | u8 basic_rate_idx; | |
338 | u8 ap_rate_idx; | |
339 | u8 p2p_rate_idx; | |
5ec8a448 | 340 | |
001e39a8 EP |
341 | u8 klv_template_id; |
342 | ||
5ec8a448 | 343 | bool qos; |
154da67c | 344 | } sta; |
a8ab39a4 EP |
345 | struct { |
346 | u8 global_hlid; | |
347 | u8 bcast_hlid; | |
c7ffb902 EP |
348 | |
349 | /* HLIDs bitmap of associated stations */ | |
350 | unsigned long sta_hlid_map[BITS_TO_LONGS( | |
351 | WL12XX_MAX_LINKS)]; | |
170d0e67 EP |
352 | |
353 | /* recoreded keys - set here before AP startup */ | |
354 | struct wl1271_ap_key *recorded_keys[MAX_NUM_KEYS]; | |
e5a359f8 EP |
355 | |
356 | u8 mgmt_rate_idx; | |
357 | u8 bcast_rate_idx; | |
358 | u8 ucast_rate_idx[CONF_TX_MAX_AC_COUNT]; | |
a8ab39a4 | 359 | } ap; |
154da67c EP |
360 | }; |
361 | ||
4438aca9 EP |
362 | /* the hlid of the last transmitted skb */ |
363 | int last_tx_hlid; | |
364 | ||
c7ffb902 EP |
365 | unsigned long links_map[BITS_TO_LONGS(WL12XX_MAX_LINKS)]; |
366 | ||
1fe9f161 EP |
367 | u8 ssid[IEEE80211_MAX_SSID_LEN + 1]; |
368 | u8 ssid_len; | |
369 | ||
1b92f15e EP |
370 | /* The current band */ |
371 | enum ieee80211_band band; | |
61f845f4 | 372 | int channel; |
83d08d3f | 373 | enum nl80211_channel_type channel_type; |
1b92f15e | 374 | |
091185d6 | 375 | u32 bitrate_masks[WLCORE_NUM_BANDS]; |
87fbcb0f | 376 | u32 basic_rate_set; |
30d0c8fd EP |
377 | |
378 | /* | |
379 | * currently configured rate set: | |
380 | * bits 0-15 - 802.11abg rates | |
381 | * bits 16-23 - 802.11n MCS index mask | |
382 | * support only 1 stream, thus only 8 bits for the MCS rates (0-7). | |
383 | */ | |
d2d66c56 | 384 | u32 basic_rate; |
30d0c8fd | 385 | u32 rate_set; |
bddb29b8 EP |
386 | |
387 | /* probe-req template for the current AP */ | |
388 | struct sk_buff *probereq; | |
6840e37a | 389 | |
6a899796 EP |
390 | /* Beaconing interval (needed for ad-hoc) */ |
391 | u32 beacon_int; | |
392 | ||
f75c753f EP |
393 | /* Default key (for WEP) */ |
394 | u32 default_key; | |
395 | ||
6840e37a EP |
396 | /* Our association ID */ |
397 | u16 aid; | |
98b86253 EP |
398 | |
399 | /* Session counter for the chipset */ | |
400 | int session_counter; | |
252efa4f | 401 | |
74ec8395 EP |
402 | /* retry counter for PSM entries */ |
403 | u8 psm_entry_retry; | |
04324d99 | 404 | |
6bd65029 EP |
405 | /* in dBm */ |
406 | int power_level; | |
407 | ||
04324d99 EP |
408 | int rssi_thold; |
409 | int last_rssi_event; | |
d0802abd | 410 | |
5ec8a448 EP |
411 | /* save the current encryption type for auto-arp config */ |
412 | u8 encryption_type; | |
413 | __be32 ip_addr; | |
414 | ||
d0802abd EP |
415 | /* RX BA constraint value */ |
416 | bool ba_support; | |
417 | bool ba_allowed; | |
48e93e40 | 418 | |
9eb599e9 EP |
419 | /* Rx Streaming */ |
420 | struct work_struct rx_streaming_enable_work; | |
421 | struct work_struct rx_streaming_disable_work; | |
422 | struct timer_list rx_streaming_timer; | |
423 | ||
48e93e40 EP |
424 | /* |
425 | * This struct must be last! | |
426 | * data that has to be saved acrossed reconfigs (e.g. recovery) | |
427 | * should be declared in this struct. | |
428 | */ | |
429 | struct { | |
430 | u8 persistent[0]; | |
431 | /* | |
432 | * Security sequence number | |
433 | * bits 0-15: lower 16 bits part of sequence number | |
434 | * bits 16-47: higher 32 bits part of sequence number | |
435 | * bits 48-63: not in use | |
436 | */ | |
437 | u64 tx_security_seq; | |
438 | ||
439 | /* 8 bits of the last sequence number in use */ | |
440 | u8 tx_security_last_seq_lsb; | |
441 | }; | |
87fbcb0f EP |
442 | }; |
443 | ||
444 | static inline struct wl12xx_vif *wl12xx_vif_to_data(struct ieee80211_vif *vif) | |
445 | { | |
446 | return (struct wl12xx_vif *)vif->drv_priv; | |
447 | } | |
448 | ||
449 | static inline | |
450 | struct ieee80211_vif *wl12xx_wlvif_to_vif(struct wl12xx_vif *wlvif) | |
451 | { | |
452 | return container_of((void *)wlvif, struct ieee80211_vif, drv_priv); | |
453 | } | |
454 | ||
87627214 EP |
455 | #define wl12xx_for_each_wlvif(wl, wlvif) \ |
456 | list_for_each_entry(wlvif, &wl->wlvif_list, list) | |
457 | ||
e4120df9 EP |
458 | #define wl12xx_for_each_wlvif_continue(wl, wlvif) \ |
459 | list_for_each_entry_continue(wlvif, &wl->wlvif_list, list) | |
460 | ||
4b730b6a EP |
461 | #define wl12xx_for_each_wlvif_bss_type(wl, wlvif, _bss_type) \ |
462 | wl12xx_for_each_wlvif(wl, wlvif) \ | |
463 | if (wlvif->bss_type == _bss_type) | |
464 | ||
465 | #define wl12xx_for_each_wlvif_sta(wl, wlvif) \ | |
466 | wl12xx_for_each_wlvif_bss_type(wl, wlvif, BSS_TYPE_STA_BSS) | |
467 | ||
468 | #define wl12xx_for_each_wlvif_ap(wl, wlvif) \ | |
469 | wl12xx_for_each_wlvif_bss_type(wl, wlvif, BSS_TYPE_AP_BSS) | |
470 | ||
7019c80e | 471 | int wl1271_plt_start(struct wl1271 *wl, const enum plt_mode plt_mode); |
f5fc0f86 | 472 | int wl1271_plt_stop(struct wl1271 *wl); |
9eb599e9 | 473 | int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif); |
baacb9ae | 474 | void wl12xx_queue_recovery_work(struct wl1271 *wl); |
95dac04f | 475 | size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen); |
a6eab0c8 ES |
476 | int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter, |
477 | u16 offset, u8 flags, | |
478 | u8 *pattern, u8 len); | |
479 | void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter); | |
480 | struct wl12xx_rx_filter *wl1271_rx_filter_alloc(void); | |
481 | int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter); | |
482 | void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter, | |
483 | u8 *buf); | |
f5fc0f86 LC |
484 | |
485 | #define JOIN_TIMEOUT 5000 /* 5000 milliseconds to join */ | |
486 | ||
98b86253 EP |
487 | #define SESSION_COUNTER_MAX 6 /* maximum value for the session counter */ |
488 | #define SESSION_COUNTER_INVALID 7 /* used with dummy_packet */ | |
f5fc0f86 LC |
489 | |
490 | #define WL1271_DEFAULT_POWER_LEVEL 0 | |
491 | ||
787b2dc4 IY |
492 | #define WL1271_TX_QUEUE_LOW_WATERMARK 32 |
493 | #define WL1271_TX_QUEUE_HIGH_WATERMARK 256 | |
f5fc0f86 | 494 | |
a620865e IY |
495 | #define WL1271_DEFERRED_QUEUE_LIMIT 64 |
496 | ||
01ac17ec JO |
497 | /* WL1271 needs a 200ms sleep after power on, and a 20ms sleep before power |
498 | on in case is has been shut down shortly before */ | |
e8a8b252 SW |
499 | #define WL1271_PRE_POWER_ON_SLEEP 20 /* in milliseconds */ |
500 | #define WL1271_POWER_ON_SLEEP 200 /* in milliseconds */ | |
f5fc0f86 | 501 | |
e8b03a2b SL |
502 | /* Macros to handle wl1271.sta_rate_set */ |
503 | #define HW_BG_RATES_MASK 0xffff | |
504 | #define HW_HT_RATES_OFFSET 16 | |
b3a47ee0 | 505 | #define HW_MIMO_RATES_OFFSET 24 |
e8b03a2b | 506 | |
95dac04f IY |
507 | #define WL12XX_HW_BLOCK_SIZE 256 |
508 | ||
8388569a | 509 | #endif /* __WLCORE_I_H__ */ |