r8180_wx.c

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

/* 
   This file contains wireless extension handlers.

   This is part of rtl8180 OpenSource driver.
   Copyright (C) Andrea Merello 2004-2005  <[e-mail]> 
   Released under the terms of GPL (General Public Licence)
   
   Parts of this driver are based on the GPL part 
   of the official realtek driver.
   
   Parts of this driver are based on the rtl8180 driver skeleton 
   from Patric Schenke & Andres Salomon.

   Parts of this driver are based on the Intel Pro Wireless 2100 GPL driver.
   
   We want to tanks the Authors of those projects and the Ndiswrapper 
   project Authors.
*/



#include "r8180.h"
#include "r8180_hw.h"
#include "r8180_sa2400.h"

#define RATE_COUNT 4
u32 rtl8180_rates[] = {1000000,2000000,5500000,11000000};

static int r8180_wx_get_freq(struct net_device *dev,
			     struct iw_request_info *a,
			     union iwreq_data *wrqu, char *b)
{
	struct r8180_priv *priv = dev->priv;
	struct iw_freq *fwrq = & wrqu->freq;

#ifdef WEXT_USECHANNELS
	fwrq->m = priv->chan;
	fwrq->e = 0;
#else
	fwrq->m = wlan_frequencies[priv->chan-1] * 100000;
	fwrq->e = 1;
#endif
	return 0;
}


int r8180_wx_set_key(struct net_device *dev, struct iw_request_info *info, 
		     union iwreq_data *wrqu, char *key)
{
	struct r8180_priv *priv = dev->priv;
	struct iw_point *erq = &(wrqu->encoding);	

	if (erq->flags & IW_ENCODE_DISABLED) {
	}
	
	
/*	i = erq->flags & IW_ENCODE_INDEX;
	if (i < 1 || i > 4)
*/	
	
	if (erq->length > 0) {

		//int len = erq->length <= 5 ? 5 : 13;
		
		u32* tkey= (u32*) key;
		priv->key0[0] = tkey[0];
		priv->key0[1] = tkey[1];
		priv->key0[2] = tkey[2];
		priv->key0[3] = tkey[3] &0xff;
		DMESG("Setting wep key to %x %x %x %x", 
		      tkey[0],tkey[1],tkey[2],tkey[3]);
		rtl8180_set_hw_wep(dev);
	}
	return 0;
}


static int r8180_set_beaconinterval(struct net_device *dev, struct iw_request_info *aa,
			  union iwreq_data *wrqu, char *b)
{
	int *parms = (int *)b;
	int bi = parms[0];
	
	struct r8180_priv *priv = dev->priv;
	
	down(&priv->wx_sem);
	DMESG("setting beacon interval to %x",bi);
	
	priv->ieee80211->beacon_interval=bi;
	rtl8180_commit(dev);
	up(&priv->wx_sem);
		
	return 0;	
}


static int r8180_debug_tx(struct net_device *dev, struct iw_request_info *aa,
			  union iwreq_data *wrqu, char *b)
{struct r8180_priv *priv=dev->priv;	

	write_nic_byte(dev,TX_DMA_POLLING,
		       (1<<TX_DMA_POLLING_NORMPRIORITY_SHIFT) |
		        priv->dma_poll_mask);	
/*
	if (!priv->up) return -1;

	int *parms = (int *)b;
	int len = parms[0];
	char probe[] = {0x40,0x00,0x00,0xff,0xff,0xff,0xff,
			0xff,0xff,0xff,0xff,0xff,0xff};

	char *a = (char *) kmalloc(len*sizeof(char)+sizeof(probe), GFP_KERNEL);
	int i,j;
	
	
	for(i=0;i<sizeof(probe);i++)
		a[i]=probe[i];

	for(j=0;j<len-1;i++,j++){
		if (i%2) 
			a[i]=0xab;
		else 
			a[i]=0xcd;
	}
	
	a[i]=0x24;
	
	DMESG("TX %x bytes..", len+sizeof(probe));
	rtl8180_tx(dev, (u32*)a, i+1, NORM_PRIORITY, 0, 0);
	kfree(a);
	
	*/
	#if 0
	struct r8180_priv *priv = dev->priv;
	fix_tx_fifo(dev);
	#endif
	//check_txnpbuf(dev);
	return 0;
}


static int r8180_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
			     union iwreq_data *wrqu, char *b)
{
	struct r8180_priv *priv=dev->priv;	

	wrqu->mode = priv->ieee80211->iw_mode;
	return 0;
}



