devlibif.c

atheros ar5001 5002 driver

 	A_UINT32 devNum
)
{
	devSleep(devNum);

	return;
}

void m_getEepromStruct
(
 	A_UINT32 devNum,
 	A_UINT16 eepStructFlag,
	void **ppReturnStruct,
	A_UINT32 *pSizeStruct
)
{
	getEepromStruct(devNum, eepStructFlag, ppReturnStruct, pSizeStruct);

	return;
}

void m_changeField
(
 	A_UINT32 devNum,
 	A_CHAR *fieldName, 
 	A_UINT32 newValue
)
{
	changeField(devNum, fieldName, newValue);
   
    	return;
}


void m_changeMultipleFieldsAllModes
(
 	A_UINT32		devNum,
 	PARSE_MODE_INFO *fieldsToChange, 
 	A_UINT32 numFields
)
{
	changeMultipleFieldsAllModes(devNum, fieldsToChange, numFields);
   
    return;
}

void m_changeMultipleFields
(
 	A_UINT32		devNum,
 	PARSE_FIELD_INFO *fieldsToChange, 
 	A_UINT32 numFields
)
{
	changeMultipleFields(devNum, fieldsToChange, numFields);
   
    return;
}

void m_enableWep
(
 	A_UINT32 devNum,
 	A_UCHAR  key
)
{
	enableWep(devNum, key);
   
    	return;
}

void m_enablePAPreDist
(
 	A_UINT32 devNum,
 	A_UINT16 rate,
 	A_UINT32 power
)
{
	//enablePAPreDist(devNum, rate, power);
   
    	return;

}

void m_dumpRegs
(
 	A_UINT32 devNum
)
{
	dumpPciRegValues(devNum);

	return;
}

void m_dumpPciWrites
(
 	A_UINT32 devNum
)
{
	displayPciRegWrites(devNum);

	return;
}

A_BOOL m_testLib
(
 	A_UINT32 devNum,
 	A_UINT32 timeout
)
{
	A_BOOL ret;

	ret = testLib(devNum, timeout);

	return ret;
}

void m_displayFieldValues 
(
 	A_UINT32 devNum,
 	A_CHAR *fieldName,
	A_UINT32 *baseValue,
	A_UINT32 *turboValue

)
{
	getField(devNum, fieldName, baseValue, turboValue);

	return;
}

A_UINT32 m_getFieldValue
(
 	A_UINT32 devNum,
 	A_CHAR   *fieldName,
 	A_UINT32 turbo,
	A_UINT32 *baseValue,
	A_UINT32 *turboValue

)
{
	getField(devNum, fieldName, baseValue, turboValue);

	return 0;
}

A_INT32 m_getFieldForMode
(
 	A_UINT32 devNum,
 	A_CHAR   *fieldName,
 	A_UINT32 mode,
	A_UINT32 turbo

)
{
	return getFieldForMode(devNum, fieldName, mode, turbo);
}

A_UINT32 m_readField
(
 	A_UINT32 devNum,
 	A_CHAR   *fieldName,
 	A_UINT32 printValue,
	A_UINT32 *unsignedValue,
	A_INT32 *signedValue,
	A_BOOL  *signedFlag

)
{
	readField(devNum, fieldName, unsignedValue, signedValue, signedFlag);

	return 0;
}

void m_writeField
(
 	A_UINT32 devNum,
 	A_CHAR *fieldName, 
 	A_UINT32 newValue
)
{
	writeField(devNum, fieldName, newValue);

    	return;
}

void m_forceSinglePCDACTable
(
	A_UINT32 devNum,
	A_UINT16 pcdac
)
{
	ForceSinglePCDACTable(devNum,pcdac);

	return;
}

void m_forcePCDACTable
(
	A_UINT32 devNum,
	A_UINT16 *pcdac
)
{
	forcePCDACTable(devNum,pcdac);

	return;
}

void m_forcePowerTxMax
(
	A_UINT32 devNum,
	A_UINT32 length,
	A_UINT16 *pRatesPower
)
{

	if (length != NUM_RATES) {
		uiPrintf("m_forcePowerTxMax: RatesPower should be a 8 byte array. given %d\n", length);
		return;
	}
	forcePowerTxMax(devNum, (A_INT16 *) pRatesPower);

	return;
}

void m_forceSinglePowerTxMax
(
	A_UINT32 devNum,
	A_UINT16 txPower
)
{
	forceSinglePowerTxMax(devNum,txPower);
	return;
}

void m_setQueue
(
 	A_UINT32 devNum,
	A_UINT32 qcuNumber
)
{
	setQueue(devNum,qcuNumber);

    	return;
}

