r8180_core.c

rtl8180网卡在linux下的驱动程序源代码

				_rssi = 0x32;
				*rssi = 0x32;
			}
		}
		break;
		
	/* case 4 */
	case RFCHIPID_MAXIM:
		lsb = temp2 & 1;
		temp2 &= 0x7e;
		temp2 >>= 1;
		temp2 += 0x42;
		if( lsb != 0 ){
			temp2 += 0xa;
		}
		*rssi = temp2 & 0xff;
		_rssi = temp2 & 0xff;
		break;
	}

	if ( _rssi < 0x64 ){
		if ( _rssi == 0 ) {
			*rssi = 1;
		}
	} else {
		*rssi = 0x64;
	}
	
	return;
}


void rtl8180_irq_enable(struct net_device *dev)
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;	
/*
	write_nic_word(dev,INTA_MASK,INTA_RXOK | INTA_RXDESCERR | INTA_RXOVERFLOW |\ 
	INTA_TXOVERFLOW | INTA_HIPRIORITYDESCERR | INTA_HIPRIORITYDESCOK |\ 
	INTA_NORMPRIORITYDESCERR | INTA_NORMPRIORITYDESCOK |\
	INTA_LOWPRIORITYDESCERR | INTA_LOWPRIORITYDESCOK | INTA_TIMEOUT);
*/
	write_nic_word(dev,INTA_MASK, priv->irq_mask);
}


void rtl8180_irq_disable(struct net_device *dev)
{
	write_nic_word(dev,INTA_MASK,0);
	read_nic_word(dev,INTA_MASK); /* force pci posting */
}


void rtl8180_set_mode(struct net_device *dev,int mode)
{
	u8 ecmd;
	ecmd=read_nic_byte(dev, EPROM_CMD);
	ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
	ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
	ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
	ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
	write_nic_byte(dev, EPROM_CMD, ecmd);
}


void rtl8180_update_msr(struct net_device *dev)
{
	struct r8180_priv *priv = dev->priv;
	u8 msr;
	
	msr  = read_nic_byte(dev, MSR);
	msr &= ~ MSR_LINK_MASK;
	
	/* does not change in link_state != WLAN_LINK_ASSOCIATED.
	 * msr must be updated if the state is ASSOCIATING. 
	 * this is intentional and make sense for ad-hoc and
	 * master (see the create BSS/IBSS func
	 */
	if (priv->ieee80211->link_state==WLAN_LINK_NONE){ 
			msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
	}else if (priv->ieee80211->iw_mode == IW_MODE_INFRA){
			msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
	}else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC){
			msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
	}else if (priv->ieee80211->iw_mode == IW_MODE_MASTER){
			msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
		
	}
	write_nic_byte(dev, MSR, msr);
}


void rtl8180_update_beacon_security(struct net_device *dev)
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;	
	struct ieee80211_crypt_data* crypt;
	short encrypt;
	if(priv->ieee80211->host_encrypt)
		crypt = priv->ieee80211->crypt[priv->ieee80211->tx_keyidx];
	else crypt = NULL;
	encrypt = ( crypt && crypt->ops);
	//DMESG("%x",priv->beacon_buf);
	   
	if(priv->beacon_buf){
		if (priv->ieee80211->hw_wep || encrypt)
			
				priv->beacon_buf->capability |= BEACON_CAPABILITY_WEP;
		else
			priv->beacon_buf->capability &= ~BEACON_CAPABILITY_WEP;		
	} 
}

void rtl8180_update_beacon_ch(struct net_device *dev)
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;	
	if(priv->beacon_buf) ((u8*)priv->beacon_buf)[priv->master_beaconsize-1] = 
		priv->ieee80211->master_chan;
	//DMESG("beacon was %d now %d",((u8*)priv->beacon_buf)[priv->master_beaconsize-1],priv->chan);
	//priv->ieee80211->master_chan = priv->chan;
//	priv->chan = priv->ieee80211->master_chan;
//	rf_set_chan(dev,priv->ieee80211->master_chan);
}


void rtl8180_set_chan(struct net_device *dev,short ch)
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	
	priv->chan=ch;
	if(priv->ieee80211->iw_mode == IW_MODE_ADHOC || 
		priv->ieee80211->iw_mode == IW_MODE_MASTER){
	
			priv->ieee80211->link_state = WLAN_LINK_ASSOCIATED;	
			priv->ieee80211->master_chan = ch;
			rtl8180_update_beacon_ch(dev); 
		}
	
	priv->rf_set_chan(dev,priv->chan);
	
}


