2 * Copyright (c) 2008, 2009 open80211s Ltd.
3 * Author: Luis Carlos Cobo <luisca@cozybit.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
10 #include <linux/kernel.h>
11 #include <linux/random.h>
12 #include "ieee80211_i.h"
16 #define PLINK_GET_LLID(p) (p + 2)
17 #define PLINK_GET_PLID(p) (p + 4)
19 #define mod_plink_timer(s, t) (mod_timer(&s->plink_timer, \
20 jiffies + HZ * t / 1000))
22 #define dot11MeshMaxRetries(s) (s->u.mesh.mshcfg.dot11MeshMaxRetries)
23 #define dot11MeshRetryTimeout(s) (s->u.mesh.mshcfg.dot11MeshRetryTimeout)
24 #define dot11MeshConfirmTimeout(s) (s->u.mesh.mshcfg.dot11MeshConfirmTimeout)
25 #define dot11MeshHoldingTimeout(s) (s->u.mesh.mshcfg.dot11MeshHoldingTimeout)
26 #define dot11MeshMaxPeerLinks(s) (s->u.mesh.mshcfg.dot11MeshMaxPeerLinks)
28 /* We only need a valid sta if user configured a minimum rssi_threshold. */
29 #define rssi_threshold_check(sta, sdata) \
30 (sdata->u.mesh.mshcfg.rssi_threshold == 0 ||\
31 (sta && (s8) -ewma_read(&sta->avg_signal) > \
32 sdata->u.mesh.mshcfg.rssi_threshold))
46 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
47 enum ieee80211_self_protected_actioncode action,
48 u8 *da, __le16 llid, __le16 plid, __le16 reason);
51 void mesh_plink_inc_estab_count(struct ieee80211_sub_if_data *sdata)
53 atomic_inc(&sdata->u.mesh.mshstats.estab_plinks);
54 mesh_accept_plinks_update(sdata);
58 void mesh_plink_dec_estab_count(struct ieee80211_sub_if_data *sdata)
60 atomic_dec(&sdata->u.mesh.mshstats.estab_plinks);
61 mesh_accept_plinks_update(sdata);
65 * mesh_plink_fsm_restart - restart a mesh peer link finite state machine
67 * @sta: mesh peer link to restart
69 * Locking: this function must be called holding sta->lock
71 static inline void mesh_plink_fsm_restart(struct sta_info *sta)
73 sta->plink_state = NL80211_PLINK_LISTEN;
74 sta->llid = sta->plid = sta->reason = 0;
75 sta->plink_retries = 0;
79 * Allocate mesh sta entry and insert into station table
81 static struct sta_info *mesh_plink_alloc(struct ieee80211_sub_if_data *sdata,
86 if (sdata->local->num_sta >= MESH_MAX_PLINKS)
89 sta = sta_info_alloc(sdata, hw_addr, GFP_KERNEL);
93 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
94 sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
95 sta_info_pre_move_state(sta, IEEE80211_STA_AUTHORIZED);
97 set_sta_flag(sta, WLAN_STA_WME);
103 * mesh_set_ht_prot_mode - set correct HT protection mode
105 * Section 9.23.3.5 of IEEE 80211-2012 describes the protection rules for HT
106 * mesh STA in a MBSS. Three HT protection modes are supported for now, non-HT
107 * mixed mode, 20MHz-protection and no-protection mode. non-HT mixed mode is
108 * selected if any non-HT peers are present in our MBSS. 20MHz-protection mode
109 * is selected if all peers in our 20/40MHz MBSS support HT and atleast one
110 * HT20 peer is present. Otherwise no-protection mode is selected.
112 static u32 mesh_set_ht_prot_mode(struct ieee80211_sub_if_data *sdata)
114 struct ieee80211_local *local = sdata->local;
115 struct sta_info *sta;
118 bool non_ht_sta = false, ht20_sta = false;
120 if (local->_oper_channel_type == NL80211_CHAN_NO_HT)
124 list_for_each_entry_rcu(sta, &local->sta_list, list) {
125 if (sdata != sta->sdata ||
126 sta->plink_state != NL80211_PLINK_ESTAB)
129 switch (sta->ch_type) {
130 case NL80211_CHAN_NO_HT:
132 "mesh_plink %pM: nonHT sta (%pM) is present\n",
133 sdata->vif.addr, sta->sta.addr);
136 case NL80211_CHAN_HT20:
138 "mesh_plink %pM: HT20 sta (%pM) is present\n",
139 sdata->vif.addr, sta->sta.addr);
149 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED;
150 else if (ht20_sta && local->_oper_channel_type > NL80211_CHAN_HT20)
151 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_20MHZ;
153 ht_opmode = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
155 if (sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
156 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
157 sdata->u.mesh.mshcfg.ht_opmode = ht_opmode;
158 changed = BSS_CHANGED_HT;
160 "mesh_plink %pM: protection mode changed to %d\n",
161 sdata->vif.addr, ht_opmode);
168 * __mesh_plink_deactivate - deactivate mesh peer link
170 * @sta: mesh peer link to deactivate
172 * All mesh paths with this peer as next hop will be flushed
174 * Locking: the caller must hold sta->lock
176 static bool __mesh_plink_deactivate(struct sta_info *sta)
178 struct ieee80211_sub_if_data *sdata = sta->sdata;
179 bool deactivated = false;
181 if (sta->plink_state == NL80211_PLINK_ESTAB) {
182 mesh_plink_dec_estab_count(sdata);
185 sta->plink_state = NL80211_PLINK_BLOCKED;
186 mesh_path_flush_by_nexthop(sta);
192 * mesh_plink_deactivate - deactivate mesh peer link
194 * @sta: mesh peer link to deactivate
196 * All mesh paths with this peer as next hop will be flushed
198 void mesh_plink_deactivate(struct sta_info *sta)
200 struct ieee80211_sub_if_data *sdata = sta->sdata;
203 spin_lock_bh(&sta->lock);
204 deactivated = __mesh_plink_deactivate(sta);
205 sta->reason = cpu_to_le16(WLAN_REASON_MESH_PEER_CANCELED);
206 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
207 sta->sta.addr, sta->llid, sta->plid,
209 spin_unlock_bh(&sta->lock);
212 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
215 static int mesh_plink_frame_tx(struct ieee80211_sub_if_data *sdata,
216 enum ieee80211_self_protected_actioncode action,
217 u8 *da, __le16 llid, __le16 plid, __le16 reason) {
218 struct ieee80211_local *local = sdata->local;
220 struct ieee80211_tx_info *info;
221 struct ieee80211_mgmt *mgmt;
222 bool include_plid = false;
223 u16 peering_proto = 0;
225 int hdr_len = offsetof(struct ieee80211_mgmt, u.action.u.self_prot) +
226 sizeof(mgmt->u.action.u.self_prot);
229 skb = dev_alloc_skb(local->tx_headroom +
231 2 + /* capability info */
233 2 + 8 + /* supported rates */
234 2 + (IEEE80211_MAX_SUPP_RATES - 8) +
235 2 + sdata->u.mesh.mesh_id_len +
236 2 + sizeof(struct ieee80211_meshconf_ie) +
237 2 + sizeof(struct ieee80211_ht_cap) +
238 2 + sizeof(struct ieee80211_ht_operation) +
239 2 + 8 + /* peering IE */
240 sdata->u.mesh.ie_len);
243 info = IEEE80211_SKB_CB(skb);
244 skb_reserve(skb, local->tx_headroom);
245 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len);
246 memset(mgmt, 0, hdr_len);
247 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
248 IEEE80211_STYPE_ACTION);
249 memcpy(mgmt->da, da, ETH_ALEN);
250 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
251 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
252 mgmt->u.action.category = WLAN_CATEGORY_SELF_PROTECTED;
253 mgmt->u.action.u.self_prot.action_code = action;
255 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
256 /* capability info */
257 pos = skb_put(skb, 2);
259 if (action == WLAN_SP_MESH_PEERING_CONFIRM) {
261 pos = skb_put(skb, 2);
262 memcpy(pos + 2, &plid, 2);
264 if (ieee80211_add_srates_ie(sdata, skb, true,
265 local->oper_channel->band) ||
266 ieee80211_add_ext_srates_ie(sdata, skb, true,
267 local->oper_channel->band) ||
268 mesh_add_rsn_ie(skb, sdata) ||
269 mesh_add_meshid_ie(skb, sdata) ||
270 mesh_add_meshconf_ie(skb, sdata))
272 } else { /* WLAN_SP_MESH_PEERING_CLOSE */
273 info->flags |= IEEE80211_TX_CTL_NO_ACK;
274 if (mesh_add_meshid_ie(skb, sdata))
278 /* Add Mesh Peering Management element */
280 case WLAN_SP_MESH_PEERING_OPEN:
282 case WLAN_SP_MESH_PEERING_CONFIRM:
286 case WLAN_SP_MESH_PEERING_CLOSE:
291 ie_len += 2; /* reason code */
298 if (WARN_ON(skb_tailroom(skb) < 2 + ie_len))
301 pos = skb_put(skb, 2 + ie_len);
302 *pos++ = WLAN_EID_PEER_MGMT;
304 memcpy(pos, &peering_proto, 2);
306 memcpy(pos, &llid, 2);
309 memcpy(pos, &plid, 2);
312 if (action == WLAN_SP_MESH_PEERING_CLOSE) {
313 memcpy(pos, &reason, 2);
317 if (action != WLAN_SP_MESH_PEERING_CLOSE) {
318 if (mesh_add_ht_cap_ie(skb, sdata) ||
319 mesh_add_ht_oper_ie(skb, sdata))
323 if (mesh_add_vendor_ies(skb, sdata))
326 ieee80211_tx_skb(sdata, skb);
334 * mesh_peer_init - initialize new mesh peer and return resulting sta_info
336 * @sdata: local meshif
337 * @addr: peer's address
338 * @elems: IEs from beacon or mesh peering frame
342 static struct sta_info *mesh_peer_init(struct ieee80211_sub_if_data *sdata,
344 struct ieee802_11_elems *elems)
346 struct ieee80211_local *local = sdata->local;
347 enum ieee80211_band band = local->oper_channel->band;
348 struct ieee80211_supported_band *sband;
349 u32 rates, basic_rates = 0;
350 struct sta_info *sta;
353 sband = local->hw.wiphy->bands[band];
354 rates = ieee80211_sta_get_rates(local, elems, band, &basic_rates);
356 sta = sta_info_get(sdata, addr);
358 /* Userspace handles peer allocation when security is enabled */
359 if (sdata->u.mesh.security & IEEE80211_MESH_SEC_AUTHED) {
360 cfg80211_notify_new_peer_candidate(sdata->dev, addr,
367 sta = mesh_plink_alloc(sdata, addr);
373 spin_lock_bh(&sta->lock);
374 sta->last_rx = jiffies;
375 if (sta->plink_state == NL80211_PLINK_ESTAB) {
376 spin_unlock_bh(&sta->lock);
380 sta->sta.supp_rates[band] = rates;
381 if (elems->ht_cap_elem &&
382 sdata->local->_oper_channel_type != NL80211_CHAN_NO_HT)
383 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
387 memset(&sta->sta.ht_cap, 0, sizeof(sta->sta.ht_cap));
389 if (elems->ht_operation) {
390 if (!(elems->ht_operation->ht_param &
391 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
392 sta->sta.ht_cap.cap &=
393 ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
395 ieee80211_ht_oper_to_channel_type(elems->ht_operation);
398 rate_control_rate_init(sta);
399 spin_unlock_bh(&sta->lock);
401 if (insert && sta_info_insert(sta))
407 void mesh_neighbour_update(struct ieee80211_sub_if_data *sdata,
409 struct ieee802_11_elems *elems)
411 struct sta_info *sta;
414 sta = mesh_peer_init(sdata, hw_addr, elems);
418 if (mesh_peer_accepts_plinks(elems) &&
419 sta->plink_state == NL80211_PLINK_LISTEN &&
420 sdata->u.mesh.accepting_plinks &&
421 sdata->u.mesh.mshcfg.auto_open_plinks &&
422 rssi_threshold_check(sta, sdata))
423 mesh_plink_open(sta);
429 static void mesh_plink_timer(unsigned long data)
431 struct sta_info *sta;
432 __le16 llid, plid, reason;
433 struct ieee80211_sub_if_data *sdata;
436 * This STA is valid because sta_info_destroy() will
437 * del_timer_sync() this timer after having made sure
438 * it cannot be readded (by deleting the plink.)
440 sta = (struct sta_info *) data;
442 if (sta->sdata->local->quiescing) {
443 sta->plink_timer_was_running = true;
447 spin_lock_bh(&sta->lock);
448 if (sta->ignore_plink_timer) {
449 sta->ignore_plink_timer = false;
450 spin_unlock_bh(&sta->lock);
454 "Mesh plink timer for %pM fired on state %d\n",
455 sta->sta.addr, sta->plink_state);
461 switch (sta->plink_state) {
462 case NL80211_PLINK_OPN_RCVD:
463 case NL80211_PLINK_OPN_SNT:
465 if (sta->plink_retries < dot11MeshMaxRetries(sdata)) {
468 "Mesh plink for %pM (retry, timeout): %d %d\n",
469 sta->sta.addr, sta->plink_retries,
471 get_random_bytes(&rand, sizeof(u32));
472 sta->plink_timeout = sta->plink_timeout +
473 rand % sta->plink_timeout;
474 ++sta->plink_retries;
475 mod_plink_timer(sta, sta->plink_timeout);
476 spin_unlock_bh(&sta->lock);
477 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
478 sta->sta.addr, llid, 0, 0);
481 reason = cpu_to_le16(WLAN_REASON_MESH_MAX_RETRIES);
482 /* fall through on else */
483 case NL80211_PLINK_CNF_RCVD:
486 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIRM_TIMEOUT);
487 sta->plink_state = NL80211_PLINK_HOLDING;
488 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
489 spin_unlock_bh(&sta->lock);
490 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
491 sta->sta.addr, llid, plid, reason);
493 case NL80211_PLINK_HOLDING:
495 del_timer(&sta->plink_timer);
496 mesh_plink_fsm_restart(sta);
497 spin_unlock_bh(&sta->lock);
500 spin_unlock_bh(&sta->lock);
506 void mesh_plink_quiesce(struct sta_info *sta)
508 if (del_timer_sync(&sta->plink_timer))
509 sta->plink_timer_was_running = true;
512 void mesh_plink_restart(struct sta_info *sta)
514 if (sta->plink_timer_was_running) {
515 add_timer(&sta->plink_timer);
516 sta->plink_timer_was_running = false;
521 static inline void mesh_plink_timer_set(struct sta_info *sta, int timeout)
523 sta->plink_timer.expires = jiffies + (HZ * timeout / 1000);
524 sta->plink_timer.data = (unsigned long) sta;
525 sta->plink_timer.function = mesh_plink_timer;
526 sta->plink_timeout = timeout;
527 add_timer(&sta->plink_timer);
530 int mesh_plink_open(struct sta_info *sta)
533 struct ieee80211_sub_if_data *sdata = sta->sdata;
535 if (!test_sta_flag(sta, WLAN_STA_AUTH))
538 spin_lock_bh(&sta->lock);
539 get_random_bytes(&llid, 2);
541 if (sta->plink_state != NL80211_PLINK_LISTEN) {
542 spin_unlock_bh(&sta->lock);
545 sta->plink_state = NL80211_PLINK_OPN_SNT;
546 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
547 spin_unlock_bh(&sta->lock);
549 "Mesh plink: starting establishment with %pM\n",
552 return mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_OPEN,
553 sta->sta.addr, llid, 0, 0);
556 void mesh_plink_block(struct sta_info *sta)
558 struct ieee80211_sub_if_data *sdata = sta->sdata;
561 spin_lock_bh(&sta->lock);
562 deactivated = __mesh_plink_deactivate(sta);
563 sta->plink_state = NL80211_PLINK_BLOCKED;
564 spin_unlock_bh(&sta->lock);
567 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON);
571 void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata, struct ieee80211_mgmt *mgmt,
572 size_t len, struct ieee80211_rx_status *rx_status)
574 struct ieee802_11_elems elems;
575 struct sta_info *sta;
576 enum plink_event event;
577 enum ieee80211_self_protected_actioncode ftype;
579 bool matches_local = true;
583 __le16 plid, llid, reason;
584 static const char *mplstates[] = {
585 [NL80211_PLINK_LISTEN] = "LISTEN",
586 [NL80211_PLINK_OPN_SNT] = "OPN-SNT",
587 [NL80211_PLINK_OPN_RCVD] = "OPN-RCVD",
588 [NL80211_PLINK_CNF_RCVD] = "CNF_RCVD",
589 [NL80211_PLINK_ESTAB] = "ESTAB",
590 [NL80211_PLINK_HOLDING] = "HOLDING",
591 [NL80211_PLINK_BLOCKED] = "BLOCKED"
594 /* need action_code, aux */
595 if (len < IEEE80211_MIN_ACTION_SIZE + 3)
598 if (is_multicast_ether_addr(mgmt->da)) {
600 "Mesh plink: ignore frame from multicast address\n");
604 baseaddr = mgmt->u.action.u.self_prot.variable;
605 baselen = (u8 *) mgmt->u.action.u.self_prot.variable - (u8 *) mgmt;
606 if (mgmt->u.action.u.self_prot.action_code ==
607 WLAN_SP_MESH_PEERING_CONFIRM) {
611 ieee802_11_parse_elems(baseaddr, len - baselen, &elems);
612 if (!elems.peering) {
614 "Mesh plink: missing necessary peer link ie\n");
618 sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) {
620 "Mesh plink: can't establish link with secure peer\n");
624 ftype = mgmt->u.action.u.self_prot.action_code;
625 ie_len = elems.peering_len;
626 if ((ftype == WLAN_SP_MESH_PEERING_OPEN && ie_len != 4) ||
627 (ftype == WLAN_SP_MESH_PEERING_CONFIRM && ie_len != 6) ||
628 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len != 6
631 "Mesh plink: incorrect plink ie length %d %d\n",
636 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
637 (!elems.mesh_id || !elems.mesh_config)) {
638 mpl_dbg(sdata, "Mesh plink: missing necessary ie\n");
641 /* Note the lines below are correct, the llid in the frame is the plid
642 * from the point of view of this host.
644 memcpy(&plid, PLINK_GET_LLID(elems.peering), 2);
645 if (ftype == WLAN_SP_MESH_PEERING_CONFIRM ||
646 (ftype == WLAN_SP_MESH_PEERING_CLOSE && ie_len == 8))
647 memcpy(&llid, PLINK_GET_PLID(elems.peering), 2);
651 sta = sta_info_get(sdata, mgmt->sa);
652 if (!sta && ftype != WLAN_SP_MESH_PEERING_OPEN) {
653 mpl_dbg(sdata, "Mesh plink: cls or cnf from unknown peer\n");
658 if (ftype == WLAN_SP_MESH_PEERING_OPEN &&
659 !rssi_threshold_check(sta, sdata)) {
660 mpl_dbg(sdata, "Mesh plink: %pM does not meet rssi threshold\n",
666 if (sta && !test_sta_flag(sta, WLAN_STA_AUTH)) {
667 mpl_dbg(sdata, "Mesh plink: Action frame from non-authed peer\n");
672 if (sta && sta->plink_state == NL80211_PLINK_BLOCKED) {
677 /* Now we will figure out the appropriate event... */
678 event = PLINK_UNDEFINED;
679 if (ftype != WLAN_SP_MESH_PEERING_CLOSE &&
680 !mesh_matches_local(sdata, &elems)) {
681 matches_local = false;
683 case WLAN_SP_MESH_PEERING_OPEN:
686 case WLAN_SP_MESH_PEERING_CONFIRM:
694 if (!sta && !matches_local) {
696 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
698 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
699 mgmt->sa, llid, plid, reason);
702 /* ftype == WLAN_SP_MESH_PEERING_OPEN */
703 if (!mesh_plink_free_count(sdata)) {
704 mpl_dbg(sdata, "Mesh plink error: no more free plinks\n");
709 } else if (matches_local) {
711 case WLAN_SP_MESH_PEERING_OPEN:
712 if (!mesh_plink_free_count(sdata) ||
713 (sta->plid && sta->plid != plid))
718 case WLAN_SP_MESH_PEERING_CONFIRM:
719 if (!mesh_plink_free_count(sdata) ||
720 (sta->llid != llid || sta->plid != plid))
725 case WLAN_SP_MESH_PEERING_CLOSE:
726 if (sta->plink_state == NL80211_PLINK_ESTAB)
727 /* Do not check for llid or plid. This does not
728 * follow the standard but since multiple plinks
729 * per sta are not supported, it is necessary in
730 * order to avoid a livelock when MP A sees an
731 * establish peer link to MP B but MP B does not
732 * see it. This can be caused by a timeout in
733 * B's peer link establishment or B beign
737 else if (sta->plid != plid)
739 else if (ie_len == 7 && sta->llid != llid)
745 mpl_dbg(sdata, "Mesh plink: unknown frame subtype\n");
751 if (event == OPN_ACPT) {
752 /* allocate sta entry if necessary and update info */
753 sta = mesh_peer_init(sdata, mgmt->sa, &elems);
755 mpl_dbg(sdata, "Mesh plink: failed to init peer!\n");
762 "Mesh plink (peer, state, llid, plid, event): %pM %s %d %d %d\n",
763 mgmt->sa, mplstates[sta->plink_state],
764 le16_to_cpu(sta->llid), le16_to_cpu(sta->plid),
767 spin_lock_bh(&sta->lock);
768 switch (sta->plink_state) {
769 /* spin_unlock as soon as state is updated at each case */
770 case NL80211_PLINK_LISTEN:
773 mesh_plink_fsm_restart(sta);
774 spin_unlock_bh(&sta->lock);
777 sta->plink_state = NL80211_PLINK_OPN_RCVD;
779 get_random_bytes(&llid, 2);
781 mesh_plink_timer_set(sta, dot11MeshRetryTimeout(sdata));
782 spin_unlock_bh(&sta->lock);
783 mesh_plink_frame_tx(sdata,
784 WLAN_SP_MESH_PEERING_OPEN,
785 sta->sta.addr, llid, 0, 0);
786 mesh_plink_frame_tx(sdata,
787 WLAN_SP_MESH_PEERING_CONFIRM,
788 sta->sta.addr, llid, plid, 0);
791 spin_unlock_bh(&sta->lock);
796 case NL80211_PLINK_OPN_SNT:
800 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
803 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
804 sta->reason = reason;
805 sta->plink_state = NL80211_PLINK_HOLDING;
806 if (!mod_plink_timer(sta,
807 dot11MeshHoldingTimeout(sdata)))
808 sta->ignore_plink_timer = true;
811 spin_unlock_bh(&sta->lock);
812 mesh_plink_frame_tx(sdata,
813 WLAN_SP_MESH_PEERING_CLOSE,
814 sta->sta.addr, llid, plid, reason);
817 /* retry timer is left untouched */
818 sta->plink_state = NL80211_PLINK_OPN_RCVD;
821 spin_unlock_bh(&sta->lock);
822 mesh_plink_frame_tx(sdata,
823 WLAN_SP_MESH_PEERING_CONFIRM,
824 sta->sta.addr, llid, plid, 0);
827 sta->plink_state = NL80211_PLINK_CNF_RCVD;
828 if (!mod_plink_timer(sta,
829 dot11MeshConfirmTimeout(sdata)))
830 sta->ignore_plink_timer = true;
832 spin_unlock_bh(&sta->lock);
835 spin_unlock_bh(&sta->lock);
840 case NL80211_PLINK_OPN_RCVD:
844 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
847 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
848 sta->reason = reason;
849 sta->plink_state = NL80211_PLINK_HOLDING;
850 if (!mod_plink_timer(sta,
851 dot11MeshHoldingTimeout(sdata)))
852 sta->ignore_plink_timer = true;
855 spin_unlock_bh(&sta->lock);
856 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
857 sta->sta.addr, llid, plid, reason);
861 spin_unlock_bh(&sta->lock);
862 mesh_plink_frame_tx(sdata,
863 WLAN_SP_MESH_PEERING_CONFIRM,
864 sta->sta.addr, llid, plid, 0);
867 del_timer(&sta->plink_timer);
868 sta->plink_state = NL80211_PLINK_ESTAB;
869 spin_unlock_bh(&sta->lock);
870 mesh_plink_inc_estab_count(sdata);
871 changed |= mesh_set_ht_prot_mode(sdata);
872 changed |= BSS_CHANGED_BEACON;
873 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
877 spin_unlock_bh(&sta->lock);
882 case NL80211_PLINK_CNF_RCVD:
886 reason = cpu_to_le16(WLAN_REASON_MESH_CONFIG);
889 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
890 sta->reason = reason;
891 sta->plink_state = NL80211_PLINK_HOLDING;
892 if (!mod_plink_timer(sta,
893 dot11MeshHoldingTimeout(sdata)))
894 sta->ignore_plink_timer = true;
897 spin_unlock_bh(&sta->lock);
898 mesh_plink_frame_tx(sdata,
899 WLAN_SP_MESH_PEERING_CLOSE,
900 sta->sta.addr, llid, plid, reason);
903 del_timer(&sta->plink_timer);
904 sta->plink_state = NL80211_PLINK_ESTAB;
905 spin_unlock_bh(&sta->lock);
906 mesh_plink_inc_estab_count(sdata);
907 changed |= mesh_set_ht_prot_mode(sdata);
908 changed |= BSS_CHANGED_BEACON;
909 mpl_dbg(sdata, "Mesh plink with %pM ESTABLISHED\n",
911 mesh_plink_frame_tx(sdata,
912 WLAN_SP_MESH_PEERING_CONFIRM,
913 sta->sta.addr, llid, plid, 0);
916 spin_unlock_bh(&sta->lock);
921 case NL80211_PLINK_ESTAB:
924 reason = cpu_to_le16(WLAN_REASON_MESH_CLOSE);
925 sta->reason = reason;
926 __mesh_plink_deactivate(sta);
927 sta->plink_state = NL80211_PLINK_HOLDING;
929 mod_plink_timer(sta, dot11MeshHoldingTimeout(sdata));
930 spin_unlock_bh(&sta->lock);
931 changed |= mesh_set_ht_prot_mode(sdata);
932 changed |= BSS_CHANGED_BEACON;
933 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
934 sta->sta.addr, llid, plid, reason);
938 spin_unlock_bh(&sta->lock);
939 mesh_plink_frame_tx(sdata,
940 WLAN_SP_MESH_PEERING_CONFIRM,
941 sta->sta.addr, llid, plid, 0);
944 spin_unlock_bh(&sta->lock);
948 case NL80211_PLINK_HOLDING:
951 if (del_timer(&sta->plink_timer))
952 sta->ignore_plink_timer = 1;
953 mesh_plink_fsm_restart(sta);
954 spin_unlock_bh(&sta->lock);
961 reason = sta->reason;
962 spin_unlock_bh(&sta->lock);
963 mesh_plink_frame_tx(sdata, WLAN_SP_MESH_PEERING_CLOSE,
964 sta->sta.addr, llid, plid, reason);
967 spin_unlock_bh(&sta->lock);
971 /* should not get here, PLINK_BLOCKED is dealt with at the
972 * beginning of the function
974 spin_unlock_bh(&sta->lock);
981 ieee80211_bss_info_change_notify(sdata, changed);