Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6.git] / net / mac80211 / iface.c
1 /*
2  * Copyright 2002-2005, Instant802 Networks, Inc.
3  * Copyright 2005-2006, Devicescape Software, Inc.
4  * Copyright (c) 2006 Jiri Benc <jbenc@suse.cz>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10 #include <linux/kernel.h>
11 #include <linux/if_arp.h>
12 #include <linux/netdevice.h>
13 #include <linux/rtnetlink.h>
14 #include <net/mac80211.h>
15 #include "ieee80211_i.h"
16 #include "sta_info.h"
17 #include "debugfs_netdev.h"
18 #include "mesh.h"
19
20 void ieee80211_if_sdata_init(struct ieee80211_sub_if_data *sdata)
21 {
22         int i;
23
24         /* Default values for sub-interface parameters */
25         sdata->drop_unencrypted = 0;
26         for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
27                 skb_queue_head_init(&sdata->fragments[i].skb_list);
28
29         INIT_LIST_HEAD(&sdata->key_list);
30 }
31
32 static void ieee80211_if_sdata_deinit(struct ieee80211_sub_if_data *sdata)
33 {
34         int i;
35
36         for (i = 0; i < IEEE80211_FRAGMENT_MAX; i++)
37                 __skb_queue_purge(&sdata->fragments[i].skb_list);
38 }
39
40 /* Must be called with rtnl lock held. */
41 int ieee80211_if_add(struct net_device *dev, const char *name,
42                      struct net_device **new_dev, int type,
43                      struct vif_params *params)
44 {
45         struct net_device *ndev;
46         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
47         struct ieee80211_sub_if_data *sdata = NULL;
48         int ret;
49
50         ASSERT_RTNL();
51         ndev = alloc_netdev(sizeof(*sdata) + local->hw.vif_data_size,
52                             name, ieee80211_if_setup);
53         if (!ndev)
54                 return -ENOMEM;
55
56         ndev->needed_headroom = local->tx_headroom +
57                                 4*6 /* four MAC addresses */
58                                 + 2 + 2 + 2 + 2 /* ctl, dur, seq, qos */
59                                 + 6 /* mesh */
60                                 + 8 /* rfc1042/bridge tunnel */
61                                 - ETH_HLEN /* ethernet hard_header_len */
62                                 + IEEE80211_ENCRYPT_HEADROOM;
63         ndev->needed_tailroom = IEEE80211_ENCRYPT_TAILROOM;
64
65         ret = dev_alloc_name(ndev, ndev->name);
66         if (ret < 0)
67                 goto fail;
68
69         memcpy(ndev->dev_addr, local->hw.wiphy->perm_addr, ETH_ALEN);
70         ndev->base_addr = dev->base_addr;
71         ndev->irq = dev->irq;
72         ndev->mem_start = dev->mem_start;
73         ndev->mem_end = dev->mem_end;
74         SET_NETDEV_DEV(ndev, wiphy_dev(local->hw.wiphy));
75
76         sdata = IEEE80211_DEV_TO_SUB_IF(ndev);
77         ndev->ieee80211_ptr = &sdata->wdev;
78         sdata->wdev.wiphy = local->hw.wiphy;
79         sdata->vif.type = IEEE80211_IF_TYPE_AP;
80         sdata->dev = ndev;
81         sdata->local = local;
82         ieee80211_if_sdata_init(sdata);
83
84         ret = register_netdevice(ndev);
85         if (ret)
86                 goto fail;
87
88         ieee80211_debugfs_add_netdev(sdata);
89         ieee80211_if_set_type(ndev, type);
90
91         if (ieee80211_vif_is_mesh(&sdata->vif) &&
92             params && params->mesh_id_len)
93                 ieee80211_if_sta_set_mesh_id(&sdata->u.sta,
94                                              params->mesh_id_len,
95                                              params->mesh_id);
96
97         /* we're under RTNL so all this is fine */
98         if (unlikely(local->reg_state == IEEE80211_DEV_UNREGISTERED)) {
99                 __ieee80211_if_del(local, sdata);
100                 return -ENODEV;
101         }
102         list_add_tail_rcu(&sdata->list, &local->interfaces);
103
104         if (new_dev)
105                 *new_dev = ndev;
106
107         return 0;
108
109 fail:
110         free_netdev(ndev);
111         return ret;
112 }
113
114 void ieee80211_if_set_type(struct net_device *dev, int type)
115 {
116         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
117         int oldtype = sdata->vif.type;
118
119         /*
120          * We need to call this function on the master interface
121          * which already has a hard_start_xmit routine assigned
122          * which must not be changed.
123          */
124         if (dev != sdata->local->mdev)
125                 dev->hard_start_xmit = ieee80211_subif_start_xmit;
126
127         /*
128          * Called even when register_netdevice fails, it would
129          * oops if assigned before initialising the rest.
130          */
131         dev->uninit = ieee80211_if_reinit;
132
133         /* most have no BSS pointer */
134         sdata->bss = NULL;
135         sdata->vif.type = type;
136
137         sdata->basic_rates = 0;
138
139         switch (type) {
140         case IEEE80211_IF_TYPE_WDS:
141                 /* nothing special */
142                 break;
143         case IEEE80211_IF_TYPE_VLAN:
144                 sdata->u.vlan.ap = NULL;
145                 break;
146         case IEEE80211_IF_TYPE_AP:
147                 sdata->u.ap.force_unicast_rateidx = -1;
148                 sdata->u.ap.max_ratectrl_rateidx = -1;
149                 skb_queue_head_init(&sdata->u.ap.ps_bc_buf);
150                 sdata->bss = &sdata->u.ap;
151                 INIT_LIST_HEAD(&sdata->u.ap.vlans);
152                 break;
153         case IEEE80211_IF_TYPE_MESH_POINT:
154         case IEEE80211_IF_TYPE_STA:
155         case IEEE80211_IF_TYPE_IBSS: {
156                 struct ieee80211_sub_if_data *msdata;
157                 struct ieee80211_if_sta *ifsta;
158
159                 ifsta = &sdata->u.sta;
160                 INIT_WORK(&ifsta->work, ieee80211_sta_work);
161                 setup_timer(&ifsta->timer, ieee80211_sta_timer,
162                             (unsigned long) sdata);
163                 skb_queue_head_init(&ifsta->skb_queue);
164
165                 ifsta->capab = WLAN_CAPABILITY_ESS;
166                 ifsta->auth_algs = IEEE80211_AUTH_ALG_OPEN |
167                         IEEE80211_AUTH_ALG_SHARED_KEY;
168                 ifsta->flags |= IEEE80211_STA_CREATE_IBSS |
169                         IEEE80211_STA_WMM_ENABLED |
170                         IEEE80211_STA_AUTO_BSSID_SEL |
171                         IEEE80211_STA_AUTO_CHANNEL_SEL;
172
173                 msdata = IEEE80211_DEV_TO_SUB_IF(sdata->local->mdev);
174                 sdata->bss = &msdata->u.ap;
175
176                 if (ieee80211_vif_is_mesh(&sdata->vif))
177                         ieee80211_mesh_init_sdata(sdata);
178                 break;
179         }
180         case IEEE80211_IF_TYPE_MNTR:
181                 dev->type = ARPHRD_IEEE80211_RADIOTAP;
182                 dev->hard_start_xmit = ieee80211_monitor_start_xmit;
183                 sdata->u.mntr_flags = MONITOR_FLAG_CONTROL |
184                                       MONITOR_FLAG_OTHER_BSS;
185                 break;
186         default:
187                 printk(KERN_WARNING "%s: %s: Unknown interface type 0x%x",
188                        dev->name, __func__, type);
189         }
190         ieee80211_debugfs_change_if_type(sdata, oldtype);
191 }
192
193 /* Must be called with rtnl lock held. */
194 void ieee80211_if_reinit(struct net_device *dev)
195 {
196         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
197         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
198         struct sk_buff *skb;
199         int flushed;
200
201         ASSERT_RTNL();
202
203         ieee80211_free_keys(sdata);
204
205         ieee80211_if_sdata_deinit(sdata);
206
207         /* Need to handle mesh specially to allow eliding the function call */
208         if (ieee80211_vif_is_mesh(&sdata->vif))
209                 mesh_rmc_free(dev);
210
211         switch (sdata->vif.type) {
212         case IEEE80211_IF_TYPE_INVALID:
213                 /* cannot happen */
214                 WARN_ON(1);
215                 break;
216         case IEEE80211_IF_TYPE_AP: {
217                 /* Remove all virtual interfaces that use this BSS
218                  * as their sdata->bss */
219                 struct ieee80211_sub_if_data *tsdata, *n;
220                 struct beacon_data *beacon;
221
222                 list_for_each_entry_safe(tsdata, n, &local->interfaces, list) {
223                         if (tsdata != sdata && tsdata->bss == &sdata->u.ap) {
224                                 printk(KERN_DEBUG "%s: removing virtual "
225                                        "interface %s because its BSS interface"
226                                        " is being removed\n",
227                                        sdata->dev->name, tsdata->dev->name);
228                                 list_del_rcu(&tsdata->list);
229                                 /*
230                                  * We have lots of time and can afford
231                                  * to sync for each interface
232                                  */
233                                 synchronize_rcu();
234                                 __ieee80211_if_del(local, tsdata);
235                         }
236                 }
237
238                 beacon = sdata->u.ap.beacon;
239                 rcu_assign_pointer(sdata->u.ap.beacon, NULL);
240                 synchronize_rcu();
241                 kfree(beacon);
242
243                 while ((skb = skb_dequeue(&sdata->u.ap.ps_bc_buf))) {
244                         local->total_ps_buffered--;
245                         dev_kfree_skb(skb);
246                 }
247
248                 break;
249         }
250         case IEEE80211_IF_TYPE_WDS:
251                 /* nothing to do */
252                 break;
253         case IEEE80211_IF_TYPE_MESH_POINT:
254         case IEEE80211_IF_TYPE_STA:
255         case IEEE80211_IF_TYPE_IBSS:
256                 kfree(sdata->u.sta.extra_ie);
257                 sdata->u.sta.extra_ie = NULL;
258                 kfree(sdata->u.sta.assocreq_ies);
259                 sdata->u.sta.assocreq_ies = NULL;
260                 kfree(sdata->u.sta.assocresp_ies);
261                 sdata->u.sta.assocresp_ies = NULL;
262                 if (sdata->u.sta.probe_resp) {
263                         dev_kfree_skb(sdata->u.sta.probe_resp);
264                         sdata->u.sta.probe_resp = NULL;
265                 }
266
267                 break;
268         case IEEE80211_IF_TYPE_MNTR:
269                 dev->type = ARPHRD_ETHER;
270                 break;
271         case IEEE80211_IF_TYPE_VLAN:
272                 sdata->u.vlan.ap = NULL;
273                 break;
274         }
275
276         flushed = sta_info_flush(local, sdata);
277         WARN_ON(flushed);
278
279         memset(&sdata->u, 0, sizeof(sdata->u));
280         ieee80211_if_sdata_init(sdata);
281 }
282
283 /* Must be called with rtnl lock held. */
284 void __ieee80211_if_del(struct ieee80211_local *local,
285                         struct ieee80211_sub_if_data *sdata)
286 {
287         struct net_device *dev = sdata->dev;
288
289         ieee80211_debugfs_remove_netdev(sdata);
290         unregister_netdevice(dev);
291         /* Except master interface, the net_device will be freed by
292          * net_device->destructor (i. e. ieee80211_if_free). */
293 }
294
295 /* Must be called with rtnl lock held. */
296 int ieee80211_if_remove(struct net_device *dev, const char *name, int id)
297 {
298         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
299         struct ieee80211_sub_if_data *sdata, *n;
300
301         ASSERT_RTNL();
302
303         list_for_each_entry_safe(sdata, n, &local->interfaces, list) {
304                 if ((sdata->vif.type == id || id == -1) &&
305                     strcmp(name, sdata->dev->name) == 0 &&
306                     sdata->dev != local->mdev) {
307                         list_del_rcu(&sdata->list);
308                         synchronize_rcu();
309                         __ieee80211_if_del(local, sdata);
310                         return 0;
311                 }
312         }
313         return -ENODEV;
314 }
315
316 void ieee80211_if_free(struct net_device *dev)
317 {
318         struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
319
320         ieee80211_if_sdata_deinit(sdata);
321         free_netdev(dev);
322 }