wt_dev_pci.c

mini-PCI driver for LHWT chipsets

	/*Adapter->RegMacParameter.ABGMode = IEEE80211B_ONLY;*/
	
	WtWlanInitWt4Hw(Adapter, Adapter->RegMacParameter.ABGMode);
	WtWlanHwIntInit(Adapter);
	WtEnableInterrupts( Adapter );
	
	//printk(LEVEL" Adapter->CSRAddress->IntMaskCtrl = %08x\r\n",Adapter->CSRAddress->IntMaskCtrl);
   	//printk(LEVEL"  %s  intmaskctrl = %04x intstatus = %04x : %08x %08x\n", __FUNCTION__,  Adapter->CSRAddress->IntMaskCtrl, Adapter->CSRAddress->IntStatus, &Adapter->MainMemAddress->HwCSMem.CSRAddress, Adapter->MainMemAddress->HwCSMem.SysCfg.ChipFreq);	
	//spin_unlock_irqrestore(&Adapter->slock, flags);
	netif_start_queue(ndev);
	
        FN_EXIT(0,0);
	return 0;
	
}

static int
WtClose(struct net_device *ndev)
{
	WT_ADAPTER *Adapter = netdev_priv(ndev);
	
	FN_ENTER;

	netif_stop_queue(ndev);
	
	FN_EXIT(0,0);
	return wt4_bring_down(Adapter);
	//return 0;
}                                                          				

//#if 0
static int
wt4_bring_down(WT_ADAPTER *Adapter)
{
	FN_ENTER;
	
	FN_EXIT(0,0);
	
	return 0;
}
//#endif


struct net_device_stats *
wt_eth_statistics(struct net_device *ndev)
{
       
	WT_ADAPTER *Adapter = netdev_priv(ndev);
	Adapter->statistics.rx_packets= ieee2host32( (ULONG)Adapter->MainMemAddress->HwCSMem.HwStatistic.RcvMpduCounter );
 	Adapter->statistics.tx_packets= ieee2host32( (ULONG)Adapter->MainMemAddress->HwCSMem.HwStatistic.XmtMsduCounter );
 	Adapter->statistics.rx_bytes=100000;//Adapter->statistics.rx_bytes;
 	Adapter->statistics.rx_errors= ieee2host32( (ULONG)Adapter->MainMemAddress->HwCSMem.HwStatistic.RcvMissedCounter );
 	Adapter->statistics.tx_errors= ieee2host32( (ULONG)Adapter->MainMemAddress->HwCSMem.HwStatistic.XmtMsduCounter-(ULONG)Adapter->MainMemAddress->HwCSMem.HwStatistic.XmtSuccessMsduCounter );
 	Adapter->statistics.rx_dropped= ieee2host32( (ULONG)Adapter->MainMemAddress->HwCSMem.HwStatistic.RcvMissedCounter );	
 	Adapter->statistics.tx_dropped= ieee2host32( (ULONG)Adapter->MainMemAddress->HwCSMem.HwStatistic.XmtMsduCounter-(ULONG)Adapter->MainMemAddress->HwCSMem.HwStatistic.XmtSuccessMsduCounter );	
 	Adapter->statistics.multicast=0;	
 	Adapter->statistics.collisions=0;
 	Adapter->statistics.rx_length_errors=0;	
 	Adapter->statistics.rx_over_errors=0;
 	Adapter->statistics.rx_crc_errors=0;	
 	Adapter->statistics.rx_frame_errors=0;
 	Adapter->statistics.rx_fifo_errors=0;	
 	Adapter->statistics.rx_missed_errors=0;
 	Adapter->statistics.tx_aborted_errors=0;	
 	Adapter->statistics.tx_carrier_errors=0;
 	Adapter->statistics.tx_fifo_errors=0;	
 	Adapter->statistics.tx_heartbeat_errors=0;
 	Adapter->statistics.tx_window_errors=0;
 	Adapter->statistics.rx_compressed=0;	
 	Adapter->statistics.tx_compressed=0;
	return &Adapter->statistics;

}

