wlan_config.c

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

			printf("Line %d: Invalid sub_event line '%s'.",
								*line, pos);
			errors++;
			continue;
		}

		*pos2++ = '\0';
		if (*pos2 == '"') {
			if (strchr(pos2 + 1, '"') == NULL) {
				printf("Line %d: invalid quotation '%s'.", 
								*line, pos2);
				errors++;
				continue;
			}
		}

		for (i = 0; i < NUM_SUB_EVENT_FIELDS; i++) {
			if (strcmp(pos, sub_event_fields[i].name) == 0) {
				if (sub_event_fields[i].parser(EventData,
								*line, pos2)) {
					printf("Line %d: failed to parse %s"
						"'%s'.", *line, pos, pos2);
					errors++;
					}
				break;
			}
		}
		if (i == NUM_SUB_EVENT_FIELDS) {
			printf("Line %d: unknown sub_event field '%s'.", 
								*line, pos);
			errors++;
		}
	}
	return 0;
}

int process_event_subscribe(int argc, char *argv[])
{
	u8			*buf;
	char			event_data[512];
	char			filename[48] = "";
	FILE			*fp;
	EventSubscribe		EventData;
	struct ifreq		userdata;
	u8			*pos;
	int			line = 0;
	int			CmdNum = SUBSCRIBE_EVENT; 

	memset(&EventData, 0, sizeof(EventSubscribe));
	
	if (argc != 4) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: ./wlanconfig eth1 subevent <filename>\n");
		exit(1);
	}
	
	strncpy(filename, argv[3], MIN(sizeof(filename)-1, strlen(argv[3])));

	if ((fp = fopen(filename, "r")) == NULL) {
		fprintf(stderr, "Cannot open file %s\n", argv[1]);
		exit(1);
	}

	while ((pos = wlan_config_get_line(event_data, sizeof(event_data), fp, 
							(int *)&line))) {
		if (strcmp(pos, "Events={") == 0) {
			wlan_get_subscribe_event_data(fp, &line, &EventData);
		}
	}

	fclose(fp);

	buf = (u8 *)malloc(512);

	memcpy(buf, &CmdNum, sizeof(int));
	memcpy(buf + sizeof(int), (u8 *)&EventData.Action, 
							sizeof(EventSubscribe));

	strncpy(userdata.ifr_name, DevName, IFNAMSIZ);
	userdata.ifr_data = buf;
	
	if (ioctl(sockfd, WLAN_SETCONF_GETCONF, &userdata)) {
		fprintf(stderr, "wlanconfig: SUBSCRIBE_EVENT not"
						" supported by %s\n", DevName);
			return -1;
   	}
	
#define GET_EVENTS	0
#define BIT_0		(1 << 0) 
#define BIT_1		(1 << 1)
#define BIT_2		(1 << 2)
#define BIT_3		(1 << 3)
	if (EventData.Action == GET_EVENTS) {
		u16		Events;

		Events = *(u16 *)(buf + sizeof(int));

		printf("Events Subscribed to Firmware are\n");

		if (Events & BIT_0) {
			printf("RSSI_LOW\n");
		}

		if (Events & BIT_1) {
			printf("SNR_LOW\n");
		}

		if (Events & BIT_2) {
			printf("MAX_FAIL\n");
		}

		if (Events & BIT_3) {
			printf("LINK LOSS\n");
		}
			
	}
		
	free(buf);

	return 0;
}
#endif

#ifdef CAL_DATA
/* To Change the calibration */
int process_cal_data_ext(int argc, char *argv[])
{
	int				i, count;
	u8				*buf, *CmdBuf;
	FILE				*fp;
	char				filename[48] = "";
	HostCmd_DS_802_11_CAL_DATA_EXT	cal_data; 
	struct ifreq			userdata;
	int				CmdNum = CAL_DATA_EXT_CONFIG;

	printf("Enter process_cal_data_ext()\n");
	memset(&cal_data, 0, sizeof(cal_data));

	buf = (u8 *) &cal_data.Action;
	
	if (argc != 4) {
		printf("Error: invalid no of arguments\n");
		printf("Syntax: ./wlanconfig eth1 caldataext <filename>\n");
		exit(1);
	}
	
	strncpy(filename, argv[3], MIN(sizeof(filename)-1, strlen(argv[3])));
	if ((fp = fopen(filename, "r")) == NULL) {
		fprintf(stderr, "Cannot open file %s\n", argv[1]);
		exit(1);
	}
	
	count = fparse_for_hex(fp, buf); //copyfile data to buf+1
	fclose(fp);

	CmdBuf = malloc(sizeof(HostCmd_DS_802_11_CAL_DATA_EXT) + sizeof(int));
	memcpy(CmdBuf, &CmdNum, sizeof(int));
	memcpy(CmdBuf + sizeof(int), &cal_data, 
					sizeof(HostCmd_DS_802_11_CAL_DATA_EXT));
	strncpy(userdata.ifr_name, DevName, IFNAMSIZ);
	userdata.ifr_data = CmdBuf;

#ifdef  DEBUG	
	printf("\n");
	printf("HEXDUMP of the configuration file:");
	for (i = 0; i < count; i++) {
		if (!(i % 16))
			printf("\n");
		printf("%02x ", buf[i]);
	}
	printf("\n\n");
#endif
	if (ioctl(sockfd, WLAN_SETCONF_GETCONF, &userdata)) { 
		fprintf(stderr, "wlanconfig: CAL DATA not supported by %s\n", 
								DevName);
			return -1;
   	}

	free(CmdBuf); //free CmdBuf
	printf("Exit process_cal_data_ext()\n"); 
	return 0;
}
#endif