void m_mapQueue
(
 	A_UINT32 devNum,
	A_UINT32 qcuNumber,
	A_UINT32 dcuNumber
)
{
	mapQueue(devNum,qcuNumber,dcuNumber);

    	return;
}

void m_clearKeyCache
(
 	A_UINT32 devNum
)
{
	clearKeyCache(devNum);

    	return;
}

void m_getMacAddr
(
 	A_UINT32 devNum,
	A_UINT16 wmac,
	A_UINT16 instNo,
	A_UINT8 *macAddr
)
{
	getMacAddr(devNum,wmac,instNo, macAddr);

   	return;
}


A_UINT16 m_closeDevice
(
    A_UINT32 devNum
)
{
	A_UINT16 devIndex;

	devIndex = getDevIndex(devNum);
	// Close manufacturing library structs for this device
	closeDevice(devNum);

    // Close low level structs for this device
	if (devIndex != (A_UINT16)-1) {
  		deviceCleanup(devIndex);
	}
	return (devIndex);
}

/**************************************************************************
* OSregRead - MLIB command for reading a register
*
* RETURNS: value read
*/
A_UINT32 OSregRead
(
    	A_UINT32 devNum,
    	A_UINT32 regOffset
)
{
	A_UINT32         regReturn;
	A_UINT16 devIndex;

	// no need to check for invalid devindex as these are called from lib and should 
	// have a valid devindex
	devIndex = getDevIndex(devNum);

	/* read the register */
	regReturn = hwMemRead32(devIndex,regOffset); 

	return(regReturn);
}

/**************************************************************************
* OSregWrite - MLIB command for writing a register
*
*/
void OSregWrite
(
	A_UINT32 devNum,
    A_UINT32 regOffset,
    A_UINT32 regValue
)
{
	A_UINT16 devIndex;

	// no need to check for invalid devindex as these are called from lib and should 
	// have a valid devindex
	devIndex = getDevIndex(devNum);

	/* write the register */
	hwMemWrite32(devIndex,regOffset, regValue); 
}

/**************************************************************************
* OScfgRead - MLIB command for reading a pci configuration register
*
* RETURNS: value read
*/
A_UINT32 OScfgRead
(
	A_UINT32 devNum,
    A_UINT32 regOffset
)
{
    A_UINT32         regReturn;
	A_UINT16 devIndex;

	// no need to check for invalid devindex as these are called from lib and should 
	// have a valid devindex
	devIndex = getDevIndex(devNum);

	regReturn = hwCfgRead32(devIndex, regOffset); 

    return(regReturn);
}

/**************************************************************************
* OScfgWrite - MLIB command for writing a pci config register
*
*/
void OScfgWrite
(
	A_UINT32 devNum,
   	A_UINT32 regOffset,
   	A_UINT32 regValue
)
{
	A_UINT16 devIndex;

	// no need to check for invalid devindex as these are called from lib and should 
	// have a valid devindex
	devIndex = getDevIndex(devNum);

	hwCfgWrite32(devIndex, regOffset, regValue); 
}

/**************************************************************************
* OSmemRead - MLIB command to read a block of memory
*
* read a block of memory
*
* RETURNS: An array containing the bytes read
*/
void OSmemRead
(
	A_UINT32 devNum,
   	A_UINT32 physAddr, 
	A_UCHAR  *bytesRead,
   	A_UINT32 length
)
{
	A_UINT16 devIndex;

	// no need to check for invalid devindex as these are called from lib and should 
	// have a valid devindex
	devIndex = getDevIndex(devNum);
	
   	/* check to see if the size will make us bigger than the send buffer */
   	if (length > MAX_MEMREAD_BYTES) {
       		uiPrintf("Error: OSmemRead length too large, can only read %x bytes\n", MAX_MEMREAD_BYTES);
		return;
   	}

	if (bytesRead == NULL) {
       		uiPrintf("Error: OSmemRead received a NULL ptr to the bytes to read - please preallocate\n");
		return;
    	}

	if(hwMemReadBlock(devIndex, bytesRead, physAddr, length) == -1) {
		uiPrintf("Error: OSmemRead failed call to hwMemReadBlock()\n");
		return;
	}
}

