athreg.c

Atheros AP Test with Agilent N4010A source code

				writableRegister=1;
				break;
			}
		}

		includeRegister = 1;
#ifdef PHOENIX
		if (  !start_strcmp("phs", pLibDev->regArray[iIndex].regName) ||
					!start_strcmp("analog", pLibDev->regArray[iIndex].regName)) {

			includeRegister = 1;
		}
		else 
			includeRegister = 0;
#endif

		if (writableRegister && includeRegister) {
			pLibDev->pciValuesArray[currentRegister].offset = addressToWrite;
			pLibDev->pciValuesArray[currentRegister].baseValue = baseValueToWrite;
			pLibDev->pciValuesArray[currentRegister].turboValue = turboValueToWrite;
			currentRegister++;     
		}
//		printf("currentRegister=%d\n", currentRegister);
    }
//printf("3\n");
    //now do the radio registers.
    pLibDev->pRfPciValues = &pLibDev->pciValuesArray[currentRegister];
    pLibDev->rfRegArrayIndex = currentField;
	if(!ParseRfRegs(devNum, &pLibDev->regArray[currentField], 
		currentField, pLibDev->sizeRegArray, &pLibDev->pciValuesArray[currentRegister], pLibDev->rfBankInfo)) {
		mError(devNum, EIO, "Device Number %d:Unable to parseRfFields\n", devNum);
        free(pLibDev->pciValuesArray);
        pLibDev->pciValuesArray = NULL;
//		free(pLibDev->resetFieldValuesArray);
		return 0;
	}
//    numRfPciWrites = createRfPciValues(&pLibDev->regArray[currentField], 
//                currentField, pLibDev->sizeRegArray, &pLibDev->pciValuesArray[currentRegister]);
//printf("4\n");
	numRfPciWrites = new_createRfPciValues(devNum, ALL_BANKS, 0);
//	printf("5\n");
#ifndef PHOENIX
    if(numRfPciWrites == 0) {
        mError(devNum, EIO, "Device Number %d:Error creating pci values for rf registers\n", devNum);
        free(pLibDev->pciValuesArray);
        pLibDev->pciValuesArray = NULL;
//		free(pLibDev->resetFieldValuesArray);
        return 0;
    }
#endif
//printf("6\n");
    pLibDev->sizePciValuesArray = (A_UINT16)(numRfPciWrites + currentRegister);
#ifdef _DBEUG
printf("numRfPciWrites=%d:currentRegister=%d:sizePciValues=%d\n", numRfPciWrites, currentRegister, pLibDev->sizePciValuesArray);
#endif
    return 1;
}

A_UINT16
ParseRfRegs
(
 A_UINT32 devNum,
 ATHEROS_REG_FILE *pRfFields,
 A_UINT32         indexRfField,
 A_UINT32         sizeRegArray,
 PCI_REG_VALUES *pRfWriteValues,
 RF_REG_INFO	*pRfRegBanks
)
{
    A_UINT32 currentRegBank;
	A_UINT16 sizeRfReg;

	//loop round all remaining register fields
    while (indexRfField < sizeRegArray) {
        if((pRfFields->regOffset + 1) > NUM_RF_BANKS) {
			mError(devNum, EIO, "Num rf register banks exceeds number hard coded in software\n");
			return 0;
		}
        
        currentRegBank = pRfFields->regOffset;
		pRfRegBanks[currentRegBank].bankNum = currentRegBank;
		pRfRegBanks[currentRegBank].pRegFields = pRfFields;
		pRfRegBanks[currentRegBank].pPciValues = pRfWriteValues;
        pRfRegBanks[currentRegBank].numRegFields = 0;
		sizeRfReg = 0;
		//loop round all the fields of this register bank
		while ((indexRfField < sizeRegArray) &&
			(pRfFields->regOffset == currentRegBank)) {
			//see if the end of the register is larger than current calculation of reg size
			if((A_UINT32)(pRfFields->fieldStartBitPos - 1 + pRfFields->fieldSize) > sizeRfReg) {
				sizeRfReg = (A_UINT16)(pRfFields->fieldSize + sizeRfReg);
			}
			pRfRegBanks[currentRegBank].numRegFields++;
			pRfFields++;
			indexRfField++;
		}
		//calculate number pci registers
		pRfRegBanks[currentRegBank].numPciRegs = (A_UINT16)(sizeRfReg/8); 
		if(sizeRfReg > pRfRegBanks[currentRegBank].numPciRegs * 8) {
			pRfRegBanks[currentRegBank].numPciRegs++;
		}
		pRfWriteValues += pRfRegBanks[currentRegBank].numPciRegs;
	}

	return 1;
} 

