parseloadear.c

Atheros AP Test with Agilent N4010A source code

#ifdef __ATH_DJGPPDOS__
#include <unistd.h>
#ifndef EILSEQ  
    #define EILSEQ EIO
#endif	// EILSEQ

 #define __int64	long long
 #define HANDLE long
 typedef unsigned long DWORD;
 #define Sleep	delay
 #include <bios.h>
 #include <dir.h>
#endif	// #ifdef __ATH_DJGPPDOS__

#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#ifdef LINUX
#include "linuxdrv.h"
#else
#include "ntdrv.h"
#endif
#include "common_hw.h"


#include "wlantype.h"
#include "athreg.h"
#include "ear_defs.h"
#include "ear_externs.h"

static char delimiters[]   = " \t\n:\r\f";
#define RESERVED_MODE_BIT_MASK	0x120

int parseEarCfgFile(char *earcfg_filename, EAR_CFG **ear_cfg) {

	FILE *fileStream;
	char lineBuffer[MAX_FILE_WIDTH];
	char *token;
	int select;
	A_UINT16 iIndex;
	REGISTER_CFG *temp_reg_cfg=NULL;
	REGISTER_WRITE_TYPE0 *temp_reg_write_type0=NULL;
	REGISTER_WRITE_TYPE1 *temp_reg_write_type1=NULL;
	REGISTER_WRITE_TYPE2 *temp_reg_write_type2=NULL;
	REGISTER_WRITE_TYPE3 *temp_reg_write_type3=NULL;
	A_UINT16 temp_value, temp_end_bit, temp_num_bits, temp_type1_value;
	A_UINT16 version_mask;
	A_UINT16 version_mask_given=0;

	fileStream = (FILE *) fopen(earcfg_filename, "r");
	if (fileStream == NULL) {
		printf("Unable to open ear cfg file %s\n", earcfg_filename);
		return -1;
	}

	while( fgets(lineBuffer, MAX_FILE_WIDTH, fileStream) != NULL ) {
		//printf("lineBuffer = %s\n", lineBuffer);
		token = (char *) strtok(lineBuffer, delimiters);
		if (token == NULL) continue;
		if (token[0] == '#') {
			continue;
		}
		select = (int) atoi(token);
		//printf("select = %d\n", select);
		switch(select) {
			case REGISTER_HEADER_TYPE: // register header
				ASSERT(version_mask_given != 0);
				if ((*ear_cfg)->reg_cfg == NULL) {
					(*ear_cfg)->reg_cfg = (REGISTER_CFG *) malloc(sizeof(REGISTER_CFG));
					temp_reg_cfg = (*ear_cfg)->reg_cfg;
				}
				else {
					temp_reg_cfg->next = (REGISTER_CFG *) malloc(sizeof(REGISTER_CFG));
					temp_reg_cfg = temp_reg_cfg->next;
					temp_reg_cfg->write_type.reg_write_type1 = NULL;
				}

				ASSERT(temp_reg_cfg != NULL);
				temp_reg_cfg->next = NULL;
				temp_reg_cfg->write_type.reg_write_type0 = NULL;
				
				temp_reg_cfg->version_mask = version_mask; // copy the version mask, if u have new set
				token = (char *) strtok(NULL, delimiters);
				ASSERT(token != NULL);
				temp_reg_cfg->reg_hdr.field0.pack0.type = atoi(token);	

				token = (char *) strtok(NULL, delimiters);
				ASSERT(token != NULL);
				sscanf(token, "%x", &temp_value);
//    				if ( temp_value & RESERVED_MODE_BIT_MASK) {
//	    				printf("WARNING:*** Reserved mode bits set, thus clearing the reserved bits  *** \n");
//					temp_value = temp_value & ~RESERVED_MODE_BIT_MASK;
//    				}
				temp_reg_cfg->reg_hdr.field0.pack0.reg_modality_mask = temp_value;
		    

				token = (char *) strtok(NULL, delimiters);
				ASSERT(token != NULL);
				temp_reg_cfg->reg_hdr.field0.pack0.stage = atoi(token);	

				token = (char *) strtok(NULL, delimiters);
				ASSERT(token != NULL);
				sscanf(token, "%x", &temp_value);
				temp_reg_cfg->reg_hdr.field1.channel_modifier = temp_value;
				temp_reg_cfg->reg_hdr.field0.pack0.channel_modifier_present = (temp_reg_cfg->reg_hdr.field1.channel_modifier?1:0);

				token = (char *) strtok(NULL, delimiters);
				ASSERT(token != NULL);
				sscanf(token, "%x", &temp_value);
				temp_reg_cfg->reg_hdr.field2.disabler_mask = temp_value;
				temp_reg_cfg->reg_hdr.field0.pack0.disabler_present =  (temp_reg_cfg->reg_hdr.field2.disabler_mask?1:0);

				token = (char *) strtok(NULL, delimiters);
				ASSERT(token != NULL);
				sscanf(token, "%x", &temp_value);
				temp_reg_cfg->reg_hdr.pll_value = temp_value;

				temp_reg_cfg->reg_hdr.field0.pack0.bit15 = 0;

				break;
			case REGISTER_WRITES_TYPE: // register data
				switch(temp_reg_cfg->reg_hdr.field0.pack0.type) {
					case WRITE_TYPE0:
						if (temp_reg_cfg->write_type.reg_write_type0 == NULL) {
							temp_reg_cfg->write_type.reg_write_type0 = (REGISTER_WRITE_TYPE0 *) malloc(sizeof(REGISTER_WRITE_TYPE0));
							temp_reg_write_type0 = temp_reg_cfg->write_type.reg_write_type0;
						}
						else {
							temp_reg_write_type0->next = (REGISTER_WRITE_TYPE0 *) malloc(sizeof(REGISTER_WRITE_TYPE0));
							temp_reg_write_type0 = temp_reg_write_type0->next;
						}
						ASSERT(temp_reg_write_type0 != NULL);
						temp_reg_write_type0->next = NULL;

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_reg_write_type0->field0.pack.tag = atoi(token);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						sscanf(token, "%x", &temp_value);
						temp_reg_write_type0->field0.pack.address = temp_value>>2;
						//printf("TYPE0:Address parsed = %x\n", temp_reg_write_type0->field0.pack.address<<2);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						sscanf(token, "%x", &temp_reg_write_type0->msw);

						if (temp_reg_write_type0->field0.pack.tag == 0 || temp_reg_write_type0->field0.pack.tag == 3) {
						    token = (char *) strtok(NULL, delimiters);
						    ASSERT(token != NULL);
						    sscanf(token, "%x", &temp_reg_write_type0->lsw);
						}
						break;
					case WRITE_TYPE1:
						if (temp_reg_cfg->write_type.reg_write_type1 == NULL) {
							temp_reg_cfg->write_type.reg_write_type1 = (REGISTER_WRITE_TYPE1 *) malloc(sizeof(REGISTER_WRITE_TYPE1));
							temp_reg_write_type1 = temp_reg_cfg->write_type.reg_write_type1;
						}
						else {
							temp_reg_write_type1->next = (REGISTER_WRITE_TYPE1 *) malloc(sizeof(REGISTER_WRITE_TYPE1));
							temp_reg_write_type1 = temp_reg_write_type1->next;
						}

						ASSERT(temp_reg_write_type1 != NULL);
						temp_reg_write_type1->next = NULL;
						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_value = atoi(token);
						ASSERT(temp_value != 0);
						temp_reg_write_type1->field0.pack.num = temp_value - 1;

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						sscanf(token, "%x", &temp_value);
						temp_reg_write_type1->field0.pack.address = temp_value>>2;

						for(iIndex=0; iIndex<=temp_reg_write_type1->field0.pack.num; iIndex++) {

						   token = (char *) strtok(NULL, delimiters);
						   ASSERT(token != NULL);
						   sscanf(token, "%x", &temp_type1_value);
						   temp_reg_write_type1->data_msw[iIndex] = temp_type1_value;

						   token = (char *) strtok(NULL, delimiters);
						   ASSERT(token != NULL);
						   sscanf(token, "%x", &temp_type1_value);
						   temp_reg_write_type1->data_lsw[iIndex] = temp_type1_value;

						}
						break;
					case WRITE_TYPE2:
						if (temp_reg_cfg->write_type.reg_write_type2 == NULL) {
							temp_reg_cfg->write_type.reg_write_type2 = (REGISTER_WRITE_TYPE2 *) malloc(sizeof(REGISTER_WRITE_TYPE2));
							temp_reg_write_type2 = temp_reg_cfg->write_type.reg_write_type2;
						}
						else {
							temp_reg_write_type2->next = (REGISTER_WRITE_TYPE2 *) malloc(sizeof(REGISTER_WRITE_TYPE2));
							temp_reg_write_type2 = temp_reg_write_type2->next;
						}
						ASSERT(temp_reg_write_type2 != NULL);
						temp_reg_write_type2->next = NULL;

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_reg_write_type2->field0.pack0.last = atoi(token);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_reg_write_type2->field0.pack0.analog_bank = atoi(token);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_reg_write_type2->field0.pack0.column = atoi(token);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_end_bit = atoi(token);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_reg_write_type2->field0.pack0.start_bit = atoi(token);

						temp_num_bits = temp_end_bit - temp_reg_write_type2->field0.pack0.start_bit + 1;

						if (temp_num_bits > 12) {
							temp_reg_write_type2->num_bits = temp_num_bits;
							temp_reg_write_type2->field0.pack0.extended = 1;
							temp_reg_write_type2->num_data = A_DIV_UP(temp_num_bits, 16);
							temp_reg_write_type2->data = (A_UINT16 *) malloc(temp_num_bits * sizeof(A_UINT16));
							iIndex=0;
							while(iIndex<temp_reg_write_type2->num_data) {
								token = (char *) strtok(NULL, delimiters);
								ASSERT(token != NULL);
								sscanf(token, "%x", &temp_value);
								temp_reg_write_type2->data[iIndex++] = temp_value;
							}
						}
						else {
							temp_reg_write_type2->field1.pack1.num_bits = temp_num_bits;
							temp_reg_write_type2->field0.pack0.extended = 0;

							token = (char *) strtok(NULL, delimiters);
							ASSERT(token != NULL);
							sscanf(token, "%x", &temp_value);
							temp_reg_write_type2->field1.pack1.data = temp_value;
						}

						break;
					case WRITE_TYPE3:
						if (temp_reg_cfg->write_type.reg_write_type3 == NULL) {
							temp_reg_cfg->write_type.reg_write_type3 = (REGISTER_WRITE_TYPE3 *) malloc(sizeof(REGISTER_WRITE_TYPE3));
							temp_reg_write_type3 = temp_reg_cfg->write_type.reg_write_type3;
						}
						else {
							temp_reg_write_type3->next = (REGISTER_WRITE_TYPE3 *) malloc(sizeof(REGISTER_WRITE_TYPE3));
							temp_reg_write_type3 = temp_reg_write_type3->next;
						}
						ASSERT(temp_reg_write_type3 != NULL);
						temp_reg_write_type3->next = NULL;

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_reg_write_type3->field0.pack.last = atoi(token);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_reg_write_type3->field0.pack.opcode = atoi(token);
						//printf("Opcode read = %x\n", temp_reg_write_type3->field0.pack.opcode);
						//printf("header value = %x\n", temp_reg_write_type3->field0.value);
						temp_reg_write_type3->field0.pack.bit13 = 0;
						temp_reg_write_type3->field0.pack.bit14 = 0;

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_end_bit = atoi(token);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);
						temp_reg_write_type3->field0.pack.start_bit = atoi(token);
						temp_reg_write_type3->field0.pack.num_bits = temp_end_bit - temp_reg_write_type3->field0.pack.start_bit + 1;
//FJC						printf("header value = %x\n", temp_reg_write_type3->field0.value);

						token = (char *) strtok(NULL, delimiters);
						ASSERT(token != NULL);