rtmp_init.c

TP Link 321 Linux Driver

	pAd->WlanCounters.TransmittedFragmentCount.vv.LowPart += (StaCsr4.field.TxOneRetryCount + StaCsr4.field.TxNoRetryCount + StaCsr5.field.TxMultiRetryCount);
	if (pAd->WlanCounters.TransmittedFragmentCount.vv.LowPart < OldValue)
	{
		pAd->WlanCounters.TransmittedFragmentCount.vv.HighPart++;
	}

	// 2rd	-success and no retry
	OldValue = pAd->WlanCounters.RetryCount.vv.LowPart;
	pAd->WlanCounters.NoRetryCount.vv.LowPart += StaCsr4.field.TxNoRetryCount;
	if (pAd->WlanCounters.NoRetryCount.vv.LowPart < OldValue)
	{
		pAd->WlanCounters.NoRetryCount.vv.HighPart++;
	}

	// 3rd	-success and retry
	OldValue = pAd->WlanCounters.RetryCount.vv.LowPart;
	pAd->WlanCounters.RetryCount.vv.LowPart += (StaCsr4.field.TxOneRetryCount  +StaCsr5.field.TxMultiRetryCount);
	if (pAd->WlanCounters.RetryCount.vv.LowPart < OldValue)
	{
		pAd->WlanCounters.RetryCount.vv.HighPart++;
	}
	// 4th - fail
	OldValue = pAd->WlanCounters.FailedCount.vv.LowPart;
	pAd->WlanCounters.FailedCount.vv.LowPart += StaCsr5.field.TxRetryFailCount;
	if (pAd->WlanCounters.FailedCount.vv.LowPart < OldValue)
	{
		pAd->WlanCounters.FailedCount.vv.HighPart++;
	}	

	
	pAd->RalinkCounters.OneSecTxNoRetryOkCount = StaCsr4.field.TxNoRetryCount;
	pAd->RalinkCounters.OneSecTxRetryOkCount = StaCsr4.field.TxOneRetryCount + StaCsr5.field.TxMultiRetryCount;
	pAd->RalinkCounters.OneSecTxFailCount = StaCsr5.field.TxRetryFailCount;
	pAd->RalinkCounters.OneSecFalseCCACnt = StaCsr1.field.FalseCca;
	pAd->RalinkCounters.OneSecRxOkCnt = pAd->RalinkCounters.RxCount;
	pAd->RalinkCounters.RxCount = 0; //Reset RxCount
	pAd->RalinkCounters.OneSecRxFcsErrCnt = StaCsr0.field.CrcErr;
	pAd->RalinkCounters.OneSecBeaconSentCnt = StaCsr3.field.TxBeaconCount;
}

/*
	========================================================================
	
	Routine Description:
		Reset NIC from error

	Arguments:
		Adapter						Pointer to our adapter

	Return Value:
		None

	Note:
		Reset NIC from error state
		
	========================================================================
*/
VOID NICResetFromError(
	IN	PRTMP_ADAPTER	pAd)
{
	NICInitializeAsic(pAd);
#ifdef	INIT_FROM_EEPROM
	NICInitAsicFromEEPROM(pAd);
#endif
	RTUSBWriteHWMACAddress(pAd);
	
}

