rtmp_info.c

r73模块的无线网卡在Linux下的驱动程序

		{
		    previous_ev = current_ev;
			current_ev = iwe_stream_add_point(iwri_ref(&iwri) current_ev, end_buf, &iwe, custom);
            if (current_ev == previous_ev)
                break;
        }
		//Quality Statistics
		//================================
		memset(&iwe, 0, sizeof(iwe));
		iwe.cmd = IWEVQUAL;
		set_quality(pAdapter, &iwe.u.qual, pAdapter->ScanTab.BssEntry[i].Rssi);

		previous_ev = current_ev;
		current_ev = iwe_stream_add_event(iwri_ref(&iwri) current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
        if (current_ev == previous_ev)
            break;

		//Age to display seconds since last beacon
		//================================
		memset(&iwe, 0, sizeof(iwe));
		iwe.cmd = IWEVCUSTOM;
		p = custom;
		p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
				  " Last beacon: %lums ago", (jiffies - pAdapter->ScanTab.BssEntry[i].LastBeaconRxTime) / (HZ / 100));
		iwe.u.data.length = p - custom;
		if (iwe.u.data.length)
		{
		    previous_ev = current_ev;
			current_ev = iwe_stream_add_point(iwri_ref(&iwri) current_ev, end_buf, &iwe, custom);
            if (current_ev == previous_ev)
                break;
        }
#endif

		//================================
		memset(&iwe, 0, sizeof(iwe));

	}
	data->length = current_ev - extra;
	DBGPRINT(RT_DEBUG_TRACE,"<===rt_ioctl_giwscan. %d(%d) BSS returned\n",
			i, pAdapter->ScanTab.BssNr);
	return 0;
}
#endif

int rt_ioctl_siwessid(struct net_device *dev,
			 struct iw_request_info *info,
			 struct iw_point *data, char *essid)
{

	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;
	NDIS_802_11_SSID					Ssid, *pSsid=NULL;
	ULONG		Length;

    memset(&Ssid, 0, sizeof(NDIS_802_11_SSID));

	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
	Length = data->length - 1;	// minus null character
	#else
	Length = data->length;
	#endif

	if (data->flags)
	{
		if (data->length > IW_ESSID_MAX_SIZE)
		{
			return -E2BIG;
		}

		memcpy(Ssid.Ssid, essid, Length);
		Ssid.SsidLength = Length;	//minus null character.

		memcpy(pAdapter->PortCfg.Ssid, essid, Length);
		pAdapter->PortCfg.SsidLen = Length;
	}
	else
	{
		Ssid.SsidLength = 0;  // ANY ssid
		Ssid.Ssid[0] = 0;

		// reset to infra/open/none as the user set ANY ssid
        // $ iwconfig [interface] essid ""
		pAdapter->PortCfg.BssType = BSS_INFRA;
		pAdapter->PortCfg.AuthMode = Ndis802_11AuthModeOpen;//FIXME whaa? - bb
		pAdapter->PortCfg.WepStatus  = Ndis802_11EncryptionDisabled;
    }

	pSsid = &Ssid;
	pAdapter->MlmeAux.CurrReqIsFromNdis = FALSE;

	if ((pAdapter->Mlme.CntlMachine.CurrState != CNTL_IDLE))
	{
		DBGPRINT(RT_DEBUG_INFO,"- %s:: CNTL SM not idle\n",
				__FUNCTION__);
		MlmeEnqueue(pAdapter,
                    MLME_CNTL_STATE_MACHINE,
                    RT_CMD_RESET_MLME,
                    0,
                    NULL);
    }
	MlmeEnqueue(pAdapter,
				MLME_CNTL_STATE_MACHINE,
				OID_802_11_SSID,
				sizeof(NDIS_802_11_SSID),
				(VOID *)pSsid);
	RTUSBMlmeUp(pAdapter);
	DBGPRINT(RT_DEBUG_TRACE,
			"<-- rt_ioctl_siwessid:: (Ssid.SsidLength = %d, %s)\n",
			Ssid.SsidLength, Ssid.Ssid);
	return 0;
}

int rt_ioctl_giwessid(struct net_device *dev,
			 struct iw_request_info *info,
			 struct iw_point *data, char *essid)
{

	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	data->flags = 1;		/* active */

	data->length = pAdapter->PortCfg.SsidLen;
	memcpy(essid, pAdapter->PortCfg.Ssid, pAdapter->PortCfg.SsidLen);
	pAdapter->PortCfg.Ssid[pAdapter->PortCfg.SsidLen] = '\0';
	DBGPRINT(RT_DEBUG_TRACE, "===>rt_ioctl_giwessid:: (Len=%d, ssid=%s...)\n", pAdapter->PortCfg.SsidLen, pAdapter->PortCfg.Ssid);