/* this performs syncro scan blocking the caller until all channels
 * in the allowed channel map has been checked. This shouldn't
 * be directly called. Use rtl8180_start_scanning_s instead.
 */
void rtl8180_scan_s(struct net_device *dev)
{
	
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	short ch = priv->chan;
	
	do
	{
		do{
			if (priv->chan == 14) 
				priv->chan=1;
			else 
				priv->chan++;
		}while(!priv->challow[priv->chan]);
	
		
		if (priv->ieee80211->link_state == WLAN_LINK_ASSOCIATED)
			break;
		priv->rf_set_chan(dev, priv->chan);
		
		
		/* this prevent excessive time wait on rmmod when
		 * IBSS_wq is preforming sync channel scan
		 */ 
		
		if (priv->wq_hurryup) return;
		
		set_current_state(TASK_INTERRUPTIBLE);
		schedule_timeout(HZ / 2);
		
		//DMESG("scanning ch %d",priv->chan);
	}while (priv->chan != ch);
}


void rtl8180_scan(unsigned long _dev)
{
	struct net_device *dev = (struct net_device *)_dev;
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	unsigned long flag;
	
	spin_lock_irqsave(&priv->scan_lock,flag);
	
	do{
		if (priv->chan == 14) {
			priv->chan = 1;
			//priv->active_scan_num++;
		} else 
			priv->chan++;
	} while (!priv->challow[priv->chan]);
	
	priv->rf_set_chan(dev, priv->chan);
	
	priv->scan_timer.expires = jiffies + (HZ / 2);
	
	add_timer(&priv->scan_timer);
	
	spin_unlock_irqrestore(&priv->scan_lock,flag);

	if (/*(priv->active_scan_num == 1 || priv->active_scan_num == 2)
	    &&*/ priv->active_probe){
		ieee80211_probe_hidden(priv->ieee80211);
		ieee80211_probe_hidden(priv->ieee80211);
	}
}

void rtl8180_stop_scanning(struct net_device *dev)
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	unsigned long flag;

	spin_lock_irqsave(&priv->scan_lock,flag);
	del_timer_sync(&priv->scan_timer);
	spin_unlock_irqrestore(&priv->scan_lock,flag);
}


void _rtl8180_start_scanning(struct net_device *dev, short sync)
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	int i;
	int one = 0;
	short found = 0;
	
	 /* if the ieee stack has requested scan and has set the LINK state
	  * to NONE we have to update the MSR register
	  */
	  
	rtl8180_update_msr(dev);
	
	for (i = 1; i <= 14; i++) {
		 if (priv->challow[i]) {
			 if (found) {
				 one = 0;
				 break;
			 } else {
				 one = i;
				 found = 1;
			 }
		 }
	}

	/* doesn't scan at all */
	if (!found)
		return;
	
	if (one != 0) { 
		rtl8180_set_chan(dev, one);
		if (sync)
			mdelay(HZ / 2); 
		return;
	}
	
	rtl8180_stop_scanning(dev);

	//priv->active_scan_num = 0;
	/*priv->chan = 0;  This will start looping through channels starting
			 * at #1.  Otherwise low channels may get less
			 * initial scan time.
			 */
	if (sync) {
		rtl8180_scan_s(dev);
	} else {
		priv->scan_timer.expires = jiffies + (HZ / 2);
		add_timer(&priv->scan_timer);
	}
}


inline void rtl8180_start_scanning(struct net_device *dev)
{
	_rtl8180_start_scanning(dev,0);
}


inline void rtl8180_start_scanning_s(struct net_device *dev)
{
	_rtl8180_start_scanning(dev,1);
}


