ieee80211_wx.c

RTL8187 for linux驱动 提供内核支持802.11g的模块

	}
	
	if (ieee->crypt == NULL) {
		struct ieee80211_crypt_data *new_crypt;
		
		/* take WEP into use */
		new_crypt = (struct ieee80211_crypt_data *)
			kmalloc(sizeof(struct ieee80211_crypt_data), 
				GFP_KERNEL);
		if (new_crypt == NULL)
			return -ENOMEM;
		memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
		new_crypt->ops = hostap_get_crypto_ops("WEP");
		if (!new_crypt->ops) {
			request_module("hostap_crypt_wep");
			new_crypt->ops = hostap_get_crypto_ops("WEP");
		}
		if (new_crypt->ops)
			new_crypt->priv = new_crypt->ops->init();
		if (!new_crypt->ops || !new_crypt->priv) {
			kfree(new_crypt);
			new_crypt = NULL;

			printk(KERN_WARNING "%s: could not initialize WEP: "
			       "load module hostap_crypt_wep.o\n",
			       dev->name);
			return -EOPNOTSUPP;
		}
		first = 1;
		ieee->crypt = new_crypt;
	}

	i = erq->flags & IW_ENCODE_INDEX;
	if (i < 1 || i > 4)
		i = ieee->crypt->ops->get_key_idx(ieee->crypt->priv);
	else
		i--;
	if (i < 0 || i >= WEP_KEYS)
		return -EINVAL;

	if (erq->length > 0) {
		int len = erq->length <= 5 ? 5 : 13;
		if (len > erq->length)
			memset(key + erq->length, 0, len - erq->length);

		ieee->crypt->ops->set_key(i, key, len, ieee->crypt->priv);
		memcpy(sec.keys[i], key, len);
		sec.key_sizes[i] = len;
		sec.flags |= (1 << i);

		if (first) {
			ieee->crypt->ops->set_key_idx(i, ieee->crypt->priv);
			sec.active_key = i;
			sec.flags |= SEC_ACTIVE_KEY;
		}

	} else if (ieee->crypt->ops->set_key_idx(i, ieee->crypt->priv) < 0)
		return -EINVAL; /* keyidx not valid */
	else {
		sec.active_key = i;
		sec.flags |= SEC_ACTIVE_KEY;
	}
	

 done:
	ieee->open_wep = erq->flags & IW_ENCODE_OPEN;
	sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN : WLAN_AUTH_SHARED_KEY;
	sec.flags |= SEC_AUTH_MODE;

	if (ieee->func && ieee->func->set_security)
		ieee->func->set_security(ieee, &sec);

	/* Do not reset port if card is in Managed mode since resetting will
	 * generate new IEEE 802.11 authentication which may end up in looping
	 * with IEEE 802.1X.  If your hardware requires a reset after WEP
	 * configuration (for example... Prism2), implement the reset_port in 
	 * the callbacks structures used to initialize the 802.11 stack. */
	if (ieee->reset_on_keychange &&
	    ieee->iw_mode != IW_MODE_INFRA && 
	    ieee->func->reset_port &&
	    ieee->func->reset_port(dev)) {
		printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
		return -EINVAL;
	}
	return 0;
#endif
}

#endif
 int ieee80211_r8180_wx_set_essid(struct ieee80211_device *ieee, struct iw_request_info *a,union iwreq_data *wrqu,char *extra)
{
	
	
	struct ieee80211_beacon *beacon;
	struct list_head *b,*delprev,*prev,*next;
	unsigned long flags;
	//u8* tmp;
	
	delprev = NULL;	
	
	if(ieee->iw_mode == IW_MODE_ADHOC || ieee->iw_mode == IW_MODE_MASTER){
		if(wrqu->essid.flags && wrqu->essid.length) 
			ieee80211_r8180_set_master_essid(ieee,extra,wrqu->essid.length); 
		else return -1;
		//return 0;
	}
	
	//if(wrqu->essid.flags && wrqu->essid.length){
		
		memcpy(ieee->ssid,extra,wrqu->essid.length);
		ieee->ssid[wrqu->essid.length] = '\0';
		//-----
		spin_lock_irqsave(&ieee->irq_lock, flags);
		
		list_for_each(b,&ieee->beacons){
			if (delprev){
				kfree(list_entry(delprev,struct ieee80211_beacon,list));
				delprev=NULL;
			}
			
			beacon=list_entry(b,struct ieee80211_beacon,list);
			
			if(beacon->last_scanned + SCAN_JIFFI < jiffies){ 
		
				prev = b->prev;
				next = b->next;
				next->prev = prev;
				prev->next = next;
				delprev=b;
		
			}else{
				ieee80211_new_net(ieee,beacon);
		
			}
		}
	
		if (delprev){
				kfree(list_entry(delprev,struct ieee80211_beacon,list));
				delprev=NULL;
		}
		
		spin_unlock_irqrestore(&ieee->irq_lock, flags);
		//------
		
		
	//}
	
	
	return 0;
	

}


