Merge branch 'for-linus' of git://git.kernel.dk/linux-block
[linux-2.6-microblaze.git] / net / mac80211 / ocb.c
1 /*
2  * OCB mode implementation
3  *
4  * Copyright: (c) 2014 Czech Technical University in Prague
5  *            (c) 2014 Volkswagen Group Research
6  * Author:    Rostislav Lisovy <rostislav.lisovy@fel.cvut.cz>
7  * Funded by: Volkswagen Group Research
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13
14 #include <linux/delay.h>
15 #include <linux/if_ether.h>
16 #include <linux/skbuff.h>
17 #include <linux/if_arp.h>
18 #include <linux/etherdevice.h>
19 #include <linux/rtnetlink.h>
20 #include <net/mac80211.h>
21 #include <asm/unaligned.h>
22
23 #include "ieee80211_i.h"
24 #include "driver-ops.h"
25 #include "rate.h"
26
27 #define IEEE80211_OCB_HOUSEKEEPING_INTERVAL             (60 * HZ)
28 #define IEEE80211_OCB_PEER_INACTIVITY_LIMIT             (240 * HZ)
29 #define IEEE80211_OCB_MAX_STA_ENTRIES                   128
30
31 /**
32  * enum ocb_deferred_task_flags - mac80211 OCB deferred tasks
33  * @OCB_WORK_HOUSEKEEPING: run the periodic OCB housekeeping tasks
34  *
35  * These flags are used in @wrkq_flags field of &struct ieee80211_if_ocb
36  */
37 enum ocb_deferred_task_flags {
38         OCB_WORK_HOUSEKEEPING,
39 };
40
41 void ieee80211_ocb_rx_no_sta(struct ieee80211_sub_if_data *sdata,
42                              const u8 *bssid, const u8 *addr,
43                              u32 supp_rates)
44 {
45         struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
46         struct ieee80211_local *local = sdata->local;
47         struct ieee80211_chanctx_conf *chanctx_conf;
48         struct ieee80211_supported_band *sband;
49         enum nl80211_bss_scan_width scan_width;
50         struct sta_info *sta;
51         int band;
52
53         /* XXX: Consider removing the least recently used entry and
54          *      allow new one to be added.
55          */
56         if (local->num_sta >= IEEE80211_OCB_MAX_STA_ENTRIES) {
57                 net_info_ratelimited("%s: No room for a new OCB STA entry %pM\n",
58                                      sdata->name, addr);
59                 return;
60         }
61
62         ocb_dbg(sdata, "Adding new OCB station %pM\n", addr);
63
64         rcu_read_lock();
65         chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
66         if (WARN_ON_ONCE(!chanctx_conf)) {
67                 rcu_read_unlock();
68                 return;
69         }
70         band = chanctx_conf->def.chan->band;
71         scan_width = cfg80211_chandef_to_scan_width(&chanctx_conf->def);
72         rcu_read_unlock();
73
74         sta = sta_info_alloc(sdata, addr, GFP_ATOMIC);
75         if (!sta)
76                 return;
77
78         sta->rx_stats.last_rx = jiffies;
79
80         /* Add only mandatory rates for now */
81         sband = local->hw.wiphy->bands[band];
82         sta->sta.supp_rates[band] =
83                 ieee80211_mandatory_rates(sband, scan_width);
84
85         spin_lock(&ifocb->incomplete_lock);
86         list_add(&sta->list, &ifocb->incomplete_stations);
87         spin_unlock(&ifocb->incomplete_lock);
88         ieee80211_queue_work(&local->hw, &sdata->work);
89 }
90
91 static struct sta_info *ieee80211_ocb_finish_sta(struct sta_info *sta)
92         __acquires(RCU)
93 {
94         struct ieee80211_sub_if_data *sdata = sta->sdata;
95         u8 addr[ETH_ALEN];
96
97         memcpy(addr, sta->sta.addr, ETH_ALEN);
98
99         ocb_dbg(sdata, "Adding new IBSS station %pM (dev=%s)\n",
100                 addr, sdata->name);
101
102         sta_info_move_state(sta, IEEE80211_STA_AUTH);
103         sta_info_move_state(sta, IEEE80211_STA_ASSOC);
104         sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
105
106         rate_control_rate_init(sta);
107
108         /* If it fails, maybe we raced another insertion? */
109         if (sta_info_insert_rcu(sta))
110                 return sta_info_get(sdata, addr);
111         return sta;
112 }
113
114 static void ieee80211_ocb_housekeeping(struct ieee80211_sub_if_data *sdata)
115 {
116         struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
117
118         ocb_dbg(sdata, "Running ocb housekeeping\n");
119
120         ieee80211_sta_expire(sdata, IEEE80211_OCB_PEER_INACTIVITY_LIMIT);
121
122         mod_timer(&ifocb->housekeeping_timer,
123                   round_jiffies(jiffies + IEEE80211_OCB_HOUSEKEEPING_INTERVAL));
124 }
125
126 void ieee80211_ocb_work(struct ieee80211_sub_if_data *sdata)
127 {
128         struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
129         struct sta_info *sta;
130
131         if (ifocb->joined != true)
132                 return;
133
134         sdata_lock(sdata);
135
136         spin_lock_bh(&ifocb->incomplete_lock);
137         while (!list_empty(&ifocb->incomplete_stations)) {
138                 sta = list_first_entry(&ifocb->incomplete_stations,
139                                        struct sta_info, list);
140                 list_del(&sta->list);
141                 spin_unlock_bh(&ifocb->incomplete_lock);
142
143                 ieee80211_ocb_finish_sta(sta);
144                 rcu_read_unlock();
145                 spin_lock_bh(&ifocb->incomplete_lock);
146         }
147         spin_unlock_bh(&ifocb->incomplete_lock);
148
149         if (test_and_clear_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags))
150                 ieee80211_ocb_housekeeping(sdata);
151
152         sdata_unlock(sdata);
153 }
154
155 static void ieee80211_ocb_housekeeping_timer(unsigned long data)
156 {
157         struct ieee80211_sub_if_data *sdata = (void *)data;
158         struct ieee80211_local *local = sdata->local;
159         struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
160
161         set_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags);
162
163         ieee80211_queue_work(&local->hw, &sdata->work);
164 }
165
166 void ieee80211_ocb_setup_sdata(struct ieee80211_sub_if_data *sdata)
167 {
168         struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
169
170         setup_timer(&ifocb->housekeeping_timer,
171                     ieee80211_ocb_housekeeping_timer,
172                     (unsigned long)sdata);
173         INIT_LIST_HEAD(&ifocb->incomplete_stations);
174         spin_lock_init(&ifocb->incomplete_lock);
175 }
176
177 int ieee80211_ocb_join(struct ieee80211_sub_if_data *sdata,
178                        struct ocb_setup *setup)
179 {
180         struct ieee80211_local *local = sdata->local;
181         struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
182         u32 changed = BSS_CHANGED_OCB | BSS_CHANGED_BSSID;
183         int err;
184
185         if (ifocb->joined == true)
186                 return -EINVAL;
187
188         sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
189         sdata->smps_mode = IEEE80211_SMPS_OFF;
190         sdata->needed_rx_chains = sdata->local->rx_chains;
191
192         mutex_lock(&sdata->local->mtx);
193         err = ieee80211_vif_use_channel(sdata, &setup->chandef,
194                                         IEEE80211_CHANCTX_SHARED);
195         mutex_unlock(&sdata->local->mtx);
196         if (err)
197                 return err;
198
199         ieee80211_bss_info_change_notify(sdata, changed);
200
201         ifocb->joined = true;
202
203         set_bit(OCB_WORK_HOUSEKEEPING, &ifocb->wrkq_flags);
204         ieee80211_queue_work(&local->hw, &sdata->work);
205
206         netif_carrier_on(sdata->dev);
207         return 0;
208 }
209
210 int ieee80211_ocb_leave(struct ieee80211_sub_if_data *sdata)
211 {
212         struct ieee80211_if_ocb *ifocb = &sdata->u.ocb;
213         struct ieee80211_local *local = sdata->local;
214         struct sta_info *sta;
215
216         ifocb->joined = false;
217         sta_info_flush(sdata);
218
219         spin_lock_bh(&ifocb->incomplete_lock);
220         while (!list_empty(&ifocb->incomplete_stations)) {
221                 sta = list_first_entry(&ifocb->incomplete_stations,
222                                        struct sta_info, list);
223                 list_del(&sta->list);
224                 spin_unlock_bh(&ifocb->incomplete_lock);
225
226                 sta_info_free(local, sta);
227                 spin_lock_bh(&ifocb->incomplete_lock);
228         }
229         spin_unlock_bh(&ifocb->incomplete_lock);
230
231         netif_carrier_off(sdata->dev);
232         clear_bit(SDATA_STATE_OFFCHANNEL, &sdata->state);
233         ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_OCB);
234
235         mutex_lock(&sdata->local->mtx);
236         ieee80211_vif_release_channel(sdata);
237         mutex_unlock(&sdata->local->mtx);
238
239         skb_queue_purge(&sdata->skb_queue);
240
241         del_timer_sync(&sdata->u.ocb.housekeeping_timer);
242         /* If the timer fired while we waited for it, it will have
243          * requeued the work. Now the work will be running again
244          * but will not rearm the timer again because it checks
245          * whether we are connected to the network or not -- at this
246          * point we shouldn't be anymore.
247          */
248
249         return 0;
250 }