/******************************************************************************
    Network device configuration functions
******************************************************************************/
static int
WtAllocMemory(WT_ADAPTER *Adapter)
{
	
	FN_ENTER;
	printk("%sLEVEL   Adapter = %08x\r\n", __FUNCTION__,  Adapter);
	printk("%sLEVEL   Adapter->pdev = %08x\r\n", __FUNCTION__,   Adapter->pdev);

	if((pci_resource_len(Adapter->pdev, 0) == wt4_mainmem_size) /*&& (pci_resource_flags(Adapter->pdev, 0) == 0)*/){
	   
	    Adapter->MainMemAddress = ioremap(pci_resource_start(Adapter->pdev, 0),wt4_mainmem_size);
	    
	    if (!(Adapter->MainMemAddress))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	    
	}
	else if((pci_resource_len(Adapter->pdev, 0) == wt4_eeprom_size) /*&& (pci_resource_flags(Adapter->pdev, 0) == 0)*/){
	
            Adapter->device_base2 = ioremap(pci_resource_start(Adapter->pdev, 0),wt4_eeprom_size);
	    
	    if (!(Adapter->device_base2))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	    
	}
	else{
	
	    Adapter->device_base1 = ioremap(pci_resource_start(Adapter->pdev, 0),wt4_io_size);
	    
	    if (!(Adapter->device_base1))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	}
	
	
	if((pci_resource_len(Adapter->pdev, 1) == wt4_mainmem_size) /*&& (pci_resource_flags(Adapter->pdev, 1) == 0)*/){
	   
	    Adapter->MainMemAddress = ioremap(pci_resource_start(Adapter->pdev, 1),wt4_mainmem_size);
	    
	    if (!(Adapter->MainMemAddress))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	    
	}
	else if((pci_resource_len(Adapter->pdev, 1) == wt4_eeprom_size) /*&& (pci_resource_flags(Adapter->pdev, 1) == 0)*/){
	
            Adapter->device_base2 = ioremap(pci_resource_start(Adapter->pdev, 1),wt4_eeprom_size);
	    
	    if (!(Adapter->device_base2))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	    
	}
	else{
	
	    Adapter->device_base1 = ioremap(pci_resource_start(Adapter->pdev, 1),wt4_io_size);
	    
	    if (!(Adapter->device_base1))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	}
	
	
	if((pci_resource_len(Adapter->pdev, 2) == wt4_mainmem_size) /*&& (pci_resource_flags(Adapter->pdev, 2) == 0)*/){
	   
	    Adapter->MainMemAddress = ioremap(pci_resource_start(Adapter->pdev, 2),wt4_mainmem_size);
	    
	    if (!(Adapter->MainMemAddress))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	    
	}
	else if((pci_resource_len(Adapter->pdev, 2) == wt4_eeprom_size) /*&& (pci_resource_flags(Adapter->pdev, 2) == 0)*/){
	
            Adapter->device_base2 = ioremap(pci_resource_start(Adapter->pdev, 2),wt4_eeprom_size);
	    
	    if (!(Adapter->device_base2))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	    
	}
	else{
	
	    Adapter->device_base1 = ioremap(pci_resource_start(Adapter->pdev, 2),wt4_io_size);
	    
	    if (!(Adapter->device_base1))
	    {
	        printk(" <0>PCI memory remapping failed \n");
		return -1;
	    }
	}

	/* allaction for recv and tran buffer */	
//	printk(LEVEL" now begin to init the resouces for receive and transmition!\n");	   		
	WtInitList(Adapter);
	WtSoftParaInit(Adapter);
	WtInitSend(Adapter);
	NICInitRecv(Adapter);

	//printk(LEVEL" now end to init the resouces for receive and transmition!\n");
	
	ParameterAlloc( Adapter );

	wt4_acl_init(&Adapter->acl);//4.2232
	wt4_wpa_ie_init(Adapter);

//	printk("In file %s line %d Function %s \n", __FILE__, __LINE__, __FUNCTION__);		
	
      FN_EXIT(0,0);
	
	return 0;
	
#if 0
out_free:
	WtFreeMemory(Adapter);
	FN_EXIT(0,0);
	return -1;
#endif

}

