自学教程：C++ wiphy_to_dev函数代码示例

int cfg80211_wext_siwgenie(struct net_device *dev,			   struct iw_request_info *info,			   struct iw_point *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	u8 *ie = extra;	int ie_len = data->length, err;	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EOPNOTSUPP;	if (!ie_len)		ie = NULL;	wdev_lock(wdev);	/* no change */	err = 0;	if (wdev->wext.ie_len == ie_len &&	    memcmp(wdev->wext.ie, ie, ie_len) == 0)		goto out;	if (ie_len) {		ie = kmemdup(extra, ie_len, GFP_KERNEL);		if (!ie) {			err = -ENOMEM;			goto out;		}	} else		ie = NULL;	kfree(wdev->wext.ie);	wdev->wext.ie = ie;	wdev->wext.ie_len = ie_len;	if (wdev->sme_state != CFG80211_SME_IDLE) {		err = __cfg80211_disconnect(rdev, dev,					    WLAN_REASON_DEAUTH_LEAVING, false);		if (err)			goto out;	}	/* userspace better not think we'll reconnect */	err = 0; out:	wdev_unlock(wdev);	return err;}

static int cfg80211_set_ringparam(struct net_device *dev,				  struct ethtool_ringparam *rp){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	if (rp->rx_mini_pending != 0 || rp->rx_jumbo_pending != 0)		return -EINVAL;	if (rdev->ops->set_ringparam)		return rdev->ops->set_ringparam(wdev->wiphy,						rp->tx_pending, rp->rx_pending);	return -ENOTSUPP;}

void cfg80211_send_assoc_timeout(struct net_device *dev, const u8 *addr){    struct wireless_dev *wdev = dev->ieee80211_ptr;    struct wiphy *wiphy = wdev->wiphy;    struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);    wdev_lock(wdev);    nl80211_send_assoc_timeout(rdev, dev, addr, GFP_KERNEL);    if (wdev->sme_state == CFG80211_SME_CONNECTING)        __cfg80211_connect_result(dev, addr, NULL, 0, NULL, 0,                                  WLAN_STATUS_UNSPECIFIED_FAILURE,                                  false, NULL);    wdev_unlock(wdev);}

static int cfg80211_wext_siwpower(struct net_device *dev,				  struct iw_request_info *info,				  struct iw_param *wrq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	bool ps = wdev->ps;	int timeout = wdev->ps_timeout;	int err;	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EINVAL;	if (!rdev->ops->set_power_mgmt)		return -EOPNOTSUPP;	if (wrq->disabled) {		ps = false;	} else {		switch (wrq->flags & IW_POWER_MODE) {		case IW_POWER_ON:       /* If not specified */		case IW_POWER_MODE:     /* If set all mask */		case IW_POWER_ALL_R:    /* If explicitely state all */			ps = true;			break;		default:                /* Otherwise we ignore */			return -EINVAL;		}		if (wrq->flags & ~(IW_POWER_MODE | IW_POWER_TIMEOUT))			return -EINVAL;		if (wrq->flags & IW_POWER_TIMEOUT)			timeout = wrq->value / 1000;	}	err = rdev->ops->set_power_mgmt(wdev->wiphy, dev, ps, timeout);	if (err)		return err;	wdev->ps = ps;	wdev->ps_timeout = timeout;	return 0;}

static int cfg80211_wext_siwtxpower(struct net_device *dev,				    struct iw_request_info *info,				    union iwreq_data *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	enum nl80211_tx_power_setting type;	int dbm = 0;	if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)		return -EINVAL;	if (data->txpower.flags & IW_TXPOW_RANGE)		return -EINVAL;	if (!rdev->ops->set_tx_power)		return -EOPNOTSUPP;		if (!data->txpower.disabled) {		rfkill_set_sw_state(rdev->rfkill, false);		if (data->txpower.fixed) {			if (data->txpower.value < 0)				return -EINVAL;			dbm = data->txpower.value;			type = NL80211_TX_POWER_FIXED;					} else {			if (data->txpower.value < 0) {				type = NL80211_TX_POWER_AUTOMATIC;			} else {				dbm = data->txpower.value;				type = NL80211_TX_POWER_LIMITED;			}		}	} else {		rfkill_set_sw_state(rdev->rfkill, true);		schedule_work(&rdev->rfkill_sync);		return 0;	}	return rdev->ops->set_tx_power(wdev->wiphy, type, DBM_TO_MBM(dbm));}