int ieee80211_r8180_wx_set_wap(struct ieee80211_device *ieee,
			 struct iw_request_info *info,
			 union iwreq_data *awrq,
			 char *extra)
{
	struct sockaddr *temp = (struct sockaddr *)awrq;
	struct ieee80211_beacon *beacon;
	
	struct list_head *b,*delprev,*prev,*next;
	unsigned long flags;
	
	
	delprev = NULL;	
	if (temp->sa_family != ARPHRD_ETHER)
		return -EINVAL;
	memcpy(ieee->ap, temp->sa_data, ETH_ALEN); 
	if(ieee->iw_mode == IW_MODE_ADHOC || ieee->iw_mode == IW_MODE_MASTER){
		memcpy(ieee->beacon_cell_ssid, temp->sa_data, ETH_ALEN);
	}else{
		//IEEE80211DMESG("Setting AP to"MACSTR, MAC2STR(ieee->ap));
		spin_lock_irqsave(&ieee->irq_lock, flags);
			
		list_for_each(b,&ieee->beacons){
		
		if (delprev){
				kfree(list_entry(delprev,struct ieee80211_beacon,list));
				delprev=NULL;
			}
			
			beacon=list_entry(b,struct ieee80211_beacon,list);
			
		
			if(beacon->last_scanned + SCAN_JIFFI < jiffies){ 
		
				prev = b->prev;
				next = b->next;
				next->prev = prev;
				prev->next = next;
				delprev=b;
				
			}else{
				ieee80211_new_net(ieee,beacon);
				
			}
		}
	
		if (delprev){
				kfree(list_entry(delprev,struct ieee80211_beacon,list));
				delprev=NULL;
		}
		
		spin_unlock_irqrestore(&ieee->irq_lock, flags);
		//------
	}
	return 0;
}
	
 int ieee80211_r8180_wx_get_essid(struct ieee80211_device *ieee, struct iw_request_info *a,union iwreq_data *wrqu,char *b)
{
	int len;
	
	if(ieee->iw_mode == IW_MODE_ADHOC || ieee->iw_mode == IW_MODE_MASTER){
		if(ieee->master_essid == NULL) return -1;
		len = strlen(ieee->master_essid);
		wrqu->essid.length = len;
		memcpy(b,ieee->master_essid,len);
		wrqu->essid.flags = 1;
		return 0;
	}else{
		if(ieee->ssid[0] == '\0') return -1;
		len = strlen(ieee->ssid);
		wrqu->essid.length = len;
		memcpy(b,ieee->ssid,len);
		wrqu->essid.flags = 1;
		return 0;
	}
	

}





int ieee80211_r8180_wx_get_encode(struct ieee80211_device *ieee,
			   struct iw_request_info *info, 
			   union iwreq_data *wrqu, char *key)
{
	struct iw_point *erq = &(wrqu->encoding);
#ifdef CONFIG_IEEE80211_NOWEP
	erq->length = 0;
	erq->flags = IW_ENCODE_DISABLED;
	return 0;
#else
	int i, len;
	struct ieee80211_crypt_data *crypt;

	i = erq->flags & IW_ENCODE_INDEX;
	if (i < 1 || i > 4)
		i = ieee->tx_keyidx;
	else
		i--;
	if (i < 0 || i >= WEP_KEYS)
		return -EINVAL;
	crypt = ieee->crypt[i];
	erq->flags = i + 1;
								
	if (crypt == NULL || crypt->ops == NULL) {
		erq->length = 0;
		erq->flags |= IW_ENCODE_DISABLED;
		return 0;
	}

	if (strcmp(crypt->ops->name, "WEP") != 0) {
		/* only WEP is supported with wireless extensions, so just
		 * report that encryption is used */
		erq->length = 0;
		erq->flags |= IW_ENCODE_ENABLED;
		return 0;
	}

	len = crypt->ops->get_key(key, WEP_KEY_LEN, NULL, crypt->priv);
	erq->length = (len >= 0 ? len : 0);

	if (ieee->host_encrypt)
		erq->flags |= IW_ENCODE_ENABLED;
	else
		erq->flags |= IW_ENCODE_DISABLED;
	if (ieee->open_wep)
		erq->flags |= IW_ENCODE_OPEN;
	else
		erq->flags |= IW_ENCODE_RESTRICTED;

	return 0;
#endif
}


int ieee80211_r8180_wx_set_rate(struct ieee80211_device *ieee, 
			     struct iw_request_info *info,
			     union iwreq_data *wrqu, char *extra)
{
	//struct r8180_priv *priv = dev->priv;
	u32 target_rate = wrqu->bitrate.value;
	u32 rate = 0;

	if (target_rate == 1000000 || 
	    (!wrqu->bitrate.fixed && target_rate > 1000000))
		rate = 0;
	if (target_rate == 2000000 || 
	    (!wrqu->bitrate.fixed && target_rate > 2000000))
		rate = 1;
	if (target_rate == 5500000 || 
	    (!wrqu->bitrate.fixed && target_rate > 5500000))
		rate = 2;
	if (target_rate == 11000000 || 
	    (!wrqu->bitrate.fixed && target_rate > 11000000))
		rate = 3;
	
	ieee->rate = rate;
	return 0; 
}


int ieee80211_r8180_wx_get_rate(struct ieee80211_device *ieee, 
			     struct iw_request_info *info, 
			     union iwreq_data *wrqu, char *extra)
{
	

	switch(ieee->rate) {
	case 0:
		wrqu->bitrate.value = 1000000;
		break;
	case 1:
		wrqu->bitrate.value = 2000000;
		break;
	case 2:
		wrqu->bitrate.value = 5500000;
		break;
	case 3:
		wrqu->bitrate.value = 11000000;
		break;
	default:
		wrqu->bitrate.value = 11000000;
	}
	return 0;
}


EXPORT_SYMBOL(ieee80211_r8180_wx_set_encode);
EXPORT_SYMBOL(ieee80211_r8180_wx_get_encode);
EXPORT_SYMBOL(wlan_frequencies);
EXPORT_SYMBOL(ieee80211_r8180_wx_set_essid);
EXPORT_SYMBOL(ieee80211_r8180_wx_get_scan);
EXPORT_SYMBOL(ieee80211_r8180_wx_get_essid);
EXPORT_SYMBOL(ieee80211_r8180_wx_set_rate);
EXPORT_SYMBOL(ieee80211_r8180_wx_get_rate);
EXPORT_SYMBOL(ieee80211_r8180_wx_set_wap);