staging: vt6656: Remove hostapd functions. (90f96acd) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/staging/vt6656/bssdb.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -771,8 +771,8 @@ void BSSvAddMulticastNode(struct vnt_private *pDevice)
		{
		struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;

		if (!pDevice->bEnableHostWEP)
		memset(&pMgmt->sNodeDBTable[0], 0, sizeof(KnownNodeDB));

		memset(pMgmt->sNodeDBTable[0].abyMACAddr, 0xff, WLAN_ADDR_LEN);
		pMgmt->sNodeDBTable[0].bActive = true;
		pMgmt->sNodeDBTable[0].bPSEnable = false;

drivers/staging/vt6656/device.h

+0 −7

Original line number	Diff line number	Diff line
		@@ -707,13 +707,6 @@ struct vnt_private {
		int bwextstep3;
		int bWPASuppWextEnabled;

		/* user space daemon: hostapd, is used for HOSTAP */
		int bEnableHostapd;
		int bEnable8021x;
		int bEnableHostWEP;
		struct net_device *apdev;
		int (tx_80211)(struct sk_buff skb, struct net_device *dev);

		u32 uChannel;

		struct iw_statistics wstats; /* wireless stats */

drivers/staging/vt6656/dpc.c

+3 −207

Original line number	Diff line number	Diff line
		@@ -29,7 +29,6 @@
		* s_bAPModeRxCtl- AP Rcv frame filer Ctl.
		* s_bAPModeRxData- AP Rcv data frame handle
		* s_bHandleRxEncryption- Rcv decrypted data via on-fly
		* s_bHostWepRxEncryption- Rcv encrypted data via host
		* s_byGetRateIdx- get rate index
		* s_vGetDASA- get data offset
		* s_vProcessRxMACHeader- Rcv 802.11 and translate to 802.3
		@@ -86,10 +85,6 @@ static int s_bHandleRxEncryption(struct vnt_private pDevice, u8 pbyFrame,
		u32 FrameSize, u8 pbyRsr, u8 pbyNewRsr, PSKeyItem *pKeyOut,
		s32 pbExtIV, u16 pwRxTSC15_0, u32 *pdwRxTSC47_16);

		static int s_bHostWepRxEncryption(struct vnt_private pDevice, u8 pbyFrame,
		u32 FrameSize, u8 pbyRsr, int bOnFly, PSKeyItem pKey, u8 pbyNewRsr,
		s32 pbExtIV, u16 pwRxTSC15_0, u32 *pdwRxTSC47_16);

		/*+
		*
		* Description:
		@@ -267,7 +262,6 @@ int RXbBulkInProcessData(struct vnt_private pDevice, struct vnt_rcb pRCB,
		PSKeyItem pKey = NULL;
		u16 wRxTSC15_0 = 0;
		u32 dwRxTSC47_16 = 0;
		SKeyItem STempKey;
		/* signed long ldBm = 0; */
		int bIsWEP = false; int bExtIV = false;
		u32 dwWbkStatus;
		@@ -400,39 +394,9 @@ int RXbBulkInProcessData(struct vnt_private pDevice, struct vnt_rcb pRCB,

		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"rx WEP pkt\n");
		bIsWEP = true;
		if ((pDevice->bEnableHostWEP) && (iSANodeIndex >= 0)) {
		pKey = &STempKey;
		pKey->byCipherSuite = pMgmt->sNodeDBTable[iSANodeIndex].byCipherSuite;
		pKey->dwKeyIndex = pMgmt->sNodeDBTable[iSANodeIndex].dwKeyIndex;
		pKey->uKeyLength = pMgmt->sNodeDBTable[iSANodeIndex].uWepKeyLength;
		pKey->dwTSC47_16 = pMgmt->sNodeDBTable[iSANodeIndex].dwTSC47_16;
		pKey->wTSC15_0 = pMgmt->sNodeDBTable[iSANodeIndex].wTSC15_0;
		memcpy(pKey->abyKey,
		&pMgmt->sNodeDBTable[iSANodeIndex].abyWepKey[0],
		pKey->uKeyLength
		);

		bRxDecryOK = s_bHostWepRxEncryption(pDevice,
		pbyFrame,
		FrameSize,
		pbyRsr,
		pMgmt->sNodeDBTable[iSANodeIndex].bOnFly,
		pKey,
		pbyNewRsr,
		&bExtIV,
		&wRxTSC15_0,
		&dwRxTSC47_16);
		} else {
		bRxDecryOK = s_bHandleRxEncryption(pDevice,
		pbyFrame,
		FrameSize,
		pbyRsr,
		pbyNewRsr,
		&pKey,
		&bExtIV,
		&wRxTSC15_0,
		&dwRxTSC47_16);
		}
		bRxDecryOK = s_bHandleRxEncryption(pDevice, pbyFrame, FrameSize,
		pbyRsr, pbyNewRsr, &pKey, &bExtIV, &wRxTSC15_0, &dwRxTSC47_16);

		if (bRxDecryOK) {
		if ((*pbyNewRsr & NEWRSR_DECRYPTOK) == 0) {
		@@ -516,22 +480,6 @@ int RXbBulkInProcessData(struct vnt_private pDevice, struct vnt_rcb pRCB,
		}
		pRxPacket->byRxChannel = (*pbyRxSts) >> 2;

		// hostap Deamon handle 802.11 management
		if (pDevice->bEnableHostapd) {
		skb->dev = pDevice->apdev;
		//skb->data += 4;
		//skb->tail += 4;
		skb->data += 8;
		skb->tail += 8;
		skb_put(skb, FrameSize);
		skb_reset_mac_header(skb);
		skb->pkt_type = PACKET_OTHERHOST;
		skb->protocol = htons(ETH_P_802_2);
		memset(skb->cb, 0, sizeof(skb->cb));
		netif_rx(skb);
		return true;
		}

		//
		// Insert the RCB in the Recv Mng list
		//
		@@ -653,45 +601,6 @@ int RXbBulkInProcessData(struct vnt_private pDevice, struct vnt_rcb pRCB,
		}
		*/

		// -----------------------------------------------

		if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) && (pDevice->bEnable8021x == true)){
		u8 abyMacHdr[24];

		// Only 802.1x packet incoming allowed
		if (bIsWEP)
		cbIVOffset = 8;
		else
		cbIVOffset = 0;
		wEtherType = (skb->data[cbIVOffset + 8 + 24 + 6] << 8) \|
		skb->data[cbIVOffset + 8 + 24 + 6 + 1];

		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"wEtherType = %04x \n", wEtherType);
		if (wEtherType == ETH_P_PAE) {
		skb->dev = pDevice->apdev;

		if (bIsWEP == true) {
		// strip IV header(8)
		memcpy(&abyMacHdr[0], (skb->data + 8), 24);
		memcpy((skb->data + 8 + cbIVOffset), &abyMacHdr[0], 24);
		}

		skb->data += (cbIVOffset + 8);
		skb->tail += (cbIVOffset + 8);
		skb_put(skb, FrameSize);
		skb_reset_mac_header(skb);
		skb->pkt_type = PACKET_OTHERHOST;
		skb->protocol = htons(ETH_P_802_2);
		memset(skb->cb, 0, sizeof(skb->cb));
		netif_rx(skb);
		return true;

		}
		// check if 802.1x authorized
		if (!(pMgmt->sNodeDBTable[iSANodeIndex].dwFlags & WLAN_STA_AUTHORIZED))
		return false;
		}

		if ((pKey != NULL) && (pKey->byCipherSuite == KEY_CTL_TKIP)) {
		if (bIsWEP) {
		FrameSize -= 8; //MIC
		@@ -1097,119 +1006,6 @@ static int s_bHandleRxEncryption(struct vnt_private pDevice, u8 pbyFrame,
		return true;
		}

		static int s_bHostWepRxEncryption(struct vnt_private pDevice, u8 pbyFrame,
		u32 FrameSize, u8 pbyRsr, int bOnFly, PSKeyItem pKey, u8 pbyNewRsr,
		s32 pbExtIV, u16 pwRxTSC15_0, u32 *pdwRxTSC47_16)
		{
		struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
		struct ieee80211_hdr *pMACHeader;
		u32 PayloadLen = FrameSize;
		u8 *pbyIV;
		u8 byKeyIdx;
		u8 byDecMode = KEY_CTL_WEP;

		*pwRxTSC15_0 = 0;
		*pdwRxTSC47_16 = 0;

		pbyIV = pbyFrame + WLAN_HDR_ADDR3_LEN;
		if ( WLAN_GET_FC_TODS((u16 )pbyFrame) &&
		WLAN_GET_FC_FROMDS((u16 )pbyFrame) ) {
		pbyIV += 6; // 6 is 802.11 address4
		PayloadLen -= 6;
		}
		byKeyIdx = (*(pbyIV+3) & 0xc0);
		byKeyIdx >>= 6;
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"\nKeyIdx: %d\n", byKeyIdx);

		if (pMgmt->byCSSGK == KEY_CTL_TKIP)
		byDecMode = KEY_CTL_TKIP;
		else if (pMgmt->byCSSGK == KEY_CTL_CCMP)
		byDecMode = KEY_CTL_CCMP;

		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"AES:%d %d %d\n", pMgmt->byCSSPK, pMgmt->byCSSGK, byDecMode);

		if (byDecMode != pKey->byCipherSuite) {
		return false;
		}

		if (byDecMode == KEY_CTL_WEP) {
		// handle WEP
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"byDecMode == KEY_CTL_WEP\n");
		if ((pDevice->byLocalID <= REV_ID_VT3253_A1) \|\|
		(((PSKeyTable)(pKey->pvKeyTable))->bSoftWEP == true) \|\|
		(bOnFly == false)) {
		// Software WEP
		// 1. 3253A
		// 2. WEP 256
		// 3. NotOnFly

		PayloadLen -= (WLAN_HDR_ADDR3_LEN + 4 + 4); // 24 is 802.11 header,4 is IV, 4 is crc
		memcpy(pDevice->abyPRNG, pbyIV, 3);
		memcpy(pDevice->abyPRNG + 3, pKey->abyKey, pKey->uKeyLength);
		rc4_init(&pDevice->SBox, pDevice->abyPRNG, pKey->uKeyLength + 3);
		rc4_encrypt(&pDevice->SBox, pbyIV+4, pbyIV+4, PayloadLen);

		if (ETHbIsBufferCrc32Ok(pbyIV+4, PayloadLen)) {
		*pbyNewRsr \|= NEWRSR_DECRYPTOK;
		}
		}
		} else if ((byDecMode == KEY_CTL_TKIP) \|\|
		(byDecMode == KEY_CTL_CCMP)) {
		// TKIP/AES

		PayloadLen -= (WLAN_HDR_ADDR3_LEN + 8 + 4); // 24 is 802.11 header, 8 is IV&ExtIV, 4 is crc
		pdwRxTSC47_16 = cpu_to_le32((u32 *)(pbyIV + 4));
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ExtIV: %x\n", *pdwRxTSC47_16);

		if (byDecMode == KEY_CTL_TKIP) {
		pwRxTSC15_0 = cpu_to_le16(MAKEWORD((pbyIV+2), *pbyIV));
		} else {
		pwRxTSC15_0 = cpu_to_le16((u16 *)pbyIV);
		}
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"TSC0_15: %x\n", *pwRxTSC15_0);

		if (byDecMode == KEY_CTL_TKIP) {

		if ((pDevice->byLocalID <= REV_ID_VT3253_A1) \|\| (bOnFly == false)) {
		// Software TKIP
		// 1. 3253 A
		// 2. NotOnFly
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"soft KEY_CTL_TKIP \n");
		pMACHeader = (struct ieee80211_hdr *) (pbyFrame);
		TKIPvMixKey(pKey->abyKey, pMACHeader->addr2, pwRxTSC15_0, pdwRxTSC47_16, pDevice->abyPRNG);
		rc4_init(&pDevice->SBox, pDevice->abyPRNG, TKIP_KEY_LEN);
		rc4_encrypt(&pDevice->SBox, pbyIV+8, pbyIV+8, PayloadLen);
		if (ETHbIsBufferCrc32Ok(pbyIV+8, PayloadLen)) {
		*pbyNewRsr \|= NEWRSR_DECRYPTOK;
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ICV OK!\n");
		} else {
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ICV FAIL!!!\n");
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"PayloadLen = %d\n", PayloadLen);
		}
		}
		}

		if (byDecMode == KEY_CTL_CCMP) {
		if (bOnFly == false) {
		// Software CCMP
		// NotOnFly
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"soft KEY_CTL_CCMP\n");
		if (AESbGenCCMP(pKey->abyKey, pbyFrame, FrameSize)) {
		*pbyNewRsr \|= NEWRSR_DECRYPTOK;
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CCMP MIC compare OK!\n");
		} else {
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"CCMP MIC fail!\n");
		}
		}
		}

		}// end of TKIP/AES

		if ((*(pbyIV+3) & 0x20) != 0)
		*pbExtIV = true;
		return true;
		}

		static int s_bAPModeRxData(struct vnt_private pDevice, struct sk_buff skb,
		u32 FrameSize, u32 cbHeaderOffset, s32 iSANodeIndex, s32 iDANodeIndex)
		{

drivers/staging/vt6656/iocmd.h

+0 −301

Original line number	Diff line number	Diff line
		@@ -29,57 +29,12 @@
		#ifndef __IOCMD_H__
		#define __IOCMD_H__

		// ioctl Command code
		#define MAGIC_CODE 0x3142
		#define IOCTL_CMD_TEST (SIOCDEVPRIVATE + 0)
		#define IOCTL_CMD_SET (SIOCDEVPRIVATE + 1)
		#define IOCTL_CMD_HOSTAPD (SIOCDEVPRIVATE + 2)
		#define IOCTL_CMD_WPA (SIOCDEVPRIVATE + 3)

		typedef enum tagWMAC_CMD {

		WLAN_CMD_BSS_SCAN,
		WLAN_CMD_BSS_JOIN,
		WLAN_CMD_DISASSOC,
		WLAN_CMD_SET_WEP,
		WLAN_CMD_GET_LINK,
		WLAN_CMD_GET_LISTLEN,
		WLAN_CMD_GET_LIST,
		WLAN_CMD_GET_MIB,
		WLAN_CMD_GET_STAT,
		WLAN_CMD_STOP_MAC,
		WLAN_CMD_START_MAC,
		WLAN_CMD_AP_START,
		WLAN_CMD_SET_HOSTAPD,
		WLAN_CMD_SET_HOSTAPD_STA,
		WLAN_CMD_SET_802_1X,
		WLAN_CMD_SET_HOST_WEP,
		WLAN_CMD_SET_WPA,
		WLAN_CMD_GET_NODE_CNT,
		WLAN_CMD_ZONETYPE_SET,
		WLAN_CMD_GET_NODE_LIST

		} WMAC_CMD, *PWMAC_CMD;

		typedef enum tagWZONETYPE {
		ZoneType_USA = 0,
		ZoneType_Japan = 1,
		ZoneType_Europe = 2
		} WZONETYPE;

		#define ADHOC 0
		#define INFRA 1
		#define BOTH 2
		#define AP 3

		#define ADHOC_STARTED 1
		#define ADHOC_JOINTED 2

		#define PHY80211a 0
		#define PHY80211b 1
		#define PHY80211g 2

		#define SSID_ID 0
		#define SSID_MAXLEN 32
		#define BSSID_LEN 6
		#define WEP_NKEYS 4
		@@ -88,82 +43,6 @@ typedef enum tagWZONETYPE {
		#define WEP_104BIT_LEN 13
		#define WEP_232BIT_LEN 16

		// Ioctl interface structure
		// Command structure
		//
		typedef struct tagSCmdRequest {
		u8 name[16];
		void *data;
		u16 wResult;
		u16 wCmdCode;
		} __packed SCmdRequest, *PSCmdRequest;

		//
		// Scan
		//

		typedef struct tagSCmdScan {

		u8 ssid[SSID_MAXLEN + 2];

		} __packed SCmdScan, *PSCmdScan;

		//
		// BSS Join
		//

		typedef struct tagSCmdBSSJoin {

		u16 wBSSType;
		u16 wBBPType;
		u8 ssid[SSID_MAXLEN + 2];
		u32 uChannel;
		bool bPSEnable;
		bool bShareKeyAuth;

		} __packed SCmdBSSJoin, *PSCmdBSSJoin;

		//
		// Zonetype Setting
		//

		typedef struct tagSCmdZoneTypeSet {

		bool bWrite;
		WZONETYPE ZoneType;

		} __packed SCmdZoneTypeSet, *PSCmdZoneTypeSet;

		typedef struct tagSWPAResult {
		char ifname[100];
		u8 proto;
		u8 key_mgmt;
		u8 eap_type;
		bool authenticated;
		} __packed SWPAResult, *PSWPAResult;

		typedef struct tagSCmdStartAP {

		u16 wBSSType;
		u16 wBBPType;
		u8 ssid[SSID_MAXLEN + 2];
		u32 uChannel;
		u32 uBeaconInt;
		bool bShareKeyAuth;
		u8 byBasicRate;

		} __packed SCmdStartAP, *PSCmdStartAP;

		typedef struct tagSCmdSetWEP {

		bool bEnableWep;
		u8 byKeyIndex;
		u8 abyWepKey[WEP_NKEYS][WEP_KEYMAXLEN];
		bool bWepKeyAvailable[WEP_NKEYS];
		u32 auWepKeyLength[WEP_NKEYS];

		} __packed SCmdSetWEP, *PSCmdSetWEP;

		typedef struct tagSBSSIDItem {

		u32 uChannel;
		@@ -177,12 +56,6 @@ typedef struct tagSBSSIDItem {

		} __packed SBSSIDItem;

		typedef struct tagSBSSIDList {

		u32 uItem;
		SBSSIDItem sBSSIDList[0];
		} __packed SBSSIDList, *PSBSSIDList;

		typedef struct tagSNodeItem {
		// STA info
		u16 wAID;
		@@ -203,180 +76,6 @@ typedef struct tagSNodeItem {

		} __packed SNodeItem;

		typedef struct tagSNodeList {

		u32 uItem;
		SNodeItem sNodeList[0];

		} __packed SNodeList, *PSNodeList;

		typedef struct tagSCmdLinkStatus {

		bool bLink;
		u16 wBSSType;
		u8 byState;
		u8 abyBSSID[BSSID_LEN];
		u8 abySSID[SSID_MAXLEN + 2];
		u32 uChannel;
		u32 uLinkRate;

		} __packed SCmdLinkStatus, *PSCmdLinkStatus;

		//
		// 802.11 counter
		//
		typedef struct tagSDot11MIBCount {
		u32 TransmittedFragmentCount;
		u32 MulticastTransmittedFrameCount;
		u32 FailedCount;
		u32 RetryCount;
		u32 MultipleRetryCount;
		u32 RTSSuccessCount;
		u32 RTSFailureCount;
		u32 ACKFailureCount;
		u32 FrameDuplicateCount;
		u32 ReceivedFragmentCount;
		u32 MulticastReceivedFrameCount;
		u32 FCSErrorCount;
		} __packed SDot11MIBCount, *PSDot11MIBCount;

		//
		// statistic counter
		//
		typedef struct tagSStatMIBCount {
		//
		// ISR status count
		//
		u32 dwIsrTx0OK;
		u32 dwIsrTx1OK;
		u32 dwIsrBeaconTxOK;
		u32 dwIsrRxOK;
		u32 dwIsrTBTTInt;
		u32 dwIsrSTIMERInt;
		u32 dwIsrUnrecoverableError;
		u32 dwIsrSoftInterrupt;
		u32 dwIsrRxNoBuf;
		/////////////////////////////////////

		u32 dwIsrUnknown; /* unknown interrupt count */

		// RSR status count
		//
		u32 dwRsrFrmAlgnErr;
		u32 dwRsrErr;
		u32 dwRsrCRCErr;
		u32 dwRsrCRCOk;
		u32 dwRsrBSSIDOk;
		u32 dwRsrADDROk;
		u32 dwRsrICVOk;
		u32 dwNewRsrShortPreamble;
		u32 dwRsrLong;
		u32 dwRsrRunt;

		u32 dwRsrRxControl;
		u32 dwRsrRxData;
		u32 dwRsrRxManage;

		u32 dwRsrRxPacket;
		u32 dwRsrRxOctet;
		u32 dwRsrBroadcast;
		u32 dwRsrMulticast;
		u32 dwRsrDirected;
		// 64-bit OID
		u32 ullRsrOK;

		// for some optional OIDs (64 bits) and DMI support
		u32 ullRxBroadcastBytes;
		u32 ullRxMulticastBytes;
		u32 ullRxDirectedBytes;
		u32 ullRxBroadcastFrames;
		u32 ullRxMulticastFrames;
		u32 ullRxDirectedFrames;

		u32 dwRsrRxFragment;
		u32 dwRsrRxFrmLen64;
		u32 dwRsrRxFrmLen65_127;
		u32 dwRsrRxFrmLen128_255;
		u32 dwRsrRxFrmLen256_511;
		u32 dwRsrRxFrmLen512_1023;
		u32 dwRsrRxFrmLen1024_1518;

		// TSR0,1 status count
		//
		u32 dwTsrTotalRetry[2]; /* total collision retry count */
		u32 dwTsrOnceRetry[2]; /* this packet had one collision */
		u32 dwTsrMoreThanOnceRetry[2]; /* this packet had many collisions */
		u32 dwTsrRetry[2]; /* this packet has ever occur collision,
		* that is (dwTsrOnceCollision0 plus
		* dwTsrMoreThanOnceCollision0) */
		u32 dwTsrACKData[2];
		u32 dwTsrErr[2];
		u32 dwAllTsrOK[2];
		u32 dwTsrRetryTimeout[2];
		u32 dwTsrTransmitTimeout[2];

		u32 dwTsrTxPacket[2];
		u32 dwTsrTxOctet[2];
		u32 dwTsrBroadcast[2];
		u32 dwTsrMulticast[2];
		u32 dwTsrDirected[2];

		// RD/TD count
		u32 dwCntRxFrmLength;
		u32 dwCntTxBufLength;

		u8 abyCntRxPattern[16];
		u8 abyCntTxPattern[16];

		/* Software check.... */
		u32 dwCntRxDataErr; /* rx buffer data CRC err count */
		u32 dwCntDecryptErr; /* rx buffer data CRC err count */
		u32 dwCntRxICVErr; /* rx buffer data CRC err count */
		u32 idxRxErrorDesc; /* index for rx data error RD */

		/* 64-bit OID */
		u32 ullTsrOK[2];

		// for some optional OIDs (64 bits) and DMI support
		u32 ullTxBroadcastFrames[2];
		u32 ullTxMulticastFrames[2];
		u32 ullTxDirectedFrames[2];
		u32 ullTxBroadcastBytes[2];
		u32 ullTxMulticastBytes[2];
		u32 ullTxDirectedBytes[2];
		} __packed SStatMIBCount, *PSStatMIBCount;

		typedef struct tagSCmdValue {

		u32 dwValue;

		} __packed SCmdValue, *PSCmdValue;

		//
		// hostapd & viawget ioctl related
		//

		// VIAGWET_IOCTL_HOSTAPD ioctl() cmd:
		enum {
		VIAWGET_HOSTAPD_FLUSH = 1,
		VIAWGET_HOSTAPD_ADD_STA = 2,
		VIAWGET_HOSTAPD_REMOVE_STA = 3,
		VIAWGET_HOSTAPD_GET_INFO_STA = 4,
		VIAWGET_HOSTAPD_SET_ENCRYPTION = 5,
		VIAWGET_HOSTAPD_GET_ENCRYPTION = 6,
		VIAWGET_HOSTAPD_SET_FLAGS_STA = 7,
		VIAWGET_HOSTAPD_SET_ASSOC_AP_ADDR = 8,
		VIAWGET_HOSTAPD_SET_GENERIC_ELEMENT = 9,
		VIAWGET_HOSTAPD_MLME = 10,
		VIAWGET_HOSTAPD_SCAN_REQ = 11,
		VIAWGET_HOSTAPD_STA_CLEAR_STATS = 12,
		};

		#define VIAWGET_HOSTAPD_GENERIC_ELEMENT_HDR_LEN \
		((int) (&((struct viawget_hostapd_param *) 0)->u.generic_elem.data))

		// Maximum length for algorithm names (-1 for nul termination) used in ioctl()

		struct viawget_hostapd_param {
		u32 cmd;
		u8 sta_addr[6];

drivers/staging/vt6656/iwctl.c

+0 −16

Original line number	Diff line number	Diff line
		@@ -382,12 +382,6 @@ int iwctl_siwmode(struct net_device dev, struct iw_request_info info,
		if (pMgmt == NULL)
		return -EFAULT;

		if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP && pDevice->bEnableHostapd) {
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO
		"Can't set operation mode, hostapd is running\n");
		return rc;
		}

		switch (*wmode) {
		case IW_MODE_ADHOC:
		if (pMgmt->eConfigMode != WMAC_CONFIG_IBSS_STA) {
		@@ -407,19 +401,9 @@ int iwctl_siwmode(struct net_device dev, struct iw_request_info info,
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to infrastructure\n");
		break;
		case IW_MODE_MASTER:

		pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
		rc = -EOPNOTSUPP;
		break;

		if (pMgmt->eConfigMode != WMAC_CONFIG_AP) {
		pMgmt->eConfigMode = WMAC_CONFIG_AP;
		if (pDevice->flags & DEVICE_FLAGS_OPENED)
		pDevice->bCommit = true;
		}
		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "set mode to Access Point\n");
		break;

		case IW_MODE_REPEAT:
		pMgmt->eConfigMode = WMAC_CONFIG_ESS_STA;
		rc = -EOPNOTSUPP;