int
WtFreeMemory(WT_ADAPTER *Adapter)
{
	
	FN_ENTER;
		
        /* release the resources allocted to wt4!!! */
	if (Adapter->MainMemAddress) {
	    iounmap(Adapter->MainMemAddress);
	    Adapter->MainMemAddress = NULL;
	   }
	   
	if (Adapter->device_base1) {
	    iounmap(Adapter->device_base1);
	    Adapter->device_base1 = NULL;
	   }
	   
	if (Adapter->device_base2) {
	    iounmap(Adapter->device_base2);
	    Adapter->device_base2 = NULL;
	   }

	   
	ParameterFree( Adapter );
	
	if (Adapter->WtWlanTxBufMem) {
	    kfree(Adapter->WtWlanTxBufMem);
	    Adapter->WtWlanTxBufMem = NULL;
	}
        if (Adapter->WtWlanRxBufMem) {
	    kfree(Adapter->WtWlanRxBufMem);
	    Adapter->WtWlanRxBufMem = NULL;
	}
	
	
	/* Free the acces control list and the WPA list */
	wt4_acl_clean(&Adapter->acl);//05.4.22
	wt4_wpa_ie_clean(Adapter);
	
	FN_EXIT(0,0);

	return 0;
	
}
 
 NDIS_STATUS Wt4InitStatistics (IN PWT_ADAPTER Adapter)
{
	NDIS_STATUS        Status = NDIS_STATUS_SUCCESS;

	Adapter->statistics.rx_packets=0;
 	Adapter->statistics.tx_packets=0;
 //	Adapter->statistics.rx_bytes=0;
 //	Adapter->statistics.tx_bytes=0;
 	Adapter->statistics.rx_errors=0;
 	Adapter->statistics.tx_errors=0;
 	Adapter->statistics.rx_dropped=0;	
 	Adapter->statistics.tx_dropped=0;	
 	Adapter->statistics.multicast=0;	
 	Adapter->statistics.collisions=0;
 	
 	Adapter->statistics.rx_length_errors=0;	
 	Adapter->statistics.rx_over_errors=0;
 	Adapter->statistics.rx_crc_errors=0;	
 	Adapter->statistics.rx_frame_errors=0;
 	Adapter->statistics.rx_fifo_errors=0;	
 	Adapter->statistics.rx_missed_errors=0;
 	
 	Adapter->statistics.tx_aborted_errors=0;	
 	Adapter->statistics.tx_carrier_errors=0;
 	Adapter->statistics.tx_fifo_errors=0;	
 	Adapter->statistics.tx_heartbeat_errors=0;
 	Adapter->statistics.tx_window_errors=0;
 	
 	Adapter->statistics.rx_compressed=0;	
 	Adapter->statistics.tx_compressed=0;
	return  Status;

}

 
struct net_device *WtNdevSetup(struct pci_dev *pdev)
{
	WT_ADAPTER *Adapter; 
       struct net_device *ndev = alloc_etherdev(sizeof(WT_ADAPTER));

        FN_ENTER;
	
	//memset(Adapter, 0, sizeof(WT_ADAPTER));
       // printk("%sLEVEL   pci_resource_start(pdev, 0)= %08x\r\n", __FUNCTION__,  pci_resource_start(pdev, 0));
	//struct net_device *ndev = alloc_etherdev(sizeof(WT_ADAPTER));
	 
	if (!ndev)
	   return ndev;
 	
	
	SET_MODULE_OWNER(ndev);
	pci_set_drvdata(pdev, ndev);
 

	// setup the structure members 
	ndev->base_addr = pci_resource_start(pdev, 0);
	//ndev->base_addr = 0x1f800000;
//	printk("%sLEVEL   ndev->base_addr = %08x\r\n", __FUNCTION__,  ndev->base_addr);
	ndev->irq = pdev->irq;

	// initialize the function pointers 
	ndev->open = &WtOpen;
	ndev->stop = &WtClose;
	ndev->get_stats = &wt_eth_statistics;
	ndev->get_wireless_stats = &wt4_get_wireless_stats;

