URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [tags/] [linux-2.6/] [linux-2.6.24_or32_unified_v2.3/] [net/] [wireless/] [core.c] - Blame information for rev 8

Details | Compare with Previous | View Log


/*
 * This is the linux wireless configuration interface.
 *
 * Copyright 2006, 2007         Johannes Berg <johannes@sipsolutions.net>
 */
 
#include <linux/if.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/nl80211.h>
#include <linux/debugfs.h>
#include <linux/notifier.h>
#include <linux/device.h>
#include <net/genetlink.h>
#include <net/cfg80211.h>
#include <net/wireless.h>
#include "nl80211.h"
#include "core.h"
#include "sysfs.h"
 
/* name for sysfs, %d is appended */
#define PHY_NAME "phy"
 
MODULE_AUTHOR("Johannes Berg");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("wireless configuration support");
 
/* RCU might be appropriate here since we usually
 * only read the list, and that can happen quite
 * often because we need to do it for each command */
LIST_HEAD(cfg80211_drv_list);
DEFINE_MUTEX(cfg80211_drv_mutex);
static int wiphy_counter;
 
/* for debugfs */
static struct dentry *ieee80211_debugfs_dir;
 
/* requires cfg80211_drv_mutex to be held! */
static struct cfg80211_registered_device *cfg80211_drv_by_wiphy(int wiphy)
{
        struct cfg80211_registered_device *result = NULL, *drv;
 
        list_for_each_entry(drv, &cfg80211_drv_list, list) {
                if (drv->idx == wiphy) {
                        result = drv;
                        break;
                }
        }
 
        return result;
}
 
/* requires cfg80211_drv_mutex to be held! */
static struct cfg80211_registered_device *
__cfg80211_drv_from_info(struct genl_info *info)
{
        int ifindex;
        struct cfg80211_registered_device *bywiphy = NULL, *byifidx = NULL;
        struct net_device *dev;
        int err = -EINVAL;
 
        if (info->attrs[NL80211_ATTR_WIPHY]) {
                bywiphy = cfg80211_drv_by_wiphy(
                                nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));
                err = -ENODEV;
        }
 
        if (info->attrs[NL80211_ATTR_IFINDEX]) {
                ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
                dev = dev_get_by_index(&init_net, ifindex);
                if (dev) {
                        if (dev->ieee80211_ptr)
                                byifidx =
                                        wiphy_to_dev(dev->ieee80211_ptr->wiphy);
                        dev_put(dev);
                }
                err = -ENODEV;
        }
 
        if (bywiphy && byifidx) {
                if (bywiphy != byifidx)
                        return ERR_PTR(-EINVAL);
                else
                        return bywiphy; /* == byifidx */
        }
        if (bywiphy)
                return bywiphy;
 
        if (byifidx)
                return byifidx;
 
        return ERR_PTR(err);
}
 
struct cfg80211_registered_device *
cfg80211_get_dev_from_info(struct genl_info *info)
{
        struct cfg80211_registered_device *drv;
 
        mutex_lock(&cfg80211_drv_mutex);
        drv = __cfg80211_drv_from_info(info);
 
        /* if it is not an error we grab the lock on
         * it to assure it won't be going away while
         * we operate on it */
        if (!IS_ERR(drv))
                mutex_lock(&drv->mtx);
 
        mutex_unlock(&cfg80211_drv_mutex);
 
        return drv;
}
 
struct cfg80211_registered_device *
cfg80211_get_dev_from_ifindex(int ifindex)
{
        struct cfg80211_registered_device *drv = ERR_PTR(-ENODEV);
        struct net_device *dev;
 
        mutex_lock(&cfg80211_drv_mutex);
        dev = dev_get_by_index(&init_net, ifindex);
        if (!dev)
                goto out;
        if (dev->ieee80211_ptr) {
                drv = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
                mutex_lock(&drv->mtx);
        } else
                drv = ERR_PTR(-ENODEV);
        dev_put(dev);
 out:
        mutex_unlock(&cfg80211_drv_mutex);
        return drv;
}
 
