mconfig.c

atheros ar5001 5002 driver

		// noise cal takes a long time to complete in simulation
		// need not wait for the noise cal to complete
#ifdef SIM
			enableCal = DO_OFSET_CAL;
#endif

//		printf("SNOOP: doing cal %d\n", enableCal);
		for (i = 0; i < 1000; i++)
		{
			if ((REGR(devNum, PHY_AGC_CONTROL) & (enableCal)) == 0 )
			{
				break;
			}
			mSleep(1);
		}
		if(i >= 1000) {
			//mError(EIO, "Device Number %d:resetDevice: device failed to finish offset and/or noisefloor calibration in 10 ms\n");
			printf("Device Number %d:Didn't complete cal but keep going anyway\n", devNum);
		}
	}

	else {
//		printf("SNOOP: Both noisefloor and offset cal have been disabled\n");
	}

	//check for any post reset EAR modificatons
	if (earHere) {
        ar5212EarModify(devNum, pLibDev->pEarHead, EAR_LC_POST_RESET, freq, &modifier);
    }

    
	} // end of else (use_init...
	pLibDev->devState = RESET_STATE;

#ifndef __ATH_DJGPPDOS__
	// ART ANI routine
	tweakArtAni(devNum, prev_freq, pLibDev->freqForResetDevice);
#endif
}

/**************************************************************************
 * testLib -  test function  that check for software interrupt (added to 
 *			  create dktest functionality).  Returns TRUE if pass, FALSE 
 *			  otherwise
 *
 */
MANLIB_API A_BOOL testLib
(
 A_UINT32 devNum,
 A_UINT32 timeout
)
{
	ISR_EVENT	event;
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32	i;
	A_UINT32    saveRegValue;
	A_UINT32    testRegValue;
	A_UINT32    testValues[] = {0xffffffff, 0x00000000, 0xa5a5a5a5};

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:testLib\n", devNum);
		return(FALSE);
	}
	if (pLibDev->devState < RESET_STATE) {
		mError(devNum, EILSEQ, "Device Number %d:testLib: Device should be out of Reset before testing library\n", devNum);
		return(FALSE);
	}

#ifndef SIM
	//enable software interrupt
	REGW(devNum, F2_IMR, REGR(devNum, F2_IMR) | F2_IMR_SWI);
#endif

	//#################Hard code maui2 for now
	REGW(devNum, 0xA0, REGR(devNum, 0xA0) | F2_IMR_SWI);

#ifndef SIM
	//clear ISR before enable
	REGR(devNum, F2_ISR);
#endif

	REGR(devNum, 0x80);
	REGW(devNum, F2_IER, F2_IER_ENABLE);

	//create the software interrupt
	REGW(devNum, F2_CR, REGR(devNum, F2_CR) | F2_CR_SWI);
	//wait for software interrupt
	for (i = 0; i < timeout; i++)
	{
		event = pLibDev->devMap.getISREvent(devNum);
		if (event.valid)
		{
            //see if it is the SW interrupt
			if (event.ISRValue & F2_ISR_SWI) {
				//This is the event we are waiting for
				break;
			}
		}
		mSleep(1);		
	}
	if (i == timeout) {
		mError(devNum, 21, "Device Number %d:Error: Software interrupt not received\n", devNum);
		return(FALSE);
	}

	//perform a simple register test
	saveRegValue = REGR(devNum, F2_STA_ID0);
	for(i = 0; i < sizeof(testValues)/sizeof(A_UINT32); i++) {
		REGW(devNum, F2_STA_ID0, testValues[i]);
		testRegValue = REGR(devNum, F2_STA_ID0);
		if(testRegValue != testValues[i]) {
			mError(devNum, 71, "Device Number %d:Failed simple register test, wrote %x, read %x\n", devNum, testValues[i], testRegValue);
			REGW(devNum, F2_STA_ID0, saveRegValue);
			return(FALSE);
		}
	}
	REGW(devNum, F2_STA_ID0, saveRegValue);
	return(TRUE);
}




/**************************************************************************
 * checkRegs - Perform register tests to various domains of the AR5K
 *
 */
