[net-next-2.6.git] / drivers / staging / rtl8192su / r8192S_firmware.c

/**************************************************************************************************
 * Procedure:    Init boot code/firmware code/data session
 *
 * Description: This routine will intialize firmware. If any error occurs during the initialization
 * 		process, the routine shall terminate immediately and return fail.
 *		NIC driver should call NdisOpenFile only from MiniportInitialize.
 *
 * Arguments:   The pointer of the adapter

 * Returns:
 *        NDIS_STATUS_FAILURE - the following initialization process should be terminated
 *        NDIS_STATUS_SUCCESS - if firmware initialization process success
**************************************************************************************************/
#include "r8192U.h"
#include "r8192S_firmware.h"
#include <linux/unistd.h>

#include "r8192S_hw.h"
#include "r8192SU_HWImg.h"

#include <linux/firmware.h>

#define   byte(x,n)  ( (x >> (8 * n)) & 0xff  )

//
// Description:   This routine will intialize firmware. If any error occurs during the initialization
//				process, the routine shall terminate immediately and return fail.
//
// Arguments:   The pointer of the adapter
//			   Code address (Virtual address, should fill descriptor with physical address)
//			   Code size
// Created by Roger, 2008.04.10.
//
bool FirmwareDownloadCode(struct net_device *dev, u8 *	code_virtual_address,u32 buffer_len)
{
	struct r8192_priv   *priv = ieee80211_priv(dev);
	bool 		    rt_status = true;
	u16		    frag_threshold = MAX_FIRMWARE_CODE_SIZE; //Fragmentation might be required in 90/92 but not in 92S
	u16		    frag_length, frag_offset = 0;
	struct sk_buff	    *skb;
	unsigned char	    *seg_ptr;
	cb_desc		    *tcb_desc;
	u8                  	    bLastIniPkt = 0;
	u16 			    ExtraDescOffset = 0;


	RT_TRACE(COMP_FIRMWARE, "--->FirmwareDownloadCode()\n" );

	//MAX_TRANSMIT_BUFFER_SIZE
	if(buffer_len >= MAX_FIRMWARE_CODE_SIZE-USB_HWDESC_HEADER_LEN)
	{
		RT_TRACE(COMP_ERR, "Size over MAX_FIRMWARE_CODE_SIZE! \n");
		goto cmdsend_downloadcode_fail;
	}

	ExtraDescOffset = USB_HWDESC_HEADER_LEN;

	do {
		if((buffer_len-frag_offset) > frag_threshold)
		{
			frag_length = frag_threshold + ExtraDescOffset;
		}
		else
		{
			frag_length = (u16)(buffer_len - frag_offset + ExtraDescOffset);
		bLastIniPkt = 1;
		}

		/* Allocate skb buffer to contain firmware info and tx descriptor info. */
		skb  = dev_alloc_skb(frag_length);
		memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));

		tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
		tcb_desc->queue_index = TXCMD_QUEUE;
		tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
		tcb_desc->bLastIniPkt = bLastIniPkt;

		skb_reserve(skb, ExtraDescOffset);
		seg_ptr = (u8 *)skb_put(skb, (u32)(frag_length-ExtraDescOffset));
		memcpy(seg_ptr, code_virtual_address+frag_offset, (u32)(frag_length-ExtraDescOffset));

		tcb_desc->txbuf_size= frag_length;

		if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)||
			(!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\
			(priv->ieee80211->queue_stop) )
		{
			RT_TRACE(COMP_FIRMWARE,"=====================================================> tx full!\n");
			skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
		}
		else
		{
			priv->ieee80211->softmac_hard_start_xmit(skb,dev);
		}

		frag_offset += (frag_length - ExtraDescOffset);

	}while(frag_offset < buffer_len);

	return rt_status ;


cmdsend_downloadcode_fail:
	rt_status = false;
	RT_TRACE(COMP_ERR, "CmdSendDownloadCode fail !!\n");
	return rt_status;

}


RT_STATUS
FirmwareEnableCPU(struct net_device *dev)
{

	RT_STATUS	rtStatus = RT_STATUS_SUCCESS;
	u8		tmpU1b, CPUStatus = 0;
	u16		tmpU2b;
	u32		iCheckTime = 200;

	RT_TRACE(COMP_FIRMWARE, "-->FirmwareEnableCPU()\n" );
	// Enable CPU.
	tmpU1b = read_nic_byte(dev, SYS_CLKR);
	write_nic_byte(dev,  SYS_CLKR, (tmpU1b|SYS_CPU_CLKSEL)); //AFE source

	tmpU2b = read_nic_word(dev, SYS_FUNC_EN);
	write_nic_word(dev, SYS_FUNC_EN, (tmpU2b|FEN_CPUEN));

	//Polling IMEM Ready after CPU has refilled.
	do
	{
		CPUStatus = read_nic_byte(dev, TCR);
		if(CPUStatus& IMEM_RDY)
		{
			RT_TRACE(COMP_FIRMWARE, "IMEM Ready after CPU has refilled.\n");
			break;
		}

		//usleep(100);
		udelay(100);
	}while(iCheckTime--);

	if(!(CPUStatus & IMEM_RDY))
		return RT_STATUS_FAILURE;

	RT_TRACE(COMP_FIRMWARE, "<--FirmwareEnableCPU(): rtStatus(%#x)\n", rtStatus);
	return rtStatus;
}