void rtl8180_rx_enable(struct net_device *dev)
{
	u8 cmd;
	u32 rxconf;
	/* for now we accept data, management & ctl frame*/
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	
	rxconf=read_nic_dword(dev,RX_CONF);
	rxconf = rxconf &~ MAC_FILTER_MASK;
	rxconf = rxconf | (1<<ACCEPT_MNG_FRAME_SHIFT);
	rxconf = rxconf | (1<<ACCEPT_DATA_FRAME_SHIFT);
	rxconf = rxconf | (1<<ACCEPT_BCAST_FRAME_SHIFT);
	rxconf = rxconf | (1<<ACCEPT_MCAST_FRAME_SHIFT);
	if (dev->flags & IFF_PROMISC) DMESG ("NIC in promisc mode");
	
	if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
	   dev->flags & IFF_PROMISC){
		rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
	}else{
		rxconf = rxconf | (1<<ACCEPT_NICMAC_FRAME_SHIFT);
		rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
	}
	
	/*if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
		rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
		rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
	}*/
	
	if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
		rxconf = rxconf | (1<<ACCEPT_CTL_FRAME_SHIFT);	
		rxconf = rxconf | (1<<ACCEPT_ICVERR_FRAME_SHIFT);
		rxconf = rxconf | (1<<ACCEPT_PWR_FRAME_SHIFT);
	}
	
	if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
		rxconf = rxconf | (1<<ACCEPT_CRCERR_FRAME_SHIFT);
	
	if(!priv->card_8185){
		rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
		rxconf = rxconf | (RX_FIFO_THRESHOLD_512<<RX_FIFO_THRESHOLD_SHIFT);
	}
	
	rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
	rxconf = rxconf &~ MAX_RX_DMA_MASK;
	rxconf = rxconf | (MAX_RX_DMA_2048<<MAX_RX_DMA_SHIFT);
	
	if(!priv->card_8185)
		rxconf = rxconf | RCR_ONLYERLPKT;
	
	rxconf = rxconf &~ RCR_CS_MASK;
	rxconf |= (priv->rcr_csense<<RCR_CS_SHIFT);

	
	write_nic_dword(dev, RX_CONF, rxconf);
	
	fix_rx_fifo(dev);
	
#ifdef DEBUG_RX
	DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RX_CONF));
#endif
	cmd=read_nic_byte(dev,CMD);
	write_nic_byte(dev,CMD,cmd | (1<<CMD_RX_ENABLE_SHIFT));

	/* In rtl8139 driver seems that DMA threshold has to be written 
	 *  after enabling RX, so we rewrite RX_CONFIG register 
	 */
	//mdelay(100);
	write_nic_dword(dev, RX_CONF, rxconf); 
	
}


void set_nic_txring(struct net_device *dev)
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	write_nic_dword(dev, TX_NORMPRIORITY_RING_ADDR, priv->txnpringdma);
	write_nic_dword(dev, TX_HIGHPRIORITY_RING_ADDR, priv->txhpringdma);
	write_nic_dword(dev, TX_LOWPRIORITY_RING_ADDR, priv->txlpringdma);
	write_nic_dword(dev, TX_BEACON_RING_ADDR, priv->txbeaconringdma);
}


void rtl8180_conttx_enable(struct net_device *dev)
{
	u32 txconf;
	txconf = read_nic_dword(dev,TX_CONF);
	txconf = txconf &~ TX_LOOPBACK_MASK;
	txconf = txconf | (TX_LOOPBACK_CONTINUE <<TX_LOOPBACK_SHIFT);
	write_nic_dword(dev,TX_CONF,txconf);
}


void rtl8180_conttx_disable(struct net_device *dev)
{
	u32 txconf;
	txconf = read_nic_dword(dev,TX_CONF);
	txconf = txconf &~ TX_LOOPBACK_MASK;
	txconf = txconf | (TX_LOOPBACK_NONE <<TX_LOOPBACK_SHIFT);
	write_nic_dword(dev,TX_CONF,txconf);
}


