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