FIRMWARE_8192S_STATUS
FirmwareGetNextStatus(FIRMWARE_8192S_STATUS FWCurrentStatus)
{
	FIRMWARE_8192S_STATUS	NextFWStatus = 0;

	switch(FWCurrentStatus)
	{
		case FW_STATUS_INIT:
			NextFWStatus = FW_STATUS_LOAD_IMEM;
			break;

		case FW_STATUS_LOAD_IMEM:
			NextFWStatus = FW_STATUS_LOAD_EMEM;
			break;

		case FW_STATUS_LOAD_EMEM:
			NextFWStatus = FW_STATUS_LOAD_DMEM;
			break;

		case FW_STATUS_LOAD_DMEM:
			NextFWStatus = FW_STATUS_READY;
			break;

		default:
			RT_TRACE(COMP_ERR,"Invalid FW Status(%#x)!!\n", FWCurrentStatus);
			break;
	}
	return	NextFWStatus;
}

bool
FirmwareCheckReady(struct net_device *dev,	u8 LoadFWStatus)
{
	struct r8192_priv 	*priv = ieee80211_priv(dev);
	RT_STATUS	rtStatus = RT_STATUS_SUCCESS;
	rt_firmware	*pFirmware = priv->pFirmware;
	int			PollingCnt = 1000;
	//u8	 	tmpU1b, CPUStatus = 0;
	u8	 	CPUStatus = 0;
	u32		tmpU4b;
	//bool		bOrgIMREnable;

	RT_TRACE(COMP_FIRMWARE, "--->FirmwareCheckReady(): LoadStaus(%d),", LoadFWStatus);

	pFirmware->FWStatus = (FIRMWARE_8192S_STATUS)LoadFWStatus;
	if( LoadFWStatus == FW_STATUS_LOAD_IMEM)
	{
		do
		{//Polling IMEM code done.
			CPUStatus = read_nic_byte(dev, TCR);
			if(CPUStatus& IMEM_CODE_DONE)
				break;

			udelay(5);
		}while(PollingCnt--);
		if(!(CPUStatus & IMEM_CHK_RPT) || PollingCnt <= 0)
		{
			RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_IMEM FAIL CPU, Status=%x\r\n", CPUStatus);
			return false;
		}
	}
	else if( LoadFWStatus == FW_STATUS_LOAD_EMEM)
	{//Check Put Code OK and Turn On CPU
		do
		{//Polling EMEM code done.
			CPUStatus = read_nic_byte(dev, TCR);
			if(CPUStatus& EMEM_CODE_DONE)
				break;

			udelay(5);
		}while(PollingCnt--);
		if(!(CPUStatus & EMEM_CHK_RPT))
		{
			RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_EMEM FAIL CPU, Status=%x\r\n", CPUStatus);
			return false;
		}

		// Turn On CPU
		rtStatus = FirmwareEnableCPU(dev);
		if(rtStatus != RT_STATUS_SUCCESS)
		{
			RT_TRACE(COMP_ERR, "Enable CPU fail ! \n" );
			return false;
		}
	}
	else if( LoadFWStatus == FW_STATUS_LOAD_DMEM)
	{
		do
		{//Polling DMEM code done
			CPUStatus = read_nic_byte(dev, TCR);
			if(CPUStatus& DMEM_CODE_DONE)
				break;

			udelay(5);
		}while(PollingCnt--);

		if(!(CPUStatus & DMEM_CODE_DONE))
		{
			RT_TRACE(COMP_ERR, "Polling  DMEM code done fail ! CPUStatus(%#x)\n", CPUStatus);
			return false;
		}

		RT_TRACE(COMP_FIRMWARE, "DMEM code download success, CPUStatus(%#x)\n", CPUStatus);

//              PollingCnt = 100; // Set polling cycle to 10ms.
              PollingCnt = 10000; // Set polling cycle to 10ms.

		do
		{//Polling Load Firmware ready
			CPUStatus = read_nic_byte(dev, TCR);
			if(CPUStatus & FWRDY)
				break;

			udelay(100);
		}while(PollingCnt--);

		RT_TRACE(COMP_FIRMWARE, "Polling Load Firmware ready, CPUStatus(%x)\n", CPUStatus);

		//if(!(CPUStatus & LOAD_FW_READY))
		//if((CPUStatus & LOAD_FW_READY) != 0xff)
		if((CPUStatus & LOAD_FW_READY) != LOAD_FW_READY)
		{
			RT_TRACE(COMP_ERR, "Polling Load Firmware ready fail ! CPUStatus(%x)\n", CPUStatus);
			return false;
		}

	       //
              // <Roger_Notes> USB interface will update reserved followings parameters later!!
              // 2008.08.28.
              //

	       //
              // <Roger_Notes> If right here, we can set TCR/RCR to desired value
              // and config MAC lookback mode to normal mode. 2008.08.28.
              //
              tmpU4b = read_nic_dword(dev,TCR);
		write_nic_dword(dev, TCR, (tmpU4b&(~TCR_ICV)));

		tmpU4b = read_nic_dword(dev, RCR);
		write_nic_dword(dev, RCR,
			(tmpU4b|RCR_APPFCS|RCR_APP_ICV|RCR_APP_MIC));

		RT_TRACE(COMP_FIRMWARE, "FirmwareCheckReady(): Current RCR settings(%#x)\n", tmpU4b);


		// Set to normal mode.
		write_nic_byte(dev, LBKMD_SEL, LBK_NORMAL);

	}

	RT_TRACE(COMP_FIRMWARE, "<---FirmwareCheckReady(): LoadFWStatus(%d), rtStatus(%x)\n", LoadFWStatus, rtStatus);
	return (rtStatus == RT_STATUS_SUCCESS) ? true:false;
}