MANLIB_API A_UINT32 checkRegs
(
 A_UINT32 devNum
)
{
	LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
    A_UINT32 failures = 0;
    A_UINT32 addr, i, loop, wrData, rdData, pattern;
    A_UINT32 regAddr[2] = {F2_STA_ID0, PHY_BASE+(8 << 2)};
    A_UINT32 regHold[2];
    A_UINT32 patternData[4] = {0x55555555, 0xaaaaaaaa, 0x66666666, 0x99999999};

	if(pLibDev->swDevID == 0x0007) {
		// Test PHY & MAC registers
		for(i = 0; i < 2; i++) {
			addr = regAddr[i];
			regHold[i] = REGR(devNum, addr);
			for (loop=0; loop < 0x10000; loop++) {

				wrData =  (loop << 16) | loop;
				REGW(devNum, addr, wrData);
				rdData = REGR(devNum, addr);
				if (rdData != wrData) {
					failures++;
				}
			}

			for (pattern=0; pattern<4; pattern++) {

				wrData = patternData[pattern];

				REGW(devNum, addr, wrData);
				rdData = REGR(devNum, addr);

				if (wrData != rdData) {
					failures++;
				}
			}
		}    

   		// Disable AGC to A2 traffic
		REGW(devNum, 0x9808, REGR(devNum, 0x9808) | 0x08000000);

		// Test Radio Register
		for (loop=0; loop < 10000; loop++) {
			wrData = loop & 0x3f;

			// ------ DAC 1 Write -------
			REGW(devNum, (PHY_BASE+(0x35<<2)), (reverseBits(wrData, 6) << 16) | (reverseBits(wrData, 6) << 8) | 0x24);      
			REGW(devNum, (PHY_BASE+(0x34<<2)), 0x0);
			REGW(devNum, (PHY_BASE+(0x34<<2)), 0x00120017);      
    
			for (i=0; i<18; i++) {
				REGW(devNum, PHY_BASE+(0x20<<2), 0x00010000);
			}
    
			rdData = reverseBits((REGR(devNum, PHY_BASE+(256<<2)) >> 26) & 0x3f, 6);
    
			if (rdData != wrData) {
					failures++;
			}
    
			REGW(devNum, (PHY_BASE+(0x34<<2)), 0x0);
			REGW(devNum, (PHY_BASE+(0x34<<2)), 0x00110017);      
    
			for (i=0; i<18; i++) {
				REGW(devNum, PHY_BASE+(0x20<<2), 0x00010000);
			}
    
			rdData = reverseBits((REGR(devNum, PHY_BASE+(256<<2)) >> 26) & 0x3f, 6);
    
			if (rdData != wrData) {
					failures++;
			}
		}
		REGW(devNum, (PHY_BASE+(0x34<<2)), 0x14);
		for(i = 0; i < 2; i++) {
			REGW(devNum, regAddr[i], regHold[i]);
		}

		// Re-enable AGC to A2 traffic
		REGW(devNum, 0x9808, REGR(devNum, 0x9808) & (~0x08000000));
		gLibInfo.pLibDevArray[devNum]->devState = INIT_STATE;
	}
	else {
		mError(devNum, EIO, "Device Number %d:CheckRegs not implemented for this deviceID\n", devNum);
	}

    return failures;
}

/**************************************************************************
 * changeChannel - Change the channel of the given device
 *
 */
MANLIB_API void changeChannel
(
 A_UINT32 devNum,
 A_UINT32 freq		// New channel
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:changeChannel\n", devNum);
		return;
	}
	if (pLibDev->devState < RESET_STATE) {
		mError(devNum, EILSEQ, "Device Number %d:changeChannel: Device should be out of Reset before changing channel\n", devNum);
		return;
	}

	// Disable AGC to A2 traffic
//	REGW(devNum, 0x9808, REGR(devNum, 0x9808) | 0x08000000);
	//AGC disable may not always work, this should
	REGW(devNum, PHY_ACTIVE, PHY_ACTIVE_DIS);
	mSleep(1);

	setChannel(devNum, freq);
	//set falseDetectBackoff.  May get overwritten by eeprom value
	if((pLibDev->swDevID & 0xff) >= 0x0012) {
		applyFalseDetectBackoff(devNum, freq, pLibDev->suppliedFalseDetBackoff[pLibDev->mode]);
	}


	//set the transmit power
	//#############Comment out for now, until fix the calibration sequencing issue.
	initializeTransmitPower(devNum, freq, 0, NULL);

	// Re-enable AGC to A2 traffic
//	REGW(devNum, 0x9808, REGR(devNum, 0x9808) & (~0x08000000));
	//AGC disable may not always work, this should
	REGW(devNum, PHY_ACTIVE, PHY_ACTIVE_EN);
	mSleep(1);

	// Set the noise floor after setting the channel.
	REGW(devNum, PHY_AGC_CONTROL, REGR(devNum, PHY_AGC_CONTROL) | PHY_AGC_CONTROL_NF);
	mSleep(2);
}

