1 /* 2 * Off-channel operation helpers 3 * 4 * Copyright 2003, Jouni Malinen <jkmaline@cc.hut.fi> 5 * Copyright 2004, Instant802 Networks, Inc. 6 * Copyright 2005, Devicescape Software, Inc. 7 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz> 8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net> 9 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License version 2 as 13 * published by the Free Software Foundation. 14 */ 15 #include <linux/export.h> 16 #include <net/mac80211.h> 17 #include "ieee80211_i.h" 18 #include "driver-ops.h" 19 20 /* 21 * Tell our hardware to disable PS. 22 * Optionally inform AP that we will go to sleep so that it will buffer 23 * the frames while we are doing off-channel work. This is optional 24 * because we *may* be doing work on-operating channel, and want our 25 * hardware unconditionally awake, but still let the AP send us normal frames. 26 */ 27 static void ieee80211_offchannel_ps_enable(struct ieee80211_sub_if_data *sdata) 28 { 29 struct ieee80211_local *local = sdata->local; 30 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd; 31 32 local->offchannel_ps_enabled = false; 33 34 /* FIXME: what to do when local->pspolling is true? */ 35 36 del_timer_sync(&local->dynamic_ps_timer); 37 del_timer_sync(&ifmgd->bcn_mon_timer); 38 del_timer_sync(&ifmgd->conn_mon_timer); 39 40 cancel_work_sync(&local->dynamic_ps_enable_work); 41 42 if (local->hw.conf.flags & IEEE80211_CONF_PS) { 43 local->offchannel_ps_enabled = true; 44 local->hw.conf.flags &= ~IEEE80211_CONF_PS; 45 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 46 } 47 48 if (!local->offchannel_ps_enabled || 49 !(local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)) 50 /* 51 * If power save was enabled, no need to send a nullfunc 52 * frame because AP knows that we are sleeping. But if the 53 * hardware is creating the nullfunc frame for power save 54 * status (ie. IEEE80211_HW_PS_NULLFUNC_STACK is not 55 * enabled) and power save was enabled, the firmware just 56 * sent a null frame with power save disabled. So we need 57 * to send a new nullfunc frame to inform the AP that we 58 * are again sleeping. 59 */ 60 ieee80211_send_nullfunc(local, sdata, 1); 61 } 62 63 /* inform AP that we are awake again, unless power save is enabled */ 64 static void ieee80211_offchannel_ps_disable(struct ieee80211_sub_if_data *sdata) 65 { 66 struct ieee80211_local *local = sdata->local; 67 68 if (!local->ps_sdata) 69 ieee80211_send_nullfunc(local, sdata, 0); 70 else if (local->offchannel_ps_enabled) { 71 /* 72 * In !IEEE80211_HW_PS_NULLFUNC_STACK case the hardware 73 * will send a nullfunc frame with the powersave bit set 74 * even though the AP already knows that we are sleeping. 75 * This could be avoided by sending a null frame with power 76 * save bit disabled before enabling the power save, but 77 * this doesn't gain anything. 78 * 79 * When IEEE80211_HW_PS_NULLFUNC_STACK is enabled, no need 80 * to send a nullfunc frame because AP already knows that 81 * we are sleeping, let's just enable power save mode in 82 * hardware. 83 */ 84 /* TODO: Only set hardware if CONF_PS changed? 85 * TODO: Should we set offchannel_ps_enabled to false? 86 */ 87 local->hw.conf.flags |= IEEE80211_CONF_PS; 88 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS); 89 } else if (local->hw.conf.dynamic_ps_timeout > 0) { 90 /* 91 * If IEEE80211_CONF_PS was not set and the dynamic_ps_timer 92 * had been running before leaving the operating channel, 93 * restart the timer now and send a nullfunc frame to inform 94 * the AP that we are awake. 95 */ 96 ieee80211_send_nullfunc(local, sdata, 0); 97 mod_timer(&local->dynamic_ps_timer, jiffies + 98 msecs_to_jiffies(local->hw.conf.dynamic_ps_timeout)); 99 } 100 101 ieee80211_sta_reset_beacon_monitor(sdata); 102 ieee80211_sta_reset_conn_monitor(sdata); 103 } 104 105 void ieee80211_offchannel_stop_vifs(struct ieee80211_local *local, 106 bool offchannel_ps_enable) 107 { 108 struct ieee80211_sub_if_data *sdata; 109 110 if (WARN_ON(local->use_chanctx)) 111 return; 112 113 /* 114 * notify the AP about us leaving the channel and stop all 115 * STA interfaces. 116 */ 117 mutex_lock(&local->iflist_mtx); 118 list_for_each_entry(sdata, &local->interfaces, list) { 119 if (!ieee80211_sdata_running(sdata)) 120 continue; 121 122 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) 123 continue; 124 125 if (sdata->vif.type != NL80211_IFTYPE_MONITOR) 126 set_bit(SDATA_STATE_OFFCHANNEL, &sdata->state); 127 128 /* Check to see if we should disable beaconing. */ 129 if (sdata->vif.type == NL80211_IFTYPE_AP || 130 sdata->vif.type == NL80211_IFTYPE_ADHOC || 131 sdata->vif.type == NL80211_IFTYPE_MESH_POINT) 132 ieee80211_bss_info_change_notify( 133 sdata, BSS_CHANGED_BEACON_ENABLED); 134 135 if (sdata->vif.type != NL80211_IFTYPE_MONITOR) { 136 netif_tx_stop_all_queues(sdata->dev); 137 if (offchannel_ps_enable && 138 (sdata->vif.type == NL80211_IFTYPE_STATION) && 139 sdata->u.mgd.associated) 140 ieee80211_offchannel_ps_enable(sdata); 141 } 142 } 143 mutex_unlock(&local->iflist_mtx); 144 } 145 146 void ieee80211_offchannel_return(struct ieee80211_local *local, 147 bool offchannel_ps_disable) 148 { 149 struct ieee80211_sub_if_data *sdata; 150 151 if (WARN_ON(local->use_chanctx)) 152 return; 153 154 mutex_lock(&local->iflist_mtx); 155 list_for_each_entry(sdata, &local->interfaces, list) { 156 if (sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE) 157 continue; 158 159 if (sdata->vif.type != NL80211_IFTYPE_MONITOR) 160 clear_bit(SDATA_STATE_OFFCHANNEL, &sdata->state); 161 162 if (!ieee80211_sdata_running(sdata)) 163 continue; 164 165 /* Tell AP we're back */ 166 if (offchannel_ps_disable && 167 sdata->vif.type == NL80211_IFTYPE_STATION) { 168 if (sdata->u.mgd.associated) 169 ieee80211_offchannel_ps_disable(sdata); 170 } 171 172 if (sdata->vif.type != NL80211_IFTYPE_MONITOR) { 173 /* 174 * This may wake up queues even though the driver 175 * currently has them stopped. This is not very 176 * likely, since the driver won't have gotten any 177 * (or hardly any) new packets while we weren't 178 * on the right channel, and even if it happens 179 * it will at most lead to queueing up one more 180 * packet per queue in mac80211 rather than on 181 * the interface qdisc. 182 */ 183 netif_tx_wake_all_queues(sdata->dev); 184 } 185 186 if (sdata->vif.type == NL80211_IFTYPE_AP || 187 sdata->vif.type == NL80211_IFTYPE_ADHOC || 188 sdata->vif.type == NL80211_IFTYPE_MESH_POINT) 189 ieee80211_bss_info_change_notify( 190 sdata, BSS_CHANGED_BEACON_ENABLED); 191 } 192 mutex_unlock(&local->iflist_mtx); 193 } 194 195 void ieee80211_handle_roc_started(struct ieee80211_roc_work *roc) 196 { 197 if (roc->notified) 198 return; 199 200 if (roc->mgmt_tx_cookie) { 201 if (!WARN_ON(!roc->frame)) { 202 ieee80211_tx_skb(roc->sdata, roc->frame); 203 roc->frame = NULL; 204 } 205 } else { 206 cfg80211_ready_on_channel(&roc->sdata->wdev, (unsigned long)roc, 207 roc->chan, roc->chan_type, 208 roc->req_duration, GFP_KERNEL); 209 } 210 211 roc->notified = true; 212 } 213 214 static void ieee80211_hw_roc_start(struct work_struct *work) 215 { 216 struct ieee80211_local *local = 217 container_of(work, struct ieee80211_local, hw_roc_start); 218 struct ieee80211_roc_work *roc, *dep, *tmp; 219 220 mutex_lock(&local->mtx); 221 222 if (list_empty(&local->roc_list)) 223 goto out_unlock; 224 225 roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work, 226 list); 227 228 if (!roc->started) 229 goto out_unlock; 230 231 roc->hw_begun = true; 232 roc->hw_start_time = local->hw_roc_start_time; 233 234 ieee80211_handle_roc_started(roc); 235 list_for_each_entry_safe(dep, tmp, &roc->dependents, list) { 236 ieee80211_handle_roc_started(dep); 237 238 if (dep->duration > roc->duration) { 239 u32 dur = dep->duration; 240 dep->duration = dur - roc->duration; 241 roc->duration = dur; 242 list_move(&dep->list, &roc->list); 243 } 244 } 245 out_unlock: 246 mutex_unlock(&local->mtx); 247 } 248 249 void ieee80211_ready_on_channel(struct ieee80211_hw *hw) 250 { 251 struct ieee80211_local *local = hw_to_local(hw); 252 253 local->hw_roc_start_time = jiffies; 254 255 trace_api_ready_on_channel(local); 256 257 ieee80211_queue_work(hw, &local->hw_roc_start); 258 } 259 EXPORT_SYMBOL_GPL(ieee80211_ready_on_channel); 260 261 void ieee80211_start_next_roc(struct ieee80211_local *local) 262 { 263 struct ieee80211_roc_work *roc; 264 265 lockdep_assert_held(&local->mtx); 266 267 if (list_empty(&local->roc_list)) { 268 ieee80211_run_deferred_scan(local); 269 return; 270 } 271 272 roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work, 273 list); 274 275 if (WARN_ON_ONCE(roc->started)) 276 return; 277 278 if (local->ops->remain_on_channel) { 279 int ret, duration = roc->duration; 280 281 /* XXX: duplicated, see ieee80211_start_roc_work() */ 282 if (!duration) 283 duration = 10; 284 285 ret = drv_remain_on_channel(local, roc->chan, 286 roc->chan_type, 287 duration); 288 289 roc->started = true; 290 291 if (ret) { 292 wiphy_warn(local->hw.wiphy, 293 "failed to start next HW ROC (%d)\n", ret); 294 /* 295 * queue the work struct again to avoid recursion 296 * when multiple failures occur 297 */ 298 ieee80211_remain_on_channel_expired(&local->hw); 299 } 300 } else { 301 /* delay it a bit */ 302 ieee80211_queue_delayed_work(&local->hw, &roc->work, 303 round_jiffies_relative(HZ/2)); 304 } 305 } 306 307 void ieee80211_roc_notify_destroy(struct ieee80211_roc_work *roc) 308 { 309 struct ieee80211_roc_work *dep, *tmp; 310 311 /* was never transmitted */ 312 if (roc->frame) { 313 cfg80211_mgmt_tx_status(&roc->sdata->wdev, 314 (unsigned long)roc->frame, 315 roc->frame->data, roc->frame->len, 316 false, GFP_KERNEL); 317 kfree_skb(roc->frame); 318 } 319 320 if (!roc->mgmt_tx_cookie) 321 cfg80211_remain_on_channel_expired(&roc->sdata->wdev, 322 (unsigned long)roc, 323 roc->chan, roc->chan_type, 324 GFP_KERNEL); 325 326 list_for_each_entry_safe(dep, tmp, &roc->dependents, list) 327 ieee80211_roc_notify_destroy(dep); 328 329 kfree(roc); 330 } 331 332 void ieee80211_sw_roc_work(struct work_struct *work) 333 { 334 struct ieee80211_roc_work *roc = 335 container_of(work, struct ieee80211_roc_work, work.work); 336 struct ieee80211_sub_if_data *sdata = roc->sdata; 337 struct ieee80211_local *local = sdata->local; 338 bool started; 339 340 mutex_lock(&local->mtx); 341 342 if (roc->abort) 343 goto finish; 344 345 if (WARN_ON(list_empty(&local->roc_list))) 346 goto out_unlock; 347 348 if (WARN_ON(roc != list_first_entry(&local->roc_list, 349 struct ieee80211_roc_work, 350 list))) 351 goto out_unlock; 352 353 if (!roc->started) { 354 struct ieee80211_roc_work *dep; 355 356 /* start this ROC */ 357 358 /* switch channel etc */ 359 ieee80211_recalc_idle(local); 360 361 local->tmp_channel = roc->chan; 362 local->tmp_channel_type = roc->chan_type; 363 ieee80211_hw_config(local, 0); 364 365 /* tell userspace or send frame */ 366 ieee80211_handle_roc_started(roc); 367 list_for_each_entry(dep, &roc->dependents, list) 368 ieee80211_handle_roc_started(dep); 369 370 /* if it was pure TX, just finish right away */ 371 if (!roc->duration) 372 goto finish; 373 374 roc->started = true; 375 ieee80211_queue_delayed_work(&local->hw, &roc->work, 376 msecs_to_jiffies(roc->duration)); 377 } else { 378 /* finish this ROC */ 379 finish: 380 list_del(&roc->list); 381 started = roc->started; 382 ieee80211_roc_notify_destroy(roc); 383 384 if (started) { 385 drv_flush(local, false); 386 387 local->tmp_channel = NULL; 388 ieee80211_hw_config(local, 0); 389 390 ieee80211_offchannel_return(local, true); 391 } 392 393 ieee80211_recalc_idle(local); 394 395 if (started) 396 ieee80211_start_next_roc(local); 397 } 398 399 out_unlock: 400 mutex_unlock(&local->mtx); 401 } 402 403 static void ieee80211_hw_roc_done(struct work_struct *work) 404 { 405 struct ieee80211_local *local = 406 container_of(work, struct ieee80211_local, hw_roc_done); 407 struct ieee80211_roc_work *roc; 408 409 mutex_lock(&local->mtx); 410 411 if (list_empty(&local->roc_list)) 412 goto out_unlock; 413 414 roc = list_first_entry(&local->roc_list, struct ieee80211_roc_work, 415 list); 416 417 if (!roc->started) 418 goto out_unlock; 419 420 list_del(&roc->list); 421 422 ieee80211_roc_notify_destroy(roc); 423 424 /* if there's another roc, start it now */ 425 ieee80211_start_next_roc(local); 426 427 out_unlock: 428 mutex_unlock(&local->mtx); 429 } 430 431 void ieee80211_remain_on_channel_expired(struct ieee80211_hw *hw) 432 { 433 struct ieee80211_local *local = hw_to_local(hw); 434 435 trace_api_remain_on_channel_expired(local); 436 437 ieee80211_queue_work(hw, &local->hw_roc_done); 438 } 439 EXPORT_SYMBOL_GPL(ieee80211_remain_on_channel_expired); 440 441 void ieee80211_roc_setup(struct ieee80211_local *local) 442 { 443 INIT_WORK(&local->hw_roc_start, ieee80211_hw_roc_start); 444 INIT_WORK(&local->hw_roc_done, ieee80211_hw_roc_done); 445 INIT_LIST_HEAD(&local->roc_list); 446 } 447 448 void ieee80211_roc_purge(struct ieee80211_sub_if_data *sdata) 449 { 450 struct ieee80211_local *local = sdata->local; 451 struct ieee80211_roc_work *roc, *tmp; 452 LIST_HEAD(tmp_list); 453 454 mutex_lock(&local->mtx); 455 list_for_each_entry_safe(roc, tmp, &local->roc_list, list) { 456 if (roc->sdata != sdata) 457 continue; 458 459 if (roc->started && local->ops->remain_on_channel) { 460 /* can race, so ignore return value */ 461 drv_cancel_remain_on_channel(local); 462 } 463 464 list_move_tail(&roc->list, &tmp_list); 465 roc->abort = true; 466 } 467 468 ieee80211_start_next_roc(local); 469 mutex_unlock(&local->mtx); 470 471 list_for_each_entry_safe(roc, tmp, &tmp_list, list) { 472 if (local->ops->remain_on_channel) { 473 list_del(&roc->list); 474 ieee80211_roc_notify_destroy(roc); 475 } else { 476 ieee80211_queue_delayed_work(&local->hw, &roc->work, 0); 477 478 /* work will clean up etc */ 479 flush_delayed_work(&roc->work); 480 } 481 } 482 483 WARN_ON_ONCE(!list_empty(&tmp_list)); 484 } 485