static int r8180_wx_get_rate(struct net_device *dev, 
			     struct iw_request_info *info, 
			     union iwreq_data *wrqu, char *extra)
{
	struct r8180_priv *priv = dev->priv;
	return ieee80211_r8180_wx_get_rate(priv->ieee80211,info,wrqu,extra);
}



static int r8180_wx_set_rate(struct net_device *dev, 
			     struct iw_request_info *info, 
			     union iwreq_data *wrqu, char *extra)
{
	int ret;
	struct r8180_priv *priv = dev->priv;	
	
	down(&priv->wx_sem);

	ret = ieee80211_r8180_wx_set_rate(priv->ieee80211,info,wrqu,extra);
	
	up(&priv->wx_sem);
	
	return ret;
}


static int r8180_wx_set_crcmon(struct net_device *dev, 
			       struct iw_request_info *info, 
			       union iwreq_data *wrqu, char *extra)
{
	struct r8180_priv *priv = dev->priv;
	int *parms = (int *)extra;
	int enable = (parms[0] > 0);
	short prev = priv->crcmon;

	down(&priv->wx_sem);
	
	if(enable) 
		priv->crcmon=1;
	else 
		priv->crcmon=0;

	DMESG("bad CRC in monitor mode are %s", 
	      priv->crcmon ? "accepted" : "rejected");

	if(prev != priv->crcmon && priv->up){
		rtl8180_down(dev);
		rtl8180_up(dev);
	}
	
	up(&priv->wx_sem);
	
	return 0;
}


static int r8180_wx_set_monitor(struct net_device *dev, 
				struct iw_request_info *info, 
				union iwreq_data *wrqu, char *extra)
{
	struct r8180_priv *priv = dev->priv;
	int *parms = (int *)extra;
	int enable = (parms[0] > 0);
	
	down(&priv->wx_sem);
	
	if (enable && IW_MODE_MONITOR == priv->ieee80211->iw_mode) {
		priv->rf_set_chan(dev, parms[1]);
		goto out;
	}
	
	
	if(enable) {
	  		priv->chan=parms[1];
			priv->rf_set_chan(dev, parms[1]);
			priv->ieee80211->iw_mode = IW_MODE_MONITOR;
			/* this is the priv for orinoco kismet compatibility, so
			   uses the normal ieee80211 header, regardless the prism
			   header flag
			 */
			dev->type=ARPHRD_IEEE80211;
	  			
				
	} else {
		
		if (priv->ieee80211->iw_mode != IW_MODE_MONITOR)
			goto out;
		
		priv->ieee80211->iw_mode = IW_MODE_INFRA;
		dev->type=ARPHRD_ETHER;
	}

	if(priv->up){
		rtl8180_down(dev);
		rtl8180_up(dev);
	}
	
out:
	up(&priv->wx_sem);
	return 0;
}


static int r8180_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
			     union iwreq_data *wrqu, char *b)
{
	struct r8180_priv *priv = dev->priv;
	
	down(&priv->wx_sem);
	
	if (wrqu->mode == priv->ieee80211->iw_mode)
		goto out;
		
	if(wrqu->mode == IW_MODE_MONITOR){
		if(priv->prism_hdr)
			dev->type=ARPHRD_IEEE80211_PRISM;
		else  
			dev->type=ARPHRD_IEEE80211;
	}else{
		dev->type=ARPHRD_ETHER;
	}
	
	priv->ieee80211->iw_mode = wrqu->mode;
	
	if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
		IBSS_randomize_cell(dev);
	if(priv->ieee80211->iw_mode == IW_MODE_MASTER)
		memcpy(priv->ieee80211->beacon_cell_ssid, dev->dev_addr, ETH_ALEN);
	
	/* if the user set the MAC of the ad-hoc cell and then
	 * switch to managed mode, we have to make sure that association
	 * attempts does not fail just because the user provide the essid
	 * and the nic is still checking for the AP MAC
	 */
	if(priv->ieee80211->iw_mode == IW_MODE_INFRA)
		memset(priv->ieee80211->ap, 0, ETH_ALEN); 
	
	if(priv->up) {
		rtl8180_down(dev);
		rtl8180_up(dev);
	}
	
out:
	up(&priv->wx_sem);
	return 0;
}


static int rtl8180_wx_get_range(struct net_device *dev, 
				struct iw_request_info *info, 
				union iwreq_data *wrqu, char *extra)
{
	struct iw_range *range = (struct iw_range *)extra;
	struct r8180_priv *priv = dev->priv;
	u16 val;
	int i;

