parseloadear.c

Atheros AP Test with Agilent N4010A source code

						sscanf(token, "%x", &temp_reg_write_type3->address);

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

						if (temp_reg_write_type3->field0.pack.num_bits > 16) {
						    token = (char *) strtok(NULL, delimiters);
						    ASSERT(token != NULL);
						    sscanf(token, "%x", &temp_reg_write_type3->data_lsw);
						}

						break;

				}
				break;
			case VERSION_MASK_TYPE: // version mask
				token = (char *) strtok(NULL, delimiters);
				sscanf(token, "%x", &version_mask);
				version_mask |= (1<<15);
				version_mask_given = 1;
				break;
			case VERSION_ID_TYPE: // Versiod id
				token = (char *) strtok(NULL, delimiters);
				//sscanf(token, "%x", &(*ear_cfg)->version_id);
				sscanf(token, "%x", *ear_cfg);
				break;
		}
	}

	fclose(fileStream);
	return 0;

}

void printModeString(A_UINT16 modes) {

    A_CHAR *pModesArray[9] = {"11B ", "11G ", "T2 ", "11GXR ", "11A ", "NA ", "T5 ", "11AXR ", "NA "};
    int i;
    int newModes;

    if (modes == ALL_MODES) {
        newModes = 0xDF;
    } else {
        newModes = modes;
    }

    for(i = 0; i < 9; i++) {
        if (newModes & (1 << i)) {
            printf("%s", pModesArray[i]);
        }
    }
    printf("\n");
}

/* returns number of ear locations created 
 * returns -1 upon failure */