A_UINT16
createRfBankPciValues
(
 A_UINT32 devNum,
 RF_REG_INFO	*pRfRegBank
)
{
	ATHEROS_REG_FILE *pRfFields;
    PCI_REG_VALUES *pRfWriteValues;
	A_UCHAR         currentRfReg;
    A_UINT16        numRegBits;
    A_UCHAR         baseByteValue;
    A_UINT32        tempBaseValue = 0;
    A_UCHAR         turboByteValue;
    A_UINT32        tempTurboValue = 0;
    A_UCHAR         load;
    A_UCHAR         i, j;
	A_UINT32		x = 0;
    A_UINT32        pciAddress;
    A_BOOL          fieldLeftOver = 0;
    A_UCHAR         tempValueSize = 0;
    A_UCHAR         mask;

	pRfFields = pRfRegBank->pRegFields;
	if(pRfFields == NULL) {
		return 1;
	}
	pRfWriteValues = pRfRegBank->pPciValues;
	while( x < pRfRegBank->numRegFields ) {
		//loop round all the fields for this register
        currentRfReg = pRfFields->rfRegNumber;
        numRegBits = 0;
        while ((x < pRfRegBank->numRegFields ) &&
				(pRfFields->rfRegNumber == currentRfReg )) {
            baseByteValue = 0;
            turboByteValue = 0;
            load = 0;
            //create 8 bit values to be written on Pci bus
            for(i = 0; i < 8; ) {
                //check for any fields left over from last time
                if (fieldLeftOver) {
                    //write the rest of the bit field 
                    if (tempValueSize > 8) {
                        baseByteValue = (A_UCHAR)(tempBaseValue & 0xff);
                        turboByteValue = (A_UCHAR)(tempTurboValue & 0xff);
                        tempBaseValue = tempBaseValue >> 8;
                        tempTurboValue = tempTurboValue >> 8;
                        i += 8;
                    }
                    else { 
                        baseByteValue |= tempBaseValue;
                        turboByteValue |= tempTurboValue;
                        i = (A_UCHAR)(i + tempValueSize);

                        fieldLeftOver = 0;
                        pRfFields++; 
						x++;
//                        indexRfField++;
                    }
                }
                else if((pRfFields->fieldStartBitPos - 1) > (i+numRegBits)) {
                    //Dont have anything to write, write 0
                    i++;
                }
                else {
                    if (i + pRfFields->fieldSize > 8) {
                        //note code is not setup to handle a field size > 32
                        if (pRfFields->fieldSize > 32) {
                            mError(devNum, EINVAL, "Rf field size is greater than 32, not currently supported by software\n");
                            return(0);
                        }
                        
                        //create a mask for the number of bits that will fit
                        mask = 0;
                        for (j = 0; j < (8 - i); j++) {
                            mask |= (0x1 << j);
                        }
                        tempBaseValue = reverseRfBits(pRfFields->fieldBaseValue, pRfFields->fieldSize, pRfFields->dontReverse);
                        tempTurboValue = reverseRfBits(pRfFields->fieldTurboValue, pRfFields->fieldSize, pRfFields->dontReverse);
                        baseByteValue |= (tempBaseValue & mask) << i;
                        turboByteValue |= (tempTurboValue & mask) << i;
                        fieldLeftOver = 1;
                        tempBaseValue = tempBaseValue >> (8 - i);
                        tempTurboValue = tempTurboValue >> (8 - i);
                        tempValueSize = (A_UCHAR)(pRfFields->fieldSize - (8 - i));
                        i = (A_UCHAR)(i + (8 - i));
                    }
                    else {

                        baseByteValue |= (reverseRfBits(pRfFields->fieldBaseValue, pRfFields->fieldSize, pRfFields->dontReverse) << i);
                        turboByteValue |= (reverseRfBits(pRfFields->fieldTurboValue, pRfFields->fieldSize, pRfFields->dontReverse) << i);

                        //check for the field going over 8 bits
                        i = (A_UCHAR)(i + pRfFields->fieldSize);
                        pRfFields++;
						x++;
//                        indexRfField++;
                    }
                }

                if( (x >= pRfRegBank->numRegFields)||(pRfFields->rfRegNumber != currentRfReg) ||
                    (pRfFields->regOffset != pRfRegBank->bankNum)) {
                    load = 0x10;
                    break;
                }
            }

            numRegBits = (A_UINT16)(numRegBits + i);
            //should now have an 8 bit value to write
            //calculate the pci address to write to 
            pciAddress = (((i - 1) + load + 0x20 + 0x600)  << 2) + 0x8000;

            if(currentRfReg == 0) {
                //first register of bank so write address to pci array
                pRfWriteValues->offset = pciAddress;
                pRfWriteValues->baseValue = 0;
                pRfWriteValues->turboValue = 0;
                //pRfRegBank->numPciRegs++;
            }
            else {
                //we should be at the correct address, do a check
                if (pciAddress != pRfWriteValues->offset) {
                    mError(devNum, EIO, "createRfBankPciValues: unexpected internal software problem, bank %d, field %s\n", pRfRegBank->bankNum, pRfFields->fieldName);
                    return(0);
                }
            }

            //write the byte value into array
            pRfWriteValues->baseValue |= (baseByteValue << (currentRfReg * 8));
            pRfWriteValues->turboValue |= (turboByteValue << (currentRfReg * 8));
            pRfWriteValues++;
        } //end while same register

        //moved onto a new rf register,  move
        //pRfWriteValues back to the start of the writes for this bank
		pRfWriteValues = pRfRegBank->pPciValues;
	}
	return 1;
}

