rtusb_main.c

华硕无线网卡 167G linux 驱动

					0,
					NULL);
				RTUSBUp(pAdapter, &pAdapter->mlme_semaphore);
			}
			break;

			case	OID_802_11_RX_ANTENNA_SELECTED:
			{
				UCHAR	RxValue;
				NDIS_802_11_ANTENNA	Antenna = *(NDIS_802_11_ANTENNA *)pData;
				DBGPRINT_RAW(RT_DEBUG_TRACE, "Set::OID_802_11_RX_ANTENNA_SELECTED (=%d)\n", Antenna);
				if(Antenna == 0xFFFFFFFF)
				{// Diversity
					pAdapter->PortCfg.CurrentRxAntenna = (UCHAR)Antenna;
					RTUSBReadBBPRegister(pAdapter, BBP_Rx_Configure, &RxValue);
					RxValue = (RxValue & 0xFC) | 0x01;
					RTUSBWriteBBPRegister(pAdapter, BBP_Rx_Configure, RxValue);
				}
				else if(Antenna < pAdapter->PortCfg.NumberOfAntenna)
				{
					pAdapter->PortCfg.CurrentRxAntenna = (UCHAR)Antenna;

					RTUSBReadBBPRegister(pAdapter, BBP_Rx_Configure, &RxValue);
					if(Antenna == 0)
					{// Antenna A
						RxValue = (RxValue & 0xFC) | 0x00;
					}
					else if(Antenna == 1)
					{// Antenna B
						RxValue = (RxValue & 0xFC) | 0x02;
					}
					RTUSBWriteBBPRegister(pAdapter, BBP_Rx_Configure, RxValue);
				}
			}
			break;

			case	OID_802_11_TX_ANTENNA_SELECTED:
			{
				NDIS_802_11_ANTENNA	Antenna = *(NDIS_802_11_ANTENNA *)pData;
				DBGPRINT_RAW(RT_DEBUG_TRACE, "Set::OID_802_11_TX_ANTENNA_SELECTED (=%d)\n", Antenna);
				if ((Antenna != 0xFFFFFFFF) && (Antenna >= pAdapter->PortCfg.NumberOfAntenna))
				{
				}
				else
				{
					UCHAR	TxValue;
					USHORT	Value5, Value6;
					pAdapter->PortCfg.CurrentTxAntenna = (UCHAR)Antenna;
					RTUSBReadBBPRegister(pAdapter, BBP_Tx_Configure, &TxValue);
					RTUSBReadMACRegister(pAdapter, PHY_CSR5, &Value5);
					RTUSBReadMACRegister(pAdapter, PHY_CSR6, &Value6);
					if(Antenna == 0xFFFFFFFF)
					{// Diversity
						TxValue = (TxValue & 0xFC) | 0x01;
						Value5 = (Value5 & 0xFFFC) | 0x0001;
						Value6 = (Value6 & 0xFFFC) | 0x0001;
					}
					else if(Antenna == 0)
					{// Antenna A
						TxValue = (TxValue & 0xFC) | 0x00;
						Value5 = (Value5 & 0xFFFC) | 0x0000;
						Value6 = (Value6 & 0xFFFC) | 0x0000;
					}
					else if(Antenna == 1)
					{// Antenna B
						TxValue = (TxValue & 0xFC) | 0x02;
						Value5 = (Value5 & 0xFFFC) | 0x0002;
						Value6 = (Value6 & 0xFFFC) | 0x0002;
					}
					RTUSBWriteBBPRegister(pAdapter, BBP_Tx_Configure, TxValue);
					RTUSBWriteMACRegister(pAdapter, PHY_CSR5, Value5);
					RTUSBWriteMACRegister(pAdapter, PHY_CSR6, Value6);
				}
			}
			break;

			case	RT_OID_SINGLE_WRITE_MAC:
			{
				USHORT	Offset, Value;
				Offset = *((PUSHORT)pData);
				Value = *((PUSHORT)(pData + 2));
				DBGPRINT_RAW(RT_DEBUG_INFO, "offset = 0x%04x	value = 0x%04x\n", Offset, Value);
				RTUSBWriteMACRegister(pAdapter, Offset, Value);
			}
			break;
			
			case	RT_OID_SINGLE_READ_MAC:
			{
				USHORT	Offset = *((PUSHORT)pData);
				PUSHORT	pValue = (PUSHORT)(pData + 2);
				DBGPRINT_RAW(RT_DEBUG_INFO, "offset = 0x%04x\n", Offset);
				RTUSBReadMACRegister(pAdapter, Offset, pValue);
				DBGPRINT_RAW(RT_DEBUG_INFO, "value = 0x%04x\n", *pValue);
			}
			break;

			case	RT_OID_MULTI_READ_MAC:
			{
				USHORT	Offset = *((PUSHORT)pData);
				USHORT	Length = *((PUSHORT)(pData + 2));
				RTUSBMultiReadMAC(pAdapter, Offset, pData + 4, Length);
			}
			break;

			case	RT_OID_MULTI_WRITE_MAC:
			{
				USHORT	Offset = *((PUSHORT)pData);
				USHORT	Length = *((PUSHORT)(pData + 2));
				RTUSBMultiWriteMAC(pAdapter, Offset, pData + 4, Length);
			}
			break;

			case	RT_OID_USB_VENDOR_EEPROM_READ:
			{
				USHORT	Offset = *((PUSHORT)pData);
				USHORT	Length = *((PUSHORT)(pData + 2));
				RTUSBReadEEPROM(pAdapter, Offset, pData + 4, Length);
			}
			break;
				    
			case	RT_OID_USB_VENDOR_EEPROM_WRITE:
			{
				USHORT	Offset = *((PUSHORT)pData);
#if 0
				USHORT	Length = *((PUSHORT)(pData + 2));
				RTUSBWriteEEPROM(pAdapter, Offset, pData + 4, Length);
#else//F/W restricts the max EEPROM write size to 62 bytes.
				USHORT	Residual = *((PUSHORT)(pData + 2));
				pData += 4;
				while (Residual > 62)
				{
				RTUSBWriteEEPROM(pAdapter, Offset, pData, 62);
				Offset += 62;
				Residual -= 62;
				pData += 62;
				}
				RTUSBWriteEEPROM(pAdapter, Offset, pData, Residual);
#endif
			}
			break;

			case	RT_OID_USB_VENDOR_ENTER_TESTMODE:
				RTUSB_VendorRequest(pAdapter,
					0,
					DEVICE_VENDOR_REQUEST_OUT,
					0x1,
					0x4,
					0x1,
					NULL,
					0);
					break;

			case	RT_OID_USB_VENDOR_EXIT_TESTMODE:
				RTUSB_VendorRequest(pAdapter,
					0,
					DEVICE_VENDOR_REQUEST_OUT,
					0x1,
					0x4,
					0x0,
					NULL,
					0);
			break;

			case	RT_OID_USB_RESET_BULK_OUT:
				DBGPRINT_RAW(RT_DEBUG_ERROR, "RT_OID_USB_RESET_BULK_OUT\n");
			break;

			case	RT_OID_USB_RESET_BULK_IN:
					{
				int	i;
				DBGPRINT_RAW(RT_DEBUG_ERROR, "!!!!!RT_OID_USB_RESET_BULK_IN\n");
				DBGPRINT_RAW(RT_DEBUG_ERROR, "!!!!!RT_OID_USB_RESET_BULK_IN\n");
				DBGPRINT_RAW(RT_DEBUG_ERROR, "!!!!!RT_OID_USB_RESET_BULK_IN\n");
				RTMP_SET_FLAG(pAdapter, fRTMP_ADAPTER_RESET_PIPE_IN_PROGRESS);
				RT2570InitializeAsic(pAdapter);
				RTUSBWriteMACRegister(pAdapter, TXRX_CSR2, 1);
				for (i = 0; i < RX_RING_SIZE; i++)
				{
					PRX_CONTEXT  pRxContext = &(pAdapter->RxContext[i]);

					if (pRxContext->pUrb != NULL)
					{
						usb_kill_urb(pRxContext->pUrb);
						usb_free_urb(pRxContext->pUrb);
						pRxContext->pUrb = NULL;
					}
					if (pRxContext->TransferBuffer != NULL)
					{
						FreeMemory(pRxContext->TransferBuffer); 
						pRxContext->TransferBuffer = NULL;
					}

				}
				NICInitRecv(pAdapter);
				RTMP_CLEAR_FLAG(pAdapter, fRTMP_ADAPTER_RESET_PIPE_IN_PROGRESS);
				if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_BULKIN_RESET))
				{
					RTMP_CLEAR_FLAG(pAdapter, fRTMP_ADAPTER_BULKIN_RESET);
				}

				if (!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_RADIO_OFF))
				{
					RTUSBBulkReceive(pAdapter);
					RTUSBWriteMACRegister(pAdapter, TXRX_CSR2, 0x7e);
				}
				}
			break;

			case	RT_OID_802_11_STA_CONFIG:
			{
				RT_802_11_STA_CONFIG *pStaConfig = (RT_802_11_STA_CONFIG *)pData;
				if (pStaConfig->EnableTxBurst != pAdapter->PortCfg.EnableTxBurst)
				{
					pAdapter->PortCfg.EnableTxBurst = pStaConfig->EnableTxBurst;
					//Currently Tx burst mode is only implemented in infrastructure mode.
					if (INFRA_ON(pAdapter))
					{
						if (pAdapter->PortCfg.EnableTxBurst)
						{
							//Extend slot time if any encryption method is used to give ASIC more time to do encryption/decryption during Tx burst mode.
							if (pAdapter->PortCfg.WepStatus != Ndis802_11EncryptionDisabled)
								RTUSBWriteMACRegister(pAdapter, MAC_CSR10, 0x20);
							//Set CWmin/CWmax to 0.
							RTUSBWriteMACRegister(pAdapter, MAC_CSR22, 0x100);
						}
						else
						{
							if (pAdapter->PortCfg.WepStatus != Ndis802_11EncryptionDisabled)
								AsicSetSlotTime(pAdapter, (BOOLEAN)pAdapter->PortCfg.ShortSlotInUsed);
							RTUSBWriteMACRegister(pAdapter, MAC_CSR22, 0x53);
						}
					}
				}
				pAdapter->PortCfg.EnableTurboRate = pStaConfig->EnableTurboRate;
				pAdapter->PortCfg.UseBGProtection = pStaConfig->UseBGProtection;
				//pAdapter->PortCfg.UseShortSlotTime = pStaConfig->UseShortSlotTime;
				pAdapter->PortCfg.UseShortSlotTime = 1; // 2003-10-30 always SHORT SLOT capable
				if (pAdapter->PortCfg.AdhocMode != pStaConfig->AdhocMode)
				{
					// allow dynamic change of "USE OFDM rate or not" in ADHOC mode
					// if setting changed, need to reset current TX rate as well as BEACON frame format
					pAdapter->PortCfg.AdhocMode = pStaConfig->AdhocMode;
					if (pAdapter->PortCfg.BssType == BSS_INDEP)
					{
						MlmeUpdateTxRates(pAdapter, FALSE);
						MakeIbssBeacon(pAdapter);
					}
				}
				DBGPRINT(RT_DEBUG_TRACE, "Set::RT_OID_802_11_STA_CONFIG (Burst=%d,72/100=%d,Protection=%d,ShortSlot=%d,Adhoc=%d\n",
				pStaConfig->EnableTxBurst,
				pStaConfig->EnableTurboRate,
				pStaConfig->UseBGProtection,
				pStaConfig->UseShortSlotTime,
				pStaConfig->AdhocMode);
			}
			break;

			case	RT_OID_SET_PSM_BIT_SAVE:
				MlmeSetPsmBit(pAdapter, PWR_SAVE);
				EnqueueNullFrame(pAdapter, pAdapter->PortCfg.TxRate);
				break;

				case	RT_OID_SET_RADIO:
					if (pAdapter->PortCfg.bRadio == TRUE){
						MlmeRadioOn(pAdapter);
						// Update extra information
						pAdapter->ExtraInfo = EXTRA_INFO_CLEAR;
					}
					else{
						MlmeRadioOff(pAdapter);
						// Update extra information
						pAdapter->ExtraInfo = SW_RADIO_OFF;
					}
					break;

				case	RT_OID_RESET_FROM_ERROR:
				case	RT_OID_RESET_FROM_NDIS:
					{
						UINT	i = 0;

						RTUSBRejectPendingPackets(pAdapter);//reject all NDIS packets waiting in TX queue
						RTUSBCleanUpDataBulkOutQueue(pAdapter);
						MlmeSuspend(pAdapter);

						//Add code to access necessary registers here.
						//disable Rx
						RTUSBWriteMACRegister(pAdapter, TXRX_CSR2, 1);
						//Ask our device to complete any pending bulk in IRP.
						while ((atomic_read(&pAdapter->PendingRx) > 0) || (pAdapter->BulkOutPending == TRUE))
						{
							if (atomic_read(&pAdapter->PendingRx) > 0)
							{
								DBGPRINT_RAW(RT_DEBUG_TRACE, "BulkIn IRP Pending!!!\n");
								RTUSB_VendorRequest(pAdapter,
													0,
													DEVICE_VENDOR_REQUEST_OUT,
													0x0C,
													0x0,
													0x0,
													NULL,
													0);
							}

							if (pAdapter->BulkOutPending == TRUE)
							{
								DBGPRINT_RAW(RT_DEBUG_TRACE, "BulkOut IRP Pending!!!\n");
								if (i == 0)
								{
									RTUSBCancelPendingBulkOutIRP(pAdapter);
									i++;
								}
							}

							NdisMSleep(500000);
						}

						NICResetFromError(pAdapter);
						if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_HARDWARE_ERROR))
						{
							RTMP_CLEAR_FLAG(pAdapter, fRTMP_ADAPTER_HARDWARE_ERROR);
						}
						if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_BULKIN_RESET))
						{
							RTMP_CLEAR_FLAG(pAdapter, fRTMP_ADAPTER_BULKIN_RESET);
						}
						if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_BULKOUT_RESET))
						{
							RTMP_CLEAR_FLAG(pAdapter, fRTMP_ADAPTER_BULKOUT_RESET);
						}

						RTMP_CLEAR_FLAG(pAdapter, fRTMP_ADAPTER_RESET_IN_PROGRESS);

						if ((!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_RADIO_OFF)) &&
							(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_HALT_IN_PROGRESS)) &&
							(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_REMOVE_IN_PROGRESS)))
						{
							MlmeResume(pAdapter);
							RTUSBBulkReceive(pAdapter);
							RTUSBWriteMACRegister(pAdapter, TXRX_CSR2, 0x7e);
						}
					}
					break;

				case	RT_OID_LINK_DOWN:
					DBGPRINT_RAW(RT_DEBUG_TRACE, "LinkDown(RT_OID_LINK_DOWN)\n");
					LinkDown(pAdapter);
					break;

				case	RT_OID_VENDOR_WRITE_BBP:
					{
						UCHAR	Offset, Value;
						Offset = *((PUCHAR)pData);
						Value = *((PUCHAR)(pData + 1));
						RTUSBWriteBBPRegister(pAdapter, Offset, Value);
					}
					break;

				case	RT_OID_VENDOR_READ_BBP:
					{
						UCHAR	Offset = *((PUCHAR)pData);
						PUCHAR	pValue = (PUCHAR)(pData + 1);

						DBGPRINT_RAW(RT_DEBUG_INFO, "offset = 0x%02x\n", Offset);
						RTUSBReadBBPRegister(pAdapter, Offset, pValue);
						DBGPRINT_RAW(RT_DEBUG_INFO, "value = 0x%02x\n", *pValue);
					}
					break;

				case	RT_OID_VENDOR_WRITE_RF:
					{
						ULONG	Value = *((PULONG)pData);

						DBGPRINT_RAW(RT_DEBUG_INFO, "value = 0x%08x\n", Value);
						RTUSBWriteRFRegister(pAdapter, Value);
					}
					break;
				    
				case	RT_OID_802_11_RESET_COUNTERS:
					{
						UCHAR	Value[22];

						RTUSBMultiReadMAC(pAdapter, STA_CSR0, Value, 22);
					}
					break;


				case	RT_OID_USB_VENDOR_RESET:
					RTUSB_VendorRequest(pAdapter,
										0,
										DEVICE_VENDOR_REQUEST_OUT,
										1,
										1,
										0,
										NULL,
										0);
					break;

				case	RT_OID_USB_VENDOR_UNPLUG:
					RTUSB_VendorRequest(pAdapter,
										0,
										DEVICE_VENDOR_REQUEST_OUT,
										1,
										2,
										0,
										NULL,
										0);
					break;

				case	RT_OID_USB_VENDOR_SWITCH_FUNCTION:
					RTUSBWriteMACRegister(pAdapter, MAC_CSR13, 0x2121);
					RTUSBWriteMACRegister(pAdapter, MAC_CSR14, 0x1e1e);
					RTUSBWriteMACRegister(pAdapter, MAC_CSR1, 3);
					RTUSBWriteMACRegister(pAdapter, PHY_CSR4, 0xf);

					RTUSB_VendorRequest(pAdapter,
										0,
										DEVICE_VENDOR_REQUEST_OUT,
										1,
										3,
										0,
										NULL,
										0);
					break;

				case	RT_OID_VENDOR_FLIP_IQ:
					{
						USHORT	Value1, Value2;
						RTUSBReadMACRegister(pAdapter, PHY_CSR5, &Value1);
						RTUSBReadMACRegister(pAdapter, PHY_CSR6, &Value2);
						if (*pData == 1)
						{
							DBGPRINT_RAW(RT_DEBUG_INFO, "I/Q Flip\n");
							Value1 = Value1 | 0x0004;
							Value2 = Value2 | 0x0004;
						}
						else
						{
							DBGPRINT_RAW(RT_DEBUG_INFO, "I/Q Not Flip\n");
							Value1 = Value1 & 0xFFFB;
							Value2 = Value2 & 0xFFFB;
						}
						RTUSBWriteMACRegister(pAdapter, PHY_CSR5, Value1);
						RTUSBWriteMACRegister(pAdapter, PHY_CSR6, Value2);
					}
					break;

				case	RT_OID_UPDATE_TX_RATE:
					MlmeUpdateTxRates(pAdapter, FALSE);
					if (ADHOC_ON(pAdapter))
						MakeIbssBeacon(pAdapter);
					break;

