cf_util.c

Windows CE 6.0 BSP for VOIP sample phone. Intel PXA270 platform.

		NdisRawWritePortUshort(
    		pCf -> ulMrvDrvVirtualIoBase + CFMACREG_HCR_HOST_INT_MASK, 0 );

	}
    
    if ( firmwareDelay >= FWDELAY )
    {
        DBGPRINT(DBG_FWDL,("INIT - CF card failed to start!\n"));
#if DBG        
// DANGER        _asm int 3;
#endif         
        return NDIS_STATUS_FAILURE;
    }
    
    DBGPRINT(DBG_FWDL,("CF started in less than %d ms.\n",firmwareDelay*50));
    DBGPRINT(DBG_FWDL,("INIT - Firmware download end\n"));

    return NDIS_STATUS_SUCCESS;
}

#ifdef MRV_USE_HELPER_IMAGE

//************************************************************************************
//* Function: 		cf_DownloadHelperImage
//*	Description:	Downloads the helper image to device over compact flash interface.
//* Returns			IX_STATUS_SUCCESS if all OK. IX_STATUS_FAILURE if any problems.
//* NOTE:			Please notice that the paramter is the mask of interrupts to disable.
//*						Routine will only disable the interrupts specified in the mask
//* Date:			
//************************************************************************************
NDIS_STATUS
cf_DownloadHelperImage(
	PCF_OBJECT pCf,
    IN PMRVDRV_ADAPTER Adapter
)
{
    	UINT    	blockCount = 0;
    	UINT    	sizeOfFirmware;
    	UINT    	sizeSend = 0;
    	UINT    	sizeBlockInUshort;
    	UINT    	cmdIOaddr;
    	USHORT  i, sizeBlock, *pusPtr; //  usTempUshort,
    	UCHAR   ucTempUchar;
    	// USHORT  usTemp;
    	ULONG   	firmwareDelay = 0;
    	UCHAR   *pPtr;
    
	//AllenDBGPRINT(DBG_FWDL,("DownloadHelperImage >> \n"));
	
    	sizeOfFirmware = sizeof(helperfmimage);
    	cmdIOaddr = pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_IO_CMD_WRITE_PORT; 

    	// set byte 4 of the helper image to 0 for CF
    	pPtr = helperfmimage + 4;
    	*pPtr = 0;    // 0 for CF

    	while (sizeSend <= sizeOfFirmware)
    	{
		blockCount++;
        	sizeBlock = 256;

        	///AllenDBGPRINT(DBG_FWDL, ("block count = %d, sizeBlock = %d\n", blockCount, sizeBlock));

		// Get number of ushorts
        	sizeBlockInUshort = (sizeBlock + 1) / 2;
        	pusPtr = (PUSHORT)(helperfmimage + ((blockCount-1) * sizeBlock));

        	// Write number of bytes to be sent
        	NdisRawWritePortUshort(
     					pCf ->ulMrvDrvVirtualIoBase + CFMACREG_HCR_IO_CMD_WRITE_LEN,
	        			sizeBlockInUshort*2);

       	 for (i=0; i<sizeBlockInUshort; i++ )
        	{
            		NdisRawWritePortUshort(cmdIOaddr,*pusPtr);
            		pusPtr++;
        	}
      
		///AllenDBGPRINT(DBG_FWDL,("Downloaded Block %d of Firmware, blockSize = %d, Total size so far= %d\n", 
		///					blockCount, sizeBlockInUshort*2, sizeSend));

		// Assert the Command Download Over interrupt
    		NdisRawWritePortUchar(
   					pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_HOST_STATUS,
		        		CFMACREG_HCR_HS_CmdDnLdOvr);
	    	NdisRawWritePortUshort(
   					pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_CARD_INT_CAUSE,
        				CFMACREG_HCR_CIC_CmdDnLdOvr);
              
	    	firmwareDelay = 0; 
	    	do {
	        	NdisRawReadPortUchar(
		       		pCf -> ulMrvDrvVirtualIoBase + CFMACREG_CCR_CARD_STATUS,
		        		&ucTempUchar);
            
			if( (ucTempUchar & CFMACREG_CCR_CS_CmdDnLdRdy) )
			{
				break;
			}

            		// NdisMSleep(1);   //NdisStallExecution(30);
            		NdisStallExecution(1);
            		firmwareDelay++;
       	 } while (firmwareDelay < FWBLOCK_DELAY);
        
		if ( firmwareDelay >= FWBLOCK_DELAY )
        	{
            		///AllenDBGPRINT(DBG_FWDL,("Downloading FW died on block %d\n",blockCount));
            		return NDIS_STATUS_FAILURE;
        	}

		///AllenDBGPRINT(DBG_FWDL|DBG_LOAD,("Ready for next block after less than %d ms\n", firmwareDelay*1));

        	sizeSend += sizeBlock;
    	}
	
    	NdisRawWritePortUshort( pCf ->ulMrvDrvVirtualIoBase + 
				CFMACREG_HCR_IO_CMD_WRITE_LEN, 0x00);

	// Assert the Command Download Over interrupt
       NdisRawWritePortUchar(
   				pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_HOST_STATUS,
		    		CFMACREG_HCR_HS_CmdDnLdOvr);
	NdisRawWritePortUshort(
   				pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_CARD_INT_CAUSE,
        			CFMACREG_HCR_CIC_CmdDnLdOvr);	
       
	firmwareDelay = 0; 
	do {
	        NdisRawReadPortUchar(
		       		pCf -> ulMrvDrvVirtualIoBase + CFMACREG_CCR_CARD_STATUS,
		        		&ucTempUchar);
            
		if( (ucTempUchar & CFMACREG_CCR_CS_CmdDnLdRdy) )
		{
				break;
		}
		//NdisMSleep(1);   //NdisStallExecution(30);
            	NdisStallExecution(1);
            	firmwareDelay++;
       } while (firmwareDelay < FWBLOCK_DELAY);
       
	///AllenDBGPRINT(DBG_FWDL,("Wait  for helper download ready %d ms\n", firmwareDelay*1));
       
 	NdisStallExecution(50);   //NdisMSleep(50);
	//AllenDBGPRINT(DBG_FWDL|DBG_LOAD,("DownloadHelperImage << \n"));

	return NDIS_STATUS_SUCCESS;
}

