sta_ioctl.c

Linux下的RT系列无线网卡驱动,可以直接在x86平台上编译

            pAdapter->StaCfg.BssType = BSS_ADHOC;
            pAdapter->net_dev->type = pAdapter->StaCfg.OriDevType;
			DBGPRINT(RT_DEBUG_TRACE, ("===>rt_ioctl_siwmode::SIOCSIWMODE (AD-HOC)\n"));
			break;
		case IW_MODE_INFRA:
			if (pAdapter->StaCfg.BssType != BSS_INFRA)
			{			    
				// Config has changed
				pAdapter->bConfigChanged = TRUE;
                if (MONITOR_ON(pAdapter))
                {
                    RTMP_IO_WRITE32(pAdapter, RX_FILTR_CFG, STANORMAL);
                    RTMP_IO_READ32(pAdapter, MAC_SYS_CTRL, &Value);
					Value &= (~0x80);
					RTMP_IO_WRITE32(pAdapter, MAC_SYS_CTRL, Value);
                    OPSTATUS_CLEAR_FLAG(pAdapter, fOP_STATUS_MEDIA_STATE_CONNECTED);
                    pAdapter->StaCfg.bAutoReconnect = TRUE;
                    LinkDown(pAdapter, FALSE);
                }
                if (ADHOC_ON(pAdapter))
				{
					// Set the AutoReconnectSsid to prevent it reconnect to old SSID
					// Since calling this indicate user don't want to connect to that SSID anymore.
					pAdapter->MlmeAux.AutoReconnectSsidLen= 32;
					NdisZeroMemory(pAdapter->MlmeAux.AutoReconnectSsid, pAdapter->MlmeAux.AutoReconnectSsidLen);			
				
					LinkDown(pAdapter, FALSE);
				}
			}			
            pAdapter->StaCfg.BssType = BSS_INFRA;
            pAdapter->net_dev->type = pAdapter->StaCfg.OriDevType;
			DBGPRINT(RT_DEBUG_TRACE, ("===>rt_ioctl_siwmode::SIOCSIWMODE (INFRA)\n"));
			break;
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,20))
        case IW_MODE_MONITOR:
            {
				UCHAR	bbpValue = 0;
				BCN_TIME_CFG_STRUC csr;
				OPSTATUS_CLEAR_FLAG(pAdapter, fOP_STATUS_INFRA_ON);
                OPSTATUS_CLEAR_FLAG(pAdapter, fOP_STATUS_ADHOC_ON);
				OPSTATUS_SET_FLAG(pAdapter, fOP_STATUS_MEDIA_STATE_CONNECTED);
				// disable all periodic state machine
				pAdapter->StaCfg.bAutoReconnect = FALSE;
				// reset all mlme state machine
				MlmeRestartStateMachine(pAdapter);
				DBGPRINT(RT_DEBUG_TRACE, ("fOP_STATUS_MEDIA_STATE_CONNECTED \n"));
                if (pAdapter->CommonCfg.CentralChannel == 0)
                {
                    if (pAdapter->CommonCfg.PhyMode == PHY_11AN_MIXED)
                        pAdapter->CommonCfg.CentralChannel = 36;
                    else
                        pAdapter->CommonCfg.CentralChannel = 6;
                }
                else
                    N_ChannelCheck(pAdapter);
				if (pAdapter->CommonCfg.PhyMode >= PHY_11ABGN_MIXED &&
                    pAdapter->CommonCfg.RegTransmitSetting.field.BW == BW_40 &&
                    pAdapter->CommonCfg.RegTransmitSetting.field.EXTCHA == EXTCHA_ABOVE)
				{
					// 40MHz ,control channel at lower
					RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R4, &bbpValue);
					bbpValue &= (~0x18);
					bbpValue |= 0x10;
					RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R4, bbpValue);
					pAdapter->CommonCfg.BBPCurrentBW = BW_40;
					//  RX : control channel at lower 
					RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R3, &bbpValue);
					bbpValue &= (~0x20);
					RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R3, bbpValue);

					RTMP_IO_READ32(pAdapter, TX_BAND_CFG, &Value);
					Value &= 0xfffffffe;
					RTMP_IO_WRITE32(pAdapter, TX_BAND_CFG, Value);
					pAdapter->CommonCfg.CentralChannel = pAdapter->CommonCfg.Channel + 2;
                    AsicSwitchChannel(pAdapter, pAdapter->CommonCfg.CentralChannel, FALSE);
				    AsicLockChannel(pAdapter, pAdapter->CommonCfg.CentralChannel);
                    DBGPRINT(RT_DEBUG_TRACE, ("BW_40 ,control_channel(%d), CentralChannel(%d) \n", 
                                               pAdapter->CommonCfg.Channel,
                                               pAdapter->CommonCfg.CentralChannel));
				}
				else if (pAdapter->CommonCfg.PhyMode >= PHY_11ABGN_MIXED &&
                         pAdapter->CommonCfg.RegTransmitSetting.field.BW == BW_40 &&
                         pAdapter->CommonCfg.RegTransmitSetting.field.EXTCHA == EXTCHA_BELOW)
				{
					// 40MHz ,control channel at upper
					RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R4, &bbpValue);
					bbpValue &= (~0x18);
					bbpValue |= 0x10;
					RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R4, bbpValue);
					pAdapter->CommonCfg.BBPCurrentBW = BW_40;
					RTMP_IO_READ32(pAdapter, TX_BAND_CFG, &Value);
					Value |= 0x1;
					RTMP_IO_WRITE32(pAdapter, TX_BAND_CFG, Value);
					
					RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R3, &bbpValue);
					bbpValue |= (0x20);
					RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R3, bbpValue);
					pAdapter->CommonCfg.CentralChannel = pAdapter->CommonCfg.Channel - 2;
                    AsicSwitchChannel(pAdapter, pAdapter->CommonCfg.CentralChannel, FALSE);
				    AsicLockChannel(pAdapter, pAdapter->CommonCfg.CentralChannel);
                    DBGPRINT(RT_DEBUG_TRACE, ("BW_40 ,control_channel(%d), CentralChannel(%d) \n", 
                                               pAdapter->CommonCfg.Channel,
                                               pAdapter->CommonCfg.CentralChannel));
				}
				else
				{
					// 20MHz
					RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R4, &bbpValue);
					bbpValue &= (~0x18);
					RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R4, bbpValue);
					pAdapter->CommonCfg.BBPCurrentBW = BW_40;
                    AsicSwitchChannel(pAdapter, pAdapter->CommonCfg.Channel, FALSE);
				    AsicLockChannel(pAdapter, pAdapter->CommonCfg.Channel);
					DBGPRINT(RT_DEBUG_TRACE, ("BW_40, Channel(%d)\n", pAdapter->CommonCfg.Channel));
				}
				// Enable Rx with promiscuous reception
				RTMP_IO_WRITE32(pAdapter, RX_FILTR_CFG, 0x3);
				// ASIC supporsts sniffer function with replacing RSSI with timestamp.
				//RTMP_IO_READ32(pAdapter, MAC_SYS_CTRL, &Value);
				//Value |= (0x80);
				//RTMP_IO_WRITE32(pAdapter, MAC_SYS_CTRL, Value);
				// disable sync
				RTMP_IO_READ32(pAdapter, BCN_TIME_CFG, &csr.word);
				csr.field.bBeaconGen = 0;
				csr.field.bTBTTEnable = 0;
				csr.field.TsfSyncMode = 0;
				RTMP_IO_WRITE32(pAdapter, BCN_TIME_CFG, csr.word);
            }
            
			pAdapter->StaCfg.BssType = BSS_MONITOR;
            pAdapter->net_dev->type = ARPHRD_IEEE80211_PRISM; //ARPHRD_IEEE80211; // IEEE80211
			DBGPRINT(RT_DEBUG_TRACE, ("===>rt_ioctl_siwmode::SIOCSIWMODE (MONITOR)\n"));
			break;