/**************************************************************************
* OSmemWrite - MLIB command to write a block of memory
*
*/
void OSmemWrite
(
	A_UINT32 devNum,
    	A_UINT32 physAddr,
	A_UCHAR  *bytesWrite,
	A_UINT32 length
)
{
	A_UINT16 devIndex;

	// no need to check for invalid devindex as these are called from lib and should 
	// have a valid devindex
	devIndex = getDevIndex(devNum);
	
   	/* check to see if the size will make us bigger than the send buffer */
   	if (length > MAX_MEMREAD_BYTES) {
        uiPrintf("Error: OSmemWrite length too large, can only read %x bytes\n", MAX_MEMREAD_BYTES);
		return;
   	}
	if (bytesWrite == NULL) {
        uiPrintf("Error: OSmemWrite received a NULL ptr to the bytes to write\n");
		return;	
	}

	if(hwMemWriteBlock(devIndex, bytesWrite, length, &(physAddr)) == -1) {
		uiPrintf("Error:  OSmemWrite failed call to hwMemWriteBlock()\n");
		return;
    }
}

ISR_EVENT getISREvent
(
 	A_UINT32 devNum
)
{
    MDK_WLAN_DEV_INFO    *pdevInfo;
	static EVENT_STRUCT locEventSpace;
	// Initialize event to invalid.
	ISR_EVENT event = {0, 0};
	A_UINT16 devIndex;

	// no need to check for invalid devindex as these are called from lib and should 
	// have a valid devindex
	devIndex = getDevIndex(devNum);
	
	pdevInfo = globDrvInfo.pDevInfoArray[devIndex];

#ifdef JUNGO
    	if (pdevInfo->pdkInfo->pSharedInfo->anyEvents) {
		//call into the kernel plugin to get the event
		if (hwGetNextEvent(devIndex,(void *)&locEventSpace) != -1) {
		if (locEventSpace.type == ISR_INTERRUPT) {
				event.valid = 1;
				event.ISRValue = locEventSpace.result;
		#ifdef MAUI
		{
			A_UINT32 i;

			for (i=0;i<5;i++) {
				event.additionalInfo[i] = locEventSpace.additionalParams[i]; 
			}
		}
		#endif
			}
			else {
				uiPrintf("Error: getISREvent - found a non-ISR event in a client - is this possible???\n");
				uiPrintf("If this has become a possibility... then remove this error check\n");
			}
		}
		else {
			uiPrintf("Error: getISREvent Unable to get event from kernel plugin when it said we had one\n");
		}
	}

#else
	locEventSpace.type = 0;
	if (hwGetNextEvent(devIndex,&locEventSpace) != -1) {
		if(locEventSpace.type == ISR_INTERRUPT) {
			event.valid = 1;
			event.ISRValue = locEventSpace.result;
		}	
		#ifdef MAUI
		{
			A_UINT32 i;
				for (i=0;i<5;i++) {
				event.additionalInfo[i] = locEventSpace.additionalParams[i]; 
			}
		}
		#endif
	}
#endif
	return(event);
}


/**************************************************************************
* initializeMLIB - initialization call to MLIB
*
* RETURNS: value read
*/
A_INT32 initializeMLIB(MDK_WLAN_DEV_INFO *pdevInfo)
{
	static DEVICE_MAP devMap;
	A_UINT32 devNum;

	devMap.DEV_CFG_ADDRESS = 0;
	devMap.DEV_CFG_RANGE = MAX_CFG_OFFSET;
#ifdef JUNGO
	devMap.DEV_MEMORY_ADDRESS = (unsigned long) pdevInfo->pdkInfo->dma_mem_addr;	
	devMap.DEV_REG_ADDRESS = pdevInfo->pdkInfo->pSharedInfo->devMapAddress;
#else
	devMap.DEV_MEMORY_ADDRESS = (unsigned long) pdevInfo->pdkInfo->memPhyAddr;
	devMap.DEV_REG_ADDRESS = pdevInfo->pdkInfo->f2MapAddress;
#endif
	devMap.DEV_MEMORY_RANGE = pdevInfo->pdkInfo->memSize;
	devMap.DEV_REG_RANGE = LIB_REG_RANGE;
	devMap.OScfgRead = OScfgRead;
	devMap.OScfgWrite = OScfgWrite;
	devMap.OSmemRead = OSmemRead;
	devMap.OSmemWrite = OSmemWrite;
	devMap.OSregRead = OSregRead;
	devMap.OSregWrite = OSregWrite;
	devMap.getISREvent = getISREvent;
	devMap.devIndex = pdevInfo->pdkInfo->devIndex;
	devNum = initializeDevice(devMap);

	// Setup quick access device to handle table
	assert(devNum < LIB_MAX_DEV);

    	// Point library at MDKclient memory map
    	useMDKMemory(devNum, pdevInfo->pbuffMapBytes, pdevInfo->pnumBuffs);

	return devNum;
}

void closeMLIB(A_UINT32 devNum)
{
	closeDevice(devNum);
}

void m_devlibCleanup()
{
	devlibCleanup();
}

void m_changeCal
(
  A_UINT32 calFlags
)
{
	enableCal = calFlags;
	return;
}