wlan_config.c

marvell cf wifi driver source code CF-8385-linux-x86-5.0.4.p0-132-src.rar

	else 	
		return atoi(buf);
}

void display_sleep_params(wlan_ioctl_sleep_params_config *sp)
{
	printf("Sleep Params for %s:\n", sp->Action ? "set" : "get");
   	printf("----------------------------------------\n");
	printf("Error		: %u\n", sp->Error);
	printf("Offset		: %u\n", sp->Offset);
	printf("StableTime	: %u\n", sp->StableTime);
	printf("CalControl	: %u\n", sp->CalControl);
	printf("ExtSleepClk	: %u\n", sp->ExtSleepClk);
	printf("Reserved	: %u\n", sp->Reserved);
}

int process_sleep_params(int argc, char *argv[])
{
	struct iwreq			iwr;
	int				ret;
	wlan_ioctl_sleep_params_config 	sp;

	if (argc < 4) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: ./wlanconfig eth1 sleepparams get/set <p1>"
				" <p2> <p3> <p4> <p5> <p6>\n");
		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_params(wlan_ioctl_bca_params_config *bca)
{
	printf("BCA Params for %s:\n", bca->Action ? "set" : "get");
   	printf("----------------------------------------\n");
	printf("Mode		: %u\n", bca->Mode);	
	printf("Antenna		: %u\n", bca->Antenna);	
	printf("BtFreq		: %u\n", bca->BtFreq);	
	printf("TxPriorityLow32	: %u\n", bca->Txpl32);	
	printf("TxPriorityHigh32: %u\n", bca->Txph32);	
	printf("RxPriorityLow32	: %u\n", bca->Rxpl32);	
	printf("RxPriorityHigh32: %u\n", bca->Rxph32);	
}

int process_bca(int argc, char *argv[]) 
{
	struct iwreq			iwr;
	int				ret;
	wlan_ioctl_bca_params_config 	bca;

	if (argc < 4) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: ./wlanconfig eth1 bca get/set <p1>"
				" <p2> <p3> <p4> <p5> <p6> <p7>\n");
		exit(1);
	}

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

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

		bca.Action = 1;
		if ((ret = atoval(argv[4])) < 0)
			return -EINVAL;
		bca.Mode = (unsigned short) ret;
		if ((ret = atoval(argv[5])) < 0)
			return -EINVAL;
		bca.Antenna = (unsigned short) ret;
		if ((ret = atoval(argv[6])) < 0)
			return -EINVAL;
		bca.BtFreq = (unsigned short) ret;
		if ((ret = atoval(argv[7])) < 0)
			return -EINVAL;
		bca.Txpl32 = (unsigned char) ret;
		if ((ret = atoval(argv[8])) < 0)
			return -EINVAL;
		bca.Txph32 = (unsigned char) ret;
		if ((ret = atoval(argv[9])) < 0)
			return -EINVAL;
		bca.Rxpl32 = (unsigned short) ret;
		if ((ret = atoval(argv[10])) < 0)
			return -EINVAL;
		bca.Rxph32 = (unsigned short) ret;
	} else 	{
		return -EINVAL;
	}

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

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

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

	display_bca_params(&bca);

	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;
}

/*void display_req_tpc_params(wlan_ioctl_tpc_request_params *tpc)
{
	printf("TPC Params :\n");
   	printf("----------------------------------------\n");
	printf("Mac Addr		: %x:%x:%x:%x:%x:%x\n", 
		tpc->mac[0],tpc->mac[1],tpc->mac[2],tpc->mac[3],tpc->mac[4],
		tpc->mac[5]);
	printf("time-out		: %u\n", tpc->timeout);	
	printf("index			: %u\n", tpc->index);	
	printf("TxPower			: %d\n", tpc->TxPower);	
	printf("LinkMargin		: %d\n", tpc->LinkMargin);	
	printf("RSSI			: %d\n", tpc->RSSI);	
}


int process_requesttpc(int argc, char *argv[]) 
{
	int				ret;
	unsigned char			mac[6];
	struct iwreq			iwr;
	wlan_ioctl_tpc_request_params 	tpc;

	if (argc != 6) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: ./wlanconfig eth1 requesttpc <p1> <p2> <p3>\n");
		exit(1);
	}

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

	memset(&tpc, 0, sizeof(wlan_ioctl_tpc_request_params));
	memset(mac, 0, sizeof(mac));
	
	sscanf(argv[3], "%4x:%4x:%4x:%4x:%4x:%4x",
			(unsigned int *)&mac[0], 
			(unsigned int *)&mac[1], 
			(unsigned int *)&mac[2], 
			(unsigned int *)&mac[3], 
			(unsigned int *)&mac[4], 
			(unsigned int *)&mac[5]); 

	memcpy(&tpc.mac, mac, sizeof(mac));

	if ((ret = atoval(argv[4])) < 0)
		return -EINVAL;
	tpc.timeout = (unsigned short) ret;
	if ((ret = atoval(argv[5])) < 0)
		return -EINVAL;
	tpc.index = (unsigned char) ret;

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

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

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

	display_req_tpc_params(&tpc);

	return 0;
}
Temporary COmmented out. Needs to fix the compileing issue*/

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]);