wlan_config.c

marvell wifi driver GSPI-8385-LINUX-OMAP1510-5.0.10.p0-144-src.rar

		exit(1);
	}

	if (IOCTL_WLANSLEEPPARAMS <= 0) {
		return -EOPNOTSUPP;
	}

	memset(&sp, 0, sizeof(wlan_ioctl_sleep_params_config));
	if (!strcmp(argv[3], "get")) {
		sp.Action = 0;
	} else if (!strncmp(argv[3], "set", 3)) {
		if (argc != 10) {
			printf("Error: invalid no of arguments\n");
			printf("Syntax: ./wlanconfig eth1 sleepparams get/set" 
					"<p1> <p2> <p3> <p4> <p5> <p6>\n");
			exit(1);
		}

		sp.Action = 1;
		if ((ret = atoval(argv[4])) < 0)
			return -EINVAL;
		sp.Error = (unsigned short) ret;
		if ((ret = atoval(argv[5])) < 0)
			return -EINVAL;
		sp.Offset = (unsigned short) ret;
		if ((ret = atoval(argv[6])) < 0)
			return -EINVAL;
		sp.StableTime = (unsigned short) ret;
		if ((ret = atoval(argv[7])) < 0)
			return -EINVAL;
		sp.CalControl = (unsigned char) ret;
		if ((ret = atoval(argv[8])) < 0)
			return -EINVAL;
		sp.ExtSleepClk = (unsigned char) ret;
		if ((ret = atoval(argv[9])) < 0)
			return -EINVAL;
		sp.Reserved = (unsigned short) ret;
	} else 	{
		return -EINVAL;
	}

	memset(&iwr, 0, sizeof(iwr));
	
	if (SUBIOCTL_WLANSLEEPPARAMS > 0) {
		iwr.u.data.flags = SUBIOCTL_WLANSLEEPPARAMS;
	}

	strncpy(iwr.ifr_name, DevName, IFNAMSIZ);
	iwr.u.data.pointer = (caddr_t) &sp;
	iwr.u.data.length = sizeof(wlan_ioctl_sleep_params_config);

	if (ioctl(sockfd, IOCTL_WLANSLEEPPARAMS, &iwr) < 0) {
		perror("wlanconfig");
		return -1;
	}

	display_sleep_params(&sp);

	return 0;
}

void display_bca_ts_params(wlan_ioctl_bca_timeshare_config *bca_ts)
{
	printf("BCA Time Share Params for %s:\n", bca_ts->Action?"set" : "get");
   	printf("----------------------------------------\n");
	printf("TrafficType		: %u\n", bca_ts->TrafficType);	
	printf("TimeShareInterval	: %u\n", bca_ts->TimeShareInterval);	
	printf("BTTime			: %u\n", bca_ts->BTTime);	
}

int process_bca_ts(int argc, char *argv[]) 
{
	int				ret, i;
	struct iwreq			iwr;
	wlan_ioctl_bca_timeshare_config	bca_ts;

	if (argc < 5) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: ./wlanconfig eth1 bca_ts get/set <p1>"
								" <p2> <p3>\n");
		exit(1);
	}

	if (IOCTL_WLANBCA_TS <= 0) {
		return -EOPNOTSUPP;
	}

	memset(&bca_ts, 0, sizeof(wlan_ioctl_bca_timeshare_config));
	
	if ((ret = atoval(argv[4])) < 0)
		return -EINVAL;
	if (ret > 1)
		return -EINVAL;
	bca_ts.TrafficType = (unsigned short) ret; // 0 or 1
	
	if (!strcmp(argv[3], "get")) {
		bca_ts.Action = 0;
	} else if (!strncmp(argv[3], "set", 3)) {
		if (argc != 7) {
			printf("Error: invalid no of arguments\n");
			printf("Syntax: ./wlanconfig eth1 bca_ts get/set" 
							" <p1> <p2> <p3>\n");
			exit(1);
		}

		bca_ts.Action = 1;
		
		if ((ret = atoval(argv[5])) < 0)
			return -EINVAL;
		/* If value is not multiple of 10 then take the floor value */
		i = ret % 10;
		ret -= i;
		/* Valid Range for TimeShareInterval: < 20 ... 60_000 > ms */
		if (ret < 20  || ret > 60000) {
			printf("Invalid TimeShareInterval Range:"
						" < 20 ... 60000 > ms\n");
			return -EINVAL;
		}
		bca_ts.TimeShareInterval = (unsigned int) ret;
		
		if ((ret = atoval(argv[6])) < 0)
			return -EINVAL;
		/* If value is not multiple of 10 then take the floor value */
		i = ret % 10;
		ret -= i;
		
		if (ret > bca_ts.TimeShareInterval) {
			printf("Invalid BTTime"
				"  Range: < 0 .. TimeShareInterval > ms\n");
			return -EINVAL;
		}
		bca_ts.BTTime = (unsigned int) ret;
	} else 	{
		return -EINVAL;
	}

	memset(&iwr, 0, sizeof(iwr));
	
	if (SUBIOCTL_WLANBCA_TS > 0) {
		iwr.u.data.flags = SUBIOCTL_WLANBCA_TS;
	}

	strncpy(iwr.ifr_name, DevName, IFNAMSIZ);
	iwr.u.data.pointer = (caddr_t) &bca_ts;
	iwr.u.data.length = sizeof(wlan_ioctl_bca_timeshare_config);

	if (ioctl(sockfd, IOCTL_WLANBCA_TS, &iwr) < 0) {
		perror("wlanconfig");
		return -1;
	}

	display_bca_ts_params(&bca_ts);

	return 0;
}