int cfg80211_wext_siwmlme(struct net_device *dev,			  struct iw_request_info *info,			  struct iw_point *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct iw_mlme *mlme = (struct iw_mlme *)extra;	struct cfg80211_registered_device *rdev;	union {		struct cfg80211_disassoc_request disassoc;		struct cfg80211_deauth_request deauth;	} cmd;	if (!wdev)		return -EOPNOTSUPP;	rdev = wiphy_to_dev(wdev->wiphy);	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EINVAL;	if (mlme->addr.sa_family != ARPHRD_ETHER)		return -EINVAL;	memset(&cmd, 0, sizeof(cmd));	switch (mlme->cmd) {	case IW_MLME_DEAUTH:		if (!rdev->ops->deauth)			return -EOPNOTSUPP;		cmd.deauth.peer_addr = mlme->addr.sa_data;		cmd.deauth.reason_code = mlme->reason_code;		return rdev->ops->deauth(wdev->wiphy, dev, &cmd.deauth);	case IW_MLME_DISASSOC:		if (!rdev->ops->disassoc)			return -EOPNOTSUPP;		cmd.disassoc.peer_addr = mlme->addr.sa_data;		cmd.disassoc.reason_code = mlme->reason_code;		return rdev->ops->disassoc(wdev->wiphy, dev, &cmd.disassoc);	default:		return -EOPNOTSUPP;	}}

int cfg80211_wext_giwfreq(struct net_device *dev,			  struct iw_request_info *info,			  struct iw_freq *freq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	switch (wdev->iftype) {	case NL80211_IFTYPE_STATION:		return cfg80211_mgd_wext_giwfreq(dev, info, freq, extra);	case NL80211_IFTYPE_ADHOC:		return cfg80211_ibss_wext_giwfreq(dev, info, freq, extra);	default:		if (!rdev->channel)			return -EINVAL;		freq->m = rdev->channel->center_freq;		freq->e = 6;		return 0;	}}

int cfg80211_ibss_wext_siwessid(struct net_device *dev,                                struct iw_request_info *info,                                struct iw_point *data, char *ssid){    struct wireless_dev *wdev = dev->ieee80211_ptr;    struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);    size_t len = data->length;    int err;    /* call only for ibss! */    if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))        return -EINVAL;    if (!rdev->ops->join_ibss)        return -EOPNOTSUPP;    wdev_lock(wdev);    err = 0;    if (wdev->ssid_len)        err = __cfg80211_leave_ibss(rdev, dev, true);    wdev_unlock(wdev);    if (err)        return err;    /* iwconfig uses nul termination in SSID.. */    if (len > 0 && ssid[len - 1] == '/0')        len--;    wdev->wext.ibss.ssid = wdev->ssid;    memcpy(wdev->wext.ibss.ssid, ssid, len);    wdev->wext.ibss.ssid_len = len;    mutex_lock(&rdev->devlist_mtx);    wdev_lock(wdev);    err = cfg80211_ibss_wext_join(rdev, wdev);    wdev_unlock(wdev);    mutex_unlock(&rdev->devlist_mtx);    return err;}

int cfg80211_wext_giwrate(struct net_device *dev,			  struct iw_request_info *info,			  struct iw_param *rate, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	/* we are under RTNL - globally locked - so can use a static struct */	static struct station_info sinfo;	u8 addr[ETH_ALEN];	int err;	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EOPNOTSUPP;	if (!rdev->ops->get_station)		return -EOPNOTSUPP;	err = 0;	wdev_lock(wdev);	if (wdev->current_bss)		memcpy(addr, wdev->current_bss->pub.bssid, ETH_ALEN);	else		err = -EOPNOTSUPP;	wdev_unlock(wdev);	if (err)		return err;	err = rdev->ops->get_station(&rdev->wiphy, dev, addr, &sinfo);	if (err)		return err;	if (!(sinfo.filled & STATION_INFO_TX_BITRATE))		return -EOPNOTSUPP;	rate->value = 0;	if (!(sinfo.txrate.flags & RATE_INFO_FLAGS_MCS))		rate->value = 100000 * sinfo.txrate.legacy;	return 0;}

void cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid, gfp_t gfp){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	struct cfg80211_event *ev;	unsigned long flags;	CFG80211_DEV_WARN_ON(!wdev->ssid_len);	ev = kzalloc(sizeof(*ev), gfp);	if (!ev)		return;	ev->type = EVENT_IBSS_JOINED;	memcpy(ev->cr.bssid, bssid, ETH_ALEN);	spin_lock_irqsave(&wdev->event_lock, flags);	list_add_tail(&ev->list, &wdev->event_list);	spin_unlock_irqrestore(&wdev->event_lock, flags);	queue_work(cfg80211_wq, &rdev->event_work);}

void __cfg80211_ibss_joined(struct net_device *dev, const u8 *bssid){    struct wireless_dev *wdev = dev->ieee80211_ptr;    struct cfg80211_bss *bss;#ifdef CONFIG_CFG80211_WEXT    union iwreq_data wrqu;#endif    if (WARN_ON(wdev->iftype != NL80211_IFTYPE_ADHOC))        return;    if (!wdev->ssid_len)        return;    bss = cfg80211_get_bss(wdev->wiphy, NULL, bssid,                           wdev->ssid, wdev->ssid_len,                           WLAN_CAPABILITY_IBSS, WLAN_CAPABILITY_IBSS);    if (WARN_ON(!bss))        return;    if (wdev->current_bss) {        cfg80211_unhold_bss(wdev->current_bss);        cfg80211_put_bss(wdev->wiphy, &wdev->current_bss->pub);    }    cfg80211_hold_bss(bss_from_pub(bss));    wdev->current_bss = bss_from_pub(bss);    wdev->sme_state = CFG80211_SME_CONNECTED;    cfg80211_upload_connect_keys(wdev);    nl80211_send_ibss_bssid(wiphy_to_dev(wdev->wiphy), dev, bssid,                            GFP_KERNEL);#ifdef CONFIG_CFG80211_WEXT    memset(&wrqu, 0, sizeof(wrqu));    memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);    wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);#endif}

static int cfg80211_wext_siwpmksa(struct net_device *dev,				  struct iw_request_info *info,				  struct iw_point *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	struct cfg80211_pmksa cfg_pmksa;	struct iw_pmksa *pmksa = (struct iw_pmksa *)extra;	memset(&cfg_pmksa, 0, sizeof(struct cfg80211_pmksa));	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EINVAL;	cfg_pmksa.bssid = pmksa->bssid.sa_data;	cfg_pmksa.pmkid = pmksa->pmkid;	switch (pmksa->cmd) {	case IW_PMKSA_ADD:		if (!rdev->ops->set_pmksa)			return -EOPNOTSUPP;		return rdev->ops->set_pmksa(&rdev->wiphy, dev, &cfg_pmksa);	case IW_PMKSA_REMOVE:		if (!rdev->ops->del_pmksa)			return -EOPNOTSUPP;		return rdev->ops->del_pmksa(&rdev->wiphy, dev, &cfg_pmksa);	case IW_PMKSA_FLUSH:		if (!rdev->ops->flush_pmksa)			return -EOPNOTSUPP;		return rdev->ops->flush_pmksa(&rdev->wiphy, dev);	default:		return -EOPNOTSUPP;	}}

int cfg80211_wext_siwmode(struct net_device *dev, struct iw_request_info *info,			  u32 *mode, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev;	struct vif_params vifparams;	enum nl80211_iftype type;	int ret;	rdev = wiphy_to_dev(wdev->wiphy);	switch (*mode) {	case IW_MODE_INFRA:		type = NL80211_IFTYPE_STATION;		break;	case IW_MODE_ADHOC:		type = NL80211_IFTYPE_ADHOC;		break;	case IW_MODE_REPEAT:		type = NL80211_IFTYPE_WDS;		break;	case IW_MODE_MONITOR:		type = NL80211_IFTYPE_MONITOR;		break;	default:		return -EINVAL;	}	if (type == wdev->iftype)		return 0;	memset(&vifparams, 0, sizeof(vifparams));	cfg80211_lock_rdev(rdev);	ret = cfg80211_change_iface(rdev, dev, type, NULL, &vifparams);	cfg80211_unlock_rdev(rdev);	return ret;}

static int cfg80211_wext_siwretry(struct net_device *dev,				  struct iw_request_info *info,				  struct iw_param *retry, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	u32 changed = 0;	u8 olong = wdev->wiphy->retry_long;	u8 oshort = wdev->wiphy->retry_short;	int err;	if (retry->disabled ||	    (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)		return -EINVAL;	if (retry->flags & IW_RETRY_LONG) {		wdev->wiphy->retry_long = retry->value;		changed |= WIPHY_PARAM_RETRY_LONG;	} else if (retry->flags & IW_RETRY_SHORT) {		wdev->wiphy->retry_short = retry->value;		changed |= WIPHY_PARAM_RETRY_SHORT;	} else {		wdev->wiphy->retry_short = retry->value;		wdev->wiphy->retry_long = retry->value;		changed |= WIPHY_PARAM_RETRY_LONG;		changed |= WIPHY_PARAM_RETRY_SHORT;	}	if (!changed)		return 0;	err = rdev->ops->set_wiphy_params(wdev->wiphy, changed);	if (err) {		wdev->wiphy->retry_short = oshort;		wdev->wiphy->retry_long = olong;	}	return err;}

static int cfg80211_wext_giwrate(struct net_device *dev,				 struct iw_request_info *info,				 struct iw_param *rate, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);		static struct station_info sinfo;	u8 addr[ETH_ALEN];	int err;	if (wdev->iftype != NL80211_IFTYPE_STATION)		return -EOPNOTSUPP;	if (!rdev->ops->get_station)		return -EOPNOTSUPP;	err = 0;	wdev_lock(wdev);	if (wdev->current_bss)		memcpy(addr, wdev->current_bss->pub.bssid, ETH_ALEN);	else		err = -EOPNOTSUPP;	wdev_unlock(wdev);	if (err)		return err;	err = rdev->ops->get_station(&rdev->wiphy, dev, addr, &sinfo);	if (err)		return err;	if (!(sinfo.filled & STATION_INFO_TX_BITRATE))		return -EOPNOTSUPP;	rate->value = 100000 * cfg80211_calculate_bitrate(&sinfo.txrate);	return 0;}

int cfg80211_wext_siwrts(struct net_device *dev,			 struct iw_request_info *info,			 struct iw_param *rts, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	u32 orts = wdev->wiphy->rts_threshold;	int err;	if (rts->disabled || !rts->fixed)		wdev->wiphy->rts_threshold = (u32) -1;	else if (rts->value < 0)		return -EINVAL;	else		wdev->wiphy->rts_threshold = rts->value;	err = rdev->ops->set_wiphy_params(wdev->wiphy,					  WIPHY_PARAM_RTS_THRESHOLD);	if (err)		wdev->wiphy->rts_threshold = orts;	return err;}

void __cfg80211_send_deauth(struct net_device *dev,				   const u8 *buf, size_t len){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct wiphy *wiphy = wdev->wiphy;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)buf;	const u8 *bssid = mgmt->bssid;	bool was_current = false;	trace___cfg80211_send_deauth(dev);	ASSERT_WDEV_LOCK(wdev);	if (wdev->current_bss &&	    ether_addr_equal(wdev->current_bss->pub.bssid, bssid)) {		cfg80211_unhold_bss(wdev->current_bss);		cfg80211_put_bss(wiphy, &wdev->current_bss->pub);		wdev->current_bss = NULL;		was_current = true;	}	nl80211_send_deauth(rdev, dev, buf, len, GFP_KERNEL);	if (wdev->sme_state == CFG80211_SME_CONNECTED && was_current) {		u16 reason_code;		bool from_ap;		reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);		from_ap = !ether_addr_equal(mgmt->sa, dev->dev_addr);		__cfg80211_disconnected(dev, NULL, 0, reason_code, from_ap);	} else if (wdev->sme_state == CFG80211_SME_CONNECTING) {		__cfg80211_connect_result(dev, mgmt->bssid, NULL, 0, NULL, 0,					  WLAN_STATUS_UNSPECIFIED_FAILURE,					  false, NULL);	}}