	return 0;

}

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

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	if (data->length > IW_ESSID_MAX_SIZE)
		return -E2BIG;

	memset(pAdapter->nickn, 0, IW_ESSID_MAX_SIZE);
	memcpy(pAdapter->nickn, nickname, data->length);


	return 0;
}

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

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	data->length = strlen(pAdapter->nickn) ;
	memcpy(nickname, pAdapter->nickn, data->length);
	nickname[data->length] = '\0';
	data->flags = 1;
	return 0;
}

int rt_ioctl_siwrts(struct net_device *dev,
			   struct iw_request_info *info,
			   struct iw_param *rts, char *extra)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;
	u16 val;

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	if (rts->disabled)
		val = MAX_RTS_THRESHOLD;
	else if (rts->value < 0 || rts->value > MAX_RTS_THRESHOLD) {
		DBGPRINT(RT_DEBUG_ERROR,"- %s: Invalid argument\n", __FUNCTION__);
		return -EINVAL;
	}
	else if (rts->value == 0)
		val = MAX_RTS_THRESHOLD;
	else
		val = rts->value;

	pAdapter->PortCfg.RtsThreshold = val;

	return 0;
}

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

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	rts->value = pAdapter->PortCfg.RtsThreshold;
	rts->disabled = (rts->value == MAX_RTS_THRESHOLD);
	rts->fixed = 1;

	return 0;
}

int rt_ioctl_siwfrag(struct net_device *dev,
			struct iw_request_info *info,
			struct iw_param *rts, char *extra)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;
	u16 val;

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	if (rts->disabled)
		val = MAX_FRAG_THRESHOLD;
	else if (rts->value >= MIN_FRAG_THRESHOLD || rts->value <= MAX_FRAG_THRESHOLD)
		val = rts->value & ~0x1; /* even numbers only */
	else if (rts->value == 0)
		val = MAX_FRAG_THRESHOLD;
	else {
		DBGPRINT(RT_DEBUG_ERROR,"- %s: Invalid argument\n", __FUNCTION__);
		return -EINVAL;
	}
	pAdapter->PortCfg.FragmentThreshold = val;
	return 0;
}

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

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	rts->value = pAdapter->PortCfg.FragmentThreshold;
	rts->disabled = (rts->value == 2346);
	rts->fixed = 1;

	return 0;
}

int rt_ioctl_siwencode(struct net_device *dev,
			  struct iw_request_info *info,
			  struct iw_point *erq, char *keybuf)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;
	union {
		char buf[sizeof(NDIS_802_11_WEP)+MAX_LEN_OF_KEY- 1];
		NDIS_802_11_WEP keyinfo;
	} WepKey;
	int 	index, i, len;
	CHAR	kid = 0;

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	memset(&WepKey, 0, sizeof(WepKey));

	if (erq->flags & IW_ENCODE_DISABLED)
	{
		pAdapter->PortCfg.PairCipher = Ndis802_11WEPDisabled;
		pAdapter->PortCfg.GroupCipher = Ndis802_11WEPDisabled;
		pAdapter->PortCfg.WepStatus = Ndis802_11WEPDisabled;
	}
	else
	{
		pAdapter->PortCfg.PairCipher = Ndis802_11WEPEnabled;
		pAdapter->PortCfg.GroupCipher = Ndis802_11WEPEnabled;
		pAdapter->PortCfg.WepStatus = Ndis802_11WEPEnabled;
	}

	if (erq->flags & IW_ENCODE_RESTRICTED)
		pAdapter->PortCfg.AuthMode = Ndis802_11AuthModeShared;
	else
		pAdapter->PortCfg.AuthMode = Ndis802_11AuthModeOpen;

	if(pAdapter->PortCfg.WepStatus == Ndis802_11WEPDisabled)
		pAdapter->PortCfg.AuthMode = Ndis802_11AuthModeOpen;

	if ((erq->flags & IW_ENCODE_DISABLED) == 0)
	{
		/* Enable crypto. */
		if (erq->length > IFNAMSIZ) {
			DBGPRINT(RT_DEBUG_ERROR,"- %s: Invalid length argument (%d)\n",
					__FUNCTION__, erq->length);
			return -EINVAL;
		}
		/* Old solution to take  default key  */
		index = (erq->flags & IW_ENCODE_INDEX) ;
		if((index < 0) || (index > NR_WEP_KEYS)) {
			DBGPRINT(RT_DEBUG_ERROR,"- %s: Invalid index argument (%d)\n",
					__FUNCTION__, index);
			return -EINVAL;
		}
		DBGPRINT(RT_DEBUG_TRACE,"- %s: erq->length=%d, erq->flags=0x%04x\n",
				__FUNCTION__, erq->length, erq->flags);

		if (index != 0)
		{
			pAdapter->PortCfg.DefaultKeyId = index -1;
		}

		if ((erq->length == 1) && (index == 0))
		{
			/* New solution to take  default key  when old way not work, not change KeyMaterial*/
			memcpy(&kid, keybuf, 1 );
			if((index < 0) || (index >= NR_WEP_KEYS)) {
				DBGPRINT(RT_DEBUG_ERROR,"- %s: Invalid argument\n",
						__FUNCTION__);
				return -EINVAL;
			}
			DBGPRINT(RT_DEBUG_TRACE,"kid = %d , erq->length = %d\n",
					kid, erq->length);
			if (kid > 0)
				pAdapter->PortCfg.DefaultKeyId = kid-1;
			else
				pAdapter->PortCfg.DefaultKeyId = 0;
		}
		else
		{
			DBGPRINT(RT_DEBUG_TRACE, "- %s: DefaultKeyId = %d, erq->length=%d, erq->flags=0x%04x\n", __FUNCTION__, pAdapter->PortCfg.DefaultKeyId, erq->length, erq->flags);
			len = erq->length;
			if(len > WEP_LARGE_KEY_LEN)
				len = WEP_LARGE_KEY_LEN;

			// If we're just turning on encryption, don't try to set key - bb
			if (len) {
				// If this instruction default key
				memset(pAdapter->SharedKey[pAdapter->PortCfg.DefaultKeyId].Key, 0, MAX_LEN_OF_KEY);
				memcpy(pAdapter->SharedKey[pAdapter->PortCfg.DefaultKeyId].Key, keybuf, len);
				memcpy(WepKey.keyinfo.KeyMaterial, keybuf, len);
				WepKey.keyinfo.KeyIndex = 0x80000000 + pAdapter->PortCfg.DefaultKeyId;
				WepKey.keyinfo.KeyLength = len;
				pAdapter->SharedKey[pAdapter->PortCfg.DefaultKeyId].KeyLen =(UCHAR) (len <= WEP_SMALL_KEY_LEN ? WEP_SMALL_KEY_LEN : WEP_LARGE_KEY_LEN);
				DBGPRINT(RT_DEBUG_TRACE,"SharedKey ");
				for (i=0; i < 5;i++)
					DBGPRINT_RAW(RT_DEBUG_TRACE," %02x ", pAdapter->SharedKey[pAdapter->PortCfg.DefaultKeyId].Key[i]);
				DBGPRINT_RAW(RT_DEBUG_TRACE, "\n");
				// need to enqueue cmd to thread
				RTUSBEnqueueCmdFromNdis(pAdapter, OID_802_11_ADD_WEP, TRUE, &WepKey, sizeof(WepKey.keyinfo) + len - 1);
			}
		}
	} /* End if (encoding not disabled) */

	DBGPRINT(RT_DEBUG_TRACE, "<-- %s: AuthMode=%d"
			" DefaultKeyId=%d, KeyLen=%d, WepStatus=%d\n",
			__FUNCTION__,
			pAdapter->PortCfg.AuthMode,
			pAdapter->PortCfg.DefaultKeyId,
			pAdapter->SharedKey[pAdapter->PortCfg.DefaultKeyId].KeyLen,
			pAdapter->PortCfg.WepStatus);
	return 0;
}