/**************************************************************************
 * setChannel - Perform the algorithm to change the channel
 *
 */
A_BOOL setChannel
(
 A_UINT32 devNum,
 A_UINT32 freq		// New channel
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 i = pLibDev->ar5kInitIndex;

	if (ar5kInitData[i].pRfAPI->setChannel == NULL)
	{
		return(0);
	}
	return (ar5kInitData[i].pRfAPI->setChannel(devNum, freq));

}

/**************************************************************************
* rereadProm - reset the EEPROM information
*
*/
MANLIB_API void rereadProm
(
 A_UINT32 devNum
)
{
	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:rereadProm\n", devNum);
		return;
	}
    gLibInfo.pLibDevArray[devNum]->eepData.eepromChecked = FALSE;

	//free up the 16K eeprom struct if needed
	freeEepStructs(devNum);
}

/**************************************************************************
* eepromRead - call correct eepromRead Function
*
* RETURNS: 16 bit value from given offset (in a 32-bit value)
*/
MANLIB_API A_UINT32 eepromRead
(
 A_UINT32 devNum, 
 A_UINT32 eepromOffset
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 i = pLibDev->ar5kInitIndex;

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

	if (ar5kInitData[i].pMacAPI->eepromRead == NULL)
	{
		return(0xdeadbeef);
	}
	return (ar5kInitData[i].pMacAPI->eepromRead(devNum, eepromOffset));
}

/**************************************************************************
* eepromWrite - Call correct eepromWrite function
*
*/
MANLIB_API void eepromWrite
(
 A_UINT32 devNum, 
 A_UINT32 eepromOffset, 
 A_UINT32 eepromValue
)
{
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32 i = pLibDev->ar5kInitIndex;

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

	if (ar5kInitData[i].pMacAPI->eepromWrite == NULL)
	{
		return;
	}
	ar5kInitData[i].pMacAPI->eepromWrite(devNum, eepromOffset, eepromValue);
	return;
}




/**************************************************************************
* setAntenna - Change antenna to the given antenna A or B
*
*/
MANLIB_API void setAntenna
(
 A_UINT32 devNum, 
 A_UINT32 antenna
)
{    
    LIB_DEV_INFO *pLibDev = gLibInfo.pLibDevArray[devNum];
	A_UINT32	antMode = 0;

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:setAntenna\n", devNum);
		return;
	}
	if (!ar5kInitData[pLibDev->ar5kInitIndex].pMacAPI->setupAntenna(devNum, antenna, &antMode))
	{
		return;
	}

}

/**************************************************************************
* setTransmitPower - Adjusts output power to a percentage of maximum.
*   resetDevice or changeChannel must be called before the setting takes affect.
*   powerScale is ignored if the EEPROM is not at least rev 1
*
*/
MANLIB_API void setPowerScale
(
 A_UINT32 devNum,
 A_UINT32 powerScale
)
{
	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:setTransmitPower\n", devNum);
		return;
	}
    if((powerScale < TP_SCALE_LOWEST) || (powerScale > TP_SCALE_HIGHEST)) {
		mError(devNum, EINVAL, "Device Number %d:setPowerScale: Invalid powerScale option: %d\n", devNum, powerScale);
		return;
    }
    gLibInfo.pLibDevArray[devNum]->txPowerData.tpScale = (A_UINT16)powerScale;
    return;
}

/**************************************************************************
* setTransmitPower - Calls the correct setTransmitPower function based on 
*		deviceID
*   
*
*/
MANLIB_API void setTransmitPower
(
 A_UINT32 devNum, 
 A_UCHAR txPowerArray[17]
)
{

	if (checkDevNum(devNum) == FALSE) {
		mError(devNum, EINVAL, "Device Number %d:setTransmitPower\n", devNum);
		return;
	}
	if (gLibInfo.pLibDevArray[devNum]->devState < RESET_STATE) {
		mError(devNum, EILSEQ, "Device Number %d:setTransmitPower: Device should be out of Reset before changing transmit power\n", devNum);
		return;
	}

	// Disable AGC to A2 traffic during A2 writes
	REGW(devNum, 0x9808, REGR(devNum, 0x9808) | 0x08000000);

	initializeTransmitPower(devNum, 0, 1, txPowerArray);
	mSleep(1);