rtmp_init.c

r73模块的无线网卡在Linux下的驱动程序

	DBGPRINT(RT_DEBUG_TRACE, "<-- NICInitializeAsic\n");

	return NDIS_STATUS_SUCCESS;
}

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

	Routine Description:
		Reset NIC Asics

	Arguments:
		Adapter						Pointer to our adapter

	Return Value:
		None

	Note:
		Reset NIC to initial state AS IS system boot up time.

	========================================================================
*/
VOID NICIssueReset(
	IN	PRTMP_ADAPTER	pAd)
{

}

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

	Routine Description:
		Check ASIC registers and find any reason the system might hang

	Arguments:
		Adapter						Pointer to our adapter

	Return Value:
		None

	========================================================================
*/
BOOLEAN	NICCheckForHang(
	IN	PRTMP_ADAPTER	pAd)
{
	return (FALSE);
}

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

	Routine Description:
		Read statistical counters from hardware registers and record them
		in software variables for later on query

	Arguments:
		pAd					Pointer to our adapter

	Return Value:
		None


	========================================================================
*/
VOID NICUpdateRawCounters(
	IN PRTMP_ADAPTER pAd)
{
	ULONG	OldValue;
	STA_CSR0_STRUC StaCsr0;
	STA_CSR1_STRUC StaCsr1;
	STA_CSR2_STRUC StaCsr2;
	STA_CSR3_STRUC StaCsr3;
	STA_CSR4_STRUC StaCsr4;
	STA_CSR5_STRUC StaCsr5;

	RTUSBReadMACRegister(pAd, STA_CSR0, &StaCsr0.word);

	// Update RX PLCP error counter
	pAd->PrivateInfo.PhyRxErrCnt += StaCsr0.field.PlcpErr;

	// Update FCS counters
	OldValue= pAd->WlanCounters.FCSErrorCount.vv.LowPart;
	pAd->WlanCounters.FCSErrorCount.vv.LowPart += (StaCsr0.field.CrcErr); // >> 7);
	if (pAd->WlanCounters.FCSErrorCount.vv.LowPart < OldValue)
		pAd->WlanCounters.FCSErrorCount.vv.HighPart++;

	// Add FCS error count to private counters
	OldValue = pAd->RalinkCounters.RealFcsErrCount.vv.LowPart;
	pAd->RalinkCounters.RealFcsErrCount.vv.LowPart += StaCsr0.field.CrcErr;
	if (pAd->RalinkCounters.RealFcsErrCount.vv.LowPart < OldValue)
		pAd->RalinkCounters.RealFcsErrCount.vv.HighPart++;


	// Update False CCA counter
	RTUSBReadMACRegister(pAd, STA_CSR1, &StaCsr1.word);
	pAd->RalinkCounters.OneSecFalseCCACnt += StaCsr1.field.FalseCca;

	// Update RX Overflow counter
	RTUSBReadMACRegister(pAd, STA_CSR2, &StaCsr2.word);
	pAd->Counters8023.RxNoBuffer += (StaCsr2.field.RxOverflowCount + StaCsr2.field.RxFifoOverflowCount);

	// Update BEACON sent count
	RTUSBReadMACRegister(pAd, STA_CSR3, &StaCsr3.word);
	pAd->RalinkCounters.OneSecBeaconSentCnt += StaCsr3.field.TxBeaconCount;

	RTUSBReadMACRegister(pAd, STA_CSR4, &StaCsr4.word);
	RTUSBReadMACRegister(pAd, STA_CSR5, &StaCsr5.word);

	// 1st - Transmit Success
	OldValue = pAd->WlanCounters.TransmittedFragmentCount.vv.LowPart;
	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);

	// Switch to current channel, since during reset process, the connection
	// should remain on.
	AsicSwitchChannel(pAd, pAd->PortCfg.Channel);
	AsicLockChannel(pAd, pAd->PortCfg.Channel);
}