	wrqu->data.length = sizeof(*range);
	memset(range, 0, sizeof(*range));

	/* Let's try to keep this struct in the same order as in
	 * linux/include/wireless.h
	 */
	
	/* TODO: See what values we can set, and remove the ones we can't
	 * set, or fill them with some default data.
	 */

	/* ~5 Mb/s real (802.11b) */
	range->throughput = 5 * 1000 * 1000;     

	// TODO: Not used in 802.11b?
//	range->min_nwid;	/* Minimal NWID we are able to set */
	// TODO: Not used in 802.11b?
//	range->max_nwid;	/* Maximal NWID we are able to set */
	
        /* Old Frequency (backward compat - moved lower ) */
//	range->old_num_channels; 
//	range->old_num_frequency;
//	range->old_freq[6]; /* Filler to keep "version" at the same offset */

//	range->sensitivity;	/* signal level threshold range */
	
	range->max_qual.qual = 100;
	/* TODO: Find real max RSSI and stick here */
	range->max_qual.level = 0;
	range->max_qual.noise = -98;
	range->max_qual.updated = 7; /* Updated all three */

	range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */
	/* TODO: Find real 'good' to 'bad' threshol value for RSSI */
	range->avg_qual.level = 20 + -98;
	range->avg_qual.noise = 0;
	range->avg_qual.updated = 7; /* Updated all three */

	range->num_bitrates = RATE_COUNT;
	
	for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) {
		range->bitrate[i] = rtl8180_rates[i];
	}
	
	range->min_frag = MIN_FRAG_THRESHOLD;
	range->max_frag = MAX_FRAG_THRESHOLD;
	
	range->pm_capa = 0;

	range->we_version_compiled = WIRELESS_EXT;
	range->we_version_source = 16;

//	range->retry_capa;	/* What retry options are supported */
//	range->retry_flags;	/* How to decode max/min retry limit */
//	range->r_time_flags;	/* How to decode max/min retry life */
//	range->min_retry;	/* Minimal number of retries */
//	range->max_retry;	/* Maximal number of retries */
//	range->min_r_time;	/* Minimal retry lifetime */
//	range->max_r_time;	/* Maximal retry lifetime */

        range->num_channels = 14;

	for (i = 0, val = 0; i < 14; i++) {
		
		// Include only legal frequencies for some countries
		if ((priv->challow)[i+1]) {
		        range->freq[val].i = i + 1;
			range->freq[val].m = wlan_frequencies[i] * 100000;
			range->freq[val].e = 1;
			val++;
		} else {
			// FIXME: do we need to set anything for channels
			// we don't use ?
		}
		
		if (val == IW_MAX_FREQUENCIES)
		break;
	}

	range->num_frequency = val;
	return 0;
}


static int r8180_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
			     union iwreq_data *wrqu, char *b)
{
	struct r8180_priv *priv = dev->priv;

#if 0
	/* this code was for sync scanning */
	int i;
	
	for(i=1; i<=14; i++){
		rf_set_chan(dev,i);
		mdelay(500);
	}
#endif
	if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || !priv->up) return -1;
	return 0;
}


static int r8180_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
			     union iwreq_data *wrqu, char *b)
{

	int ret;
	struct r8180_priv *priv = dev->priv;
	
	down(&priv->wx_sem);
	
	ret =-1;
	
	if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || !priv->up) 
		goto out;

	ret = ieee80211_r8180_wx_get_scan(priv->ieee80211, a, wrqu, b);
out:
	up(&priv->wx_sem);
	return ret;
}


static int r8180_wx_set_essid(struct net_device *dev, 
			      struct iw_request_info *a,
			      union iwreq_data *wrqu, char *b)
{
	struct r8180_priv *priv = dev->priv;
	
	int ret;
	
	down(&priv->wx_sem);
	
	if(wrqu->essid.length > SSID_LENGTH + 1){
		ret= -E2BIG;
		goto out;
	}
	
	if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
		ret= -1;
		goto out;
	}
	
	if(priv->ieee80211->iw_mode == IW_MODE_INFRA){
		rtl8180_disassociate(dev);
		rtl8180_start_scanning(dev);
	}
	
	ret =  ieee80211_r8180_wx_set_essid(priv->ieee80211,a,wrqu,b);
	
	if(ret) goto out;
	
	if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
		IBSS_randomize_cell(dev);
	
	if(priv->ieee80211->iw_mode == IW_MODE_ADHOC ||
		priv->ieee80211->iw_mode == IW_MODE_MASTER )