2 * This is the linux wireless configuration interface.
4 * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/module.h>
10 #include <linux/list.h>
11 #include <linux/nl80211.h>
12 #include <linux/debugfs.h>
13 #include <linux/notifier.h>
14 #include <linux/device.h>
15 #include <linux/rtnetlink.h>
16 #include <net/genetlink.h>
17 #include <net/cfg80211.h>
23 /* name for sysfs, %d is appended */
24 #define PHY_NAME "phy"
26 MODULE_AUTHOR("Johannes Berg");
27 MODULE_LICENSE("GPL");
28 MODULE_DESCRIPTION("wireless configuration support");
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);
36 * This is used to protect the cfg80211_drv_list, cfg80211_regdomain,
37 * country_ie_regdomain, the reg_beacon_list and the the last regulatory
38 * request receipt (last_request).
40 DEFINE_MUTEX(cfg80211_mutex);
43 static struct dentry *ieee80211_debugfs_dir;
45 /* requires cfg80211_mutex to be held! */
46 struct cfg80211_registered_device *cfg80211_drv_by_wiphy_idx(int wiphy_idx)
48 struct cfg80211_registered_device *result = NULL, *drv;
50 if (!wiphy_idx_valid(wiphy_idx))
53 assert_cfg80211_lock();
55 list_for_each_entry(drv, &cfg80211_drv_list, list) {
56 if (drv->wiphy_idx == wiphy_idx) {
65 int get_wiphy_idx(struct wiphy *wiphy)
67 struct cfg80211_registered_device *drv;
69 return WIPHY_IDX_STALE;
70 drv = wiphy_to_dev(wiphy);
71 return drv->wiphy_idx;
74 /* requires cfg80211_drv_mutex to be held! */
75 struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx)
77 struct cfg80211_registered_device *drv;
79 if (!wiphy_idx_valid(wiphy_idx))
82 assert_cfg80211_lock();
84 drv = cfg80211_drv_by_wiphy_idx(wiphy_idx);
90 /* requires cfg80211_mutex to be held! */
91 struct cfg80211_registered_device *
92 __cfg80211_drv_from_info(struct genl_info *info)
95 struct cfg80211_registered_device *bywiphyidx = NULL, *byifidx = NULL;
96 struct net_device *dev;
99 assert_cfg80211_lock();
101 if (info->attrs[NL80211_ATTR_WIPHY]) {
102 bywiphyidx = cfg80211_drv_by_wiphy_idx(
103 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));
107 if (info->attrs[NL80211_ATTR_IFINDEX]) {
108 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
109 dev = dev_get_by_index(&init_net, ifindex);
111 if (dev->ieee80211_ptr)
113 wiphy_to_dev(dev->ieee80211_ptr->wiphy);
119 if (bywiphyidx && byifidx) {
120 if (bywiphyidx != byifidx)
121 return ERR_PTR(-EINVAL);
123 return bywiphyidx; /* == byifidx */
134 struct cfg80211_registered_device *
135 cfg80211_get_dev_from_info(struct genl_info *info)
137 struct cfg80211_registered_device *drv;
139 mutex_lock(&cfg80211_mutex);
140 drv = __cfg80211_drv_from_info(info);
142 /* if it is not an error we grab the lock on
143 * it to assure it won't be going away while
144 * we operate on it */
146 mutex_lock(&drv->mtx);
148 mutex_unlock(&cfg80211_mutex);
153 struct cfg80211_registered_device *
154 cfg80211_get_dev_from_ifindex(int ifindex)
156 struct cfg80211_registered_device *drv = ERR_PTR(-ENODEV);
157 struct net_device *dev;
159 mutex_lock(&cfg80211_mutex);
160 dev = dev_get_by_index(&init_net, ifindex);
163 if (dev->ieee80211_ptr) {
164 drv = wiphy_to_dev(dev->ieee80211_ptr->wiphy);
165 mutex_lock(&drv->mtx);
167 drv = ERR_PTR(-ENODEV);
170 mutex_unlock(&cfg80211_mutex);
174 /* requires cfg80211_mutex to be held */
175 int cfg80211_dev_rename(struct cfg80211_registered_device *rdev,
178 struct cfg80211_registered_device *drv;
179 int wiphy_idx, taken = -1, result, digits;
181 assert_cfg80211_lock();
183 /* prohibit calling the thing phy%d when %d is not its number */
184 sscanf(newname, PHY_NAME "%d%n", &wiphy_idx, &taken);
185 if (taken == strlen(newname) && wiphy_idx != rdev->wiphy_idx) {
186 /* count number of places needed to print wiphy_idx */
188 while (wiphy_idx /= 10)
191 * deny the name if it is phy<idx> where <idx> is printed
192 * without leading zeroes. taken == strlen(newname) here
194 if (taken == strlen(PHY_NAME) + digits)
199 /* Ignore nop renames */
200 if (strcmp(newname, dev_name(&rdev->wiphy.dev)) == 0)
203 /* Ensure another device does not already have this name. */
204 list_for_each_entry(drv, &cfg80211_drv_list, list)
205 if (strcmp(newname, dev_name(&drv->wiphy.dev)) == 0)
208 result = device_rename(&rdev->wiphy.dev, newname);
212 if (rdev->wiphy.debugfsdir &&
213 !debugfs_rename(rdev->wiphy.debugfsdir->d_parent,
214 rdev->wiphy.debugfsdir,
215 rdev->wiphy.debugfsdir->d_parent,
217 printk(KERN_ERR "cfg80211: failed to rename debugfs dir to %s!\n",
220 nl80211_notify_dev_rename(rdev);
225 static void cfg80211_rfkill_poll(struct rfkill *rfkill, void *data)
227 struct cfg80211_registered_device *drv = data;
229 drv->ops->rfkill_poll(&drv->wiphy);
232 static int cfg80211_rfkill_set_block(void *data, bool blocked)
234 struct cfg80211_registered_device *drv = data;
235 struct wireless_dev *wdev;
241 mutex_lock(&drv->devlist_mtx);
243 list_for_each_entry(wdev, &drv->netdev_list, list)
244 dev_close(wdev->netdev);
246 mutex_unlock(&drv->devlist_mtx);
252 static void cfg80211_rfkill_sync_work(struct work_struct *work)
254 struct cfg80211_registered_device *drv;
256 drv = container_of(work, struct cfg80211_registered_device, rfkill_sync);
257 cfg80211_rfkill_set_block(drv, rfkill_blocked(drv->rfkill));
260 /* exported functions */
262 struct wiphy *wiphy_new(const struct cfg80211_ops *ops, int sizeof_priv)
264 static int wiphy_counter;
266 struct cfg80211_registered_device *drv;
269 WARN_ON(!ops->add_key && ops->del_key);
270 WARN_ON(ops->add_key && !ops->del_key);
272 alloc_size = sizeof(*drv) + sizeof_priv;
274 drv = kzalloc(alloc_size, GFP_KERNEL);
280 mutex_lock(&cfg80211_mutex);
282 drv->wiphy_idx = wiphy_counter++;
284 if (unlikely(!wiphy_idx_valid(drv->wiphy_idx))) {
286 mutex_unlock(&cfg80211_mutex);
292 mutex_unlock(&cfg80211_mutex);
294 /* give it a proper name */
295 dev_set_name(&drv->wiphy.dev, PHY_NAME "%d", drv->wiphy_idx);
297 mutex_init(&drv->mtx);
298 mutex_init(&drv->devlist_mtx);
299 INIT_LIST_HEAD(&drv->netdev_list);
300 spin_lock_init(&drv->bss_lock);
301 INIT_LIST_HEAD(&drv->bss_list);
303 device_initialize(&drv->wiphy.dev);
304 drv->wiphy.dev.class = &ieee80211_class;
305 drv->wiphy.dev.platform_data = drv;
307 drv->rfkill_ops.set_block = cfg80211_rfkill_set_block;
308 drv->rfkill = rfkill_alloc(dev_name(&drv->wiphy.dev),
309 &drv->wiphy.dev, RFKILL_TYPE_WLAN,
310 &drv->rfkill_ops, drv);
317 INIT_WORK(&drv->rfkill_sync, cfg80211_rfkill_sync_work);
318 INIT_WORK(&drv->conn_work, cfg80211_conn_work);
321 * Initialize wiphy parameters to IEEE 802.11 MIB default values.
322 * Fragmentation and RTS threshold are disabled by default with the
325 drv->wiphy.retry_short = 7;
326 drv->wiphy.retry_long = 4;
327 drv->wiphy.frag_threshold = (u32) -1;
328 drv->wiphy.rts_threshold = (u32) -1;
332 EXPORT_SYMBOL(wiphy_new);
334 int wiphy_register(struct wiphy *wiphy)
336 struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
338 enum ieee80211_band band;
339 struct ieee80211_supported_band *sband;
340 bool have_band = false;
342 u16 ifmodes = wiphy->interface_modes;
344 /* sanity check ifmodes */
346 ifmodes &= ((1 << __NL80211_IFTYPE_AFTER_LAST) - 1) & ~1;
347 if (WARN_ON(ifmodes != wiphy->interface_modes))
348 wiphy->interface_modes = ifmodes;
350 /* sanity check supported bands/channels */
351 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
352 sband = wiphy->bands[band];
358 if (WARN_ON(!sband->n_channels || !sband->n_bitrates))
362 * Since we use a u32 for rate bitmaps in
363 * ieee80211_get_response_rate, we cannot
364 * have more than 32 legacy rates.
366 if (WARN_ON(sband->n_bitrates > 32))
369 for (i = 0; i < sband->n_channels; i++) {
370 sband->channels[i].orig_flags =
371 sband->channels[i].flags;
372 sband->channels[i].orig_mag =
373 sband->channels[i].max_antenna_gain;
374 sband->channels[i].orig_mpwr =
375 sband->channels[i].max_power;
376 sband->channels[i].band = band;
387 /* check and set up bitrates */
388 ieee80211_set_bitrate_flags(wiphy);
390 res = device_add(&drv->wiphy.dev);
394 res = rfkill_register(drv->rfkill);
398 mutex_lock(&cfg80211_mutex);
400 /* set up regulatory info */
401 wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
403 list_add(&drv->list, &cfg80211_drv_list);
405 mutex_unlock(&cfg80211_mutex);
408 drv->wiphy.debugfsdir =
409 debugfs_create_dir(wiphy_name(&drv->wiphy),
410 ieee80211_debugfs_dir);
411 if (IS_ERR(drv->wiphy.debugfsdir))
412 drv->wiphy.debugfsdir = NULL;
414 if (wiphy->custom_regulatory) {
415 struct regulatory_request request;
417 request.wiphy_idx = get_wiphy_idx(wiphy);
418 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
419 request.alpha2[0] = '9';
420 request.alpha2[1] = '9';
422 nl80211_send_reg_change_event(&request);
425 cfg80211_debugfs_drv_add(drv);
430 device_del(&drv->wiphy.dev);
433 EXPORT_SYMBOL(wiphy_register);
435 void wiphy_rfkill_start_polling(struct wiphy *wiphy)
437 struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
439 if (!drv->ops->rfkill_poll)
441 drv->rfkill_ops.poll = cfg80211_rfkill_poll;
442 rfkill_resume_polling(drv->rfkill);
444 EXPORT_SYMBOL(wiphy_rfkill_start_polling);
446 void wiphy_rfkill_stop_polling(struct wiphy *wiphy)
448 struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
450 rfkill_pause_polling(drv->rfkill);
452 EXPORT_SYMBOL(wiphy_rfkill_stop_polling);
454 void wiphy_unregister(struct wiphy *wiphy)
456 struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
458 rfkill_unregister(drv->rfkill);
460 /* protect the device list */
461 mutex_lock(&cfg80211_mutex);
463 BUG_ON(!list_empty(&drv->netdev_list));
466 * Try to grab drv->mtx. If a command is still in progress,
467 * hopefully the driver will refuse it since it's tearing
468 * down the device already. We wait for this command to complete
469 * before unlinking the item from the list.
470 * Note: as codified by the BUG_ON above we cannot get here if
471 * a virtual interface is still associated. Hence, we can only
472 * get to lock contention here if userspace issues a command
473 * that identified the hardware by wiphy index.
475 mutex_lock(&drv->mtx);
476 /* unlock again before freeing */
477 mutex_unlock(&drv->mtx);
479 cancel_work_sync(&drv->conn_work);
481 cfg80211_debugfs_drv_del(drv);
483 /* If this device got a regulatory hint tell core its
484 * free to listen now to a new shiny device regulatory hint */
485 reg_device_remove(wiphy);
487 list_del(&drv->list);
488 device_del(&drv->wiphy.dev);
489 debugfs_remove(drv->wiphy.debugfsdir);
491 mutex_unlock(&cfg80211_mutex);
493 EXPORT_SYMBOL(wiphy_unregister);
495 void cfg80211_dev_free(struct cfg80211_registered_device *drv)
497 struct cfg80211_internal_bss *scan, *tmp;
498 rfkill_destroy(drv->rfkill);
499 mutex_destroy(&drv->mtx);
500 mutex_destroy(&drv->devlist_mtx);
501 list_for_each_entry_safe(scan, tmp, &drv->bss_list, list)
502 cfg80211_put_bss(&scan->pub);
506 void wiphy_free(struct wiphy *wiphy)
508 put_device(&wiphy->dev);
510 EXPORT_SYMBOL(wiphy_free);
512 void wiphy_rfkill_set_hw_state(struct wiphy *wiphy, bool blocked)
514 struct cfg80211_registered_device *drv = wiphy_to_dev(wiphy);
516 if (rfkill_set_hw_state(drv->rfkill, blocked))
517 schedule_work(&drv->rfkill_sync);
519 EXPORT_SYMBOL(wiphy_rfkill_set_hw_state);
521 static int cfg80211_netdev_notifier_call(struct notifier_block * nb,
525 struct net_device *dev = ndev;
526 struct wireless_dev *wdev = dev->ieee80211_ptr;
527 struct cfg80211_registered_device *rdev;
532 rdev = wiphy_to_dev(wdev->wiphy);
534 WARN_ON(wdev->iftype == NL80211_IFTYPE_UNSPECIFIED);
537 case NETDEV_REGISTER:
538 mutex_lock(&rdev->devlist_mtx);
539 list_add(&wdev->list, &rdev->netdev_list);
540 if (sysfs_create_link(&dev->dev.kobj, &rdev->wiphy.dev.kobj,
542 printk(KERN_ERR "wireless: failed to add phy80211 "
543 "symlink to netdev!\n");
546 wdev->sme_state = CFG80211_SME_IDLE;
547 mutex_unlock(&rdev->devlist_mtx);
548 #ifdef CONFIG_WIRELESS_EXT
549 wdev->wext.default_key = -1;
550 wdev->wext.default_mgmt_key = -1;
551 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
552 wdev->wext.ps = CONFIG_CFG80211_DEFAULT_PS_VALUE;
553 wdev->wext.ps_timeout = 500;
554 if (rdev->ops->set_power_mgmt)
555 if (rdev->ops->set_power_mgmt(wdev->wiphy, dev,
557 wdev->wext.ps_timeout)) {
558 /* assume this means it's off */
559 wdev->wext.ps = false;
563 case NETDEV_GOING_DOWN:
564 switch (wdev->iftype) {
565 case NL80211_IFTYPE_ADHOC:
566 cfg80211_leave_ibss(rdev, dev, true);
568 case NL80211_IFTYPE_STATION:
569 #ifdef CONFIG_WIRELESS_EXT
570 kfree(wdev->wext.ie);
571 wdev->wext.ie = NULL;
572 wdev->wext.ie_len = 0;
573 wdev->wext.connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
575 cfg80211_disconnect(rdev, dev,
576 WLAN_REASON_DEAUTH_LEAVING, true);
577 cfg80211_mlme_down(rdev, dev);
584 #ifdef CONFIG_WIRELESS_EXT
585 switch (wdev->iftype) {
586 case NL80211_IFTYPE_ADHOC:
587 if (wdev->wext.ibss.ssid_len)
588 cfg80211_join_ibss(rdev, dev,
591 case NL80211_IFTYPE_STATION:
592 if (wdev->wext.connect.ssid_len)
593 cfg80211_connect(rdev, dev,
594 &wdev->wext.connect);
601 case NETDEV_UNREGISTER:
602 mutex_lock(&rdev->devlist_mtx);
603 if (!list_empty(&wdev->list)) {
604 sysfs_remove_link(&dev->dev.kobj, "phy80211");
605 list_del_init(&wdev->list);
607 mutex_unlock(&rdev->devlist_mtx);
610 if (rfkill_blocked(rdev->rfkill))
611 return notifier_from_errno(-ERFKILL);
618 static struct notifier_block cfg80211_netdev_notifier = {
619 .notifier_call = cfg80211_netdev_notifier_call,
622 static int cfg80211_init(void)
626 err = wiphy_sysfs_init();
630 err = register_netdevice_notifier(&cfg80211_netdev_notifier);
632 goto out_fail_notifier;
634 err = nl80211_init();
636 goto out_fail_nl80211;
638 ieee80211_debugfs_dir = debugfs_create_dir("ieee80211", NULL);
640 err = regulatory_init();
647 debugfs_remove(ieee80211_debugfs_dir);
649 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
656 subsys_initcall(cfg80211_init);
658 static void cfg80211_exit(void)
660 debugfs_remove(ieee80211_debugfs_dir);
662 unregister_netdevice_notifier(&cfg80211_netdev_notifier);
666 module_exit(cfg80211_exit);