A_UINT16
new_createRfPciValues
(
 A_UINT32 devNum,
 A_UINT32	  bank,
 A_BOOL		  writePCI
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 numPciWrites = 0;
	A_UINT32 bankIndex = 0;
	A_BOOL earHere = FALSE;
	A_UINT32 modifier;
	
	//mask off any bits set in error
	bank = bank & 0xff;
	while (bank) {
		if(bank & 0x01) {
			if(!createRfBankPciValues(devNum, &pLibDev->rfBankInfo[bankIndex])) {
				mError(devNum, EIO, "Device Number %d:new_createRfPciValues: unable to create writes for bank %d\n", devNum, bank);
				return 0;
			}
			if (pLibDev->eePromLoad && pLibDev->eepData.eepromChecked && writePCI) {
				if(!isDragon(devNum)) {
    				if(pLibDev->p16kEepHeader->majorVersion >= 4) {
	    				earHere = ar5212IsEarEngaged(devNum, pLibDev->pEarHead, pLibDev->freqForResetDevice);
		    		}
			    	if (earHere) {
				    	ar5212EarModify(devNum, pLibDev->pEarHead, EAR_LC_RF_WRITE, pLibDev->freqForResetDevice, &modifier);
				    }
				}

			}
			numPciWrites += pLibDev->rfBankInfo[bankIndex].numPciRegs;
			if(writePCI) {
				writeRfBank(devNum, &pLibDev->rfBankInfo[bankIndex]);			
			}
		}
		bankIndex++;
		bank = bank >> 1;
	}
	
	return (A_UINT16)numPciWrites;
}

void
writeRfBank
(
 A_UINT32		devNum,
 RF_REG_INFO	*pRfRegBank
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
    PCI_REG_VALUES *pRfWriteValues = pRfRegBank->pPciValues;
	A_UINT32		i;
	A_UINT32		regValue;
	A_UINT32		cfgVersion;

    cfgVersion = ar5kInitData[pLibDev->ar5kInitIndex].cfgVersion;
	for(i = 0; i < pRfRegBank->numPciRegs; i++) {
		if((pLibDev->turbo == TURBO_ENABLE) && (cfgVersion == 0)) {
			regValue = pRfWriteValues->turboValue;
		}
		else {
			regValue = pRfWriteValues->baseValue;
		}
		if (pLibDev->devMap.remoteLib) {
			pciValues[i].offset = pRfWriteValues->offset;
			pciValues[i].baseValue = regValue;
		}
		else {
	 	REGW(devNum, pRfWriteValues->offset, regValue);
		}
		pRfWriteValues++;
	}
		if (pLibDev->devMap.remoteLib) {
			sendPciWrites(devNum, pciValues, pRfRegBank->numPciRegs);
		}

	return;
}


/* get the value held by the software array (ie does not read hardware) */
MANLIB_API void getField
(
 A_UINT32 devNum,
 A_CHAR   *fieldName,
 A_UINT32 *baseValue,		//base value out
 A_UINT32 *turboValue		//turbo value out
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
    ATHEROS_REG_FILE *fieldDetails;
    size_t		     tempSize;
	A_UINT32		 cfgVersion;
	
    cfgVersion = ar5kInitData[pLibDev->ar5kInitIndex].cfgVersion;
	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:getField\n", devNum);
		return;
	}

    //check for the existance of the regArray before we start
    if(pLibDev->regArray == NULL) {
        mError(devNum, EIO, "Device Number %d:Software has no register file values, run resetDevice before getField \n", devNum);
        return;
    }
    
    //search for the field name within the register array
    tempSize = pLibDev->sizeRegArray;
    fieldDetails = (ATHEROS_REG_FILE *)_lfind(fieldName, pLibDev->regArray, &tempSize, 
                sizeof(ATHEROS_REG_FILE), compareFields);



    if(fieldDetails == NULL) {
        mError(devNum, EINVAL, "Device Number %d:%s fieldName not found\n", devNum, fieldName);
        return;
    }

	*baseValue = fieldDetails->fieldBaseValue;
	if(cfgVersion == 0) {
		*turboValue = fieldDetails->fieldTurboValue;
	}
	else {
		*turboValue = fieldDetails->fieldBaseValue;
	}

	return;
}


MANLIB_API void changeField
(
 A_UINT32 devNum,
 A_CHAR *fieldName, 
 A_UINT32 newValue
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
    ATHEROS_REG_FILE *fieldDetails;
    size_t     tempSize;

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:changeField\n", devNum);
		return;
	}