char *readCurCmd(char *ptr, char *curCmd)
{
	int i = 0;
#define MAX_CMD_SIZE 64

	while(*ptr != ']' && i < (MAX_CMD_SIZE - 1))
		curCmd[i++] = *(++ptr);	

	if(*ptr != ']')
		return NULL;

	curCmd[i - 1] = '\0';

	return ++ptr;
}

int fparse_for_cmd_and_hex(FILE *fp, u8 *dst, u8 *cmd)
{
	char	*ptr;
	u8	*dptr;
	char	buf[256], curCmd[64];
	int	isCurCmd = 0;

	char *convert2hex(char *ptr, u8 *chr);

	dptr = dst;
	while (fgets(buf, sizeof(buf), fp)) {
		ptr = buf;

		while (*ptr) {
			// skip leading spaces
			while (*ptr && isspace(*ptr))
				ptr++;

			// skip blank lines and lines beginning with '#'
			if (*ptr == '\0' || *ptr == '#')
				break;

			if(*ptr == '[' && *(ptr + 1) != '/') {
				if(!(ptr = readCurCmd(ptr, curCmd)))
					return -1;

				if(strcasecmp(curCmd, cmd)) /* Not equal */
					isCurCmd = 0;
				else
					isCurCmd = 1;
			}

			/* Ignore the rest if it is not correct cmd */
			if(!isCurCmd)
				break;

			if(*ptr == '[' && *(ptr + 1) == '/' )
				return (dptr - dst);

			if (isxdigit(*ptr)) {
				ptr = convert2hex(ptr, dptr++);
			} else {
				/* Invalid character on data line */
				ptr++;
			}
		}
	}

	return -1;
}

int fparse_for_hex(FILE *fp, u8 *dst)
{
	char	*ptr;
	u8	*dptr;
	char	buf[256];

	char *convert2hex(char *ptr, u8 *chr);

	dptr = dst;
	while (fgets(buf, sizeof(buf), fp)) {
		ptr = buf;

		while (*ptr) {
			// skip leading spaces
			while (*ptr && isspace(*ptr))
				ptr++;

			// skip blank lines and lines beginning with '#'
			if (*ptr == '\0' || *ptr == '#')
				break;

			if (isxdigit(*ptr)) {
				ptr = convert2hex(ptr, dptr++);
			} else {
				/* Invalid character on data line */
				ptr++;
			}
		}
	}

	return (dptr - dst);
}

char *convert2hex(char *ptr, u8 *chr)
{
	u8	val;

	int hexval(int chr);

	for (val = 0; *ptr && isxdigit(*ptr); ptr++) {
		val = (val * 16) + hexval(*ptr);
	}

	*chr = val;

	return ptr;
}

int hexval(int chr)
{
	if (chr >= '0' && chr <= '9')
		return chr - '0';
	if (chr >= 'A' && chr <= 'F')
		return chr - 'A' + 10;
	if (chr >= 'a' && chr <= 'f')
		return chr - 'a' + 10;

	return 0;
}

int process_read_register(int cmd, char *stroffset)
{
	struct ifreq    userdata;
	wlan_ioctl_regrdwr reg;
	char           *whichreg;

	switch (cmd) {
		case CMD_RDMAC:
			/*
			 * HostCmd_CMD_MAC_REG_ACCESS 
			 */
			reg.WhichReg = REG_MAC;
			whichreg = "MAC";
			break;
		case CMD_RDBBP:
			/*
			 * HostCmd_CMD_BBP_REG_ACCESS 
			 */
			reg.WhichReg = REG_BBP;
			whichreg = "BBP";
			break;
		case CMD_RDRF:
			/*
			 * HostCmd_CMD_RF_REG_ACCESS 
			 */
			reg.WhichReg = REG_RF;
			whichreg = "RF";
			break;
		default:
			fprintf(stderr, 
				"Invalid Register set specified.\n");
			return -1;
	}

	reg.Action = 0;		/* READ */

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

	strncpy(userdata.ifr_name, DevName, IFNAMSIZ);
	userdata.ifr_data = (char *) &reg;

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

	printf("%s[0x%04lx] = 0x%08lx\n", 
			whichreg, reg.Offset, reg.Value);

	return 0;
}

