1 /******************************************************************************
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
24 * The full GNU General Public License is included in this distribution
25 * in the file called COPYING.
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
33 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
34 * All rights reserved.
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
46 * * Neither the name Intel Corporation nor the names of its
47 * contributors may be used to endorse or promote products derived
48 * from this software without specific prior written permission.
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62 *****************************************************************************/
64 #include <linux/jiffies.h>
65 #include <net/mac80211.h>
67 #include "iwl-notif-wait.h"
68 #include "iwl-trans.h"
70 #include "time-event.h"
75 /* A TimeUnit is 1024 microsecond */
76 #define MSEC_TO_TU(_msec) (_msec*1000/1024)
79 * For the high priority TE use a time event type that has similar priority to
80 * the FW's action scan priority.
82 #define IWL_MVM_ROC_TE_TYPE_NORMAL TE_P2P_DEVICE_DISCOVERABLE
83 #define IWL_MVM_ROC_TE_TYPE_MGMT_TX TE_P2P_CLIENT_ASSOC
85 void iwl_mvm_te_clear_data(struct iwl_mvm
*mvm
,
86 struct iwl_mvm_time_event_data
*te_data
)
88 lockdep_assert_held(&mvm
->time_event_lock
);
90 if (te_data
->id
== TE_MAX
)
93 list_del(&te_data
->list
);
94 te_data
->running
= false;
100 void iwl_mvm_roc_done_wk(struct work_struct
*wk
)
102 struct iwl_mvm
*mvm
= container_of(wk
, struct iwl_mvm
, roc_done_wk
);
107 * Flush the offchannel queue -- this is called when the time
108 * event finishes or is cancelled, so that frames queued for it
109 * won't get stuck on the queue and be transmitted in the next
111 * We have to send the command asynchronously since this cannot
112 * be under the mutex for locking reasons, but that's not an
113 * issue as it will have to complete before the next command is
114 * executed, and a new time event means a new command.
116 iwl_mvm_flush_tx_path(mvm
, BIT(IWL_MVM_OFFCHANNEL_QUEUE
), false);
119 static void iwl_mvm_roc_finished(struct iwl_mvm
*mvm
)
122 * First, clear the ROC_RUNNING status bit. This will cause the TX
123 * path to drop offchannel transmissions. That would also be done
124 * by mac80211, but it is racy, in particular in the case that the
125 * time event actually completed in the firmware (which is handled
126 * in iwl_mvm_te_handle_notif).
128 clear_bit(IWL_MVM_STATUS_ROC_RUNNING
, &mvm
->status
);
129 iwl_mvm_unref(mvm
, IWL_MVM_REF_ROC
);
132 * Of course, our status bit is just as racy as mac80211, so in
133 * addition, fire off the work struct which will drop all frames
134 * from the hardware queues that made it through the race. First
135 * it will of course synchronize the TX path to make sure that
136 * any *new* TX will be rejected.
138 schedule_work(&mvm
->roc_done_wk
);
141 static bool iwl_mvm_te_check_disconnect(struct iwl_mvm
*mvm
,
142 struct ieee80211_vif
*vif
,
145 if (vif
->type
!= NL80211_IFTYPE_STATION
)
147 if (vif
->bss_conf
.assoc
&& vif
->bss_conf
.dtim_period
)
150 IWL_ERR(mvm
, "%s\n", errmsg
);
151 ieee80211_connection_loss(vif
);
156 * Handles a FW notification for an event that is known to the driver.
158 * @mvm: the mvm component
159 * @te_data: the time event data
160 * @notif: the notification data corresponding the time event data.
162 static void iwl_mvm_te_handle_notif(struct iwl_mvm
*mvm
,
163 struct iwl_mvm_time_event_data
*te_data
,
164 struct iwl_time_event_notif
*notif
)
166 lockdep_assert_held(&mvm
->time_event_lock
);
168 IWL_DEBUG_TE(mvm
, "Handle time event notif - UID = 0x%x action %d\n",
169 le32_to_cpu(notif
->unique_id
),
170 le32_to_cpu(notif
->action
));
173 * The FW sends the start/end time event notifications even for events
174 * that it fails to schedule. This is indicated in the status field of
175 * the notification. This happens in cases that the scheduler cannot
176 * find a schedule that can handle the event (for example requesting a
177 * P2P Device discoveribility, while there are other higher priority
178 * events in the system).
180 if (!le32_to_cpu(notif
->status
)) {
181 bool start
= le32_to_cpu(notif
->action
) &
182 TE_V2_NOTIF_HOST_EVENT_START
;
183 IWL_WARN(mvm
, "Time Event %s notification failure\n",
184 start
? "start" : "end");
185 if (iwl_mvm_te_check_disconnect(mvm
, te_data
->vif
, NULL
)) {
186 iwl_mvm_te_clear_data(mvm
, te_data
);
191 if (le32_to_cpu(notif
->action
) & TE_V2_NOTIF_HOST_EVENT_END
) {
193 "TE ended - current time %lu, estimated end %lu\n",
194 jiffies
, te_data
->end_jiffies
);
196 if (te_data
->vif
->type
== NL80211_IFTYPE_P2P_DEVICE
) {
197 ieee80211_remain_on_channel_expired(mvm
->hw
);
198 iwl_mvm_roc_finished(mvm
);
202 * By now, we should have finished association
203 * and know the dtim period.
205 iwl_mvm_te_check_disconnect(mvm
, te_data
->vif
,
206 "No association and the time event is over already...");
207 iwl_mvm_te_clear_data(mvm
, te_data
);
208 } else if (le32_to_cpu(notif
->action
) & TE_V2_NOTIF_HOST_EVENT_START
) {
209 te_data
->running
= true;
210 te_data
->end_jiffies
= TU_TO_EXP_TIME(te_data
->duration
);
212 if (te_data
->vif
->type
== NL80211_IFTYPE_P2P_DEVICE
) {
213 set_bit(IWL_MVM_STATUS_ROC_RUNNING
, &mvm
->status
);
214 iwl_mvm_ref(mvm
, IWL_MVM_REF_ROC
);
215 ieee80211_ready_on_channel(mvm
->hw
);
218 IWL_WARN(mvm
, "Got TE with unknown action\n");
223 * The Rx handler for time event notifications
225 int iwl_mvm_rx_time_event_notif(struct iwl_mvm
*mvm
,
226 struct iwl_rx_cmd_buffer
*rxb
,
227 struct iwl_device_cmd
*cmd
)
229 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
230 struct iwl_time_event_notif
*notif
= (void *)pkt
->data
;
231 struct iwl_mvm_time_event_data
*te_data
, *tmp
;
233 IWL_DEBUG_TE(mvm
, "Time event notification - UID = 0x%x action %d\n",
234 le32_to_cpu(notif
->unique_id
),
235 le32_to_cpu(notif
->action
));
237 spin_lock_bh(&mvm
->time_event_lock
);
238 list_for_each_entry_safe(te_data
, tmp
, &mvm
->time_event_list
, list
) {
239 if (le32_to_cpu(notif
->unique_id
) == te_data
->uid
)
240 iwl_mvm_te_handle_notif(mvm
, te_data
, notif
);
242 spin_unlock_bh(&mvm
->time_event_lock
);
247 static bool iwl_mvm_time_event_response(struct iwl_notif_wait_data
*notif_wait
,
248 struct iwl_rx_packet
*pkt
, void *data
)
250 struct iwl_mvm
*mvm
=
251 container_of(notif_wait
, struct iwl_mvm
, notif_wait
);
252 struct iwl_mvm_time_event_data
*te_data
= data
;
253 struct iwl_time_event_resp
*resp
;
254 int resp_len
= iwl_rx_packet_payload_len(pkt
);
256 if (WARN_ON(pkt
->hdr
.cmd
!= TIME_EVENT_CMD
))
259 if (WARN_ON_ONCE(resp_len
!= sizeof(*resp
))) {
260 IWL_ERR(mvm
, "Invalid TIME_EVENT_CMD response\n");
264 resp
= (void *)pkt
->data
;
266 /* we should never get a response to another TIME_EVENT_CMD here */
267 if (WARN_ON_ONCE(le32_to_cpu(resp
->id
) != te_data
->id
))
270 te_data
->uid
= le32_to_cpu(resp
->unique_id
);
271 IWL_DEBUG_TE(mvm
, "TIME_EVENT_CMD response - UID = 0x%x\n",
276 static int iwl_mvm_time_event_send_add(struct iwl_mvm
*mvm
,
277 struct ieee80211_vif
*vif
,
278 struct iwl_mvm_time_event_data
*te_data
,
279 struct iwl_time_event_cmd
*te_cmd
)
281 static const u8 time_event_response
[] = { TIME_EVENT_CMD
};
282 struct iwl_notification_wait wait_time_event
;
285 lockdep_assert_held(&mvm
->mutex
);
287 IWL_DEBUG_TE(mvm
, "Add new TE, duration %d TU\n",
288 le32_to_cpu(te_cmd
->duration
));
290 spin_lock_bh(&mvm
->time_event_lock
);
291 if (WARN_ON(te_data
->id
!= TE_MAX
)) {
292 spin_unlock_bh(&mvm
->time_event_lock
);
296 te_data
->duration
= le32_to_cpu(te_cmd
->duration
);
297 te_data
->id
= le32_to_cpu(te_cmd
->id
);
298 list_add_tail(&te_data
->list
, &mvm
->time_event_list
);
299 spin_unlock_bh(&mvm
->time_event_lock
);
302 * Use a notification wait, which really just processes the
303 * command response and doesn't wait for anything, in order
304 * to be able to process the response and get the UID inside
305 * the RX path. Using CMD_WANT_SKB doesn't work because it
306 * stores the buffer and then wakes up this thread, by which
307 * time another notification (that the time event started)
308 * might already be processed unsuccessfully.
310 iwl_init_notification_wait(&mvm
->notif_wait
, &wait_time_event
,
312 ARRAY_SIZE(time_event_response
),
313 iwl_mvm_time_event_response
, te_data
);
315 ret
= iwl_mvm_send_cmd_pdu(mvm
, TIME_EVENT_CMD
, 0,
316 sizeof(*te_cmd
), te_cmd
);
318 IWL_ERR(mvm
, "Couldn't send TIME_EVENT_CMD: %d\n", ret
);
319 iwl_remove_notification(&mvm
->notif_wait
, &wait_time_event
);
323 /* No need to wait for anything, so just pass 1 (0 isn't valid) */
324 ret
= iwl_wait_notification(&mvm
->notif_wait
, &wait_time_event
, 1);
325 /* should never fail */
330 spin_lock_bh(&mvm
->time_event_lock
);
331 iwl_mvm_te_clear_data(mvm
, te_data
);
332 spin_unlock_bh(&mvm
->time_event_lock
);
337 void iwl_mvm_protect_session(struct iwl_mvm
*mvm
,
338 struct ieee80211_vif
*vif
,
339 u32 duration
, u32 min_duration
,
342 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
343 struct iwl_mvm_time_event_data
*te_data
= &mvmvif
->time_event_data
;
344 struct iwl_time_event_cmd time_cmd
= {};
346 lockdep_assert_held(&mvm
->mutex
);
348 if (te_data
->running
&&
349 time_after(te_data
->end_jiffies
, TU_TO_EXP_TIME(min_duration
))) {
350 IWL_DEBUG_TE(mvm
, "We have enough time in the current TE: %u\n",
351 jiffies_to_msecs(te_data
->end_jiffies
- jiffies
));
355 if (te_data
->running
) {
356 IWL_DEBUG_TE(mvm
, "extend 0x%x: only %u ms left\n",
358 jiffies_to_msecs(te_data
->end_jiffies
- jiffies
));
360 * we don't have enough time
361 * cancel the current TE and issue a new one
362 * Of course it would be better to remove the old one only
363 * when the new one is added, but we don't care if we are off
364 * channel for a bit. All we need to do, is not to return
365 * before we actually begin to be on the channel.
367 iwl_mvm_stop_session_protection(mvm
, vif
);
370 time_cmd
.action
= cpu_to_le32(FW_CTXT_ACTION_ADD
);
371 time_cmd
.id_and_color
=
372 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif
->id
, mvmvif
->color
));
373 time_cmd
.id
= cpu_to_le32(TE_BSS_STA_AGGRESSIVE_ASSOC
);
375 time_cmd
.apply_time
=
376 cpu_to_le32(iwl_read_prph(mvm
->trans
, DEVICE_SYSTEM_TIME_REG
));
378 time_cmd
.max_frags
= TE_V2_FRAG_NONE
;
379 time_cmd
.max_delay
= cpu_to_le32(max_delay
);
380 /* TODO: why do we need to interval = bi if it is not periodic? */
381 time_cmd
.interval
= cpu_to_le32(1);
382 time_cmd
.duration
= cpu_to_le32(duration
);
384 time_cmd
.policy
= cpu_to_le16(TE_V2_NOTIF_HOST_EVENT_START
|
385 TE_V2_NOTIF_HOST_EVENT_END
|
386 T2_V2_START_IMMEDIATELY
);
388 iwl_mvm_time_event_send_add(mvm
, vif
, te_data
, &time_cmd
);
392 * Explicit request to remove a time event. The removal of a time event needs to
393 * be synchronized with the flow of a time event's end notification, which also
394 * removes the time event from the op mode data structures.
396 void iwl_mvm_remove_time_event(struct iwl_mvm
*mvm
,
397 struct iwl_mvm_vif
*mvmvif
,
398 struct iwl_mvm_time_event_data
*te_data
)
400 struct iwl_time_event_cmd time_cmd
= {};
405 * It is possible that by the time we got to this point the time
406 * event was already removed.
408 spin_lock_bh(&mvm
->time_event_lock
);
410 /* Save time event uid before clearing its data */
415 * The clear_data function handles time events that were already removed
417 iwl_mvm_te_clear_data(mvm
, te_data
);
418 spin_unlock_bh(&mvm
->time_event_lock
);
421 * It is possible that by the time we try to remove it, the time event
422 * has already ended and removed. In such a case there is no need to
423 * send a removal command.
426 IWL_DEBUG_TE(mvm
, "TE 0x%x has already ended\n", uid
);
430 /* When we remove a TE, the UID is to be set in the id field */
431 time_cmd
.id
= cpu_to_le32(uid
);
432 time_cmd
.action
= cpu_to_le32(FW_CTXT_ACTION_REMOVE
);
433 time_cmd
.id_and_color
=
434 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif
->id
, mvmvif
->color
));
436 IWL_DEBUG_TE(mvm
, "Removing TE 0x%x\n", le32_to_cpu(time_cmd
.id
));
437 ret
= iwl_mvm_send_cmd_pdu(mvm
, TIME_EVENT_CMD
, 0,
438 sizeof(time_cmd
), &time_cmd
);
443 void iwl_mvm_stop_session_protection(struct iwl_mvm
*mvm
,
444 struct ieee80211_vif
*vif
)
446 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
447 struct iwl_mvm_time_event_data
*te_data
= &mvmvif
->time_event_data
;
449 lockdep_assert_held(&mvm
->mutex
);
450 iwl_mvm_remove_time_event(mvm
, mvmvif
, te_data
);
453 int iwl_mvm_start_p2p_roc(struct iwl_mvm
*mvm
, struct ieee80211_vif
*vif
,
454 int duration
, enum ieee80211_roc_type type
)
456 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
457 struct iwl_mvm_time_event_data
*te_data
= &mvmvif
->time_event_data
;
458 struct iwl_time_event_cmd time_cmd
= {};
460 lockdep_assert_held(&mvm
->mutex
);
461 if (te_data
->running
) {
462 IWL_WARN(mvm
, "P2P_DEVICE remain on channel already running\n");
467 * Flush the done work, just in case it's still pending, so that
468 * the work it does can complete and we can accept new frames.
470 flush_work(&mvm
->roc_done_wk
);
472 time_cmd
.action
= cpu_to_le32(FW_CTXT_ACTION_ADD
);
473 time_cmd
.id_and_color
=
474 cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif
->id
, mvmvif
->color
));
477 case IEEE80211_ROC_TYPE_NORMAL
:
478 time_cmd
.id
= cpu_to_le32(IWL_MVM_ROC_TE_TYPE_NORMAL
);
480 case IEEE80211_ROC_TYPE_MGMT_TX
:
481 time_cmd
.id
= cpu_to_le32(IWL_MVM_ROC_TE_TYPE_MGMT_TX
);
484 WARN_ONCE(1, "Got an invalid ROC type\n");
488 time_cmd
.apply_time
= cpu_to_le32(0);
489 time_cmd
.interval
= cpu_to_le32(1);
492 * The P2P Device TEs can have lower priority than other events
493 * that are being scheduled by the driver/fw, and thus it might not be
494 * scheduled. To improve the chances of it being scheduled, allow them
495 * to be fragmented, and in addition allow them to be delayed.
497 time_cmd
.max_frags
= min(MSEC_TO_TU(duration
)/50, TE_V2_FRAG_ENDLESS
);
498 time_cmd
.max_delay
= cpu_to_le32(MSEC_TO_TU(duration
/2));
499 time_cmd
.duration
= cpu_to_le32(MSEC_TO_TU(duration
));
501 time_cmd
.policy
= cpu_to_le16(TE_V2_NOTIF_HOST_EVENT_START
|
502 TE_V2_NOTIF_HOST_EVENT_END
|
503 T2_V2_START_IMMEDIATELY
);
505 return iwl_mvm_time_event_send_add(mvm
, vif
, te_data
, &time_cmd
);
508 void iwl_mvm_stop_p2p_roc(struct iwl_mvm
*mvm
)
510 struct iwl_mvm_vif
*mvmvif
;
511 struct iwl_mvm_time_event_data
*te_data
;
513 lockdep_assert_held(&mvm
->mutex
);
516 * Iterate over the list of time events and find the time event that is
517 * associated with a P2P_DEVICE interface.
518 * This assumes that a P2P_DEVICE interface can have only a single time
519 * event at any given time and this time event coresponds to a ROC
523 spin_lock_bh(&mvm
->time_event_lock
);
524 list_for_each_entry(te_data
, &mvm
->time_event_list
, list
) {
525 if (te_data
->vif
->type
== NL80211_IFTYPE_P2P_DEVICE
) {
526 mvmvif
= iwl_mvm_vif_from_mac80211(te_data
->vif
);
530 spin_unlock_bh(&mvm
->time_event_lock
);
533 IWL_WARN(mvm
, "P2P_DEVICE no remain on channel event\n");
537 iwl_mvm_remove_time_event(mvm
, mvmvif
, te_data
);
539 iwl_mvm_roc_finished(mvm
);