//
// Description:   This routine is to update the RF types in FW header partially.
//
// Created by Roger, 2008.12.24.
//
u8 FirmwareHeaderMapRfType(struct net_device *dev)
{
	struct r8192_priv 	*priv = ieee80211_priv(dev);
	switch(priv->rf_type)
	{
		case RF_1T1R: 	return 0x11;
		case RF_1T2R: 	return 0x12;
		case RF_2T2R: 	return 0x22;
		case RF_2T2R_GREEN: 	return 0x92;
		default:
			RT_TRACE(COMP_INIT, "Unknown RF type(%x)\n",priv->rf_type);
			break;
	}
	return 0x22;
}


//
// Description:   This routine is to update the private parts in FW header partially.
//
// Created by Roger, 2008.12.18.
//
void FirmwareHeaderPriveUpdate(struct net_device *dev, PRT_8192S_FIRMWARE_PRIV 	pFwPriv)
{
	struct r8192_priv 	*priv = ieee80211_priv(dev);
	// Update USB endpoint number for RQPN settings.
	pFwPriv->usb_ep_num = priv->EEPROMUsbEndPointNumber; // endpoint number: 4, 6 and 11.
	RT_TRACE(COMP_INIT, "FirmwarePriveUpdate(): usb_ep_num(%#x)\n", pFwPriv->usb_ep_num);

	// Update RF types for RATR settings.
	pFwPriv->rf_config = FirmwareHeaderMapRfType(dev);
}