#if 0
				case	RT_OID_UPDATE_R17:
					switch ((pAdapter->SET_R17_FLAG % 3)) 
					{
						case 1:				        	
							RTUSBWriteBBPRegister(pAdapter, 17, pAdapter->BBPTuningParameters.BBPR17LowSensitivity);
							RTUSBWriteBBPRegister(pAdapter, 24, pAdapter->BBPTuningParameters.R24HigherValue);
							RTUSBWriteBBPRegister(pAdapter, 25, pAdapter->BBPTuningParameters.R25HigherValue);
							RTUSBWriteBBPRegister(pAdapter, 61, pAdapter->BBPTuningParameters.R61HigherValue);
							DBGPRINT(RT_DEBUG_TRACE,("RT_OID_UPDATE_1 R17 = %x\n",pAdapter->BBPTuningParameters.BBPR17LowSensitivity));
							break;
						case 2:
							RTUSBWriteBBPRegister(pAdapter, 17, pAdapter->PortCfg.BbpTuning.VgcUpperBound);
							RTUSBWriteBBPRegister(pAdapter, 24, pAdapter->BBPTuningParameters.R24LowerValue);
							RTUSBWriteBBPRegister(pAdapter, 25, pAdapter->BBPTuningParameters.R25LowerValue);
							RTUSBWriteBBPRegister(pAdapter, 61, pAdapter->BBPTuningParameters.R61LowerValue);
							DBGPRINT(RT_DEBUG_TRACE,("RT_OID_UPDATE_2 R17 = %x\n",pAdapter->PortCfg.BbpTuning.VgcUpperBound));
							break;
						case 0:
							RTUSBWriteBBPRegister(pAdapter, 17, pAdapter->BBPR17InitValue);
							RTUSBWriteBBPRegister(pAdapter, 24, pAdapter->BBPTuningParameters.R24LowerValue);
							RTUSBWriteBBPRegister(pAdapter, 25, pAdapter->BBPTuningParameters.R25LowerValue);
							RTUSBWriteBBPRegister(pAdapter, 61, pAdapter->BBPTuningParameters.R61LowerValue);
							DBGPRINT(RT_DEBUG_TRACE,("RT_OID_UPDATE_0 R17 = %x\n",pAdapter->BBPR17InitValue));
							break;     
					}
					break;
#endif
				case	RT_OID_802_11_PREAMBLE:
					{
						ULONG	Preamble = *((PULONG)(cmdqelmt->buffer));
						if (Preamble == Rt802_11PreambleShort)
						{
							pAdapter->PortCfg.WindowsTxPreamble = Preamble;
							MlmeSetTxPreamble(pAdapter, Rt802_11PreambleShort);
						}
						else if ((Preamble == Rt802_11PreambleLong) || (Preamble == Rt802_11PreambleAuto))
						{
							// if user wants AUTO, initialize to LONG here, then change according to AP's
							// capability upon association.
							pAdapter->PortCfg.WindowsTxPreamble = Preamble;
							MlmeSetTxPreamble(pAdapter, Rt802_11PreambleLong);
						}
						DBGPRINT(RT_DEBUG_TRACE, "Set::RT_OID_802_11_SET_PREAMBLE (=%d)\n", Preamble);
					}
					break;

				case	OID_802_11_NETWORK_TYPE_IN_USE:
					{