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 | ||
24 | #include "wl1271.h" | |
25 | #include "wl1271_reg.h" | |
7b048c52 | 26 | #include "wl1271_io.h" |
f5fc0f86 LC |
27 | #include "wl1271_event.h" |
28 | #include "wl1271_ps.h" | |
66497dc3 | 29 | #include "wl12xx_80211.h" |
f5fc0f86 | 30 | |
90494a90 JO |
31 | void wl1271_pspoll_work(struct work_struct *work) |
32 | { | |
33 | struct delayed_work *dwork; | |
34 | struct wl1271 *wl; | |
35 | ||
36 | dwork = container_of(work, struct delayed_work, work); | |
37 | wl = container_of(dwork, struct wl1271, pspoll_work); | |
38 | ||
39 | wl1271_debug(DEBUG_EVENT, "pspoll work"); | |
40 | ||
41 | mutex_lock(&wl->mutex); | |
42 | ||
43 | if (!test_and_clear_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags)) | |
44 | goto out; | |
45 | ||
46 | if (!test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) | |
47 | goto out; | |
48 | ||
49 | /* | |
50 | * if we end up here, then we were in powersave when the pspoll | |
51 | * delivery failure occurred, and no-one changed state since, so | |
52 | * we should go back to powersave. | |
53 | */ | |
54 | wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE, true); | |
55 | ||
56 | out: | |
57 | mutex_unlock(&wl->mutex); | |
58 | }; | |
59 | ||
60 | static void wl1271_event_pspoll_delivery_fail(struct wl1271 *wl) | |
61 | { | |
62 | int delay = wl->conf.conn.ps_poll_recovery_period; | |
63 | int ret; | |
64 | ||
65 | wl->ps_poll_failures++; | |
66 | if (wl->ps_poll_failures == 1) | |
67 | wl1271_info("AP with dysfunctional ps-poll, " | |
68 | "trying to work around it."); | |
69 | ||
70 | /* force active mode receive data from the AP */ | |
71 | if (test_bit(WL1271_FLAG_PSM, &wl->flags)) { | |
72 | ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE, true); | |
73 | if (ret < 0) | |
74 | return; | |
75 | set_bit(WL1271_FLAG_PSPOLL_FAILURE, &wl->flags); | |
76 | ieee80211_queue_delayed_work(wl->hw, &wl->pspoll_work, | |
77 | msecs_to_jiffies(delay)); | |
78 | } | |
79 | ||
80 | /* | |
81 | * If already in active mode, lets we should be getting data from | |
82 | * the AP right away. If we enter PSM too fast after this, and data | |
83 | * remains on the AP, we will get another event like this, and we'll | |
84 | * go into active once more. | |
85 | */ | |
86 | } | |
87 | ||
f5fc0f86 LC |
88 | static int wl1271_event_scan_complete(struct wl1271 *wl, |
89 | struct event_mailbox *mbox) | |
90 | { | |
91 | wl1271_debug(DEBUG_EVENT, "status: 0x%x", | |
92 | mbox->scheduled_scan_status); | |
93 | ||
71449f8d | 94 | if (test_bit(WL1271_FLAG_SCANNING, &wl->flags)) { |
abb0b3bf | 95 | if (wl->scan.state == WL1271_SCAN_BAND_DUAL) { |
abb0b3bf TP |
96 | /* 2.4 GHz band scanned, scan 5 GHz band, pretend |
97 | * to the wl1271_cmd_scan function that we are not | |
98 | * scanning as it checks that. | |
99 | */ | |
71449f8d | 100 | clear_bit(WL1271_FLAG_SCANNING, &wl->flags); |
818e3063 | 101 | /* FIXME: ie missing! */ |
abb0b3bf | 102 | wl1271_cmd_scan(wl, wl->scan.ssid, wl->scan.ssid_len, |
4fb26fa9 JO |
103 | wl->scan.req, |
104 | wl->scan.active, | |
105 | wl->scan.high_prio, | |
106 | WL1271_SCAN_BAND_5_GHZ, | |
107 | wl->scan.probe_requests); | |
abb0b3bf | 108 | } else { |
abb0b3bf TP |
109 | mutex_unlock(&wl->mutex); |
110 | ieee80211_scan_completed(wl->hw, false); | |
111 | mutex_lock(&wl->mutex); | |
71449f8d | 112 | clear_bit(WL1271_FLAG_SCANNING, &wl->flags); |
abb0b3bf TP |
113 | } |
114 | } | |
f5fc0f86 LC |
115 | return 0; |
116 | } | |
117 | ||
19ad0715 JO |
118 | static int wl1271_event_ps_report(struct wl1271 *wl, |
119 | struct event_mailbox *mbox, | |
120 | bool *beacon_loss) | |
121 | { | |
122 | int ret = 0; | |
123 | ||
124 | wl1271_debug(DEBUG_EVENT, "ps_status: 0x%x", mbox->ps_status); | |
125 | ||
126 | switch (mbox->ps_status) { | |
127 | case EVENT_ENTER_POWER_SAVE_FAIL: | |
d8c42c0c JO |
128 | wl1271_debug(DEBUG_PSM, "PSM entry failed"); |
129 | ||
71449f8d | 130 | if (!test_bit(WL1271_FLAG_PSM, &wl->flags)) { |
d8c42c0c | 131 | /* remain in active mode */ |
461fa136 JO |
132 | wl->psm_entry_retry = 0; |
133 | break; | |
134 | } | |
135 | ||
19ad0715 JO |
136 | if (wl->psm_entry_retry < wl->conf.conn.psm_entry_retries) { |
137 | wl->psm_entry_retry++; | |
d8c42c0c JO |
138 | ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE, |
139 | true); | |
19ad0715 | 140 | } else { |
1a186a51 | 141 | wl1271_info("No ack to nullfunc from AP."); |
19ad0715 | 142 | wl->psm_entry_retry = 0; |
d60772f6 | 143 | *beacon_loss = true; |
19ad0715 JO |
144 | } |
145 | break; | |
146 | case EVENT_ENTER_POWER_SAVE_SUCCESS: | |
147 | wl->psm_entry_retry = 0; | |
d8c42c0c JO |
148 | |
149 | /* enable beacon filtering */ | |
150 | ret = wl1271_acx_beacon_filter_opt(wl, true); | |
151 | if (ret < 0) | |
152 | break; | |
153 | ||
154 | /* enable beacon early termination */ | |
155 | ret = wl1271_acx_bet_enable(wl, true); | |
156 | if (ret < 0) | |
157 | break; | |
158 | ||
159 | /* go to extremely low power mode */ | |
160 | wl1271_ps_elp_sleep(wl); | |
161 | if (ret < 0) | |
162 | break; | |
19ad0715 JO |
163 | break; |
164 | case EVENT_EXIT_POWER_SAVE_FAIL: | |
d8c42c0c JO |
165 | wl1271_debug(DEBUG_PSM, "PSM exit failed"); |
166 | ||
167 | if (test_bit(WL1271_FLAG_PSM, &wl->flags)) { | |
168 | wl->psm_entry_retry = 0; | |
169 | break; | |
170 | } | |
171 | ||
30240fc7 JO |
172 | /* make sure the firmware goes to active mode - the frame to |
173 | be sent next will indicate to the AP, that we are active. */ | |
d8c42c0c JO |
174 | ret = wl1271_ps_set_mode(wl, STATION_ACTIVE_MODE, |
175 | false); | |
19ad0715 JO |
176 | break; |
177 | case EVENT_EXIT_POWER_SAVE_SUCCESS: | |
178 | default: | |
179 | break; | |
180 | } | |
181 | ||
182 | return ret; | |
183 | } | |
184 | ||
00236aed JO |
185 | static void wl1271_event_rssi_trigger(struct wl1271 *wl, |
186 | struct event_mailbox *mbox) | |
187 | { | |
188 | enum nl80211_cqm_rssi_threshold_event event; | |
189 | s8 metric = mbox->rssi_snr_trigger_metric[0]; | |
190 | ||
191 | wl1271_debug(DEBUG_EVENT, "RSSI trigger metric: %d", metric); | |
192 | ||
193 | if (metric <= wl->rssi_thold) | |
194 | event = NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW; | |
195 | else | |
196 | event = NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH; | |
197 | ||
198 | if (event != wl->last_rssi_event) | |
199 | ieee80211_cqm_rssi_notify(wl->vif, event, GFP_KERNEL); | |
200 | wl->last_rssi_event = event; | |
201 | } | |
202 | ||
f5fc0f86 LC |
203 | static void wl1271_event_mbox_dump(struct event_mailbox *mbox) |
204 | { | |
205 | wl1271_debug(DEBUG_EVENT, "MBOX DUMP:"); | |
206 | wl1271_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector); | |
207 | wl1271_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask); | |
208 | } | |
209 | ||
210 | static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox) | |
211 | { | |
212 | int ret; | |
213 | u32 vector; | |
19ad0715 | 214 | bool beacon_loss = false; |
f5fc0f86 LC |
215 | |
216 | wl1271_event_mbox_dump(mbox); | |
217 | ||
d0f63b20 LC |
218 | vector = le32_to_cpu(mbox->events_vector); |
219 | vector &= ~(le32_to_cpu(mbox->events_mask)); | |
f5fc0f86 LC |
220 | wl1271_debug(DEBUG_EVENT, "vector: 0x%x", vector); |
221 | ||
222 | if (vector & SCAN_COMPLETE_EVENT_ID) { | |
223 | ret = wl1271_event_scan_complete(wl, mbox); | |
224 | if (ret < 0) | |
225 | return ret; | |
226 | } | |
227 | ||
8d2ef7bd JO |
228 | /* disable dynamic PS when requested by the firmware */ |
229 | if (vector & SOFT_GEMINI_SENSE_EVENT_ID && | |
230 | wl->bss_type == BSS_TYPE_STA_BSS) { | |
231 | if (mbox->soft_gemini_sense_info) | |
f532be6d | 232 | ieee80211_disable_dyn_ps(wl->vif); |
8d2ef7bd | 233 | else |
f532be6d | 234 | ieee80211_enable_dyn_ps(wl->vif); |
8d2ef7bd JO |
235 | } |
236 | ||
b771eee5 JO |
237 | /* |
238 | * The BSS_LOSE_EVENT_ID is only needed while psm (and hence beacon | |
239 | * filtering) is enabled. Without PSM, the stack will receive all | |
240 | * beacons and can detect beacon loss by itself. | |
64e29e44 TP |
241 | * |
242 | * As there's possibility that the driver disables PSM before receiving | |
243 | * BSS_LOSE_EVENT, beacon loss has to be reported to the stack. | |
244 | * | |
b771eee5 | 245 | */ |
64e29e44 | 246 | if (vector & BSS_LOSE_EVENT_ID) { |
1a186a51 | 247 | wl1271_info("Beacon loss detected."); |
f5fc0f86 | 248 | |
b771eee5 | 249 | /* indicate to the stack, that beacons have been lost */ |
19ad0715 JO |
250 | beacon_loss = true; |
251 | } | |
252 | ||
253 | if (vector & PS_REPORT_EVENT_ID) { | |
254 | wl1271_debug(DEBUG_EVENT, "PS_REPORT_EVENT"); | |
255 | ret = wl1271_event_ps_report(wl, mbox, &beacon_loss); | |
256 | if (ret < 0) | |
257 | return ret; | |
258 | } | |
259 | ||
90494a90 JO |
260 | if (vector & PSPOLL_DELIVERY_FAILURE_EVENT_ID) |
261 | wl1271_event_pspoll_delivery_fail(wl); | |
262 | ||
00236aed JO |
263 | if (vector & RSSI_SNR_TRIGGER_0_EVENT_ID) { |
264 | wl1271_debug(DEBUG_EVENT, "RSSI_SNR_TRIGGER_0_EVENT"); | |
265 | if (wl->vif) | |
266 | wl1271_event_rssi_trigger(wl, mbox); | |
267 | } | |
268 | ||
d60772f6 JO |
269 | if (wl->vif && beacon_loss) |
270 | ieee80211_connection_loss(wl->vif); | |
f5fc0f86 LC |
271 | |
272 | return 0; | |
273 | } | |
274 | ||
275 | int wl1271_event_unmask(struct wl1271 *wl) | |
276 | { | |
277 | int ret; | |
278 | ||
279 | ret = wl1271_acx_event_mbox_mask(wl, ~(wl->event_mask)); | |
280 | if (ret < 0) | |
281 | return ret; | |
282 | ||
283 | return 0; | |
284 | } | |
285 | ||
286 | void wl1271_event_mbox_config(struct wl1271 *wl) | |
287 | { | |
7b048c52 | 288 | wl->mbox_ptr[0] = wl1271_read32(wl, REG_EVENT_MAILBOX_PTR); |
f5fc0f86 LC |
289 | wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox); |
290 | ||
291 | wl1271_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x", | |
292 | wl->mbox_ptr[0], wl->mbox_ptr[1]); | |
293 | } | |
294 | ||
13f2dc52 | 295 | int wl1271_event_handle(struct wl1271 *wl, u8 mbox_num) |
f5fc0f86 LC |
296 | { |
297 | struct event_mailbox mbox; | |
298 | int ret; | |
299 | ||
300 | wl1271_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num); | |
301 | ||
302 | if (mbox_num > 1) | |
303 | return -EINVAL; | |
304 | ||
305 | /* first we read the mbox descriptor */ | |
7b048c52 TP |
306 | wl1271_read(wl, wl->mbox_ptr[mbox_num], &mbox, |
307 | sizeof(struct event_mailbox), false); | |
f5fc0f86 LC |
308 | |
309 | /* process the descriptor */ | |
310 | ret = wl1271_event_process(wl, &mbox); | |
311 | if (ret < 0) | |
312 | return ret; | |
313 | ||
314 | /* then we let the firmware know it can go on...*/ | |
7b048c52 | 315 | wl1271_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_EVENT_ACK); |
f5fc0f86 LC |
316 | |
317 | return 0; | |
318 | } |