/* Get wireless statistics.  Called by /proc/net/wireless and by SIOCGIWSTATS */static struct iw_statistics *cfg80211_wireless_stats(struct net_device *dev){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	/* we are under RTNL - globally locked - so can use static structs */	static struct iw_statistics wstats;	static struct station_info sinfo;	u8 bssid[ETH_ALEN];	if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION)		return NULL;	if (!rdev->ops->get_station)		return NULL;	/* Grab BSSID of current BSS, if any */	wdev_lock(wdev);	if (!wdev->current_bss) {		wdev_unlock(wdev);		return NULL;	}	memcpy(bssid, wdev->current_bss->pub.bssid, ETH_ALEN);	wdev_unlock(wdev);	if (rdev->ops->get_station(&rdev->wiphy, dev, bssid, &sinfo))		return NULL;	memset(&wstats, 0, sizeof(wstats));	switch (rdev->wiphy.signal_type) {	case CFG80211_SIGNAL_TYPE_MBM:		if (sinfo.filled & STATION_INFO_SIGNAL) {			int sig = sinfo.signal;			wstats.qual.updated |= IW_QUAL_LEVEL_UPDATED;			wstats.qual.updated |= IW_QUAL_QUAL_UPDATED;			wstats.qual.updated |= IW_QUAL_DBM;			wstats.qual.level = sig;			if (sig < -110)				sig = -110;			else if (sig > -40)				sig = -40;			wstats.qual.qual = sig + 110;			break;		}	case CFG80211_SIGNAL_TYPE_UNSPEC:		if (sinfo.filled & STATION_INFO_SIGNAL) {			wstats.qual.updated |= IW_QUAL_LEVEL_UPDATED;			wstats.qual.updated |= IW_QUAL_QUAL_UPDATED;			wstats.qual.level = sinfo.signal;			wstats.qual.qual = sinfo.signal;			break;		}	default:		wstats.qual.updated |= IW_QUAL_LEVEL_INVALID;		wstats.qual.updated |= IW_QUAL_QUAL_INVALID;	}	wstats.qual.updated |= IW_QUAL_NOISE_INVALID;	if (sinfo.filled & STATION_INFO_RX_DROP_MISC)		wstats.discard.misc = sinfo.rx_dropped_misc;	if (sinfo.filled & STATION_INFO_TX_FAILED)		wstats.discard.retries = sinfo.tx_failed;	return &wstats;}