bool FirmwareDownload92S(struct net_device *dev)
{
	struct r8192_priv 	*priv = ieee80211_priv(dev);
	bool				rtStatus = true;
	const char 		*pFwImageFileName[1] = {"RTL8192SU/rtl8192sfw.bin"};
	u8				*pucMappedFile = NULL;
	u32				ulFileLength, ulInitStep = 0;
	u8				FwHdrSize = RT_8192S_FIRMWARE_HDR_SIZE;
	rt_firmware		*pFirmware = priv->pFirmware;
	u8				FwStatus = FW_STATUS_INIT;
	PRT_8192S_FIRMWARE_HDR		pFwHdr = NULL;
	PRT_8192S_FIRMWARE_PRIV		pFwPriv = NULL;
	int 				rc;
	const struct firmware 	*fw_entry;
	u32				file_length = 0;

	pFirmware->FWStatus = FW_STATUS_INIT;

	RT_TRACE(COMP_FIRMWARE, " --->FirmwareDownload92S()\n");

/*
* Load the firmware from RTL8192SU/rtl8192sfw.bin
*/
	if(pFirmware->szFwTmpBufferLen == 0)
	{
		rc = request_firmware(&fw_entry, pFwImageFileName[ulInitStep],&priv->udev->dev);
			if(rc < 0 ) {
				RT_TRACE(COMP_ERR, "request firmware fail!\n");
				goto DownloadFirmware_Fail;
			}

			if(fw_entry->size > sizeof(pFirmware->szFwTmpBuffer)) {
				RT_TRACE(COMP_ERR, "img file size exceed the container buffer fail!\n");
				release_firmware(fw_entry);
				goto DownloadFirmware_Fail;
			}

			memcpy(pFirmware->szFwTmpBuffer,fw_entry->data,fw_entry->size);
			pFirmware->szFwTmpBufferLen = fw_entry->size;
			release_firmware(fw_entry);

			pucMappedFile = pFirmware->szFwTmpBuffer;
			file_length = pFirmware->szFwTmpBufferLen;

			/* Retrieve FW header. */
			pFirmware->pFwHeader = (PRT_8192S_FIRMWARE_HDR) pucMappedFile;
			pFwHdr = pFirmware->pFwHeader;
			RT_TRACE(COMP_FIRMWARE,"signature:%x, version:%x, size:%x, imemsize:%x, sram size:%x\n", \
					pFwHdr->Signature, pFwHdr->Version, pFwHdr->DMEMSize, \
					pFwHdr->IMG_IMEM_SIZE, pFwHdr->IMG_SRAM_SIZE);
			pFirmware->FirmwareVersion =  byte(pFwHdr->Version ,0);
			if ((pFwHdr->IMG_IMEM_SIZE==0) || (pFwHdr->IMG_IMEM_SIZE > sizeof(pFirmware->FwIMEM))) {
				RT_TRACE(COMP_ERR, "%s: memory for data image is less than IMEM required\n",\
					__FUNCTION__);
				goto DownloadFirmware_Fail;
			} else {
				pucMappedFile+=FwHdrSize;
				/* Retrieve IMEM image. */
				memcpy(pFirmware->FwIMEM, pucMappedFile, pFwHdr->IMG_IMEM_SIZE);
				pFirmware->FwIMEMLen = pFwHdr->IMG_IMEM_SIZE;
			}

			if (pFwHdr->IMG_SRAM_SIZE > sizeof(pFirmware->FwEMEM)) {
				RT_TRACE(COMP_ERR, "%s: memory for data image is less than EMEM required\n",\
					__FUNCTION__);
					goto DownloadFirmware_Fail;
				} else {
					pucMappedFile += pFirmware->FwIMEMLen;
					/* Retriecve EMEM image */
					memcpy(pFirmware->FwEMEM, pucMappedFile, pFwHdr->IMG_SRAM_SIZE);//===>6
					pFirmware->FwEMEMLen = pFwHdr->IMG_SRAM_SIZE;
				}
	}

	FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus);
	while(FwStatus!= FW_STATUS_READY)
	{
		// Image buffer redirection.
		switch(FwStatus)
		{
			case FW_STATUS_LOAD_IMEM:
				pucMappedFile = pFirmware->FwIMEM;
				ulFileLength = pFirmware->FwIMEMLen;
				break;

			case FW_STATUS_LOAD_EMEM:
				pucMappedFile = pFirmware->FwEMEM;
				ulFileLength = pFirmware->FwEMEMLen;
				break;

			case FW_STATUS_LOAD_DMEM:
				/* <Roger_Notes> Partial update the content of header private. 2008.12.18 */
                                pFwHdr = pFirmware->pFwHeader;
                                pFwPriv = (PRT_8192S_FIRMWARE_PRIV)&pFwHdr->FWPriv;
				FirmwareHeaderPriveUpdate(dev, pFwPriv);
				pucMappedFile = (u8*)(pFirmware->pFwHeader)+RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE;
				ulFileLength = FwHdrSize-RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE;
				break;

			default:
				RT_TRACE(COMP_ERR, "Unexpected Download step!!\n");
				goto DownloadFirmware_Fail;
				break;
		}

		//3//
		//3// <2> Download image file
	//3	//
		rtStatus = FirmwareDownloadCode(dev, pucMappedFile, ulFileLength);

		if(rtStatus != true)
		{
			RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n" );
			goto DownloadFirmware_Fail;
		}

		//3//
		//3// <3> Check whether load FW process is ready
	//3	//
		rtStatus = FirmwareCheckReady(dev, FwStatus);

		if(rtStatus != true)
		{
			RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n");
			goto DownloadFirmware_Fail;
		}

		FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus);
	}

	RT_TRACE(COMP_FIRMWARE, "Firmware Download Success!!\n");
	return rtStatus;

	DownloadFirmware_Fail:
	RT_TRACE(COMP_ERR, "Firmware Download Fail!!%x\n",read_nic_word(dev, TCR));
	rtStatus = false;
	return rtStatus;
}

MODULE_FIRMWARE("RTL8192SU/rtl8192sfw.bin");
Commit	Line	Data
5f53d8ca JC	1	/**************************************************************************************************
	2	* Procedure: Init boot code/firmware code/data session
	3	*
	4	* Description: This routine will intialize firmware. If any error occurs during the initialization
	5	* process, the routine shall terminate immediately and return fail.
	6	* NIC driver should call NdisOpenFile only from MiniportInitialize.
	7	*
	8	* Arguments: The pointer of the adapter
	9
	10	* Returns:
	11	* NDIS_STATUS_FAILURE - the following initialization process should be terminated
	12	* NDIS_STATUS_SUCCESS - if firmware initialization process success
	13	**************************************************************************************************/
5f53d8ca JC	14	#include "r8192U.h"
	15	#include "r8192S_firmware.h"
	16	#include <linux/unistd.h>
	17