/*
	========================================================================
	
	Routine Description:
		Load 8051 firmware RT2561.BIN file into MAC ASIC

	Arguments:
		Adapter						Pointer to our adapter

	Return Value:
		NDIS_STATUS_SUCCESS 		firmware image load ok
		NDIS_STATUS_FAILURE 		image not found

	========================================================================
*/
NDIS_STATUS NICLoadFirmware(
	IN PRTMP_ADAPTER pAd)
{
	NDIS_STATUS				Status = NDIS_STATUS_SUCCESS;
	PUCHAR					src = NULL;
	struct file				*srcf;
	INT 					retval = 0, orgfsuid, orgfsgid, i;
	mm_segment_t			orgfs;
	PUCHAR					pFirmwareImage;
	UINT					FileLength = 0;
	INT						ret;					

	
	DBGPRINT(RT_DEBUG_TRACE,"--> NICLoadFirmware\n");
	pAd->FirmwareVersion = (FIRMWARE_MAJOR_VERSION << 8) + FIRMWARE_MINOR_VERSION; //default version.

	src = RT2573_IMAGE_FILE_NAME;

	// Save uid and gid used for filesystem access.
	// Set user and group to 0 (root)	
	orgfsuid = current->fsuid;
	orgfsgid = current->fsgid;
	current->fsuid=current->fsgid = 0;
	orgfs = get_fs();
	set_fs(KERNEL_DS);
		
	pFirmwareImage = kmalloc(MAX_FIRMWARE_IMAGE_SIZE, MEM_ALLOC_FLAG);
	if (pFirmwareImage == NULL) 
	{
		DBGPRINT(RT_DEBUG_ERROR, "NICLoadFirmware-Memory allocate fail\n");
		Status = NDIS_STATUS_FAILURE;
		goto out;
	}

	if (src && *src) 
	{
		srcf = filp_open(src, O_RDONLY, 0);
		if (IS_ERR(srcf)) 
		{
			Status = NDIS_STATUS_FAILURE;
			DBGPRINT(RT_DEBUG_ERROR, "--> Error %ld opening %s\n", -PTR_ERR(srcf),src);    
		}
		else 
		{
			// The object must have a read method
			if (srcf->f_op && srcf->f_op->read) 
			{
				memset(pFirmwareImage, 0x00, MAX_FIRMWARE_IMAGE_SIZE);

				FileLength = srcf->f_op->read(srcf, pFirmwareImage, MAX_FIRMWARE_IMAGE_SIZE, &srcf->f_pos);
				if (FileLength != MAX_FIRMWARE_IMAGE_SIZE)
				{
					DBGPRINT_ERR("NICLoadFirmware: error file length (=%d) in rt73.bin\n",FileLength);
					Status = NDIS_STATUS_FAILURE;
				}
				else
				{  //FileLength == MAX_FIRMWARE_IMAGE_SIZE
					PUCHAR ptr = pFirmwareImage;
					USHORT crc = 0;
					
					for (i=0; i<(MAX_FIRMWARE_IMAGE_SIZE-2); i++, ptr++)
						crc = ByteCRC16(*ptr, crc);
					crc = ByteCRC16(0x00, crc);
					crc = ByteCRC16(0x00, crc);
					
					if ((pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-2] != (UCHAR)(crc>>8)) ||
						(pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-1] != (UCHAR)(crc)))
					{
						DBGPRINT_ERR("NICLoadFirmware: CRC = 0x%02x 0x%02x error, should be 0x%02x 0x%02x\n",
							pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-2], pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-1],
							(UCHAR)(crc>>8), (UCHAR)(crc) );

						if (retval)
						{
							DBGPRINT(RT_DEBUG_ERROR, "--> Error %d closing %s\n", -retval, src);
						}

						Status = NDIS_STATUS_FAILURE;
					}
					else
					{

						if ((pAd->FirmwareVersion) > ((pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-4] << 8) + pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-3]))
						{
							DBGPRINT_ERR("NICLoadFirmware: Ver=%d.%d, local Ver=%d.%d, used FirmwareImage talbe instead\n",
								pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-4], pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-3],
								FIRMWARE_MAJOR_VERSION, FIRMWARE_MINOR_VERSION);

							Status = NDIS_STATUS_FAILURE;
						}
						else
						{
							pAd->FirmwareVersion = (pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-4] << 8) + pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-3];
							DBGPRINT(RT_DEBUG_TRACE,"NICLoadFirmware OK: CRC = 0x%04x ver=%d.%d\n", crc,
								pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-4], pFirmwareImage[MAX_FIRMWARE_IMAGE_SIZE-3]);
						}

					}
				}
			}
			else
			{
				Status = NDIS_STATUS_FAILURE;
				DBGPRINT(RT_DEBUG_ERROR, "--> %s does not have a write method\n", src);
			}
			
			retval = filp_close(srcf, NULL);			
			if (retval)
			{
				Status = NDIS_STATUS_FAILURE;
				DBGPRINT(RT_DEBUG_ERROR, "--> Error %d closing %s\n", -retval, src);
			}
		}
	}
	else
	{
		Status = NDIS_STATUS_FAILURE;
		DBGPRINT(RT_DEBUG_ERROR, "Error src not available\n");
	}


	if (Status != NDIS_STATUS_SUCCESS)
	{	
		FileLength = FIRMAREIMAGE_LENGTH;
		memset(pFirmwareImage, 0x00, FileLength);
		NdisMoveMemory(pFirmwareImage, &FirmwareImage[0], FileLength);
		Status = NDIS_STATUS_SUCCESS; // change to success
		
		DBGPRINT(RT_DEBUG_ERROR, "NICLoadFirmware failed, used local Firmware(v %d.%d) instead\n", 
				FIRMWARE_MAJOR_VERSION, FIRMWARE_MINOR_VERSION);		
	}

	// select 8051 program bank; write entire firmware image
	for (i = 0; i < FileLength; i = i + 4)
	{
		ret = RTUSBMultiWrite(pAd, FIRMWARE_IMAGE_BASE + i, pFirmwareImage + i, 4);

		if (ret < 0)
		{
			Status = NDIS_STATUS_FAILURE;
			break;
		}
	}