int process_write_register(int cmd, char *stroffset, char *strvalue)
{
	struct ifreq    	userdata;
	wlan_ioctl_regrdwr 	reg;
	char           		*whichreg;

	switch (cmd) {
		case CMD_WRMAC:
			/*
			 * HostCmd_CMD_MAC_REG_ACCESS 
			 */
			reg.WhichReg = REG_MAC;
			whichreg = "MAC";
			break;
		case CMD_WRBBP:
			/*
			 * HostCmd_CMD_BBP_REG_ACCESS 
			 */
			reg.WhichReg = REG_BBP;
			whichreg = "BBP";
			break;
		case CMD_WRRF:
			/*
			 * HostCmd_CMD_RF_REG_ACCESS 
			 */
			reg.WhichReg = REG_RF;
			whichreg = "RF";
			break;
		default:
			fprintf(stderr, 
				"Invalid register set specified.\n");
			return -1;
	}

	reg.Action = 1;		/* WRITE */

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

	if (!strncasecmp(strvalue, "0x", 2))
		reg.Value = a2hex((strvalue + 2));
	else
		reg.Value = atoi(strvalue);

	printf("Writing %s Register 0x%04lx with 0x%08lx\n", whichreg,
			reg.Offset, reg.Value);

	strncpy(userdata.ifr_name, DevName, IFNAMSIZ);
	userdata.ifr_data = (char *) &reg;

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

	printf("%s[0x%04lx] = 0x%08lx\n",
			whichreg, reg.Offset, reg.Value);

	return 0;
}

int process_read_cfreg(char *stroffset)
{
	struct ifreq    	userdata;
	wlan_ioctl_cfregrdwr 	reg;
	
	reg.Action = 0; //Read register

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

	strncpy(userdata.ifr_name, DevName, IFNAMSIZ);
	userdata.ifr_data = (char *) &reg;

	if (ioctl(sockfd, WLANREGCFRDWR, &userdata)) {
		perror("wlanconfig");
		fprintf(stderr, 
			"wlanconfig: Register reading not supported "
			"by interface %s\n", DevName);
		return -1;
	}

	printf("CFREG[0x%04X] = 0x%04X\n",
				reg.Offset, reg.Value);

	return 0;

}
	
int process_write_cfreg(char *stroffset, char *strvalue)
{
	struct ifreq    	userdata;
	wlan_ioctl_cfregrdwr 	reg;

	reg.Action = 1; //Write register

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

	if (!strncasecmp(strvalue, "0x", 2))
		reg.Value = a2hex((strvalue + 2));
	else
		reg.Value = atoi(strvalue);

	strncpy(userdata.ifr_name, DevName, IFNAMSIZ);
	userdata.ifr_data = (char *) &reg;

	if (ioctl(sockfd, WLANREGCFRDWR, &userdata)) {
		perror("wlanconfig");
		fprintf(stderr, 
			"wlanconfig: Register writing not supported "
			"by interface %s\n", DevName);
		return -1;
	}

	return 0;
}

int ascii2hex(unsigned char *d, char *s, uint dlen)
{
	int i;
	unsigned char n;

	memset(d, 0x00, dlen);

	for (i = 0; i < dlen * 2; i++) {
		if ((s[i] >= 48) && (s[i] <= 57))
			n = s[i] - 48;
		else if ((s[i] >= 65) && (s[i] <= 70))
			n = s[i] - 65;
		else if ((s[i] >= 97) && (s[i] <= 102))
			n = s[i] - 97;
		else
			break;
		if ((i % 2) == 0)
			n = n * 16;
		d[i / 2] += n;
	}

	return i;
}

unsigned int a2hex(char *s)
{
	unsigned int    val = 0;
	unsigned char   hexc2bin(char chr);

	while (*s && isxdigit(*s)) {
		val = (val << 4) + hexc2bin(*s++);
	}

	return val;
}

unsigned char hexc2bin(char chr)
{
	if (chr >= '0' && chr <= '9')
		chr -= '0';
	else if (chr >= 'A' && chr <= 'F')
		chr -= ('A' - 10);
	else if (chr >= 'a' && chr <= 'f')
		chr -= ('a' - 10);

	return chr;
}

void hexdump(char *prompt, void *p, int len, char delim)
{
	int             i;
	unsigned char  *s = p;
	
	printf("%s : ", prompt);
	for (i = 0; i < len; i++) {
		if (i != len - 1)
			printf("%02x%c", *s++, delim);
		else
			printf("%02x\n", *s);
	}
}