#endif            
		default:
			DBGPRINT(RT_DEBUG_TRACE, ("===>rt_ioctl_siwmode::SIOCSIWMODE (unknown %d)\n", *mode));
			return -EINVAL;
	}
	
	// Reset Ralink supplicant to not use, it will be set to start when UI set PMK key
	pAdapter->StaCfg.WpaState = SS_NOTUSE;

	return 0;
}

int rt_ioctl_giwmode(struct net_device *dev,
		   struct iw_request_info *info,
		   __u32 *mode, char *extra)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;

	//check if the interface is down
	if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
	{
    	DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
    	return -ENETDOWN;   
	}

	if (ADHOC_ON(pAdapter))
		*mode = IW_MODE_ADHOC;
    else if (INFRA_ON(pAdapter))
		*mode = IW_MODE_INFRA;
#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,20))
    else if (MONITOR_ON(pAdapter))
    {
        *mode = IW_MODE_MONITOR;
    }
#endif         
    else
        *mode = IW_MODE_AUTO;

	DBGPRINT(RT_DEBUG_TRACE, ("==>rt_ioctl_giwmode(mode=%d)\n", *mode));
	return 0;
}

int rt_ioctl_siwsens(struct net_device *dev,
		   struct iw_request_info *info,
		   char *name, char *extra)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;

	//check if the interface is down
    	if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
    	{
        	DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
        	return -ENETDOWN;   
    	}

	return 0;
}