int
rt_ioctl_giwencode(struct net_device *dev,
			  struct iw_request_info *info,
			  struct iw_point *erq, char *key)
{
	PRTMP_ADAPTER pAdapter = (PRTMP_ADAPTER) dev->priv;
	int kid;

    //check if the interface is down
    if (pAdapter->RTUSBCmdThr_pid < 0)
        return -ENETDOWN;

	kid = erq->flags & IW_ENCODE_INDEX;
	DBGPRINT(RT_DEBUG_TRACE, "===>rt_ioctl_giwencode %d\n", erq->flags & IW_ENCODE_INDEX);

	if (pAdapter->PortCfg.WepStatus == Ndis802_11WEPDisabled)
	{
		erq->length = 0;
		erq->flags = IW_ENCODE_DISABLED;
	}
	else if ((kid > 0) && (kid <=4))
	{
		// copy wep key
		erq->flags = kid ;			/* NB: base 1 */
		if (erq->length > pAdapter->SharedKey[kid-1].KeyLen)
			erq->length = pAdapter->SharedKey[kid-1].KeyLen;
		memcpy(key, pAdapter->SharedKey[kid-1].Key, erq->length);
		//if ((kid == pAdapter->PortCfg.DefaultKeyId))
		//erq->flags |= IW_ENCODE_ENABLED;	/* XXX */
		if (pAdapter->PortCfg.AuthMode == Ndis802_11AuthModeShared)
			erq->flags |= IW_ENCODE_RESTRICTED;		/* XXX */
		else
			erq->flags |= IW_ENCODE_OPEN;		/* XXX */

	}
	else if (kid == 0)
	{
		if (pAdapter->PortCfg.AuthMode == Ndis802_11AuthModeShared)
			erq->flags |= IW_ENCODE_RESTRICTED;		/* XXX */
		else
			erq->flags |= IW_ENCODE_OPEN;		/* XXX */
		erq->length = pAdapter->SharedKey[pAdapter->PortCfg.DefaultKeyId].KeyLen;
		memcpy(key, pAdapter->SharedKey[pAdapter->PortCfg.DefaultKeyId].Key, erq->length);
		// copy default key ID
		if (pAdapter->PortCfg.AuthMode == Ndis802_11AuthModeShared)