wlan_config.c

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

	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

int main(int argc, char *argv[])
{
	int             cmd;
	int		PrivateCmds;

	if (argc < 3) {
		fprintf(stderr, "Invalid number of parameters!\n");
		display_usage();
		exit(1);
	}

	strncpy(DevName, argv[1], IFNAMSIZ);

	/*
	 * create a socket 
	 */
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
		fprintf(stderr, "wlanconfig: Cannot open socket.\n");
		exit(1);
	}

	PrivateCmds = get_private_info(DevName);

	marvell_init_ioctl_numbers(DevName);

	switch ((cmd = findcommand(MAX_COMMANDS, commands, argv[2]))) {
	case CMD_RDMAC:
	case CMD_RDBBP:
	case CMD_RDRF:
		if (argc < 4) {
			fprintf(stderr, 
				"Register offset required!\n");
			display_usage();
			exit(1);
		}

		if (process_read_register(cmd, argv[3])) {
			fprintf(stderr,
				"Read command failed!\n");
			exit(1);
		}
		break;
	case CMD_WRMAC:
	case CMD_WRBBP:
	case CMD_WRRF:
		if (argc < 5) {
			fprintf(stderr,
				"Register offset required &" 
					"value!\n");
			display_usage();
			exit(1);
		}
		if (process_write_register(cmd, argv[3],
					argv[4])) {
			fprintf(stderr,
				"Write command failed!\n");
			exit(1);
		}
		break;
	case CMD_RDBCA:
		//get_bca_config();
		break;
	case CMD_WRBCA:
		{
			int subcmd;

			switch ((subcmd =
				findcommand(MAX_SUBCOMMANDS,
						sub_cmds,
						argv[3]))) {
				case SUBCMD_MODE:
					break;
				default:
					fprintf(stderr,
					"Invalid sub-command" 
					"specified!\n");
					display_usage();
					exit(1);
			}
			break;
		}
	case CMD_CMD52R:
		process_sdcmd52r(argc,argv);
		break;
	case CMD_CMD52W:
		process_sdcmd52w(argc,argv);
		break;
	case CMD_CMD53R:
		process_sdcmd53r();
		break;
#ifdef SUBSCRIBE_EVENT_CTRL
	case CMD_SUB_EVENT:
		process_event_subscribe(argc, argv);
		break;
#endif

#ifdef BG_SCAN
	case CMD_BG_SCAN_CONFIG:
		process_bg_scan_config(argc, argv);
		break;
#endif /* BG_SCAN */
#ifdef WMM
	case CMD_WMM_ACK_POLICY:
		process_wmm_ack_policy(argc, argv);
		break;
	case CMD_WMM_TSPEC:
	case CMD_WMM_AC_WPAIE:
		process_wmm_para_conf(argc, argv, cmd);
		break;
#endif /* WMM */
#ifdef CAL_DATA
	case CMD_CAL_DATA:
		process_cal_data(argc, argv);
		break;
	case CMD_CAL_DATA_EXT:
		process_cal_data_ext(argc, argv); 
		break;
#endif
	case CMD_CFREGR:
		printf("process read cfreg\n");
		if (argc < 4) {
			fprintf(stderr,	"Register offset required!\n");
			display_usage();
			exit(1);
		}
		if (process_read_cfreg(argv[3])) {
			fprintf(stderr, "Read CF register failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_CFREGW:
		printf("process write cfreg\n");
		if (argc < 5) {
			fprintf(stderr,	"Register offset required!\n");
			display_usage();
			exit(1);
		}
		if (process_write_cfreg(argv[3], argv[4])) {
			fprintf(stderr, "Read CF register failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_RDEEPROM:
		printf("proces read eeprom\n");

		if(argc < 5) {
			fprintf(stderr, "Register offset, number of bytes required\n");
			display_usage();
			exit(1);
		}
		
		if(process_read_eeprom(argv[3], argv[4])) {
			fprintf(stderr, "EEPROM Read failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_GETRATE:
		if (process_get_rate()) {
			fprintf(stderr, "Get Rate Failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_SLEEPPARAMS:
		if (process_sleep_params(argc, argv)) {
			fprintf(stderr, "Sleep Params Failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_BCA:
		if (process_bca(argc, argv)) {
			fprintf(stderr, "BCA Params Failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_REQUESTTPC:
/*		if (process_requesttpc(argc, argv)) {
			fprintf(stderr, "Requesttpc Params Failed\n");
			display_usage();
			exit(1);
		}
*/
		break;
	case CMD_BCA_TS:
		if (process_bca_ts(argc, argv)) {
			fprintf(stderr, "SetBcaTs Failed\n");
			display_usage();
			exit(1);
		}
		break;
    case CMD_REASSOCIATE:
        if (process_reassociation(argc, argv))
        {
			exit(1);
        }
        break;
	case CMD_SCAN_BSSID:
		if (process_scan_bssid(argc, argv)) {
			fprintf(stderr, "ScanBssid Failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_SETADHOCCH:
		if (process_setadhocch(argc, argv)) {
			fprintf(stderr, "SetAdhocCh Failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_GETADHOCCH:
		if (process_getadhocch(argc, argv)) {
			fprintf(stderr, "GetAdhocCh Failed\n");
			display_usage();
			exit(1);
		}
		break;
#ifdef EXTSCAN		
	case CMD_EXTSCAN:
		if (process_extscan(argc, argv)) {
			fprintf(stderr, "ExtScan Failed\n");
			display_usage();
			exit(1);
		}
		break;
	case CMD_SCAN_LIST:
		if (process_scan_results(argc, argv)) {
			fprintf(stderr, "getscanlist Failed\n");
			display_usage();
			exit(1);
		}
		break;
#endif		
	default:
		fprintf(stderr, "Invalid command specified!\n");
		display_usage();
		exit(1);
	}

	return 0;
}

int process_read_eeprom(char *stroffset, char *strnob)
{
	char 			buffer[MAX_EEPROM_DATA];
	struct ifreq    	userdata;
	wlan_ioctl_regrdwr 	*reg = (wlan_ioctl_regrdwr *)buffer;

	memset(buffer, 0, sizeof(buffer));
	reg->WhichReg = REG_EEPROM;
	reg->Action = 0; // Read the eeprom

	if (!strncasecmp(stroffset, "0x", 2))
		reg->Offset = a2hex((stroffset + 2));
	else
		reg->Offset = atoi(stroffset);

	if (!strncasecmp(strnob, "0x", 2))
		reg->NOB = a2hex((strnob + 2));
	else
		reg->NOB = atoi(strnob);

	if (reg->NOB > MAX_EEPROM_DATA) {
		fprintf(stderr, "Number of bytes exceeds MAX EEPROM Read size\n");
		return -1;
	}

	strncpy(userdata.ifr_name, DevName, IFNAMSIZ);
	userdata.ifr_data = buffer;

	if (ioctl(sockfd, WLANREGRDWR, &userdata)) {
		perror("wlanconfig");
		fprintf(stderr, 
			"wlanconfig: EEPROM read not possible "
			"by interface %s\n", DevName);
		return -1;
	}

	hexdump("RD EEPROM", &reg->Value, reg->NOB, ' '); 

	return 0;
}

static char    *usage[] = {
	"Usage: wlanconfig <ethX> <cmd> [...]",
	"where",
	"	ethX	: wireless network interface",
	"	cmd	: rdmac, wrmac, rdbbp, wrbbp, rdrf, wrrf,\n"
	"		: rdbca, wrbca, sdcmd52r, sdcmd52w, sdcmd53r,\n" 
	"		: caldata, rdcfreg, wrcfreg, rdeeprom, bgscanconfig,\n"
	"		: sleepparams, bca, bca-ts, scanbssid,\n"
	"		: requesttpc, setadhocch, getadhocch,\n"
	"		: wmmparaie, wmm_ack_policy, wmmtspec\n"
	"		: reassociate\n",
#ifdef SUBSCRIBE_EVENT_CTRL
	"		: subevent\n"
#endif
	"	[...]	: additional parameters for read registers are",
	"		:	<offset>",
	"		: additional parameters for write registers are",
	"		:	<offset> <value>",
	"		: additional parameters for BlueTooth Co-existence",
	"		:  Arbitration (BCA) wrbca are:",
	"		:	mode			off | mbca | csrbci",
	"		:	antenna			single | dual",
	"		:	btfreq			off | ib | oob",
	"		:	txprioritylow32		low | high",
	"		:	txpriorityhigh32	low | high",
	"		:	rxprioritylow32		low | high",
	"		:	rxpriorityhigh32	low | high",
	"		: addition parameters for cal data",
	"		: 	< filename >",
#ifdef SUBSCRIBE_EVENT_CTRL
	"		: additonal parameter for subevent",
	"		: 	< filename >",
#endif
	"		: additional parameters for reassociate are:",
	"		:	XX:XX:XX:XX:XX:XX YY:YY:YY:YY:YY:YY < string max 32>",
	"		:	< Current BSSID > < Desired BSSID > < Desired SSID >",
};

void display_usage(void)
{
	int i;

	for (i = 0; i < (sizeof(usage) / sizeof(usage[0])); i++)
		fprintf(stderr, "%s\n", usage[i]);
}

int findcommand(int maxcmds, char *cmds[], char *cmd)
{
	int i;

	for (i = 0; i < maxcmds; i++) {
		if (!strcasecmp(cmds[i], cmd)) {
			return i;
		}
	}

	return -1;
}

int process_sdcmd52r(int argc, char *argv[])
{
	struct ifreq    userdata;
	unsigned char 	buf[6];
	unsigned int 	tmp;

	buf[0] = 0;			//CMD52 read
	if (argc == 5) {
		buf[1] = atoval(argv[3]);	//func
		tmp = 	 atoval(argv[4]);	//reg
		buf[2] = tmp & 0xff;
		buf[3] = (tmp >> 8) & 0xff;
		buf[4] = (tmp >> 16) & 0xff;
		buf[5] = (tmp >> 24) & 0xff;
	} else {
		fprintf(stderr, "Invalid number of parameters!\n");
		return -1;
	}
	

	strncpy(userdata.ifr_name, DevName, IFNAMSIZ);
	userdata.ifr_data = buf;

	if (ioctl(sockfd, WLANCMD52RDWR, &userdata)) {
		perror("wlanconfig");
		fprintf(stderr,
			"wlanconfig: CMD52 R/W not supported by "
				"interface %s\n", DevName);
		return -1;
   	}
   	printf("sdcmd52r returns 0x%02X\n", buf[0]);

   	return 0;
}

int process_sdcmd52w(int argc, char *argv[])
{
   	struct ifreq    userdata;
   	unsigned char 	buf[7];
   	unsigned int 	tmp;

	buf[0] = 1;			//CMD52 write