int rt_ioctl_giwsens(struct net_device *dev,
		   struct iw_request_info *info,
		   char *name, char *extra)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;

	//check if the interface is down
    	if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
    	{
        	DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
        	return -ENETDOWN;   
    	}

	return 0;
}

int rt_ioctl_giwrange(struct net_device *dev,
		   struct iw_request_info *info,
		   struct iw_point *data, char *extra)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;

	struct iw_range *range = (struct iw_range *) extra;
	u16 val;
	int i;

	//check if the interface is down
	if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
	{
    	DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
    	return -ENETDOWN;   
	}

	DBGPRINT(RT_DEBUG_TRACE ,("===>rt_ioctl_giwrange\n"));
	data->length = sizeof(struct iw_range);
	memset(range, 0, sizeof(struct iw_range));

	range->txpower_capa = IW_TXPOW_DBM;

	if (INFRA_ON(pAdapter)||ADHOC_ON(pAdapter))
	{
		range->min_pmp = 1 * 1024;
		range->max_pmp = 65535 * 1024;
		range->min_pmt = 1 * 1024;
		range->max_pmt = 1000 * 1024;
		range->pmp_flags = IW_POWER_PERIOD;
		range->pmt_flags = IW_POWER_TIMEOUT;
		range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT |
			IW_POWER_UNICAST_R | IW_POWER_ALL_R;
	}

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

	range->retry_capa = IW_RETRY_LIMIT;
	range->retry_flags = IW_RETRY_LIMIT;
	range->min_retry = 0;
	range->max_retry = 255;

	range->num_channels =  pAdapter->ChannelListNum;

	val = 0;
	for (i = 1; i <= range->num_channels; i++) 
	{
		u32 m;
		range->freq[val].i = pAdapter->ChannelList[i-1].Channel;
		MAP_CHANNEL_ID_TO_KHZ(pAdapter->ChannelList[i-1].Channel, m);
		range->freq[val].m = m * 100; /* HZ */
		
			range->freq[val].e = 1;
			val++;
		if (val == IW_MAX_FREQUENCIES)
			break;
	}
	range->num_frequency = val;

	range->max_qual.qual = 100; /* what is correct max? This was not
					* documented exactly. At least
					* 69 has been observed. */
	range->max_qual.level = 0; /* dB */
	range->max_qual.noise = 0; /* dB */

	/* What would be suitable values for "average/typical" qual? */
	range->avg_qual.qual = 20;
	range->avg_qual.level = -60;
	range->avg_qual.noise = -95;
	range->sensitivity = 3;

	range->max_encoding_tokens = NR_WEP_KEYS;
	range->num_encoding_sizes = 2;
	range->encoding_size[0] = 5;
	range->encoding_size[1] = 13;

	range->min_rts = 0;
	range->max_rts = 2347;
	range->min_frag = 256;
	range->max_frag = 2346;