int cfg80211_wext_giwencode(struct net_device *dev,			    struct iw_request_info *info,			    struct iw_point *erq, char *keybuf){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	int idx, err;	struct giwencode_cookie data = {		.keybuf = keybuf,		.buflen = erq->length,	};	if (!rdev->ops->get_key)		return -EOPNOTSUPP;	idx = erq->flags & IW_ENCODE_INDEX;	if (idx == 0) {		idx = wdev->wext.default_key;		if (idx < 0)			idx = 0;	} else if (idx < 1 || idx > 4)		return -EINVAL;	else		idx--;	erq->flags = idx + 1;	err = rdev->ops->get_key(&rdev->wiphy, dev, idx, NULL, &data,				 giwencode_get_key_cb);	if (!err) {		erq->length = data.buflen;		erq->flags |= IW_ENCODE_ENABLED;		return 0;	}	if (err == -ENOENT) {		erq->flags |= IW_ENCODE_DISABLED;		erq->length = 0;		return 0;	}	return err;}EXPORT_SYMBOL_GPL(cfg80211_wext_giwencode);int cfg80211_wext_siwtxpower(struct net_device *dev,			     struct iw_request_info *info,			     union iwreq_data *data, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	enum tx_power_setting type;	int dbm = 0;	if ((data->txpower.flags & IW_TXPOW_TYPE) != IW_TXPOW_DBM)		return -EINVAL;	if (data->txpower.flags & IW_TXPOW_RANGE)		return -EINVAL;	if (!rdev->ops->set_tx_power)		return -EOPNOTSUPP;	/* only change when not disabling */	if (!data->txpower.disabled) {		rfkill_set_sw_state(rdev->rfkill, false);		if (data->txpower.fixed) {			/*			 * wext doesn't support negative values, see			 * below where it's for automatic			 */			if (data->txpower.value < 0)				return -EINVAL;			dbm = data->txpower.value;			type = TX_POWER_FIXED;			/* TODO: do regulatory check! */		} else {			/*			 * Automatic power level setting, max being the value			 * passed in from userland.			 */			if (data->txpower.value < 0) {				type = TX_POWER_AUTOMATIC;			} else {				dbm = data->txpower.value;				type = TX_POWER_LIMITED;			}		}	} else {		rfkill_set_sw_state(rdev->rfkill, true);		schedule_work(&rdev->rfkill_sync);		return 0;	}	return rdev->ops->set_tx_power(wdev->wiphy, type, dbm);;}EXPORT_SYMBOL_GPL(cfg80211_wext_siwtxpower);int cfg80211_wext_giwtxpower(struct net_device *dev,			     struct iw_request_info *info,//.........这里部分代码省略.........

int cfg80211_mgd_wext_siwfreq(struct net_device *dev,			      struct iw_request_info *info,			      struct iw_freq *wextfreq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	struct ieee80211_channel *chan = NULL;	int err, freq;	/* call only for station! */	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))		return -EINVAL;	freq = cfg80211_wext_freq(wdev->wiphy, wextfreq);	if (freq < 0)		return freq;	if (freq) {		chan = ieee80211_get_channel(wdev->wiphy, freq);		if (!chan)			return -EINVAL;		if (chan->flags & IEEE80211_CHAN_DISABLED)			return -EINVAL;	}	cfg80211_lock_rdev(rdev);	mutex_lock(&rdev->devlist_mtx);	wdev_lock(wdev);	if (wdev->sme_state != CFG80211_SME_IDLE) {		bool event = true;		if (wdev->wext.connect.channel == chan) {			err = 0;			goto out;		}		/* if SSID set, we'll try right again, avoid event */		if (wdev->wext.connect.ssid_len)			event = false;		err = __cfg80211_disconnect(rdev, dev,					    WLAN_REASON_DEAUTH_LEAVING, event);		if (err)			goto out;	}	wdev->wext.connect.channel = chan;	/* SSID is not set, we just want to switch channel */	if (chan && !wdev->wext.connect.ssid_len) {		err = cfg80211_set_freq(rdev, wdev, freq, NL80211_CHAN_NO_HT);		goto out;	}	err = cfg80211_mgd_wext_connect(rdev, wdev); out:	wdev_unlock(wdev);	mutex_unlock(&rdev->devlist_mtx);	cfg80211_unlock_rdev(rdev);	return err;}