5f53d8ca JC	18	#include "r8192S_hw.h"
5f53d8ca JC	19	#include "r8192SU_HWImg.h"
5f53d8ca	20
5f53d8ca	21	#include <linux/firmware.h>
5f53d8ca JC	22
	23	#define byte(x,n) ( (x >> (8 * n)) & 0xff )
	24
	25	//
	26	// Description: This routine will intialize firmware. If any error occurs during the initialization
	27	// process, the routine shall terminate immediately and return fail.
	28	//
	29	// Arguments: The pointer of the adapter
	30	// Code address (Virtual address, should fill descriptor with physical address)
	31	// Code size
	32	// Created by Roger, 2008.04.10.
	33	//
	34	bool FirmwareDownloadCode(struct net_device dev, u8 code_virtual_address,u32 buffer_len)
	35	{
	36	struct r8192_priv *priv = ieee80211_priv(dev);
	37	bool rt_status = true;
	38	u16 frag_threshold = MAX_FIRMWARE_CODE_SIZE; //Fragmentation might be required in 90/92 but not in 92S
	39	u16 frag_length, frag_offset = 0;
	40	struct sk_buff *skb;
	41	unsigned char *seg_ptr;
	42	cb_desc *tcb_desc;
	43	u8 bLastIniPkt = 0;
	44	u16 ExtraDescOffset = 0;
	45
5f53d8ca JC	46
	47	RT_TRACE(COMP_FIRMWARE, "--->FirmwareDownloadCode()\n" );
	48
	49	//MAX_TRANSMIT_BUFFER_SIZE
	50	if(buffer_len >= MAX_FIRMWARE_CODE_SIZE-USB_HWDESC_HEADER_LEN)
	51	{
	52	RT_TRACE(COMP_ERR, "Size over MAX_FIRMWARE_CODE_SIZE! \n");
	53	goto cmdsend_downloadcode_fail;
	54	}
	55
	56	ExtraDescOffset = USB_HWDESC_HEADER_LEN;
	57
	58	do {
	59	if((buffer_len-frag_offset) > frag_threshold)
	60	{
	61	frag_length = frag_threshold + ExtraDescOffset;
	62	}
	63	else
	64	{
	65	frag_length = (u16)(buffer_len - frag_offset + ExtraDescOffset);
	66	bLastIniPkt = 1;
	67	}
	68
	69	/* Allocate skb buffer to contain firmware info and tx descriptor info. */
	70	skb = dev_alloc_skb(frag_length);
	71	memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
	72
	73	tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
	74	tcb_desc->queue_index = TXCMD_QUEUE;
	75	tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
	76	tcb_desc->bLastIniPkt = bLastIniPkt;
	77
	78	skb_reserve(skb, ExtraDescOffset);
	79	seg_ptr = (u8 *)skb_put(skb, (u32)(frag_length-ExtraDescOffset));
	80	memcpy(seg_ptr, code_virtual_address+frag_offset, (u32)(frag_length-ExtraDescOffset));
	81
	82	tcb_desc->txbuf_size= frag_length;
	83
	84	if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)\|\|
	85	(!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))\|\|\
	86	(priv->ieee80211->queue_stop) )
	87	{
	88	RT_TRACE(COMP_FIRMWARE,"=====================================================> tx full!\n");
	89	skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
	90	}
	91	else
	92	{
	93	priv->ieee80211->softmac_hard_start_xmit(skb,dev);
	94	}
	95
	96	frag_offset += (frag_length - ExtraDescOffset);
	97
	98	}while(frag_offset < buffer_len);
	99
	100	return rt_status ;
	101
	102
	103	cmdsend_downloadcode_fail:
	104	rt_status = false;
	105	RT_TRACE(COMP_ERR, "CmdSendDownloadCode fail !!\n");
	106	return rt_status;
	107
	108	}
	109
