athreg.c

Atheros AP Test with Agilent N4010A source code

    //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 changeField \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;
    }
    

	updateField(devNum, fieldDetails, newValue, 0);
	return;
}    
	
	

void updateField
(
 A_UINT32 devNum,
 ATHEROS_REG_FILE *fieldDetails,
 A_UINT32 newValue,
 A_BOOL immediate
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
    A_UINT32         i, j; 
    A_UINT32         clearMask;
    A_UINT32         *pValue = NULL;
	A_UINT32		 cfgVersion;
	A_UINT32		 modeIndex;
	A_UCHAR			 bankMask;
	A_UINT32		 regValue;


    //check that the value if not too big for the field size
	//note can't do this check if its a signed value, will just have
	//to crop the value to its field size
 	if((!fieldDetails->valueSigned) && (newValue > fieldDetails->maxValue)) {
        mError(devNum, EINVAL, "Device Number %d:updateField: field %s value [%d] is too large for field size [max=%d]\n", devNum, 
				fieldDetails->fieldName, newValue, fieldDetails->maxValue);
        return;
    }
	
	if (fieldDetails->valueSigned) {
		newValue  = newValue & fieldDetails->maxValue;
	}
    
    //change the value in reg array
    cfgVersion = ar5kInitData[pLibDev->ar5kInitIndex].cfgVersion;
	if((pLibDev->turbo == TURBO_ENABLE) && (cfgVersion == 0)) {
        fieldDetails->fieldTurboValue = newValue;
    }
    else {
        fieldDetails->fieldBaseValue = newValue;
    }

	if(cfgVersion >= 2) {
		//check to see if this is a field that exists in the mode section,
		//if so then update the mode specific value to the new value
		//note in some cases we may overwrite the mode value with the same value, thats OK
		modeIndex = fieldDetails->softwareControlled; //index to mode reg
		if(fieldDetails->existsInEepromOrMode) { //this field exists in mode section
			switch(pLibDev->mode) {
			case MODE_11A:	//11a
				if(pLibDev->turbo != TURBO_ENABLE) {	//11a base
					pLibDev->pModeArray[modeIndex].value11a = newValue;
				}
				else {			//11a turbo
					pLibDev->pModeArray[modeIndex].value11aTurbo = newValue;
				}

				break;

			case MODE_11G: //11g
			case MODE_11O: //ofdm@2.4
				if((pLibDev->turbo != TURBO_ENABLE) || (cfgVersion < 3)) {
					pLibDev->pModeArray[modeIndex].value11g = newValue;
				}
				else {
					pLibDev->pModeArray[modeIndex].value11gTurbo = newValue;
				}
				break;

			case MODE_11B: //11b
				pLibDev->pModeArray[modeIndex].value11b = newValue;
				break;
			} //end switch
		}//end if mode
	}

    if(fieldDetails->radioRegister) {
        //regenerate values again
//		createRfPciValues(&pLibDev->regArray[pLibDev->rfRegArrayIndex], 
//                          pLibDev->rfRegArrayIndex, pLibDev->sizeRegArray, pLibDev->pRfPciValues);
		//work out the mask for this bank
		bankMask = 0x01;
		for(j = 0; j < fieldDetails->regOffset; j++) {
			bankMask = (A_UCHAR)((bankMask << 1) & 0xff);
		}

		if (immediate) {
			//also write out to the registers
			REGW(devNum, 0x9808, REGR(devNum, 0x9808) | 0x08000000);
			new_createRfPciValues(devNum, bankMask, 1);
			// Re-enable AGC
			if(keepAGCDisable) {
				printf("SNOOP: Not re-enabling AGC");
			} else {
				REGW(devNum, 0x9808, REGR(devNum, 0x9808) & (~0x08000000));
			}
		}
		else {
			new_createRfPciValues(devNum, bankMask, 0);
		}
    }
    else {
        //find address and update value
        for (i = 0; i < pLibDev->sizePciValuesArray; i++) {
            if(fieldDetails->regOffset == pLibDev->pciValuesArray[i].offset) {
                if((pLibDev->turbo == TURBO_ENABLE) && (cfgVersion == 0)) {
                    pValue = &(pLibDev->pciValuesArray[i].turboValue);
                }
                else {
                    pValue = &(pLibDev->pciValuesArray[i].baseValue);
                }
                break;
            }
        }

        if(NULL == pValue) {
            //don't expect to get here, means we didn't find the address of reg in pci array
            mError(devNum, EIO, "Device Number %d:updateField: Inexpected internal software error\n", devNum);
            return;
        }

        //do a modify on the value
        clearMask = ~(fieldDetails->maxValue << fieldDetails->fieldStartBitPos);
        *pValue =  *pValue & clearMask | (newValue << fieldDetails->fieldStartBitPos);

		if(immediate) {
			//also do a read modify write on the register value
			//read the register
			regValue = REGR(devNum, fieldDetails->regOffset);


			//modify the value and write back
			clearMask = ~(fieldDetails->maxValue << fieldDetails->fieldStartBitPos);
			regValue =  regValue & clearMask | (newValue << fieldDetails->fieldStartBitPos);

			REGW(devNum, fieldDetails->regOffset, regValue);
		}
    }
	return;
}