static int cfg80211_wext_siwencodeext(struct net_device *dev,				      struct iw_request_info *info,				      struct iw_point *erq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;	const u8 *addr;	int idx;	bool remove = false;	struct key_params params;	u32 cipher;	if (wdev->iftype != NL80211_IFTYPE_STATION &&	    wdev->iftype != NL80211_IFTYPE_ADHOC)		return -EOPNOTSUPP;	/* no use -- only MFP (set_default_mgmt_key) is optional */	if (!rdev->ops->del_key ||	    !rdev->ops->add_key ||	    !rdev->ops->set_default_key)		return -EOPNOTSUPP;	switch (ext->alg) {	case IW_ENCODE_ALG_NONE:		remove = true;		cipher = 0;		break;	case IW_ENCODE_ALG_WEP:		if (ext->key_len == 5)			cipher = WLAN_CIPHER_SUITE_WEP40;		else if (ext->key_len == 13)			cipher = WLAN_CIPHER_SUITE_WEP104;		else			return -EINVAL;		break;	case IW_ENCODE_ALG_TKIP:		cipher = WLAN_CIPHER_SUITE_TKIP;		break;	case IW_ENCODE_ALG_CCMP:		cipher = WLAN_CIPHER_SUITE_CCMP;		break;	case IW_ENCODE_ALG_AES_CMAC:		cipher = WLAN_CIPHER_SUITE_AES_CMAC;		break;	default:		return -EOPNOTSUPP;	}	if (erq->flags & IW_ENCODE_DISABLED)		remove = true;	idx = erq->flags & IW_ENCODE_INDEX;	if (cipher == WLAN_CIPHER_SUITE_AES_CMAC) {		if (idx < 4 || idx > 5) {			idx = wdev->wext.default_mgmt_key;			if (idx < 0)				return -EINVAL;		} else			idx--;	} else {		if (idx < 1 || idx > 4) {			idx = wdev->wext.default_key;			if (idx < 0)				return -EINVAL;		} else			idx--;	}	addr = ext->addr.sa_data;	if (is_broadcast_ether_addr(addr))		addr = NULL;	memset(&params, 0, sizeof(params));	params.key = ext->key;	params.key_len = ext->key_len;	params.cipher = cipher;	if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {		params.seq = ext->rx_seq;		params.seq_len = 6;	}	return cfg80211_set_encryption(			rdev, dev,			!(ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY),			addr, remove,			ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY,			idx, &params);}