5f53d8ca JC	110
	111	RT_STATUS
	112	FirmwareEnableCPU(struct net_device *dev)
	113	{
	114
	115	RT_STATUS rtStatus = RT_STATUS_SUCCESS;
	116	u8 tmpU1b, CPUStatus = 0;
	117	u16 tmpU2b;
	118	u32 iCheckTime = 200;
	119
	120	RT_TRACE(COMP_FIRMWARE, "-->FirmwareEnableCPU()\n" );
5f53d8ca JC	121	// Enable CPU.
	122	tmpU1b = read_nic_byte(dev, SYS_CLKR);
	123	write_nic_byte(dev, SYS_CLKR, (tmpU1b\|SYS_CPU_CLKSEL)); //AFE source
	124
	125	tmpU2b = read_nic_word(dev, SYS_FUNC_EN);
	126	write_nic_word(dev, SYS_FUNC_EN, (tmpU2b\|FEN_CPUEN));
	127
	128	//Polling IMEM Ready after CPU has refilled.
	129	do
	130	{
	131	CPUStatus = read_nic_byte(dev, TCR);
	132	if(CPUStatus& IMEM_RDY)
	133	{
	134	RT_TRACE(COMP_FIRMWARE, "IMEM Ready after CPU has refilled.\n");
	135	break;
	136	}
	137
	138	//usleep(100);
	139	udelay(100);
	140	}while(iCheckTime--);
	141
	142	if(!(CPUStatus & IMEM_RDY))
	143	return RT_STATUS_FAILURE;
	144
	145	RT_TRACE(COMP_FIRMWARE, "<--FirmwareEnableCPU(): rtStatus(%#x)\n", rtStatus);
	146	return rtStatus;
	147	}
	148
	149	FIRMWARE_8192S_STATUS
	150	FirmwareGetNextStatus(FIRMWARE_8192S_STATUS FWCurrentStatus)
	151	{
	152	FIRMWARE_8192S_STATUS NextFWStatus = 0;
	153
	154	switch(FWCurrentStatus)
	155	{
	156	case FW_STATUS_INIT:
	157	NextFWStatus = FW_STATUS_LOAD_IMEM;
	158	break;
	159
	160	case FW_STATUS_LOAD_IMEM:
	161	NextFWStatus = FW_STATUS_LOAD_EMEM;
	162	break;
	163
	164	case FW_STATUS_LOAD_EMEM:
	165	NextFWStatus = FW_STATUS_LOAD_DMEM;
	166	break;
	167
	168	case FW_STATUS_LOAD_DMEM:
	169	NextFWStatus = FW_STATUS_READY;
	170	break;
	171
	172	default:
	173	RT_TRACE(COMP_ERR,"Invalid FW Status(%#x)!!\n", FWCurrentStatus);
	174	break;
	175	}
	176	return NextFWStatus;
	177	}
	178
	179	bool
	180	FirmwareCheckReady(struct net_device *dev, u8 LoadFWStatus)
	181	{
	182	struct r8192_priv *priv = ieee80211_priv(dev);
	183	RT_STATUS rtStatus = RT_STATUS_SUCCESS;
	184	rt_firmware *pFirmware = priv->pFirmware;
185	int PollingCnt = 1000;
186	//u8 tmpU1b, CPUStatus = 0;
187	u8 CPUStatus = 0;
188	u32 tmpU4b;
189	//bool bOrgIMREnable;
190
191	RT_TRACE(COMP_FIRMWARE, "--->FirmwareCheckReady(): LoadStaus(%d),", LoadFWStatus);
192
193	pFirmware->FWStatus = (FIRMWARE_8192S_STATUS)LoadFWStatus;
194	if( LoadFWStatus == FW_STATUS_LOAD_IMEM)
195	{
196	do
197	{//Polling IMEM code done.
198	CPUStatus = read_nic_byte(dev, TCR);
199	if(CPUStatus& IMEM_CODE_DONE)
200	break;
201
202	udelay(5);
203	}while(PollingCnt--);
204	if(!(CPUStatus & IMEM_CHK_RPT) \|\| PollingCnt <= 0)
205	{
206	RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_IMEM FAIL CPU, Status=%x\r\n", CPUStatus);
207	return false;
208	}
209	}
210	else if( LoadFWStatus == FW_STATUS_LOAD_EMEM)
211	{//Check Put Code OK and Turn On CPU
212	do
213	{//Polling EMEM code done.
214	CPUStatus = read_nic_byte(dev, TCR);
215	if(CPUStatus& EMEM_CODE_DONE)
216	break;
217
218	udelay(5);
219	}while(PollingCnt--);
220	if(!(CPUStatus & EMEM_CHK_RPT))
221	{
222	RT_TRACE(COMP_ERR, "FW_STATUS_LOAD_EMEM FAIL CPU, Status=%x\r\n", CPUStatus);
223	return false;
224	}
225
226	// Turn On CPU
227	rtStatus = FirmwareEnableCPU(dev);
228	if(rtStatus != RT_STATUS_SUCCESS)
229	{
230	RT_TRACE(COMP_ERR, "Enable CPU fail ! \n" );
231	return false;
232	}
233	}
234	else if( LoadFWStatus == FW_STATUS_LOAD_DMEM)
235	{
236	do
237	{//Polling DMEM code done
238	CPUStatus = read_nic_byte(dev, TCR);
239	if(CPUStatus& DMEM_CODE_DONE)
240	break;
241
242	udelay(5);
243	}while(PollingCnt--);
244
245	if(!(CPUStatus & DMEM_CODE_DONE))
246	{
247	RT_TRACE(COMP_ERR, "Polling DMEM code done fail ! CPUStatus(%#x)\n", CPUStatus);
248	return false;
249	}
250
251	RT_TRACE(COMP_FIRMWARE, "DMEM code download success, CPUStatus(%#x)\n", CPUStatus);
252
253	// PollingCnt = 100; // Set polling cycle to 10ms.
254	PollingCnt = 10000; // Set polling cycle to 10ms.
255
256	do
257	{//Polling Load Firmware ready
258	CPUStatus = read_nic_byte(dev, TCR);
259	if(CPUStatus & FWRDY)
260	break;
261
262	udelay(100);
263	}while(PollingCnt--);
264
265	RT_TRACE(COMP_FIRMWARE, "Polling Load Firmware ready, CPUStatus(%x)\n", CPUStatus);
266
267	//if(!(CPUStatus & LOAD_FW_READY))
268	//if((CPUStatus & LOAD_FW_READY) != 0xff)
269	if((CPUStatus & LOAD_FW_READY) != LOAD_FW_READY)
270	{
271	RT_TRACE(COMP_ERR, "Polling Load Firmware ready fail ! CPUStatus(%x)\n", CPUStatus);
272	return false;
273	}
274
275	//
276	// <Roger_Notes> USB interface will update reserved followings parameters later!!
277	// 2008.08.28.
278	//
5f53d8ca JC	279
	280	//
	281	// <Roger_Notes> If right here, we can set TCR/RCR to desired value
	282	// and config MAC lookback mode to normal mode. 2008.08.28.
	283	//
	284	tmpU4b = read_nic_dword(dev,TCR);
	285	write_nic_dword(dev, TCR, (tmpU4b&(~TCR_ICV)));
	286
	287	tmpU4b = read_nic_dword(dev, RCR);
	288	write_nic_dword(dev, RCR,
	289	(tmpU4b\|RCR_APPFCS\|RCR_APP_ICV\|RCR_APP_MIC));
	290
	291	RT_TRACE(COMP_FIRMWARE, "FirmwareCheckReady(): Current RCR settings(%#x)\n", tmpU4b);
	292
5f53d8ca JC	293
	294	// Set to normal mode.
	295	write_nic_byte(dev, LBKMD_SEL, LBK_NORMAL);
	296
	297	}
	298
	299	RT_TRACE(COMP_FIRMWARE, "<---FirmwareCheckReady(): LoadFWStatus(%d), rtStatus(%x)\n", LoadFWStatus, rtStatus);
	300	return (rtStatus == RT_STATUS_SUCCESS) ? true:false;
	301	}
	302
	303	//
	304	// Description: This routine is to update the RF types in FW header partially.
	305	//
	306	// Created by Roger, 2008.12.24.
	307	//
	308	u8 FirmwareHeaderMapRfType(struct net_device *dev)
	309	{
	310	struct r8192_priv *priv = ieee80211_priv(dev);
	311	switch(priv->rf_type)
	312	{
	313	case RF_1T1R: return 0x11;
	314	case RF_1T2R: return 0x12;
	315	case RF_2T2R: return 0x22;
	316	case RF_2T2R_GREEN: return 0x92;
	317	default:
	318	RT_TRACE(COMP_INIT, "Unknown RF type(%x)\n",priv->rf_type);
	319	break;
	320	}
	321	return 0x22;
	322	}
	323
	324
	325	//
	326	// Description: This routine is to update the private parts in FW header partially.
	327	//
	328	// Created by Roger, 2008.12.18.
	329	//
	330	void FirmwareHeaderPriveUpdate(struct net_device *dev, PRT_8192S_FIRMWARE_PRIV pFwPriv)
	331	{
	332	struct r8192_priv *priv = ieee80211_priv(dev);
5f53d8ca JC	333	// Update USB endpoint number for RQPN settings.
	334	pFwPriv->usb_ep_num = priv->EEPROMUsbEndPointNumber; // endpoint number: 4, 6 and 11.
	335	RT_TRACE(COMP_INIT, "FirmwarePriveUpdate(): usb_ep_num(%#x)\n", pFwPriv->usb_ep_num);
5f53d8ca JC	336
	337	// Update RF types for RATR settings.
	338	pFwPriv->rf_config = FirmwareHeaderMapRfType(dev);
	339	}
	340
	341
	342
	343	bool FirmwareDownload92S(struct net_device *dev)
	344	{
	345	struct r8192_priv *priv = ieee80211_priv(dev);
	346	bool rtStatus = true;
	347	const char *pFwImageFileName[1] = {"RTL8192SU/rtl8192sfw.bin"};
	348	u8 *pucMappedFile = NULL;
	349	u32 ulFileLength, ulInitStep = 0;
	350	u8 FwHdrSize = RT_8192S_FIRMWARE_HDR_SIZE;
	351	rt_firmware *pFirmware = priv->pFirmware;
	352	u8 FwStatus = FW_STATUS_INIT;
	353	PRT_8192S_FIRMWARE_HDR pFwHdr = NULL;
	354	PRT_8192S_FIRMWARE_PRIV pFwPriv = NULL;
	355	int rc;
	356	const struct firmware *fw_entry;
	357	u32 file_length = 0;
	358
	359	pFirmware->FWStatus = FW_STATUS_INIT;
	360
	361	RT_TRACE(COMP_FIRMWARE, " --->FirmwareDownload92S()\n");
	362
2f225608 FS	363	/*
	364	* Load the firmware from RTL8192SU/rtl8192sfw.bin
	365	*/
	366	if(pFirmware->szFwTmpBufferLen == 0)
5f53d8ca	367	{
2f225608 FS	368	rc = request_firmware(&fw_entry, pFwImageFileName[ulInitStep],&priv->udev->dev);
	369	if(rc < 0 ) {
	370	RT_TRACE(COMP_ERR, "request firmware fail!\n");
	371	goto DownloadFirmware_Fail;
	372	}
5f53d8ca	373
2f225608 FS	374	if(fw_entry->size > sizeof(pFirmware->szFwTmpBuffer)) {
2f225608 FS	375	RT_TRACE(COMP_ERR, "img file size exceed the container buffer fail!\n");
5f53d8ca	376	release_firmware(fw_entry);
2f225608	377	goto DownloadFirmware_Fail;
5f53d8ca	378	}
5f53d8ca	379
2f225608 FS	380	memcpy(pFirmware->szFwTmpBuffer,fw_entry->data,fw_entry->size);
	381	pFirmware->szFwTmpBufferLen = fw_entry->size;
	382	release_firmware(fw_entry);
	383
	384	pucMappedFile = pFirmware->szFwTmpBuffer;
	385	file_length = pFirmware->szFwTmpBufferLen;
5f53d8ca	386
2f225608	387	/* Retrieve FW header. */
5f53d8ca JC	388	pFirmware->pFwHeader = (PRT_8192S_FIRMWARE_HDR) pucMappedFile;
	389	pFwHdr = pFirmware->pFwHeader;
	390	RT_TRACE(COMP_FIRMWARE,"signature:%x, version:%x, size:%x, imemsize:%x, sram size:%x\n", \
	391	pFwHdr->Signature, pFwHdr->Version, pFwHdr->DMEMSize, \
	392	pFwHdr->IMG_IMEM_SIZE, pFwHdr->IMG_SRAM_SIZE);
	393	pFirmware->FirmwareVersion = byte(pFwHdr->Version ,0);
2f225608 FS	394	if ((pFwHdr->IMG_IMEM_SIZE==0) \|\| (pFwHdr->IMG_IMEM_SIZE > sizeof(pFirmware->FwIMEM))) {
	395	RT_TRACE(COMP_ERR, "%s: memory for data image is less than IMEM required\n",\
	396	__FUNCTION__);
5f53d8ca JC	397	goto DownloadFirmware_Fail;
	398	} else {
	399	pucMappedFile+=FwHdrSize;
2f225608	400	/* Retrieve IMEM image. */
5f53d8ca JC	401	memcpy(pFirmware->FwIMEM, pucMappedFile, pFwHdr->IMG_IMEM_SIZE);
	402	pFirmware->FwIMEMLen = pFwHdr->IMG_IMEM_SIZE;
	403	}
	404
2f225608 FS	405	if (pFwHdr->IMG_SRAM_SIZE > sizeof(pFirmware->FwEMEM)) {
	406	RT_TRACE(COMP_ERR, "%s: memory for data image is less than EMEM required\n",\
	407	__FUNCTION__);
	408	goto DownloadFirmware_Fail;
	409	} else {
	410	pucMappedFile += pFirmware->FwIMEMLen;
	411	/* Retriecve EMEM image */
	412	memcpy(pFirmware->FwEMEM, pucMappedFile, pFwHdr->IMG_SRAM_SIZE);//===>6
	413	pFirmware->FwEMEMLen = pFwHdr->IMG_SRAM_SIZE;
	414	}
5f53d8ca JC	415	}
	416
	417	FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus);
	418	while(FwStatus!= FW_STATUS_READY)
	419	{
	420	// Image buffer redirection.
	421	switch(FwStatus)
	422	{
	423	case FW_STATUS_LOAD_IMEM:
	424	pucMappedFile = pFirmware->FwIMEM;
	425	ulFileLength = pFirmware->FwIMEMLen;
	426	break;
	427
	428	case FW_STATUS_LOAD_EMEM:
	429	pucMappedFile = pFirmware->FwEMEM;
	430	ulFileLength = pFirmware->FwEMEMLen;
	431	break;
	432
	433	case FW_STATUS_LOAD_DMEM:
	434	/* <Roger_Notes> Partial update the content of header private. 2008.12.18 */
	435	pFwHdr = pFirmware->pFwHeader;
	436	pFwPriv = (PRT_8192S_FIRMWARE_PRIV)&pFwHdr->FWPriv;
	437	FirmwareHeaderPriveUpdate(dev, pFwPriv);
	438	pucMappedFile = (u8*)(pFirmware->pFwHeader)+RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE;
	439	ulFileLength = FwHdrSize-RT_8192S_FIRMWARE_HDR_EXCLUDE_PRI_SIZE;
	440	break;
	441
	442	default:
	443	RT_TRACE(COMP_ERR, "Unexpected Download step!!\n");
	444	goto DownloadFirmware_Fail;
	445	break;
	446	}
	447
	448	//3//
	449	//3// <2> Download image file
	450	//3 //
	451	rtStatus = FirmwareDownloadCode(dev, pucMappedFile, ulFileLength);
	452
	453	if(rtStatus != true)
	454	{
	455	RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n" );
	456	goto DownloadFirmware_Fail;
	457	}
	458
	459	//3//
	460	//3// <3> Check whether load FW process is ready
	461	//3 //
	462	rtStatus = FirmwareCheckReady(dev, FwStatus);
	463
	464	if(rtStatus != true)
	465	{
	466	RT_TRACE(COMP_ERR, "FirmwareDownloadCode() fail ! \n");
	467	goto DownloadFirmware_Fail;
	468	}
	469
	470	FwStatus = FirmwareGetNextStatus(pFirmware->FWStatus);
	471	}
	472
	473	RT_TRACE(COMP_FIRMWARE, "Firmware Download Success!!\n");
	474	return rtStatus;
	475
	476	DownloadFirmware_Fail:
	477	RT_TRACE(COMP_ERR, "Firmware Download Fail!!%x\n",read_nic_word(dev, TCR));
	478	rtStatus = false;
479	return rtStatus;
480	}
5f53d8ca	481
5d929a71	482	MODULE_FIRMWARE("RTL8192SU/rtl8192sfw.bin");