static int process_reassociation(int argc, char *argv[]) 
{
	wlan_ioctl_reassociation_info reassocInfo;
	struct iwreq			iwr;
    unsigned int mac[6];
    unsigned int idx;
    int numToks;

    /*
    ** Reassociation request is expected to be in the following format:
    **
    **  <xx:xx:xx:xx:xx:xx>  <yy:yy:yy:yy:yy:yy>  <ssid string>
    **
    **  where xx..xx is the current AP BSSID to be included in the reassoc req
    **        yy..yy is the desired AP to send the reassoc req to
    **        <ssid string> is the desired AP SSID to send the reassoc req to.
    **
    **  The current and desired AP BSSIDs are required.  
    **  The SSID string can be omitted if the desired BSSID is provided.
    **
    **  If we fail to find the desired BSSID, we attempt the SSID.
    **  If the desired BSSID is set to all 0's, the ssid string is used.
    **  
    */

    /* Verify the number of arguments is either 5 or 6 */
    if (argc != 5 && argc != 6)
    {
		fprintf(stderr, "Invalid number of parameters!\n");
        return -EINVAL;
    }

	memset(&iwr, 0, sizeof(iwr));
    memset(&reassocInfo, 0x00, sizeof(reassocInfo));

    /*
    **  Scan in and set the current AP BSSID
    */
	numToks = sscanf(argv[3], "%2x:%2x:%2x:%2x:%2x:%2x",
                     mac + 0, mac + 1, mac + 2, mac + 3, mac + 4, mac + 5);

    if (numToks != 6)
    {
		fprintf(stderr, "Invalid number of parameters!\n");
        return -EINVAL;
    }

    for (idx = 0; idx < sizeof(mac); idx++)
    {
        reassocInfo.CurrentBSSID[idx] = (unsigned char)mac[idx];
    }


    /*
    **  Scan in and set the desired AP BSSID
    */
	numToks = sscanf(argv[4], "%2x:%2x:%2x:%2x:%2x:%2x",
                     mac + 0, mac + 1, mac + 2, mac + 3, mac + 4, mac + 5);

    if (numToks != 6)
    {
		fprintf(stderr, "Invalid number of parameters!\n");
        return -EINVAL;
    }

    for (idx = 0; idx < sizeof(mac); idx++)
    {
        reassocInfo.DesiredBSSID[idx] = (unsigned char)mac[idx];
    }

    /*
    ** If the ssid string is provided, save it; otherwise it is an empty string
    */
    if (argc == 6)
    {
        strcpy(reassocInfo.DesiredSSID, argv[5]);
    }

    /* 
    ** Set up and execute the ioctl call
    */
    iwr.u.data.flags = SUBIOCTL_WLANREASSOCIATE;
	strncpy(iwr.ifr_name, DevName, IFNAMSIZ);
	iwr.u.data.pointer = (caddr_t)&reassocInfo;
	iwr.u.data.length = sizeof(reassocInfo);

	if (ioctl(sockfd, IOCTL_WLANREASSOCIATE, &iwr) < 0) {
		perror("wlanconfig: reassociate response");
		return -1;
	}

    /* No error return */
    return 0;
}