void cfg80211_put_dev(struct cfg80211_registered_device *drv)
{
        BUG_ON(IS_ERR(drv));
        mutex_unlock(&drv->mtx);
}
 
int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
                        char *newname)
{
        int idx, taken = -1, result, digits;
 
        /* prohibit calling the thing phy%d when %d is not its number */
        sscanf(newname, PHY_NAME "%d%n", &idx, &taken);
        if (taken == strlen(newname) && idx != rdev->idx) {
                /* count number of places needed to print idx */
                digits = 1;
                while (idx /= 10)
                        digits++;
                /*
                 * deny the name if it is phy<idx> where <idx> is printed
                 * without leading zeroes. taken == strlen(newname) here
                 */
                if (taken == strlen(PHY_NAME) + digits)
                        return -EINVAL;
        }
 
        /* this will check for collisions */
        result = device_rename(&rdev->wiphy.dev, newname);
        if (result)
                return result;
 
        if (!debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
                            rdev->wiphy.debugfsdir,
                            rdev->wiphy.debugfsdir->d_parent,
                            newname))
                printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n",
                       newname);
 
        nl80211_notify_dev_rename(rdev);
 
        return 0;
}
 
/* exported functions */
 
struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv)
{
        struct cfg80211_registered_device *drv;
        int alloc_size;
 
        alloc_size = sizeof(*drv) + sizeof_priv;
 
        drv = kzalloc(alloc_size, GFP_KERNEL);
        if (!drv)
                return NULL;
 
        drv->ops = ops;
 
        mutex_lock(&cfg80211_drv_mutex);
 
        drv->idx = wiphy_counter;
 
        /* now increase counter for the next device unless
         * it has wrapped previously */
        if (wiphy_counter >= 0)
                wiphy_counter++;
 
        mutex_unlock(&cfg80211_drv_mutex);
 
        if (unlikely(drv->idx < 0)) {
                /* ugh, wrapped! */
                kfree(drv);
                return NULL;
        }
 
        /* give it a proper name */
        snprintf(drv->wiphy.dev.bus_id, BUS_ID_SIZE,
                 PHY_NAME "%d", drv->idx);
 
        mutex_init(&drv->mtx);
        mutex_init(&drv->devlist_mtx);
        INIT_LIST_HEAD(&drv->netdev_list);
 
        device_initialize(&drv->wiphy.dev);
        drv->wiphy.dev.class = &ieee80211_class;
        drv->wiphy.dev.platform_data = drv;
 
        return &drv->wiphy;
}
EXPORT_SYMBOL(wiphy_new);
 
int wiphy_register(struct wiphy *wiphy)
{
        struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
        int res;
 
        mutex_lock(&cfg80211_drv_mutex);
 
        res = device_add(&drv->wiphy.dev);
        if (res)
                goto out_unlock;
 
        list_add(&drv->list, &cfg80211_drv_list);
 
        /* add to debugfs */
        drv->wiphy.debugfsdir =
                debugfs_create_dir(wiphy_name(&drv->wiphy),
                                   ieee80211_debugfs_dir);
 
        res = 0;
out_unlock:
        mutex_unlock(&cfg80211_drv_mutex);
        return res;
}
EXPORT_SYMBOL(wiphy_register);
 
void wiphy_unregister(struct wiphy *wiphy)
{
        struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
 
        /* protect the device list */
        mutex_lock(&cfg80211_drv_mutex);
 
        BUG_ON(!list_empty(&drv->netdev_list));
 
        /*
         * Try to grab drv->mtx. If a command is still in progress,
         * hopefully the driver will refuse it since it's tearing
         * down the device already. We wait for this command to complete
         * before unlinking the item from the list.
         * Note: as codified by the BUG_ON above we cannot get here if
         * a virtual interface is still associated. Hence, we can only
         * get to lock contention here if userspace issues a command
         * that identified the hardware by wiphy index.
         */
        mutex_lock(&drv->mtx);
        /* unlock again before freeing */
        mutex_unlock(&drv->mtx);
 
        list_del(&drv->list);
        device_del(&drv->wiphy.dev);
        debugfs_remove(drv->wiphy.debugfsdir);
 
        mutex_unlock(&cfg80211_drv_mutex);
}
EXPORT_SYMBOL(wiphy_unregister);
 