A_INT32 createEAR( EAR_CFG *ear_cfg, A_UINT32 ear[]) {
	A_UINT32 iIndex, numIndex=0;
	A_UINT16 prev_version_mask;
	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;

	ASSERT(ear_cfg != NULL);
	ASSERT(ear_cfg->reg_cfg != NULL);

	
	ear[numIndex++] =  ear_cfg->version_id;
	temp_reg_cfg = ear_cfg->reg_cfg;
	ear[numIndex++] = temp_reg_cfg->version_mask;
	prev_version_mask=temp_reg_cfg->version_mask;

	while(temp_reg_cfg) {
		//Copy version mask
		if (prev_version_mask != temp_reg_cfg->version_mask) {
			ear[numIndex++] = temp_reg_cfg->version_mask;
			prev_version_mask=temp_reg_cfg->version_mask;
		}
		// Copy register header
		// copy individual bit to respective positions so as to solve endian problem due to union
		ear[numIndex++] = (temp_reg_cfg->reg_hdr.field0.pack0.bit15 << 15)  \
			| (temp_reg_cfg->reg_hdr.field0.pack0.disabler_present << 14) 	\
			| (temp_reg_cfg->reg_hdr.field0.pack0.channel_modifier_present << 13) 	\
			| (temp_reg_cfg->reg_hdr.field0.pack0.stage << 11) 	\
			| (temp_reg_cfg->reg_hdr.field0.pack0.type << 9) 	\
			| (temp_reg_cfg->reg_hdr.field0.pack0.reg_modality_mask); 

//		printf("reg_hdr:%x:ear=%x:\n", temp_reg_cfg->reg_hdr.field0.value, ear[numIndex-1]);
		if (temp_reg_cfg->reg_hdr.field0.pack0.channel_modifier_present) {
			ear[numIndex++] = (temp_reg_cfg->reg_hdr.field1.pack1.bit15 << 15) \
				| temp_reg_cfg->reg_hdr.field1.pack1.bit0_14;
		}
		if (temp_reg_cfg->reg_hdr.field0.pack0.disabler_present) {
			ear[numIndex++] = temp_reg_cfg->reg_hdr.field2.disabler_mask;
			if (temp_reg_cfg->reg_hdr.field2.pack2.pll) {
				ear[numIndex++] = temp_reg_cfg->reg_hdr.pll_value;
			}
		}
		// Copy register writes
		switch(temp_reg_cfg->reg_hdr.field0.pack0.type) {
			case WRITE_TYPE0:
				temp_reg_write_type0 = temp_reg_cfg->write_type.reg_write_type0;
				while(temp_reg_write_type0) {
					ear[numIndex++] = ((temp_reg_write_type0->field0.pack.address << 2) | (temp_reg_write_type0->field0.pack.tag));
					ear[numIndex++] = temp_reg_write_type0->msw;
					if (temp_reg_write_type0->field0.pack.tag == 0 || temp_reg_write_type0->field0.pack.tag == 3) {
						ear[numIndex++] = temp_reg_write_type0->lsw;
					}
					temp_reg_write_type0 = temp_reg_write_type0->next;
				}
				break;
			case WRITE_TYPE1:
				temp_reg_write_type1 = temp_reg_cfg->write_type.reg_write_type1;
				while(temp_reg_write_type1) {
					ear[numIndex++] = ((temp_reg_write_type1->field0.pack.address << 2) | (temp_reg_write_type1->field0.pack.num));
					for(iIndex=0;iIndex<=temp_reg_write_type1->field0.pack.num; iIndex++) {
						ear[numIndex++] = temp_reg_write_type1->data_msw[iIndex];
						ear[numIndex++] = temp_reg_write_type1->data_lsw[iIndex];
					}
					temp_reg_write_type1 = temp_reg_write_type1->next;
				}
				break;
			case WRITE_TYPE2:
				temp_reg_write_type2 = temp_reg_cfg->write_type.reg_write_type2;
				while(temp_reg_write_type2) {
					ear[numIndex++] = ((temp_reg_write_type2->field0.pack0.analog_bank << 13) \
								| (temp_reg_write_type2->field0.pack0.last << 12) \
								| (temp_reg_write_type2->field0.pack0.column << 10) \
								| (temp_reg_write_type2->field0.pack0.extended << 9) \
								| (temp_reg_write_type2->field0.pack0.start_bit));
					if (temp_reg_write_type2->field0.pack0.extended) {
						ear[numIndex++] = temp_reg_write_type2->num_bits;
						for(iIndex=0; iIndex<temp_reg_write_type2->num_data; iIndex++) {
							ear[numIndex++] = temp_reg_write_type2->data[iIndex];
						}
					}
					else {
						ear[numIndex++] = ((temp_reg_write_type2->field1.pack1.num_bits << 12) | (temp_reg_write_type2->field1.pack1.data));
					}
					temp_reg_write_type2 = temp_reg_write_type2->next;
				}
				break;
			case WRITE_TYPE3:
				temp_reg_write_type3 = temp_reg_cfg->write_type.reg_write_type3;
				while(temp_reg_write_type3) {
					ear[numIndex++] = ((temp_reg_write_type3->field0.pack.last << 15) \
								| (temp_reg_write_type3->field0.pack.bit14 << 14) \
								| (temp_reg_write_type3->field0.pack.bit13 << 13) \
								| (temp_reg_write_type3->field0.pack.opcode << 10) \
								| (temp_reg_write_type3->field0.pack.start_bit << 5) \
								| (temp_reg_write_type3->field0.pack.num_bits));
					ear[numIndex++] = temp_reg_write_type3->address;
					ear[numIndex++] = temp_reg_write_type3->data_msw;
					if (temp_reg_write_type3->field0.pack.num_bits>16) {
						ear[numIndex++] = temp_reg_write_type3->data_lsw;
					}
					temp_reg_write_type3 = temp_reg_write_type3->next;
				}
				break;
		}
		temp_reg_cfg = temp_reg_cfg -> next;
	}

	ear[numIndex++] = 0;
	return numIndex;

}