int process_scan_bssid(int argc, char *argv[]) 
{
	unsigned char			mac[6];
	struct iwreq			iwr;
	int ret;
	unsigned char 			extra;

	if (argc != 4) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: ./wlanconfig eth1 scan-bssid <MAC Address>\n");
		exit(1);
	}

	if (IOCTL_WLANSCAN_BSSID <= 0) {
		return -EOPNOTSUPP;
	}

	memset(mac, 0, sizeof(mac));

	/* strip all ':' */
	ret = sscanf(argv[3], "%2x:%2x:%2x:%2x:%2x:%2x%c",
			(unsigned int *)&mac[0], 
			(unsigned int *)&mac[1], 
			(unsigned int *)&mac[2], 
			(unsigned int *)&mac[3], 
			(unsigned int *)&mac[4], 
			(unsigned int *)&mac[5], &extra); 
	
	printf("Scan BSSID %02X:%02X:%02X:%02X:%02X:%02X\n", 
		 mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]);

	if( ret != 6 ) {
		printf("Wrong MAC address format!\n");
		return -EOPNOTSUPP;
	}
	memset(&iwr, 0, sizeof(iwr));
	
	if (SUBIOCTL_WLANSCAN_BSSID > 0) {
		iwr.u.data.flags = SUBIOCTL_WLANSCAN_BSSID;
	}

	strncpy(iwr.ifr_name, DevName, IFNAMSIZ);
	iwr.u.data.pointer = (caddr_t) &mac;
	iwr.u.data.length = sizeof(mac);

	if (ioctl(sockfd, IOCTL_WLANSCAN_BSSID, &iwr) < 0) {
		perror("wlanconfig");
		return -1;
	}

	return 0;
}


int process_setadhocch(int argc, char *argv[]) 
{
	unsigned int	vals[2];
	struct iwreq	iwr;

	if (argc != 5) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: wlanconfig eth1 setadhocch <band> <channel>\n");
		exit(1);
	}

	if (IOCTL_WLANSETADHOCCH <= 0) {
		return -EOPNOTSUPP;
	}

	vals[0] = *argv[3];
	vals[1] = atoval(argv[4]);

	memset(&iwr, 0, sizeof(iwr));
	
	if (SUBIOCTL_WLANSETADHOCCH > 0) {
		iwr.u.data.flags = SUBIOCTL_WLANSETADHOCCH;
	}

	strncpy(iwr.ifr_name, DevName, IFNAMSIZ);
	iwr.u.data.pointer = (caddr_t)vals;
	iwr.u.data.length = sizeof(vals);

	if (ioctl(sockfd, IOCTL_WLANSETADHOCCH, &iwr) < 0) {
		perror("wlanconfig");
		return -1;
	}

	return 0;
}

int process_getadhocch(int argc, char *argv[]) 
{
	unsigned int	vals[2];
	struct iwreq	iwr;

	if (argc != 3) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: wlanconfig eth1 getadhocch\n");
		exit(1);
	}

	if (IOCTL_WLANGETADHOCCH <= 0) {
		return -EOPNOTSUPP;
	}

	memset(&iwr, 0, sizeof(iwr));
	
	if (SUBIOCTL_WLANGETADHOCCH > 0) {
		iwr.u.data.flags = SUBIOCTL_WLANGETADHOCCH;
	}

	strncpy(iwr.ifr_name, DevName, IFNAMSIZ);
	iwr.u.data.pointer = (caddr_t)vals;
	iwr.u.data.length = sizeof(vals);

	if (ioctl(sockfd, IOCTL_WLANGETADHOCCH, &iwr) < 0) {
		perror("wlanconfig");
		return -1;
	}

	printf("getadhocch: %c %d\n", vals[0], vals[1]);

	return 0;
}

#ifdef EXTSCAN
int process_extscan(int argc, char *argv[]) 
{
	struct iwreq			iwr;
	WCON_SSID 			Ssid;

	if (argc != 4) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: ./wlanconfig eth1 extscan <SSID>\n");
		exit(1);
	}

	if (IOCTL_WLANEXTSCAN <= 0) {
		return -EOPNOTSUPP;
	}

	printf("Ssid: %s\n", argv[3]);

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

	Ssid.ssid_len = strlen(argv[3]);
	memcpy(Ssid.ssid, argv[3], Ssid.ssid_len);

	if (SUBIOCTL_WLANEXTSCAN > 0) {
		iwr.u.data.flags = SUBIOCTL_WLANEXTSCAN;
	}

	strncpy(iwr.ifr_name, DevName, IFNAMSIZ);
	iwr.u.data.pointer = (caddr_t) &Ssid;
	iwr.u.data.length = sizeof(Ssid);

	if (ioctl(sockfd, IOCTL_WLANEXTSCAN, &iwr) < 0) {
		perror("wlanconfig");
		return -1;
	}

	return 0;
}

void parse_custom_info(WCON_HANDLE *pHandle, struct iw_point *data, int idx)
{
	int	i = 0;
	char 	*custom_cmd[] = { "wpa_ie", "rsn_ie", NULL };
	
	if (!data->pointer || !data->length) {
		printf("iw_point: Invalid Pointer/Length\n");
		return;
	}
	
	if (!strncmp(data->pointer, "wmm_ie", strlen("wmm_ie"))) {
			pHandle->ScanList[idx].Wmm = WCON_WMM_ENABLED;
	}

	while (custom_cmd[i]) {
		if (!strncmp(data->pointer, custom_cmd[i], 
					strlen(custom_cmd[i]))) {
			pHandle->ScanList[idx].WpaAP = WCON_WPA_ENABLED;
			break;
		}
		i++;
	}

	printf("Wpa:\t %s\n", pHandle->ScanList[idx].WpaAP ?
					"enabled" : "disabled");
	printf("Wmm:\t %s\n", pHandle->ScanList[idx].Wmm ?
					"enabled" : "disabled");
}