out:	
	if (pFirmwareImage != NULL)
		kfree(pFirmwareImage);

	set_fs(orgfs);
	current->fsuid = orgfsuid;
	current->fsgid = orgfsgid;

	if (Status == NDIS_STATUS_SUCCESS)
	{
		RTUSBFirmwareRun(pAd);
		
		//
		// Send LED command to Firmare after RTUSBFirmwareRun;
		//
		RTMPSetLED(pAd, LED_LINK_DOWN);

	}		

	DBGPRINT(RT_DEBUG_TRACE,"<-- NICLoadFirmware (src=%s)\n", src);  
	

	return Status;
}

/*
	========================================================================

	Routine Description:
		Find key section for Get key parameter.

	Arguments:
		buffer						Pointer to the buffer to start find the key section
		section 					the key of the secion to be find

	Return Value:
		NULL						Fail
		Others						Success
	========================================================================
*/
PUCHAR RTMPFindSection(
	IN	PCHAR	buffer)
{
	CHAR temp_buf[255];
	PUCHAR	ptr;

	strcpy(temp_buf, "[");					/*	and the opening bracket [  */
	strcat(temp_buf, "Default");
	strcat(temp_buf, "]");

  
	if((ptr = rtstrstr(buffer, temp_buf)) != NULL)
			return (ptr+strlen("\n"));
		else
			return NULL;
}

 /**
  * strstr - Find the first substring in a %NUL terminated string
  * @s1: The string to be searched
  * @s2: The string to search for
  */
char * rtstrstr(const char * s1,const char * s2)
{
	INT l1, l2;

	l2 = strlen(s2);
	if (!l2)
		return (char *) s1;
	
	l1 = strlen(s1);
	
	while (l1 >= l2)
	{
		l1--;
		if (!memcmp(s1,s2,l2))
			return (char *) s1;
		s1++;
	}
	
	return NULL;
}

/**
 * rstrtok - Split a string into tokens
 * @s: The string to be searched
 * @ct: The characters to search for
 * * WARNING: strtok is deprecated, use strsep instead. However strsep is not compatible with old architecture.
 */
char * __rstrtok;
char * rstrtok(char * s,const char * ct)
{
	char *sbegin, *send;

	sbegin  = s ? s : __rstrtok;
	if (!sbegin)
	{
		return NULL;
	}

	sbegin += strspn(sbegin,ct);
	if (*sbegin == '\0')
	{
		__rstrtok = NULL;
		return( NULL );
	}

	send = strpbrk( sbegin, ct);
	if (send && *send != '\0')
		*send++ = '\0';

	__rstrtok = send;

	return (sbegin);
}

/*
	========================================================================

	Routine Description:
		Get key parameter.

	Arguments:
		key 						Pointer to key string
		dest						Pointer to destination		
		destsize					The datasize of the destination
		buffer						Pointer to the buffer to start find the key

	Return Value:
		TRUE						Success
		FALSE						Fail

	Note:
		This routine get the value with the matched key (case case-sensitive)
	========================================================================
*/
INT RTMPGetKeyParameter(
	IN	PCHAR	key,
	OUT PCHAR	dest,	
	IN	INT 	destsize,
	IN	PCHAR	buffer)
{
    CHAR *temp_buf1;
    CHAR *temp_buf2;
	CHAR *start_ptr;
	CHAR *end_ptr;
	CHAR *ptr;
	CHAR *offset = 0;
	INT  len;

#define MAX_PARAM_BUFFER_SIZE 2048

	temp_buf1 = kmalloc(MAX_PARAM_BUFFER_SIZE, MEM_ALLOC_FLAG);
	if(temp_buf1 == NULL)
        return (FALSE);

	temp_buf2 = kmalloc(MAX_PARAM_BUFFER_SIZE, MEM_ALLOC_FLAG);
	if(temp_buf2 == NULL)
	{
		kfree(temp_buf1);
        return (FALSE);
	}

	//find section
	if((offset = RTMPFindSection(buffer)) == NULL)
    {
    	kfree(temp_buf1);
    	kfree(temp_buf2);
		return (FALSE);
    }

	strcpy(temp_buf1, "\n");
	strcat(temp_buf1, key);
	strcat(temp_buf1, "=");

	//search key
	if((start_ptr=rtstrstr(offset, temp_buf1))==NULL)
    {
    	kfree(temp_buf1);
    	kfree(temp_buf2);
        return (FALSE);
    }

	start_ptr+=strlen("\n");
   
	if((end_ptr=rtstrstr(start_ptr, "\n"))==NULL)
	   end_ptr=start_ptr+strlen(start_ptr);

	if (end_ptr<start_ptr)
    {
    	kfree(temp_buf1);