	//define function private function
	ndev->wireless_handlers = (struct iw_handler_def *) &wt4_handler_def;
        ndev->hard_start_xmit = &WtTransmit;
	// ndev->set_multicast_list = &islpci_set_multicast_list; 
	ndev->addr_len = ETH_ALEN;
	ndev->set_mac_address = &wt4_set_mac_address;
	//Get a non-zero dummy MAC address for nameif. Jean II 
	memcpy(ndev->dev_addr, dummy_mac, 6);

	// allocate a Adapterate device structure to the network device  
	Adapter = netdev_priv(ndev);
//	printk("%sLEVEL   Adapter = %08x\r\n", __FUNCTION__,  Adapter);
        Adapter->ndev = ndev;
	printk("%sLEVEL   Adapter->ndev = %08x\r\n", __FUNCTION__,   Adapter->ndev);
	Adapter->pdev = pdev;
      //  printk("%sLEVEL   Adapter->pdev = %08x\r\n", __FUNCTION__,   Adapter->pdev);
	Adapter->monitor_type = ARPHRD_IEEE80211;//05.4.22
	Adapter->ndev->type = (Adapter->iw_mode == IW_MODE_MONITOR) ?
		              Adapter->monitor_type : ARPHRD_ETHER; //05.4.22
			      
	//noe we dont need to support WAPI
	Adapter->MacParameter.bSoftDecrypt = FALSE;
	Adapter->MacParameter.bSoftEncrypt = FALSE;
	//added by hk 2006.9.27
	tasklet_init(&Adapter->TxTasklet, (void (*)(unsigned long))
		     WtHandleSendInterrupt, (unsigned long)Adapter);
	tasklet_init(&Adapter->RxTasklet, (void (*)(unsigned long))
		     WtHandleRecvInterrupt, (unsigned long)Adapter);
	
      init_waitqueue_head(&Adapter->reset_done);//05.4.22

	// init the queue read locks, process wait counter 
	sema_init(&Adapter->mgmt_sem, 1);//05.4.22
	//Adapter->mgmt_received = NULL;//05.4.22
	
	sema_init(&Adapter->stats_sem, 1);//05.4.22
	
	//init all locks we needed
	spin_lock_init(&Adapter->slock);
	spin_lock_init(&Adapter->Lock);
        spin_lock_init(&Adapter->SendLock);
        spin_lock_init(&Adapter->RcvLock);
        spin_lock_init(&Adapter->MacLock);
//	spin_lock_init(&Adapter->SsidGetLock);
//	spin_lock_init(&Adapter->SsidSetLock);


	// initialize workqueue's 
	//INIT_WORK(&Adapter->stats_work,
		//  (void (*)(void *)) wt4_update_stats, Adapter);
	Adapter->stats_timestamp = 0;


        //////////////////////////////////////////////////////////////////////////////////////////
	WtWlanAdpterWt4 = Adapter;
        //////////////////////////////////////////////////////////////////////////////////////////
//	printk("%sLEVEL   Adapter = %08x\r\n", __FUNCTION__,  Adapter);
	// allocate various memory areas 
	if (WtAllocMemory(Adapter))
	   goto do_free_netdev;
        
	// save the start and end address of the PCI memory area 
	ndev->mem_start = (unsigned long) Adapter->MainMemAddress;
//	printk("%sLEVEL   ndev->mem_start = %08x\r\n", __FUNCTION__,  ndev->mem_start);
	ndev->mem_end = ndev->mem_start + wt4_mainmem_size;//05.4.22
	
	
	// alian csraddress for convenient	
	Adapter->CSRAddress = &Adapter->MainMemAddress->HwCSMem.CSRAddress;
//	printk(LEVEL" Adapter->CSRAddress  = %08x\r\n", Adapter->CSRAddress);	
 
	if (register_netdev(ndev)) {
		
	//   printk("ERROR: register_netdev() failed ):\r\n");
	   goto do_wt_free_memory;
	}
	
        NICReadAdapterInfo(Adapter);
	wt_mgt_init(Adapter);

	Wt4InitStatistics(Adapter);	
        FN_EXIT(0,0);
	
	return ndev;
 
 do_wt_free_memory:
	WtFreeMemory(Adapter);
	
 do_free_netdev:
	pci_set_drvdata(pdev, NULL);
	free_netdev(ndev);
	Adapter = NULL;
	return NULL;
}