void parse_scan_info(WCON_HANDLE *pHandle, unsigned char buffer[], int length)
{
	int			len = 0;
	int			ap_index = -1;
	char			*mode[3] = {"auto", "ad-hoc", "infra"};
	struct iw_event		iwe;

	memset(pHandle->ScanList, 0, sizeof(pHandle->ScanList));
	pHandle->ApNum = 0;

	while (len + IW_EV_LCP_LEN < length) {
		memcpy((char *)&iwe, buffer + len, sizeof(struct iw_event));
		switch (iwe.cmd) {
		case SIOCGIWAP:
			ap_index++;
			memcpy(pHandle->ScanList[ap_index].Bssid, 
					iwe.u.ap_addr.sa_data, ETH_ALEN);
			printf("\nBSSID:\t %02X:%02X:%02X:%02X:%02X:%02X\n",
				HWA_ARG(pHandle->ScanList[ap_index].Bssid));
			break;
			
		case SIOCGIWESSID:
			iwe.u.essid.pointer = buffer + len + IW_EV_POINT_LEN;	
			if ((iwe.u.essid.pointer) && (iwe.u.essid.length)) {
				memcpy(pHandle->ScanList[ap_index].Ssid.ssid,
						(char *)iwe.u.essid.pointer,
						iwe.u.essid.length);
				pHandle->ScanList[ap_index].Ssid.ssid_len = 
							iwe.u.essid.length;
			}
			printf("SSID:\t %s\n",
				pHandle->ScanList[ap_index].Ssid.ssid);
			break;
		
		case SIOCGIWENCODE:
			if (!(iwe.u.data.flags & IW_ENCODE_DISABLED)) {
				pHandle->ScanList[ap_index].Privacy =
							WCON_ENC_ENABLED;
			}
			printf("Privacy: %s\n", 
					pHandle->ScanList[ap_index].Privacy ?
					"enabled": "disabled");
			break;

		case SIOCGIWMODE:
			pHandle->ScanList[ap_index].NetMode = iwe.u.mode;
			printf("NetMode: %s\n", 
				mode[pHandle->ScanList[ap_index].NetMode]);
			break;
	
#if WIRELESS_EXT > 14
		case IWEVCUSTOM:
			iwe.u.data.pointer = buffer + len + IW_EV_POINT_LEN;
			parse_custom_info(pHandle, &iwe.u.data, ap_index);
			break;
#endif

		case IWEVQUAL:
			pHandle->ScanList[ap_index].Rssi = iwe.u.qual.level;
			printf("Quality: %d\n", 
					pHandle->ScanList[ap_index].Rssi);
			break;
		}
		
		len += iwe.len;
	}
	
	pHandle->ApNum = ap_index + 1;
	printf("\nNo of AP's = %d\n", pHandle->ApNum);

	return;
}

int process_scan_results(int argc, char *argv[]) 
{
	unsigned char		buffer[IW_SCAN_MAX_DATA];
	struct iwreq		iwr;
	WCON_HANDLE		mhandle, *pHandle = &mhandle;

	memset(pHandle, 0, sizeof(WCON_HANDLE));
	memset(&iwr, 0, sizeof(struct iwreq));
	
	iwr.u.data.pointer = buffer;
	iwr.u.data.length = sizeof(buffer);
	strncpy(iwr.ifr_name, DevName, IFNAMSIZ);

	if ((ioctl(sockfd, SIOCGIWSCAN, &iwr)) < 0) {
		printf("Get Scan Results Failed\n");
		return -1;
	}

	parse_scan_info(pHandle, buffer, iwr.u.data.length);

	return 0;
}
#endif

#ifdef CIPHER_TEST
int process_cipher_test(int argc, char *argv[])
{
  int n, i;
  struct iwreq iwr;
  HostCmd_DS_802_11_KEY_ENCRYPT cmd;

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

  ascii2hex(cmd.KeyEncKey,  argv[4], 32);
  ascii2hex(cmd.KeyIV,      argv[5], 32);

  cmd.EncType = 
    (strcmp(argv[3], "aes") == 0) ? CIPHER_TEST_AES: CIPHER_TEST_RC4;

  cmd.Action  = HostCmd_ACT_SET;

  for (i = 0; i < 512; i++)