#if WIRELESS_EXT > 17
	/* IW_ENC_CAPA_* bit field */
	range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 | 
					IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
#endif

	return 0;
}

int rt_ioctl_siwap(struct net_device *dev,
		      struct iw_request_info *info,
		      struct sockaddr *ap_addr, char *extra)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;
    NDIS_802_11_MAC_ADDRESS Bssid;

	//check if the interface is down
	if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
	{
       	DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
       	return -ENETDOWN;   
    }

	if (pAdapter->Mlme.CntlMachine.CurrState != CNTL_IDLE)
    {
        MlmeRestartStateMachine(pAdapter);
        DBGPRINT(RT_DEBUG_TRACE, ("!!! MLME busy, reset MLME state machine !!!\n"));
    }

    // tell CNTL state machine to call NdisMSetInformationComplete() after completing
    // this request, because this request is initiated by NDIS.
    pAdapter->MlmeAux.CurrReqIsFromNdis = FALSE; 

    memset(Bssid, 0, MAC_ADDR_LEN);
    memcpy(Bssid, ap_addr->sa_data, MAC_ADDR_LEN);
    MlmeEnqueue(pAdapter, 
                MLME_CNTL_STATE_MACHINE, 
                OID_802_11_BSSID, 
                sizeof(NDIS_802_11_MAC_ADDRESS),
                (VOID *)&Bssid);
    
    DBGPRINT(RT_DEBUG_TRACE, ("IOCTL::SIOCSIWAP %02x:%02x:%02x:%02x:%02x:%02x\n",
        Bssid[0], Bssid[1], Bssid[2], Bssid[3], Bssid[4], Bssid[5]));

	return 0;
}

int rt_ioctl_giwap(struct net_device *dev,
		      struct iw_request_info *info,
		      struct sockaddr *ap_addr, char *extra)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;    

	//check if the interface is down
	if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
	{
        	DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
        	return -ENETDOWN;   
    	}

	if (INFRA_ON(pAdapter) || ADHOC_ON(pAdapter))
	{
		ap_addr->sa_family = ARPHRD_ETHER;
		memcpy(ap_addr->sa_data, &pAdapter->CommonCfg.Bssid, ETH_ALEN);
	}
	else
	{
		DBGPRINT(RT_DEBUG_TRACE, ("IOCTL::SIOCGIWAP(=EMPTY)\n"));
		return -ENOTCONN;
	}

	return 0;
}

/*
 * Units are in db above the noise floor. That means the
 * rssi values reported in the tx/rx descriptors in the
 * driver are the SNR expressed in db.
 *
 * If you assume that the noise floor is -95, which is an
 * excellent assumption 99.5 % of the time, then you can
 * derive the absolute signal level (i.e. -95 + rssi). 
 * There are some other slight factors to take into account
 * depending on whether the rssi measurement is from 11b,
 * 11g, or 11a.   These differences are at most 2db and
 * can be documented.
 *
 * NB: various calculations are based on the orinoco/wavelan
 *     drivers for compatibility
 */

static void set_quality(PRTMP_ADAPTER pAdapter,
                        struct iw_quality *iq, 
                        char rssi)
{
    u32 ChannelQuality, NorRssi;

    // Normalize Rssi
	if (rssi > -40)
        NorRssi = 100;
	else if (rssi < -90)
        NorRssi = 0;
	else
		NorRssi = (rssi + 90) * 2;