int cfg80211_mgd_wext_siwfreq(struct net_device *dev,			      struct iw_request_info *info,			      struct iw_freq *wextfreq, char *extra){	struct wireless_dev *wdev = dev->ieee80211_ptr;	struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);	struct ieee80211_channel *chan = NULL;	int err, freq;	/* call only for station! */	if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION))		return -EINVAL;	freq = cfg80211_wext_freq(wdev->wiphy, wextfreq);	if (freq < 0)		return freq;	if (freq) {		chan = ieee80211_get_channel(wdev->wiphy, freq);		if (!chan)			return -EINVAL;		if (chan->flags & IEEE80211_CHAN_DISABLED)			return -EINVAL;	}	cfg80211_lock_rdev(rdev);	mutex_lock(&rdev->devlist_mtx);	wdev_lock(wdev);	if (wdev->sme_state != CFG80211_SME_IDLE) {		bool event = true;		if (wdev->wext.connect.channel == chan) {			err = 0;			goto out;		}		/* if SSID set, we'll try right again, avoid event */		if (wdev->wext.connect.ssid_len)			event = false;		err = __cfg80211_disconnect(rdev, dev,					    WLAN_REASON_DEAUTH_LEAVING, event);		if (err)			goto out;	}	wdev->wext.connect.channel = chan;	/*	 * SSID is not set, we just want to switch monitor channel,	 * this is really just backward compatibility, if the SSID	 * is set then we use the channel to select the BSS to use	 * to connect to instead. If we were connected on another	 * channel we disconnected above and reconnect below.	 */	if (chan && !wdev->wext.connect.ssid_len) {		struct cfg80211_chan_def chandef = {			.width = NL80211_CHAN_WIDTH_20_NOHT,			.center_freq1 = freq,		};		chandef.chan = ieee80211_get_channel(&rdev->wiphy, freq);		if (chandef.chan)			err = cfg80211_set_monitor_channel(rdev, &chandef);		else			err = -EINVAL;		goto out;	}	err = cfg80211_mgd_wext_connect(rdev, wdev); out:	wdev_unlock(wdev);	mutex_unlock(&rdev->devlist_mtx);	cfg80211_unlock_rdev(rdev);	return err;}