void rtl8180_tx_enable(struct net_device *dev)
{
	u8 cmd;
	u32 txconf;
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	txconf= read_nic_dword(dev,TX_CONF);
	
	if(priv->card_8185){
	
		txconf = txconf &~ (1<<TCR_PROBE_NOTIMESTAMP_SHIFT);
	
	}else{
	
		if(priv->ieee80211->hw_seq) 
			txconf= txconf &~ (1<<TX_CONF_HEADER_AUTOICREMENT_SHIFT);
		else 
			txconf= txconf | (1<<TX_CONF_HEADER_AUTOICREMENT_SHIFT);
	}
	
	txconf = txconf &~ TX_LOOPBACK_MASK;
	txconf = txconf | (TX_LOOPBACK_NONE <<TX_LOOPBACK_SHIFT);
	txconf = txconf &~ TCR_DPRETRY_MASK;
	txconf = txconf &~ TCR_RTSRETRY_MASK;
	txconf = txconf | (priv->retry_data<<TX_DPRETRY_SHIFT);
	txconf = txconf | (priv->retry_rts<<TX_RTSRETRY_SHIFT);
	txconf = txconf &~ (1<<TX_NOCRC_SHIFT);
	
	if(priv->hw_plcp_len){
		txconf = txconf | TCR_PLCP_LEN;
		//FIXME 
		/* HW will calc PLCP lenght and extension:
		 * we have to make the ieee stack know this
		 * so it avoid to do unneeded calc
		 */
	}else{
		txconf = txconf &~ TCR_SAT;
	}
	txconf = txconf &~ TCR_MXDMA_MASK;
	txconf = txconf | (TCR_MXDMA_2048<<TCR_MXDMA_SHIFT);
	txconf = txconf &~ TCR_CWMIN;
	txconf = txconf &~ TCR_DISCW;
	
	if(priv->ieee80211->hw_wep)
		txconf=txconf &~ (1<<TX_NOICV_SHIFT);
	else
		txconf=txconf | (1<<TX_NOICV_SHIFT);
	
	write_nic_dword(dev,TX_CONF,txconf);
	
	fix_tx_fifo(dev);
	
#ifdef DEBUG_TX
	DMESG("txconf: %x %x",txconf,read_nic_dword(dev,TX_CONF));
#endif
	
	cmd=read_nic_byte(dev,CMD);
	write_nic_byte(dev,CMD,cmd | (1<<CMD_TX_ENABLE_SHIFT));		

//	mdelay(100);
	write_nic_dword(dev,TX_CONF,txconf);
//	#endif
}


void rtl8180_beacon_tx_enable(struct net_device *dev)
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	priv->dma_poll_mask &=~(1<<TX_DMA_STOP_BEACON_SHIFT);
	rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
	write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);	
	rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
}


void rtl8180_beacon_tx_disable(struct net_device *dev) 
{
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	priv->dma_poll_mask |= (1<<TX_DMA_STOP_BEACON_SHIFT);
	rtl8180_set_mode(dev,EPROM_CMD_CONFIG);
	write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
	rtl8180_set_mode(dev,EPROM_CMD_NORMAL);
}


void rtl8180_rtx_disable(struct net_device *dev)
{
	u8 cmd;
	struct r8180_priv *priv = dev->priv;
	
	cmd=read_nic_byte(dev,CMD);
	write_nic_byte(dev, CMD, cmd &~ \
		       ((1<<CMD_RX_ENABLE_SHIFT)|(1<<CMD_TX_ENABLE_SHIFT)));
	read_nic_byte(dev, CMD); // force pci posting;
	/*while (read_nic_byte(dev,CMD) & (1<<CMD_RX_ENABLE_SHIFT))
	  udelay(10); 
	*/
	if(!priv->rx_skb_complete)
		dev_kfree_skb_any(priv->rx_skb);
}


int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
{
	int i;
	u32 *tmp;
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	
	priv->txbeaconring = (u32*)pci_alloc_consistent(priv->pdev,
					  sizeof(u32)*8*count, 
					  &priv->txbeaconringdma);
	if (!priv->txbeaconring) return -1;
	for (tmp=priv->txbeaconring,i=0;i<count;i++){
		*tmp = *tmp &~ (1<<31); // descriptor empty, owned by the drv 
		/*
		*(tmp+2) = (u32)dma_tmp;
		*(tmp+3) = bufsize;
		*/
		if(i+1<count)
			*(tmp+4) = (u32)priv->txbeaconringdma+((i+1)*8*4);
		else
			*(tmp+4) = (u32)priv->txbeaconringdma;
		
		tmp=tmp+8;
	}
	return 0;
}


short alloc_tx_desc_ring(struct net_device *dev, int bufsize, int count,
			 int addr)
{
	int i;
	u32 *desc;
	u32 *tmp;
	dma_addr_t dma_desc, dma_tmp;
	struct r8180_priv *priv = (struct r8180_priv *)dev->priv;
	struct pci_dev *pdev = priv->pdev;
	void *buf;
	
	if((bufsize & 0xfff) != bufsize)
	{ 
		DMESG ("EE: TX buffer allocation too large");
		return 0;