//change the register value without updating the software array
MANLIB_API void changeRegValueField
(
 A_UINT32 devNum,
 A_CHAR *fieldName, 
 A_UINT32 newValue
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
    ATHEROS_REG_FILE *fieldDetails;
    size_t     tempSize;
    A_UINT32   clearMask;
	A_UINT32   regValue;

    //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 changeField \n", devNum);
        return;
    }
    
    if(!strncmp(fieldName, "rf_", sizeof("rf_")))
	{
		mError(devNum, EIO, "Device Number %d:rf registers not supported by this function\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;
    }
    
   //check that the value if not too big for the field size
	//note can't do this check if its a signed value, will just have
	//to crop the value to its field size
 	if((!fieldDetails->valueSigned) && (newValue > fieldDetails->maxValue)) {
        mError(devNum, EINVAL, "Device Number %d:changeRegValueField field %s value is too large for field size\n", devNum, 
				fieldDetails->fieldName);
        return;
    }
	
	if (fieldDetails->valueSigned) {
		newValue  = newValue & fieldDetails->maxValue;
	}
 
	regValue = REGR(devNum, fieldDetails->regOffset);


	//modify the value and write back
	clearMask = ~(fieldDetails->maxValue << fieldDetails->fieldStartBitPos);
	regValue =  regValue & clearMask | (newValue << fieldDetails->fieldStartBitPos);

	REGW(devNum, fieldDetails->regOffset, regValue);
	return;
}

/* read the register to get the value of the field.  Does a mask and shift 
   to return only the value of the field */
MANLIB_API void readField
(
 A_UINT32	devNum,
 A_CHAR		*fieldName,
 A_UINT32	*pUnsignedValue,			//returns unsigned value
 A_INT32	*pSignedValue,				//returns signed value
 A_BOOL		*pSignedFlag				//return true if this is a signed value
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
    ATHEROS_REG_FILE *fieldDetails;
    size_t		     tempSize;
	A_UINT32		 regValue;
	A_UINT32		 fieldValue;
	A_UINT32		 signedBit;

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:readField\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 readField \n", devNum);
        return;
    }
    

	//see if this is an rf register.  rf registers not supported
	if(strncmp(fieldName, "rf", 2) == 0) {
		mError(devNum, EINVAL, "Device Number %d:rf register reading is not supported\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;
    }
    
	if(!fieldDetails->readable) {
		mError(devNum, EIO, "Device Number %d:%s field is not readable\n", devNum, fieldName);
		return;
	}
	
	//read the register
	regValue = REGR(devNum, fieldDetails->regOffset);

	//mask and shift to get just the field value
	fieldValue = (regValue >> fieldDetails->fieldStartBitPos) & fieldDetails->maxValue;
	
	if (fieldDetails->valueSigned) {
		*pSignedFlag = 1;
				
		*pSignedValue = fieldValue;		//will contain signed representation of number
		*pUnsignedValue = fieldValue;	//will contain unsigned representation of number

		//see if the value is negative
		signedBit = 1 << (fieldDetails->fieldSize - 1);

		if(fieldValue & signedBit) {
			*pSignedValue = ((~(*pSignedValue) & fieldDetails->maxValue) + 1) & fieldDetails->maxValue;
			*pSignedValue *= -1;
		}
	}
	else {
		*pUnsignedValue = fieldValue;
		*pSignedFlag = 0;
	}

    return;
}

/* do a read modify write on the field */
MANLIB_API void writeField
(
 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:writeField\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 writeField \n", devNum);
        return;
    }
    
	//see if this is an rf register.  rf registers ARE NOW supported
//	if(strncmp(fieldName, "rf", 2) == 0) {
//		mError(EINVAL, "rf register reading is not supported\n");
//		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;
    }
    
   	updateField(devNum, fieldDetails, newValue, 1);


	return;
}


MANLIB_API void changeMultipleFields
(
 A_UINT32		  devNum,
 PARSE_FIELD_INFO *pFieldsToChange,
 A_UINT32		  numFields
)
{
	A_UINT32	i;
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
    size_t		     tempSize;
    ATHEROS_REG_FILE *fieldDetails;
	A_UINT32		newValue;
	A_UINT32		cfgVersion;

    cfgVersion = ar5kInitData[pLibDev->ar5kInitIndex].cfgVersion;

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:writeField\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 writeField \n", devNum);
        return;
    }

    tempSize = pLibDev->sizeRegArray;
	for(i = 0; i < numFields; i++) {
		fieldDetails = (ATHEROS_REG_FILE *)_lfind(pFieldsToChange[i].fieldName, pLibDev->regArray, &tempSize, 
					sizeof(ATHEROS_REG_FILE), compareFields);

		if(fieldDetails == NULL) {
			mError(devNum, EINVAL, "Device Number %d:changeMultiFields: %s fieldName not found i = %d, numFields = %d\n", devNum, pFieldsToChange[i].fieldName, i, numFields);
			return;
		}


        if (!getUnsignedFromStr(devNum, pFieldsToChange[i].valueString, (A_BOOL)fieldDetails->valueSigned, 
                fieldDetails->fieldSize,
                &newValue)) {
            mError(devNum, EINVAL, "Device Number %d:problem with base value on line %d\n", devNum, i);
			return;
        }

		updateField(devNum, fieldDetails, newValue, 0);
		if(cfgVersion == 0) {
			//for this case we need to change the turbo field also (mainly for AP)
			pLibDev->turbo = !(pLibDev->turbo);