INT LoadFirmware (PRTMP_ADAPTER pAd, char *firmName)
{
	const struct firmware *fw_entry;
	struct usb_device *dev = pAd->pUsb_Dev;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
	char udevice[16];
	snprintf(udevice, sizeof(udevice), "rt73%3.3d%3.3d", dev->bus->busnum, dev->devnum);
#else
	struct device *udevice = &dev->dev;
#endif

	size_t size;
	u8 *data;
	USHORT i, loaded = 0;
	ULONG reg;
	u16 crc = 0;
	INT status;
#define BUFFERED_COPY
#ifdef BUFFERED_COPY
	u8 buf[64];
#else
	u32 buf;
#endif
	DBGPRINT(RT_DEBUG_TRACE, "--> LoadFirmware \n");

	// Access firmware file
	if ((status = request_firmware(&fw_entry, firmName, udevice))) {
		DBGPRINT(RT_DEBUG_ERROR, "rt73: Failed to request_firmware. "
				"Check your firmware file location\n");
		KPRINT(KERN_ERR, "Failed to request_firmware. "
				"Check your firmware file location\n");
		goto fw_error;
	}

	if (fw_entry->size != FIRMWARE_IMAGE_SIZE) {
		DBGPRINT(RT_DEBUG_ERROR, "rt73: Firmware file size error "
			"(%d instead of %d)\n",
			(int)fw_entry->size, FIRMWARE_IMAGE_SIZE);
		KPRINT(KERN_ERR, "Firmware file size error "
			"(%d instead of %d)\n",
			(int)fw_entry->size, FIRMWARE_IMAGE_SIZE);
		status = -EBADF;
		goto error;
	}

	// Firmware CRC check
	size = fw_entry->size - 2;
	data = (u8 *)fw_entry->data;

	for (i=0; i < size; i++)
		crc = ByteCRC16(*data++, crc);
	crc = ByteCRC16(0x00, crc);
	crc = ByteCRC16(0x00, crc);

	if (crc != ((fw_entry->data[size] << 8) | fw_entry->data[size + 1])) {
		DBGPRINT(RT_DEBUG_ERROR, "rt73: Firmware CRC error "
				"Check your firmware file integrity\n");
		KPRINT(KERN_ERR, "Firmware CRC error "
				"Check your firmware file integrity\n");
		status = -EBADF;
		goto error;
	}

	// Wait for stable hardware
	for (i = 0; i < 100; i++) {
		RTUSBReadMACRegister(pAd, MAC_CSR0, &reg);
		if (reg)
			break;
		msleep(1);
	}

	if (!reg) {
		DBGPRINT(RT_DEBUG_ERROR, "rt73: Unstable hardware\n");
		KPRINT(KERN_ERR, "Unstable hardware\n");
		status = -EBUSY;
		goto error;
	}

	// Write firmware to device
	for (i = 0; i < FIRMWARE_IMAGE_SIZE; i += sizeof(buf)) {
#ifdef BUFFERED_COPY
		memcpy(&buf, &fw_entry->data[i], sizeof(buf));
#else
		buf = *(u32 *) &fw_entry->data[i];
#endif
		if ((status = RTUSBMultiWrite(pAd, FIRMWARE_IMAGE_BASE + i,
						&buf, sizeof(buf))) < 0) {
			DBGPRINT(RT_DEBUG_ERROR, "rt73: Firmware loading error\n");
			KPRINT(KERN_ERR, "Firmware loading error\n");
			goto error;
		}
		loaded += status;
	}
	DBGPRINT(RT_DEBUG_TRACE, "%d bytes written to device.\n", loaded);

	if (loaded < FIRMWARE_IMAGE_SIZE) {
		// Should never happen
		DBGPRINT(RT_DEBUG_ERROR, "rt73: Firmware loading incomplete\n");
		KPRINT(KERN_ERR, "Firmware loading incomplete\n");
		status = -EIO;
		goto error;
	}


	// Send 'run firmware' request to device
	if ((status = RTUSBFirmwareRun(pAd)) < 0) {
		DBGPRINT(RT_DEBUG_ERROR, "rt73: Device refuses to run firmware\n");
		KPRINT(KERN_ERR, "Device refuses to run firmware\n");
		goto error;
	}

	// Reset LED
	RTMPSetLED(pAd, LED_LINK_DOWN);

	// Firmware loaded ok
	OPSTATUS_SET_FLAG (pAd, fOP_STATUS_FIRMWARE_LOAD );
	status = 0;

error:
	release_firmware(fw_entry);

fw_error:
	DBGPRINT(RT_DEBUG_TRACE, "<-- LoadFirmware (status: %d, loaded: %d)\n",
							status, loaded);
	return status;
}

 /**
  * 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);
}

#ifndef BIG_ENDIAN
/*
	========================================================================

	Routine Description:
		Compare two memory block

	Arguments:
		Adapter 					Pointer to our adapter

	Return Value:
		1:			memory are equal
		0:			memory are not equal

	Note:

	========================================================================
*/
ULONG	RTMPEqualMemory(
	IN	PVOID	pSrc1,
	IN	PVOID	pSrc2,
	IN	ULONG	Length)
{
	PUCHAR	pMem1;
	PUCHAR	pMem2;
	ULONG	Index = 0;

	pMem1 = (PUCHAR) pSrc1;
	pMem2 = (PUCHAR) pSrc2;

	for (Index = 0; Index < Length; Index++)
	{
		if (pMem1[Index] != pMem2[Index])
		{
			break;
		}
	}

	if (Index == Length)
	{
		return (1);
	}
	else
	{
		return (0);
	}
}
#endif
/*
	========================================================================

	Routine Description:
		Compare two memory block

	Arguments:
		pSrc1		Pointer to first memory address
		pSrc2		Pointer to second memory addres

	Return Value:
		0:			memory is equal
		1:			pSrc1 memory is larger
		2:			pSrc2 memory is larger

	Note:

	========================================================================
*/
ULONG	RTMPCompareMemory(
	IN	PVOID	pSrc1,
	IN	PVOID	pSrc2,
	IN	ULONG	Length)
{
	PUCHAR	pMem1;
	PUCHAR	pMem2;
	ULONG	Index = 0;

	pMem1 = (PUCHAR) pSrc1;
	pMem2 = (PUCHAR) pSrc2;

	for (Index = 0; Index < Length; Index++)
	{
		if (pMem1[Index] > pMem2[Index])
			return (1);
		else if (pMem1[Index] < pMem2[Index])
			return (2);
	}

	// Equal
	return (0);
}

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

	Routine Description:
		Zero out memory block

	Arguments:
		pSrc1		Pointer to memory address