mlibif.c

Atheros AP Test with Agilent N4010A source code

	if (thin_client) {
       art_cfgWrite(devNum, regOffset, regValue);
	}
	else {
	   devIndex = (A_UINT16)dev2drv(devNum);
	
	   if(regOffset > MAX_CFG_OFFSET) {
		   uiPrintf("Error:  OScfgWrite: not a valid config offset\n");
		   return;
       }
	   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_UINT32 t_length, i;
	A_UCHAR *t_bytesRead;
    A_UINT32 t_physAddr, t_sOffset;
	A_UINT16 devIndex;

	if(devNumValid(devNum) == FALSE) {
		uiPrintf("Error: OSmemRead did not receive a valid devNum\n");
		return;
	}

    /* 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 (thin_client) {
	   t_length = length;
	   t_physAddr = physAddr;
	   t_sOffset = 0;
	   if (t_physAddr % 4) {
	      t_length += (t_physAddr % 4);
	      t_sOffset = (t_physAddr % 4);
	      t_physAddr &= 0xfffffffc;
	   }
 	   if ( (t_length % 4)) { 
		   t_length += (4 -(t_length % 4));
	   }
	   t_bytesRead = (A_UCHAR *) malloc(t_length * sizeof(A_UCHAR));
//       uiPrintf("SNOOP::OSmemRead:physAddr=%x:t_physAddr=%x:t_sOffset=%d:length=%d:t_length=%d:\n", physAddr, t_physAddr, t_sOffset, length, t_length);
       art_memRead(devNum, t_physAddr, t_bytesRead, t_length);

	   for(i=0;i<length;i++) {
	     bytesRead[i] = t_bytesRead[i+t_sOffset];
	   }
	   free(t_bytesRead);
	}
    else {
	   devIndex = (A_UINT16)dev2drv(devNum);

	   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_UINT32 t_length, i;
    A_UINT32 t_physAddr, t_sOffset;
	A_UINT16 devIndex;//, iIndex; 

	if(devNumValid(devNum) == FALSE) {
		uiPrintf("Error: OSmemWrite did not receive a valid devNum\n");
		return;
	}
    /* 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;	
	}
/*    uiPrintf("Writing the following values @addr=%x\n", physAddr);
    for(iIndex=0; iIndex<length; iIndex++) {
            uiPrintf("%x ", bytesWrite[iIndex]);
            if (!(iIndex+1 % 16)) uiPrintf("\n");
    }
    uiPrintf("\n");
    */
	if (thin_client) {
	   t_length = length;
	   t_physAddr = physAddr;
	   t_sOffset = 0;
	   if (t_physAddr % 4) {
	      t_length += (t_physAddr % 4);
	      t_sOffset = (t_physAddr % 4);
	      t_physAddr &= 0xfffffffc;
	   }
 	   if ( (t_length % 4)) { 
		   t_length += (4 -(t_length % 4));
	   }
	   memcpy(t_bytesWrite, bytesWrite, length * sizeof(A_UCHAR));
       art_memWrite(devNum, t_physAddr, t_bytesWrite, t_length);
	}
    else {
	  devIndex = (A_UINT16)dev2drv(devNum);

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

}

/**************************************************************************
* getISREvent - MLIB command get latest ISR event
*
*/
ISR_EVENT getISREvent
(
 A_UINT32 devNum
)
{
	// Initialize event to invalid.
  ISR_EVENT event = {0, 0};
  EVENT_STRUCT ppEvent;
  MDK_WLAN_DEV_INFO    *pdevInfo;
  A_UINT16 devIndex;

  if (thin_client) {

	if(devNumValid(devNum) == FALSE) {
		uiPrintf("Error: getISREvent did not receive a valid devNum\n");
	    return event;
	}

    if (art_getISREvent(devNum, &ppEvent) == 0xdead) return event;
    if (ppEvent.type == ISR_INTERRUPT) {
		event.valid = 1;
		event.ISRValue = ppEvent.result[0];
     }
    //printf("SNOOP::event type=%d:valid=%d:isrvalue=%d:\n", ppEvent.type, event.valid,  event.ISRValue);
    
  }
  else {

     #if defined(ANWI) || defined(LINUX)
          EVENT_STRUCT pLocEventSpace;
     #else
          EVENT_STRUCT *pLocEventSpace;
     #endif // defined(ANWI/..
     devIndex = (A_UINT16)dev2drv(devNum);
     pdevInfo = globDrvInfo.pDevInfoArray[devIndex];
        #ifdef JUNGO
         if(checkForEvents(globDrvInfo.triggeredQ)) {
                 //call into the kernel plugin to get the event
                 if((pLocEventSpace = popEvent(globDrvInfo.triggeredQ)) != NULL) {
                     if(pLocEventSpace->type == ISR_INTERRUPT) {
                         event.valid = 1;
                         event.ISRValue = pLocEventSpace->result;
                      }
                  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\n");
                  }
          }
        #endif // JUNGO
     #if defined(ANWI) || defined (LINUX)
          if (getNextEvent(devIndex, &pLocEventSpace)) {
              if(pLocEventSpace.type == ISR_INTERRUPT) {
                    event.valid = 1;
                    event.ISRValue = pLocEventSpace.result[0];
              }   
          }
     //    printf("SNOOP::event type=%d:valid=%d:isrvalue=%d:\n", pLocEventSpace.type, event.valid,  event.ISRValue);
     #endif
    }
        
	return(event);
}

/**************************************************************************
* setupDevice - initialization call to ManLIB
*
* RETURNS: devNum or -1 if fail
*/
A_INT32 setupDevice
(
 A_UINT32 whichDevice, 
 DK_DEV_INFO *pdkInfo,
 A_UINT16 remoteLib
)
{
	static DEVICE_MAP devMap;
    MDK_WLAN_DEV_INFO    *pdevInfo;
    A_UINT32 devNum;
    EVT_HANDLE  eventHdl;
	A_UINT16 devIndex;
    A_UINT16 device_fn = WMAC_FUNCTION;

        //uiPrintf("SNOOP::setupDevice called\n");
 	if ( whichDevice > WLAN_MAX_DEV ) {
		/* don't have a large enough array to accommodate this device */
		uiPrintf("Error: devInfo array not large enough, only support %d devices\n", WLAN_MAX_DEV);
	    return -1;
	}


    devIndex = (A_UINT16)(whichDevice - 1);

	if ( A_FAILED( deviceInit(devIndex, device_fn, pdkInfo) ) ) {
		uiPrintf("setupDevice Error: Failed call to local deviceInit()!\n");
        exit(EXIT_FAILURE);
	    return -1;
	}
	pdevInfo = globDrvInfo.pDevInfoArray[devIndex];

    // Finally, setup the library mapping
	devMap.DEV_CFG_ADDRESS = 0;
	devMap.DEV_CFG_RANGE = MAX_CFG_OFFSET;
#if defined(ANWI) || defined (LINUX)
	devMap.DEV_MEMORY_ADDRESS = (unsigned long) pdevInfo->pdkInfo->memPhyAddr;
#endif
#ifdef JUNGO
	devMap.DEV_MEMORY_ADDRESS = (unsigned long) pdevInfo->pdkInfo->dma.Page[0].pPhysicalAddr;
#endif
	devMap.DEV_MEMORY_RANGE = pdevInfo->pdkInfo->memSize; 
	devMap.DEV_REG_ADDRESS = pdevInfo->pdkInfo->f2MapAddress;
	devMap.DEV_REG_RANGE = 65536;
	devMap.OScfgRead = OScfgRead;
	devMap.OScfgWrite = OScfgWrite;
	devMap.OSmemRead = OSmemRead;
	devMap.OSmemWrite = OSmemWrite;
	devMap.OSregRead = OSregRead;
	devMap.OSregWrite = OSregWrite;
	devMap.getISREvent = getISREvent;
	devMap.devIndex = devIndex;

    devMap.remoteLib = remoteLib;
    devMap.r_eepromRead = art_eepromRead;
    devMap.r_eepromWrite = art_eepromWrite;
    devMap.r_eepromReadBlock = art_eepromReadBlock;
    devMap.r_eepromReadLocs = art_eepromReadLocs;
	if (thin_client) {
       devMap.r_hwReset = art_hwReset;
       devMap.r_pllProgram = art_pllProgram;
	   devMap.r_calCheck = art_calCheck;
	   devMap.r_pciWrite = art_pciWrite;
	   devMap.r_fillTxStats = art_fillTxStats;
	   devMap.r_createDescriptors = art_createDescriptors;
   }
   else {
       devMap.r_hwReset = NULL;
       devMap.r_pllProgram = NULL;
	   devMap.r_calCheck = NULL;
	   devMap.r_pciWrite = NULL;
	   devMap.r_fillTxStats = NULL;
	   devMap.r_createDescriptors = NULL;
	}
	devNum = initializeDevice(devMap);

    if(devNum > WLAN_MAX_DEV) {
        uiPrintf("setupDevice Error: Manlib Failed to initialize for this Device:devNum returned = %x\n", devNum);
        return -1;
    }
   	devNum2driverTable[devNum] = devIndex;

    // assign the handle (id, actually) that will be sent back to Perl to uniquely
    eventHdl.eventID = 0;
    eventHdl.f2Handle = (A_UINT16)devNum;

    if (!pdkInfo)
	if(!pdevInfo->pdkInfo->haveEvent) {
        if(hwCreateEvent(devIndex, ISR_INTERRUPT, 1, 0, 0, 0, eventHdl) == -1) {
            uiPrintf("setupDevice Error: Could not initalize driver ISR events\n");
            teardownDevice(devNum);
            return -1;
        }
		pdevInfo->pdkInfo->haveEvent = TRUE;
	}

    return devNum;
}

void teardownDevice
(
 A_UINT32 devNum
) 
{
        //uiPrintf("SNOOP::teardownDevice called\n");
    if(devNumValid(devNum) == FALSE) {
		uiPrintf("Error: teardownDevice did not receive a valid devNum\n");
	    return;
	}

    // Close the Manufacturing Lib
    closeDevice(devNum);
    // Close the driver Jungo driver entries
    deviceCleanup((A_UINT16)dev2drv(devNum));
	
        //uiPrintf("SNOOP::teardownDevice exit\n");
}

/**************************************************************************
* setPciWritesFlag - Change the value to flag for printing pci writes data
*
* RETURNS: N/A
*/
void changePciWritesFlag
(
	A_UINT32 devNum,
	A_UINT32 flag
)
{
    MDK_WLAN_DEV_INFO    *pdevInfo;
	A_UINT16 devIndex;

	devIndex = (A_UINT16)dev2drv(devNum);
	pdevInfo = globDrvInfo.pDevInfoArray[devIndex];

	pdevInfo->pdkInfo->printPciWrites = (A_BOOL)flag;
	return;
}