void cfg80211_dev_free(struct cfg80211_registered_device *drv)
{
        mutex_destroy(&drv->mtx);
        mutex_destroy(&drv->devlist_mtx);
        kfree(drv);
}
 
void wiphy_free(struct wiphy *wiphy)
{
        put_device(&wiphy->dev);
}
EXPORT_SYMBOL(wiphy_free);
 
static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
                                         unsigned long state,
                                         void *ndev)
{
        struct net_device *dev = ndev;
        struct cfg80211_registered_device *rdev;
 
        if (!dev->ieee80211_ptr)
                return 0;
 
        rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
 
        switch (state) {
        case NETDEV_REGISTER:
                mutex_lock(&rdev->devlist_mtx);
                list_add(&dev->ieee80211_ptr->list, &rdev->netdev_list);
                if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
                                      "phy80211")) {
                        printk(KERN_ERR "wireless: failed to add phy80211 "
                                "symlink to netdev!\n");
                }
                dev->ieee80211_ptr->netdev = dev;
                mutex_unlock(&rdev->devlist_mtx);
                break;
        case NETDEV_UNREGISTER:
                mutex_lock(&rdev->devlist_mtx);
                if (!list_empty(&dev->ieee80211_ptr->list)) {
                        sysfs_remove_link(&dev->dev.kobj, "phy80211");
                        list_del_init(&dev->ieee80211_ptr->list);
                }
                mutex_unlock(&rdev->devlist_mtx);
                break;
        }
 
        return 0;
}
 
static struct notifier_block cfg80211_netdev_notifier = {
        .notifier_call = cfg80211_netdev_notifier_call,
};
 
static int cfg80211_init(void)
{
        int err = wiphy_sysfs_init();
        if (err)
                goto out_fail_sysfs;
 
        err = register_netdevice_notifier(&cfg80211_netdev_notifier);
        if (err)
                goto out_fail_notifier;
 
        err = nl80211_init();
        if (err)
                goto out_fail_nl80211;
 
        ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
 
        return 0;
 
out_fail_nl80211:
        unregister_netdevice_notifier(&cfg80211_netdev_notifier);
out_fail_notifier:
        wiphy_sysfs_exit();
out_fail_sysfs:
        return err;
}
subsys_initcall(cfg80211_init);
 