void freeup_earcfg(EAR_CFG *ear_cfg) {
    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;
    REGISTER_CFG *temp = NULL;

    temp_reg_cfg = ear_cfg->reg_cfg;

    while(temp_reg_cfg) {
	switch(temp_reg_cfg->reg_hdr.field0.pack0.type) {
		case 0:
			temp_reg_write_type0 = temp_reg_cfg->write_type.reg_write_type0;
			while(temp_reg_write_type0) {
				REGISTER_WRITE_TYPE0 *tempp;
				tempp = (REGISTER_WRITE_TYPE0 *) temp_reg_write_type0;
				temp_reg_write_type0 = temp_reg_write_type0 -> next;
                if (tempp != NULL) {
				    A_FREE(tempp);
					tempp = NULL;
				}

			}
			break;
		case 1:
			temp_reg_write_type1 = temp_reg_cfg->write_type.reg_write_type1;
			while(temp_reg_write_type1) {
				REGISTER_WRITE_TYPE1 *tempp;
				tempp = (REGISTER_WRITE_TYPE1 *) temp_reg_write_type1;
				temp_reg_write_type1 = temp_reg_write_type1 -> next;
                if (tempp != NULL) {
    				A_FREE(tempp);
					tempp = NULL;
				}
			}
			break;
		case 2:
			temp_reg_write_type2 = temp_reg_cfg->write_type.reg_write_type2;
			while(temp_reg_write_type2) {
				REGISTER_WRITE_TYPE2 *tempp;
				tempp = (REGISTER_WRITE_TYPE2 *) temp_reg_write_type2;
				temp_reg_write_type2 = temp_reg_write_type2 -> next;
                if (tempp != NULL) {
				    A_FREE(tempp);
					tempp = NULL;
				}
			}
			break;
		case 3:
			temp_reg_write_type3 = temp_reg_cfg->write_type.reg_write_type3;
			while(temp_reg_write_type3) {
				REGISTER_WRITE_TYPE3 *tempp;
				tempp = (REGISTER_WRITE_TYPE3 *) temp_reg_write_type3;
				temp_reg_write_type3 = temp_reg_write_type3 -> next;
                if (tempp != NULL) {
				    A_FREE(tempp);
					tempp = NULL;
				}
			}
			break;
	}
	temp = (REGISTER_CFG *) temp_reg_cfg;
        temp_reg_cfg = temp_reg_cfg->next;
		if (temp != NULL) {
	A_FREE(temp);
			temp = NULL;
		}
    }

    if (ear_cfg != NULL) {
    A_FREE(ear_cfg);
		ear_cfg = NULL;
	}

}

void displayEar(A_UINT32 ear[MAX_EAR_LOCATIONS], A_UINT32 numLocations) {
	A_UINT32 iIndex=0, jIndex;
	EAR_CFG  *ear_cfg = NULL;
	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 prev_version_mask;

    /* for(jIndex=0; jIndex<numLocations; jIndex++) {
            printf(":%x:", ear[jIndex]);
            if (jIndex % 32 == 0) {printf("\n");}
    }
    */

	ear_cfg = (EAR_CFG *) malloc(sizeof(EAR_CFG));
	ASSERT(ear_cfg != NULL);
	ear_cfg->reg_cfg = NULL;
	ear_cfg->version_id = (A_UINT16) ear[iIndex++];

	uiPrintf(" Version Id = %x\n",ear_cfg->version_id);
	

	if((ear_cfg->version_id == 0x0000 ) || (ear_cfg->version_id == 0xffff))
	{
		uiPrintf("\n There is no Ear Programmed into EEPROM\n");
		return;
	}

	prev_version_mask = (A_UINT16) ear[iIndex]; //First byte after version id should be version mask

	uiPrintf(" prev_version_mask = %x\n",prev_version_mask);

	for(; iIndex<numLocations; ) {
		//printf("iIndex=%d:ear[iIndex]=%x:\n", iIndex, ear[iIndex]);
		if (ear_cfg->reg_cfg == NULL) {