#endif // #ifdef MRV_USE_HELPER_IMAGE

#ifdef POCKETPC_FIX

#define READ_SCRATCH_REGISTER(ucTemp)   \
{                                       \
    USHORT usTemp;                                                      \
                                                                        \
    NdisRawReadPortUshort(                                              \
	    pCf -> ulMrvDrvVirtualIoBase + CFMACREG_CCR_SCRATCH_PORT - 1,   \
        &usTemp);                                                       \
                                                                        \
    ucTemp = (UCHAR)(usTemp >> 8 );                                \
}

#else

#define READ_SCRATCH_REGISTER(ucTemp)   \
{                                       \
    NdisRawReadPortUchar(                                           \
	    pCf -> ulMrvDrvVirtualIoBase + CFMACREG_CCR_SCRATCH_PORT,   \
        &ucTemp);                                              \
}

#endif // #ifdef POCKETPC_FIX

//************************************************************************************
//* Function: 		cf_DownloadFWImageHelperMode
//*	Description:	Downloads the FW image to device over compact flash interface.
//* Returns			NDIS_STATUS_SUCCESS if all OK. NDIS_STATUS_FAILURE if any problems.
//* NOTE:			Please notice that the paramter is the mask of interrupts to disable.
//*						Routine will only disable the interrupts specified in the mask
//* Date:			
//************************************************************************************
NDIS_STATUS
cf_DownloadFWImageHelperMode(
	PCF_OBJECT pCf,
    	IN PMRVDRV_ADAPTER Adapter
)
{
    	UCHAR   	ucTemp;
    	UCHAR   	*pFW;
    	USHORT  rounded_len, len;
    	USHORT  update = 0;
    	UINT    	retry = 0;
    	ULONG   	i, j;
    	ULONG   	firmwareDelay;
    	USHORT  *pUshort;
	USHORT  usTemp;
	
	ULONG   	firmware_len = sizeof(fmimage);

    	pFW = fmimage;
		
       //AllenDBGPRINT(DBG_FWDL | DBG_ERROR,("cf_DownloadFWImageHelperMode >>\n"));
	   
       firmwareDelay = 0; 
       do {
		NdisRawReadPortUshort(
            			pCf ->ulMrvDrvVirtualIoBase + CFMACREG_CCR_SQ_READ_BASE_LOW,
            			&len);
        		//AllenDBGPRINT(DBG_FWDL, ("SQ_READ len = %d\n", len));
        	if (len & 0x0010) 
        		break;
       } while ( firmwareDelay < FWDELAY );

	if ( firmwareDelay >= FWDELAY )
    	{
      		//AllenDBGPRINT(DBG_FWDL,("INIT - CF card start download fail!\n"));
        	return NDIS_STATUS_FAILURE;
    	}

    	for (i=0; i<firmware_len; i+=len) 
    	{
       	NdisRawReadPortUshort(
            			pCf ->ulMrvDrvVirtualIoBase + CFMACREG_CCR_SQ_READ_BASE_LOW,
            			&len);

        	DBGPRINT(DBG_FWDL, ("Read len = %d\n", len));

        	if (len & 0x0001)
        	{	
        		if (retry++ > 20)
                	{
                		DBGPRINT(DBG_FWDL, ("err  >= 20  %d\n", retry ));
                		return NDIS_STATUS_FAILURE;
        		}
        	}
			else 
				retry = 0;	

        	if ((retry> 0) && (i != 0))
            		i -= len;

        	// Write number of bytes to be sent
        	NdisRawWritePortUshort(
     				pCf -> ulMrvDrvVirtualIoBase + CFMACREG_HCR_IO_CMD_WRITE_LEN,
	       			len);

        	// Use write ushort, Pocket PC has problem with UCHAR write
        	rounded_len = len + 1; 
        	for (j = 0; j < (ULONG)(rounded_len/2); j++)
        	{
            		pUshort = (USHORT *)(pFW+(i+j*2));
            		NdisRawWritePortUshort(
         				pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_IO_CMD_WRITE_PORT,
	            			*pUshort);  
        	}
              DBGPRINT(DBG_FWDL, ("Phase 1 \n"));
			  
        	// Assert the Command Download Over interrupt
        	NdisRawWritePortUchar(
   				    	pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_HOST_STATUS,
		    			CFMACREG_HCR_HS_CmdDnLdOvr);
	    	NdisRawWritePortUshort(
   		    			pCf->ulMrvDrvVirtualIoBase + CFMACREG_HCR_CARD_INT_CAUSE,
        				CFMACREG_HCR_CIC_CmdDnLdOvr);	

        	firmwareDelay = 0; 
	    	do{
	       	NdisRawReadPortUchar(
		       	 	pCf ->ulMrvDrvVirtualIoBase + CFMACREG_CCR_CARD_STATUS,
		        		&ucTemp);

			if ( (ucTemp & CFMACREG_CCR_CS_CmdDnLdRdy) )
				break;

			NdisStallExecution(1);
			
            		firmwareDelay++;
					
        	} while (firmwareDelay < FWBLOCK_DELAY);
          
		if ( firmwareDelay >= FWBLOCK_DELAY )
        	{
            		DBGPRINT(DBG_FWDL|DBG_ERROR,("Downloading FW died on offset 0x%x\n", i));
            		return NDIS_STATUS_FAILURE;
        	}
              DBGPRINT(DBG_FWDL, ("Phase 3\n"));
    	}

    	// Wait for FW initialization finished event
    	firmwareDelay = 0; 
    	do {
		NdisStallExecution(50);  

            	NdisRawReadPortUshort(
	       		pCf ->ulMrvDrvVirtualIoBase + CFMACREG_CCR_SCRATCH_PORT - 1,
              		&usTemp);

		//AllenDBGPRINT(DBG_FWDL,("scratch port = %04x\n", usTemp));
            	ucTemp = (UCHAR)(usTemp >> 8 );
        	
        	if ( ucTemp == MRVDRV_FW_STATUS_READY )
            		break;

        	firmwareDelay++;
    	} while ( firmwareDelay <40000 );
	
       DBGPRINT(DBG_FWDL | DBG_LOAD,("CF started in less than %d ms.\n",firmwareDelay*1000));

      if ( firmwareDelay >= 40000  )
    	{
       	DBGPRINT(DBG_FWDL | DBG_ERROR,("INIT - CF card failed to start!\n"));
        	return NDIS_STATUS_FAILURE;
    	}

	NdisRawReadPortUshort(
	       		pCf ->ulMrvDrvVirtualIoBase + CFMACREG_HCR_HOST_INT_MASK,
           			&usTemp);

	NdisRawWritePortUshort(
    				pCf ->ulMrvDrvVirtualIoBase + CFMACREG_HCR_HOST_INT_MASK, 0 );

    	DBGPRINT(DBG_FWDL|DBG_LOAD,("INIT - Firmware download end\n"));

    	return NDIS_STATUS_SUCCESS;
}