static void cfg80211_exit(void)
{
        debugfs_remove(ieee80211_debugfs_dir);
        nl80211_exit();
        unregister_netdevice_notifier(&cfg80211_netdev_notifier);
        wiphy_sysfs_exit();
}
module_exit(cfg80211_exit);

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [tags/] [linux-2.6/] [linux-2.6.24_or32_unified_v2.3/] [net/] [wireless/] [core.c] - Blame information for rev 8

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* This is the linux wireless configuration interface.`
3			`*`
4			`* Copyright 2006, 2007 Johannes Berg <johannes@sipsolutions.net>`
5			`*/`
6
7			`#include <linux/if.h>`
8			`#include <linux/module.h>`
9			`#include <linux/err.h>`
10			`#include <linux/mutex.h>`
11			`#include <linux/list.h>`
12			`#include <linux/nl80211.h>`
13			`#include <linux/debugfs.h>`
14			`#include <linux/notifier.h>`
15			`#include <linux/device.h>`
16			`#include <net/genetlink.h>`
17			`#include <net/cfg80211.h>`
18			`#include <net/wireless.h>`
19			`#include "nl80211.h"`
20			`#include "core.h"`
21			`#include "sysfs.h"`
22
23			`/* name for sysfs, %d is appended */`
24			`#define PHY_NAME "phy"`
25
26			`MODULE_AUTHOR("Johannes Berg");`
27			`MODULE_LICENSE("GPL");`
28			`MODULE_DESCRIPTION("wireless configuration support");`
29
30			`/* RCU might be appropriate here since we usually`
31			`* only read the list, and that can happen quite`
32			`* often because we need to do it for each command */`
33			`LIST_HEAD(cfg80211_drv_list);`
34			`DEFINE_MUTEX(cfg80211_drv_mutex);`
35			`static int wiphy_counter;`
36
37			`/* for debugfs */`
38			`static struct dentry *ieee80211_debugfs_dir;`
39
40			`/* requires cfg80211_drv_mutex to be held! */`
41			`static struct cfg80211_registered_device *cfg80211_drv_by_wiphy(int wiphy)`
42			`{`
43			`struct cfg80211_registered_device result = NULL, drv;`
44
45			`list_for_each_entry(drv, &cfg80211_drv_list, list) {`
46			`if (drv->idx == wiphy) {`
47			`result = drv;`
48			`break;`
49			`}`
50			`}`
51
52			`return result;`
53			`}`
54
55			`/* requires cfg80211_drv_mutex to be held! */`
56			`static struct cfg80211_registered_device *`
57			`__cfg80211_drv_from_info(struct genl_info *info)`
58			`{`
59			`int ifindex;`
60			`struct cfg80211_registered_device bywiphy = NULL, byifidx = NULL;`
61			`struct net_device *dev;`
62			`int err = -EINVAL;`
63
64			`if (info->attrs[NL80211_ATTR_WIPHY]) {`
65			`bywiphy = cfg80211_drv_by_wiphy(`
66			`nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));`
67			`err = -ENODEV;`
68			`}`
69
70			`if (info->attrs[NL80211_ATTR_IFINDEX]) {`
71			`ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);`
72			`dev = dev_get_by_index(&init_net, ifindex);`
73			`if (dev) {`
74			`if (dev->ieee80211_ptr)`
75			`byifidx =`
76			`wiphy_to_dev(dev->ieee80211_ptr->wiphy);`
77			`dev_put(dev);`
78			`}`
79			`err = -ENODEV;`
80			`}`
81
82			`if (bywiphy && byifidx) {`
83			`if (bywiphy != byifidx)`
84			`return ERR_PTR(-EINVAL);`
85			`else`
86			`return bywiphy; /* == byifidx */`
87			`}`
88			`if (bywiphy)`
89			`return bywiphy;`
90
91			`if (byifidx)`
92			`return byifidx;`
93
94			`return ERR_PTR(err);`
95			`}`
96
97			`struct cfg80211_registered_device *`
98			`cfg80211_get_dev_from_info(struct genl_info *info)`
99			`{`
100			`struct cfg80211_registered_device *drv;`
101
102			`mutex_lock(&cfg80211_drv_mutex);`
103			`drv = __cfg80211_drv_from_info(info);`
104
105			`/* if it is not an error we grab the lock on`
106			`* it to assure it won't be going away while`
107			`* we operate on it */`
108			`if (!IS_ERR(drv))`
109			`mutex_lock(&drv->mtx);`
110
111			`mutex_unlock(&cfg80211_drv_mutex);`
112
113			`return drv;`
114			`}`
115
116			`struct cfg80211_registered_device *`
117			`cfg80211_get_dev_from_ifindex(int ifindex)`
118			`{`
119			`struct cfg80211_registered_device *drv = ERR_PTR(-ENODEV);`
120			`struct net_device *dev;`
121
122			`mutex_lock(&cfg80211_drv_mutex);`
123			`dev = dev_get_by_index(&init_net, ifindex);`
124			`if (!dev)`
125			`goto out;`
126			`if (dev->ieee80211_ptr) {`
127			`drv = wiphy_to_dev(dev->ieee80211_ptr->wiphy);`
128			`mutex_lock(&drv->mtx);`
129			`} else`
130			`drv = ERR_PTR(-ENODEV);`
131			`dev_put(dev);`
132			`out:`
133			`mutex_unlock(&cfg80211_drv_mutex);`
134			`return drv;`
135			`}`
136
137			`void cfg80211_put_dev(struct cfg80211_registered_device *drv)`
138			`{`
139			`BUG_ON(IS_ERR(drv));`
140			`mutex_unlock(&drv->mtx);`
141			`}`
142
143			`int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,`
144			`char *newname)`
145			`{`
146			`int idx, taken = -1, result, digits;`
147
148			`/* prohibit calling the thing phy%d when %d is not its number */`
149			`sscanf(newname, PHY_NAME "%d%n", &idx, &taken);`
150			`if (taken == strlen(newname) && idx != rdev->idx) {`
151			`/* count number of places needed to print idx */`
152			`digits = 1;`
153			`while (idx /= 10)`
154			`digits++;`
155			`/*`
156			`* deny the name if it is phy<idx> where <idx> is printed`
157			`* without leading zeroes. taken == strlen(newname) here`
158			`*/`
159			`if (taken == strlen(PHY_NAME) + digits)`
160			`return -EINVAL;`
161			`}`
162
163			`/* this will check for collisions */`
164			`result = device_rename(&rdev->wiphy.dev, newname);`
165			`if (result)`
166			`return result;`
167
168			`if (!debugfs_rename(rdev->wiphy.debugfsdir->d_parent,`
169			`rdev->wiphy.debugfsdir,`
170			`rdev->wiphy.debugfsdir->d_parent,`
171			`newname))`
172			`printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n",`
173			`newname);`
174
175			`nl80211_notify_dev_rename(rdev);`
176
177			`return 0;`
178			`}`
179
180			`/* exported functions */`
181
182			`struct wiphy wiphy_new(struct cfg80211_ops ops, int sizeof_priv)`
183			`{`
184			`struct cfg80211_registered_device *drv;`
185			`int alloc_size;`
186
187			`alloc_size = sizeof(*drv) + sizeof_priv;`
188
189			`drv = kzalloc(alloc_size, GFP_KERNEL);`
190			`if (!drv)`
191			`return NULL;`
192
193			`drv->ops = ops;`
194
195			`mutex_lock(&cfg80211_drv_mutex);`
196
197			`drv->idx = wiphy_counter;`
198
199			`/* now increase counter for the next device unless`
200			`* it has wrapped previously */`
201			`if (wiphy_counter >= 0)`
202			`wiphy_counter++;`
203
204			`mutex_unlock(&cfg80211_drv_mutex);`
205
206			`if (unlikely(drv->idx < 0)) {`
207			`/* ugh, wrapped! */`
208			`kfree(drv);`
209			`return NULL;`
210			`}`
211
212			`/* give it a proper name */`
213			`snprintf(drv->wiphy.dev.bus_id, BUS_ID_SIZE,`
214			`PHY_NAME "%d", drv->idx);`
215
216			`mutex_init(&drv->mtx);`
217			`mutex_init(&drv->devlist_mtx);`
218			`INIT_LIST_HEAD(&drv->netdev_list);`
219
220			`device_initialize(&drv->wiphy.dev);`
221			`drv->wiphy.dev.class = &ieee80211_class;`
222			`drv->wiphy.dev.platform_data = drv;`
223
224			`return &drv->wiphy;`
225			`}`
226			`EXPORT_SYMBOL(wiphy_new);`
227
228			`int wiphy_register(struct wiphy *wiphy)`
229			`{`
230			`struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);`
231			`int res;`
232
233			`mutex_lock(&cfg80211_drv_mutex);`
234
235			`res = device_add(&drv->wiphy.dev);`
236			`if (res)`
237			`goto out_unlock;`
238
239			`list_add(&drv->list, &cfg80211_drv_list);`
240
241			`/* add to debugfs */`
242			`drv->wiphy.debugfsdir =`
243			`debugfs_create_dir(wiphy_name(&drv->wiphy),`
244			`ieee80211_debugfs_dir);`
245
246			`res = 0;`
247			`out_unlock:`
248			`mutex_unlock(&cfg80211_drv_mutex);`
249			`return res;`
250			`}`
251			`EXPORT_SYMBOL(wiphy_register);`
252
253			`void wiphy_unregister(struct wiphy *wiphy)`
254			`{`
255			`struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);`
256
257			`/* protect the device list */`
258			`mutex_lock(&cfg80211_drv_mutex);`
259
260			`BUG_ON(!list_empty(&drv->netdev_list));`
261
262			`/*`
263			`* Try to grab drv->mtx. If a command is still in progress,`
264			`* hopefully the driver will refuse it since it's tearing`
265			`* down the device already. We wait for this command to complete`
266			`* before unlinking the item from the list.`
267			`* Note: as codified by the BUG_ON above we cannot get here if`
268			`* a virtual interface is still associated. Hence, we can only`
269			`* get to lock contention here if userspace issues a command`
270			`* that identified the hardware by wiphy index.`
271			`*/`
272			`mutex_lock(&drv->mtx);`
273			`/* unlock again before freeing */`
274			`mutex_unlock(&drv->mtx);`
275
276			`list_del(&drv->list);`
277			`device_del(&drv->wiphy.dev);`
278			`debugfs_remove(drv->wiphy.debugfsdir);`
279
280			`mutex_unlock(&cfg80211_drv_mutex);`
281			`}`
282			`EXPORT_SYMBOL(wiphy_unregister);`
283
284			`void cfg80211_dev_free(struct cfg80211_registered_device *drv)`
285			`{`
286			`mutex_destroy(&drv->mtx);`
287			`mutex_destroy(&drv->devlist_mtx);`
288			`kfree(drv);`
289			`}`
290
291			`void wiphy_free(struct wiphy *wiphy)`
292			`{`
293			`put_device(&wiphy->dev);`
294			`}`
295			`EXPORT_SYMBOL(wiphy_free);`
296
297			`static int cfg80211_netdev_notifier_call(struct notifier_block * nb,`
298			`unsigned long state,`
299			`void *ndev)`
300			`{`
301			`struct net_device *dev = ndev;`
302			`struct cfg80211_registered_device *rdev;`
303
304			`if (!dev->ieee80211_ptr)`
305			`return 0;`
306
307			`rdev = wiphy_to_dev(dev->ieee80211_ptr->wiphy);`
308
309			`switch (state) {`
310			`case NETDEV_REGISTER:`
311			`mutex_lock(&rdev->devlist_mtx);`
312			`list_add(&dev->ieee80211_ptr->list, &rdev->netdev_list);`
313			`if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,`
314			`"phy80211")) {`
315			`printk(KERN_ERR "wireless: failed to add phy80211 "`
316			`"symlink to netdev!\n");`
317			`}`
318			`dev->ieee80211_ptr->netdev = dev;`
319			`mutex_unlock(&rdev->devlist_mtx);`
320			`break;`
321			`case NETDEV_UNREGISTER:`
322			`mutex_lock(&rdev->devlist_mtx);`
323			`if (!list_empty(&dev->ieee80211_ptr->list)) {`
324			`sysfs_remove_link(&dev->dev.kobj, "phy80211");`
325			`list_del_init(&dev->ieee80211_ptr->list);`
326			`}`
327			`mutex_unlock(&rdev->devlist_mtx);`
328			`break;`
329			`}`
330
331			`return 0;`
332			`}`
333
334			`static struct notifier_block cfg80211_netdev_notifier = {`
335			`.notifier_call = cfg80211_netdev_notifier_call,`
336			`};`
337
338			`static int cfg80211_init(void)`
339			`{`
340			`int err = wiphy_sysfs_init();`
341			`if (err)`
342			`goto out_fail_sysfs;`
343
344			`err = register_netdevice_notifier(&cfg80211_netdev_notifier);`
345			`if (err)`
346			`goto out_fail_notifier;`
347
348			`err = nl80211_init();`
349			`if (err)`
350			`goto out_fail_nl80211;`
351
352			`ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);`
353
354			`return 0;`
355
356			`out_fail_nl80211:`
357			`unregister_netdevice_notifier(&cfg80211_netdev_notifier);`
358			`out_fail_notifier:`
359			`wiphy_sysfs_exit();`
360			`out_fail_sysfs:`
361			`return err;`
362			`}`
363			`subsys_initcall(cfg80211_init);`
364
365			`static void cfg80211_exit(void)`
366			`{`
367			`debugfs_remove(ieee80211_debugfs_dir);`
368			`nl80211_exit();`
369			`unregister_netdevice_notifier(&cfg80211_netdev_notifier);`
370			`wiphy_sysfs_exit();`
371			`}`
372			`module_exit(cfg80211_exit);`