]>
Commit | Line | Data |
---|---|---|
f5fc0f86 LC |
1 | /* |
2 | * This file is part of wl1271 | |
3 | * | |
4 | * Copyright (C) 2008-2009 Nokia Corporation | |
5 | * | |
6 | * Contact: Luciano Coelho <luciano.coelho@nokia.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License | |
10 | * version 2 as published by the Free Software Foundation. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | |
20 | * 02110-1301 USA | |
21 | * | |
22 | */ | |
23 | ||
00d20100 SL |
24 | #include "wl12xx.h" |
25 | #include "reg.h" | |
26 | #include "io.h" | |
27 | #include "event.h" | |
28 | #include "ps.h" | |
29 | #include "scan.h" | |
66497dc3 | 30 | #include "wl12xx_80211.h" |
f5fc0f86 | 31 | |
90494a90 JO |
32 | void wl1271_pspoll_work(struct work_struct *work) |
33 | { | |
d2d66c56 EP |
34 | struct ieee80211_vif *vif; |
35 | struct wl12xx_vif *wlvif; | |
90494a90 JO |
36 | struct delayed_work *dwork; |
37 | struct wl1271 *wl; | |
c1b193eb | 38 | int ret; |
90494a90 JO |
39 | |
40 | dwork = container_of(work, struct delayed_work, work); | |
252efa4f EP |
41 | wlvif = container_of(dwork, struct wl12xx_vif, pspoll_work); |
42 | vif = container_of((void *)wlvif, struct ieee80211_vif, drv_priv); | |
43 | wl = wlvif->wl; | |
90494a90 JO |
44 | |
45 | wl1271_debug(DEBUG_EVENT, "pspoll work"); | |
46 | ||
47 | mutex_lock(&wl->mutex); | |
48 | ||
8c7f4f31 JO |
49 | if (unlikely(wl->state == WL1271_STATE_OFF)) |
50 | goto out; | |
51 | ||
90494a90 JO |
52 | if (!test_and_clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags)) |
53 | goto out; | |
54 | ||
55 | if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) | |
56 | goto out; | |
57 | ||
58 | /* | |
59 | * if we end up here, then we were in powersave when the pspoll | |
60 | * delivery failure occurred, and no-one changed state since, so | |
61 | * we should go back to powersave. | |
62 | */ | |
c1b193eb EP |
63 | ret = wl1271_ps_elp_wakeup(wl); |
64 | if (ret < 0) | |
65 | goto out; | |
66 | ||
0603d891 EP |
67 | wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE, |
68 | wlvif->basic_rate, true); | |
90494a90 | 69 | |
c1b193eb | 70 | wl1271_ps_elp_sleep(wl); |
90494a90 JO |
71 | out: |
72 | mutex_unlock(&wl->mutex); | |
73 | }; | |
74 | ||
d2d66c56 EP |
75 | static void wl1271_event_pspoll_delivery_fail(struct wl1271 *wl, |
76 | struct wl12xx_vif *wlvif) | |
90494a90 JO |
77 | { |
78 | int delay = wl->conf.conn.ps_poll_recovery_period; | |
79 | int ret; | |
80 | ||
81 | wl->ps_poll_failures++; | |
82 | if (wl->ps_poll_failures == 1) | |
83 | wl1271_info("AP with dysfunctional ps-poll, " | |
84 | "trying to work around it."); | |
85 | ||
86 | /* force active mode receive data from the AP */ | |
87 | if (test_bit(WL1271_FLAG_PSM, &wl->flags)) { | |
0603d891 | 88 | ret = wl1271_ps_set_mode(wl, wlvif, STATION_ACTIVE_MODE, |
d2d66c56 | 89 | wlvif->basic_rate, true); |
90494a90 JO |
90 | if (ret < 0) |
91 | return; | |
92 | set_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags); | |
252efa4f | 93 | ieee80211_queue_delayed_work(wl->hw, &wlvif->pspoll_work, |
90494a90 JO |
94 | msecs_to_jiffies(delay)); |
95 | } | |
96 | ||
97 | /* | |
98 | * If already in active mode, lets we should be getting data from | |
99 | * the AP right away. If we enter PSM too fast after this, and data | |
100 | * remains on the AP, we will get another event like this, and we'll | |
101 | * go into active once more. | |
102 | */ | |
103 | } | |
104 | ||
19ad0715 | 105 | static int wl1271_event_ps_report(struct wl1271 *wl, |
d2d66c56 | 106 | struct wl12xx_vif *wlvif, |
19ad0715 JO |
107 | struct event_mailbox *mbox, |
108 | bool *beacon_loss) | |
109 | { | |
110 | int ret = 0; | |
65cddbf1 | 111 | u32 total_retries = wl->conf.conn.psm_entry_retries; |
19ad0715 JO |
112 | |
113 | wl1271_debug(DEBUG_EVENT, "ps_status: 0x%x", mbox->ps_status); | |
114 | ||
115 | switch (mbox->ps_status) { | |
116 | case EVENT_ENTER_POWER_SAVE_FAIL: | |
d8c42c0c JO |
117 | wl1271_debug(DEBUG_PSM, "PSM entry failed"); |
118 | ||
71449f8d | 119 | if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) { |
d8c42c0c | 120 | /* remain in active mode */ |
461fa136 JO |
121 | wl->psm_entry_retry = 0; |
122 | break; | |
123 | } | |
124 | ||
65cddbf1 | 125 | if (wl->psm_entry_retry < total_retries) { |
19ad0715 | 126 | wl->psm_entry_retry++; |
0603d891 EP |
127 | ret = wl1271_ps_set_mode(wl, wlvif, |
128 | STATION_POWER_SAVE_MODE, | |
d2d66c56 | 129 | wlvif->basic_rate, true); |
19ad0715 | 130 | } else { |
1a186a51 | 131 | wl1271_info("No ack to nullfunc from AP."); |
19ad0715 | 132 | wl->psm_entry_retry = 0; |
d60772f6 | 133 | *beacon_loss = true; |
19ad0715 JO |
134 | } |
135 | break; | |
136 | case EVENT_ENTER_POWER_SAVE_SUCCESS: | |
137 | wl->psm_entry_retry = 0; | |
d8c42c0c JO |
138 | |
139 | /* enable beacon filtering */ | |
0603d891 | 140 | ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true); |
d8c42c0c JO |
141 | if (ret < 0) |
142 | break; | |
143 | ||
0e44eb20 SL |
144 | /* |
145 | * BET has only a minor effect in 5GHz and masks | |
146 | * channel switch IEs, so we only enable BET on 2.4GHz | |
147 | */ | |
148 | if (wl->band == IEEE80211_BAND_2GHZ) | |
149 | /* enable beacon early termination */ | |
0603d891 | 150 | ret = wl1271_acx_bet_enable(wl, wlvif, true); |
9439064c | 151 | |
6ec45dc2 EP |
152 | if (wlvif->ps_compl) { |
153 | complete(wlvif->ps_compl); | |
154 | wlvif->ps_compl = NULL; | |
9439064c | 155 | } |
19ad0715 | 156 | break; |
19ad0715 JO |
157 | default: |
158 | break; | |
159 | } | |
160 | ||
161 | return ret; | |
162 | } | |
163 | ||
00236aed JO |
164 | static void wl1271_event_rssi_trigger(struct wl1271 *wl, |
165 | struct event_mailbox *mbox) | |
166 | { | |
167 | enum nl80211_cqm_rssi_threshold_event event; | |
168 | s8 metric = mbox->rssi_snr_trigger_metric[0]; | |
169 | ||
170 | wl1271_debug(DEBUG_EVENT, "RSSI trigger metric: %d", metric); | |
171 | ||
172 | if (metric <= wl->rssi_thold) | |
173 | event = NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW; | |
174 | else | |
175 | event = NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH; | |
176 | ||
177 | if (event != wl->last_rssi_event) | |
178 | ieee80211_cqm_rssi_notify(wl->vif, event, GFP_KERNEL); | |
179 | wl->last_rssi_event = event; | |
180 | } | |
181 | ||
536129c8 | 182 | static void wl1271_stop_ba_event(struct wl1271 *wl, struct wl12xx_vif *wlvif) |
70559a06 | 183 | { |
536129c8 | 184 | if (wlvif->bss_type != BSS_TYPE_AP_BSS) { |
f4d3b6ab AN |
185 | if (!wl->ba_rx_bitmap) |
186 | return; | |
187 | ieee80211_stop_rx_ba_session(wl->vif, wl->ba_rx_bitmap, | |
cdf09495 | 188 | wl->vif->bss_conf.bssid); |
f4d3b6ab AN |
189 | } else { |
190 | int i; | |
191 | struct wl1271_link *lnk; | |
6b661895 | 192 | for (i = WL1271_AP_STA_HLID_START; i < AP_MAX_LINKS; i++) { |
f4d3b6ab AN |
193 | lnk = &wl->links[i]; |
194 | if (!wl1271_is_active_sta(wl, i) || !lnk->ba_bitmap) | |
195 | continue; | |
196 | ||
197 | ieee80211_stop_rx_ba_session(wl->vif, | |
198 | lnk->ba_bitmap, | |
199 | lnk->addr); | |
200 | } | |
201 | } | |
70559a06 SL |
202 | } |
203 | ||
77ddaa10 EP |
204 | static void wl12xx_event_soft_gemini_sense(struct wl1271 *wl, |
205 | u8 enable) | |
206 | { | |
207 | if (enable) { | |
208 | /* disable dynamic PS when requested by the firmware */ | |
209 | ieee80211_disable_dyn_ps(wl->vif); | |
210 | set_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags); | |
211 | } else { | |
212 | ieee80211_enable_dyn_ps(wl->vif); | |
213 | clear_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags); | |
214 | wl1271_recalc_rx_streaming(wl); | |
215 | } | |
216 | ||
217 | } | |
218 | ||
f5fc0f86 LC |
219 | static void wl1271_event_mbox_dump(struct event_mailbox *mbox) |
220 | { | |
221 | wl1271_debug(DEBUG_EVENT, "MBOX DUMP:"); | |
222 | wl1271_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector); | |
223 | wl1271_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask); | |
224 | } | |
225 | ||
226 | static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox) | |
227 | { | |
d2d66c56 EP |
228 | struct ieee80211_vif *vif = wl->vif; /* TODO: get as param */ |
229 | struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif); | |
f5fc0f86 LC |
230 | int ret; |
231 | u32 vector; | |
19ad0715 | 232 | bool beacon_loss = false; |
536129c8 | 233 | bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS); |
3618f30f AN |
234 | bool disconnect_sta = false; |
235 | unsigned long sta_bitmap = 0; | |
f5fc0f86 LC |
236 | |
237 | wl1271_event_mbox_dump(mbox); | |
238 | ||
d0f63b20 LC |
239 | vector = le32_to_cpu(mbox->events_vector); |
240 | vector &= ~(le32_to_cpu(mbox->events_mask)); | |
f5fc0f86 LC |
241 | wl1271_debug(DEBUG_EVENT, "vector: 0x%x", vector); |
242 | ||
243 | if (vector & SCAN_COMPLETE_EVENT_ID) { | |
34dd2aaa LC |
244 | wl1271_debug(DEBUG_EVENT, "status: 0x%x", |
245 | mbox->scheduled_scan_status); | |
246 | ||
784f694d | 247 | wl1271_scan_stm(wl, wl->scan_vif); |
f5fc0f86 LC |
248 | } |
249 | ||
6394c01b LC |
250 | if (vector & PERIODIC_SCAN_REPORT_EVENT_ID) { |
251 | wl1271_debug(DEBUG_EVENT, "PERIODIC_SCAN_REPORT_EVENT " | |
252 | "(status 0x%0x)", mbox->scheduled_scan_status); | |
33c2c06c LC |
253 | |
254 | wl1271_scan_sched_scan_results(wl); | |
6394c01b LC |
255 | } |
256 | ||
257 | if (vector & PERIODIC_SCAN_COMPLETE_EVENT_ID) { | |
258 | wl1271_debug(DEBUG_EVENT, "PERIODIC_SCAN_COMPLETE_EVENT " | |
259 | "(status 0x%0x)", mbox->scheduled_scan_status); | |
33c2c06c LC |
260 | if (wl->sched_scanning) { |
261 | wl1271_scan_sched_scan_stop(wl); | |
262 | ieee80211_sched_scan_stopped(wl->hw); | |
263 | } | |
6394c01b LC |
264 | } |
265 | ||
8d2ef7bd | 266 | if (vector & SOFT_GEMINI_SENSE_EVENT_ID && |
536129c8 | 267 | wlvif->bss_type == BSS_TYPE_STA_BSS) |
77ddaa10 EP |
268 | wl12xx_event_soft_gemini_sense(wl, |
269 | mbox->soft_gemini_sense_info); | |
8d2ef7bd | 270 | |
b771eee5 JO |
271 | /* |
272 | * The BSS_LOSE_EVENT_ID is only needed while psm (and hence beacon | |
273 | * filtering) is enabled. Without PSM, the stack will receive all | |
274 | * beacons and can detect beacon loss by itself. | |
64e29e44 TP |
275 | * |
276 | * As there's possibility that the driver disables PSM before receiving | |
277 | * BSS_LOSE_EVENT, beacon loss has to be reported to the stack. | |
278 | * | |
b771eee5 | 279 | */ |
203c903c | 280 | if ((vector & BSS_LOSE_EVENT_ID) && !is_ap) { |
1a186a51 | 281 | wl1271_info("Beacon loss detected."); |
f5fc0f86 | 282 | |
b771eee5 | 283 | /* indicate to the stack, that beacons have been lost */ |
19ad0715 JO |
284 | beacon_loss = true; |
285 | } | |
286 | ||
203c903c | 287 | if ((vector & PS_REPORT_EVENT_ID) && !is_ap) { |
19ad0715 | 288 | wl1271_debug(DEBUG_EVENT, "PS_REPORT_EVENT"); |
d2d66c56 | 289 | ret = wl1271_event_ps_report(wl, wlvif, mbox, &beacon_loss); |
19ad0715 JO |
290 | if (ret < 0) |
291 | return ret; | |
292 | } | |
293 | ||
203c903c | 294 | if ((vector & PSPOLL_DELIVERY_FAILURE_EVENT_ID) && !is_ap) |
d2d66c56 | 295 | wl1271_event_pspoll_delivery_fail(wl, wlvif); |
90494a90 | 296 | |
00236aed JO |
297 | if (vector & RSSI_SNR_TRIGGER_0_EVENT_ID) { |
298 | wl1271_debug(DEBUG_EVENT, "RSSI_SNR_TRIGGER_0_EVENT"); | |
299 | if (wl->vif) | |
300 | wl1271_event_rssi_trigger(wl, mbox); | |
301 | } | |
302 | ||
f4d3b6ab | 303 | if ((vector & BA_SESSION_RX_CONSTRAINT_EVENT_ID)) { |
70559a06 | 304 | wl1271_debug(DEBUG_EVENT, "BA_SESSION_RX_CONSTRAINT_EVENT_ID. " |
c690ec81 | 305 | "ba_allowed = 0x%x", mbox->rx_ba_allowed); |
70559a06 | 306 | |
f4d3b6ab AN |
307 | wl->ba_allowed = !!mbox->rx_ba_allowed; |
308 | ||
309 | if (wl->vif && !wl->ba_allowed) | |
536129c8 | 310 | wl1271_stop_ba_event(wl, wlvif); |
70559a06 SL |
311 | } |
312 | ||
6d158ff3 SL |
313 | if ((vector & CHANNEL_SWITCH_COMPLETE_EVENT_ID) && !is_ap) { |
314 | wl1271_debug(DEBUG_EVENT, "CHANNEL_SWITCH_COMPLETE_EVENT_ID. " | |
315 | "status = 0x%x", | |
316 | mbox->channel_switch_status); | |
317 | /* | |
318 | * That event uses for two cases: | |
319 | * 1) channel switch complete with status=0 | |
320 | * 2) channel switch failed status=1 | |
321 | */ | |
322 | if (test_and_clear_bit(WL1271_FLAG_CS_PROGRESS, &wl->flags) && | |
323 | (wl->vif)) | |
324 | ieee80211_chswitch_done(wl->vif, | |
325 | mbox->channel_switch_status ? false : true); | |
326 | } | |
327 | ||
79ebec76 | 328 | if ((vector & DUMMY_PACKET_EVENT_ID)) { |
ae47c45f SL |
329 | wl1271_debug(DEBUG_EVENT, "DUMMY_PACKET_ID_EVENT_ID"); |
330 | if (wl->vif) | |
331 | wl1271_tx_dummy_packet(wl); | |
332 | } | |
333 | ||
3618f30f AN |
334 | /* |
335 | * "TX retries exceeded" has a different meaning according to mode. | |
336 | * In AP mode the offending station is disconnected. | |
337 | */ | |
338 | if ((vector & MAX_TX_RETRY_EVENT_ID) && is_ap) { | |
339 | wl1271_debug(DEBUG_EVENT, "MAX_TX_RETRY_EVENT_ID"); | |
340 | sta_bitmap |= le16_to_cpu(mbox->sta_tx_retry_exceeded); | |
341 | disconnect_sta = true; | |
342 | } | |
343 | ||
344 | if ((vector & INACTIVE_STA_EVENT_ID) && is_ap) { | |
345 | wl1271_debug(DEBUG_EVENT, "INACTIVE_STA_EVENT_ID"); | |
346 | sta_bitmap |= le16_to_cpu(mbox->sta_aging_status); | |
347 | disconnect_sta = true; | |
348 | } | |
349 | ||
350 | if (is_ap && disconnect_sta) { | |
351 | u32 num_packets = wl->conf.tx.max_tx_retries; | |
352 | struct ieee80211_sta *sta; | |
353 | const u8 *addr; | |
354 | int h; | |
355 | ||
356 | for (h = find_first_bit(&sta_bitmap, AP_MAX_LINKS); | |
357 | h < AP_MAX_LINKS; | |
358 | h = find_next_bit(&sta_bitmap, AP_MAX_LINKS, h+1)) { | |
359 | if (!wl1271_is_active_sta(wl, h)) | |
360 | continue; | |
361 | ||
362 | addr = wl->links[h].addr; | |
363 | ||
364 | rcu_read_lock(); | |
365 | sta = ieee80211_find_sta(wl->vif, addr); | |
366 | if (sta) { | |
367 | wl1271_debug(DEBUG_EVENT, "remove sta %d", h); | |
368 | ieee80211_report_low_ack(sta, num_packets); | |
369 | } | |
370 | rcu_read_unlock(); | |
371 | } | |
372 | } | |
373 | ||
d60772f6 JO |
374 | if (wl->vif && beacon_loss) |
375 | ieee80211_connection_loss(wl->vif); | |
f5fc0f86 LC |
376 | |
377 | return 0; | |
378 | } | |
379 | ||
380 | int wl1271_event_unmask(struct wl1271 *wl) | |
381 | { | |
382 | int ret; | |
383 | ||
384 | ret = wl1271_acx_event_mbox_mask(wl, ~(wl->event_mask)); | |
385 | if (ret < 0) | |
386 | return ret; | |
387 | ||
388 | return 0; | |
389 | } | |
390 | ||
391 | void wl1271_event_mbox_config(struct wl1271 *wl) | |
392 | { | |
7b048c52 | 393 | wl->mbox_ptr[0] = wl1271_read32(wl, REG_EVENT_MAILBOX_PTR); |
f5fc0f86 LC |
394 | wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox); |
395 | ||
396 | wl1271_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x", | |
397 | wl->mbox_ptr[0], wl->mbox_ptr[1]); | |
398 | } | |
399 | ||
13f2dc52 | 400 | int wl1271_event_handle(struct wl1271 *wl, u8 mbox_num) |
f5fc0f86 LC |
401 | { |
402 | struct event_mailbox mbox; | |
403 | int ret; | |
404 | ||
405 | wl1271_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num); | |
406 | ||
407 | if (mbox_num > 1) | |
408 | return -EINVAL; | |
409 | ||
410 | /* first we read the mbox descriptor */ | |
7b048c52 TP |
411 | wl1271_read(wl, wl->mbox_ptr[mbox_num], &mbox, |
412 | sizeof(struct event_mailbox), false); | |
f5fc0f86 LC |
413 | |
414 | /* process the descriptor */ | |
415 | ret = wl1271_event_process(wl, &mbox); | |
416 | if (ret < 0) | |
417 | return ret; | |
418 | ||
419 | /* then we let the firmware know it can go on...*/ | |
7b048c52 | 420 | wl1271_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_EVENT_ACK); |
f5fc0f86 LC |
421 | |
422 | return 0; | |
423 | } |