zd1211.c

GW-US54GXS_Linux_v2.15.0.0_CE zd1211原碼

            macp->ep4isIntOut = 0;//1;

            ZD1211DEBUG(0, "interrupt out: wMaxPacketSize = %x\n", zd_le16_to_cpu(endpoint->wMaxPacketSize));
            macp->out_interval = endpoint->bInterval;
		}
	}
	

	macp->num_bulk_in = num_bulk_in;
	macp->num_bulk_out = num_bulk_out;
	macp->num_interrupt_in = num_interrupt_in;

	macp->num_interrupt_out = num_interrupt_out;

	
	macp->rx_urb = USB_ALLOC_URB(0, GFP_KERNEL);
	if (!macp->rx_urb)
		return 0;
		
	macp->tx_urb = USB_ALLOC_URB(0, GFP_KERNEL);
	if (!macp->tx_urb) {
		usb_free_urb(macp->rx_urb);
		return 0;
	}

	
	macp->intr_urb = USB_ALLOC_URB(0, GFP_KERNEL);
	if (!macp->intr_urb) {

		usb_free_urb(macp->rx_urb);
		usb_free_urb(macp->tx_urb);
		return 0;
	}
	
	macp->ctrl_urb = USB_ALLOC_URB(0, GFP_KERNEL);
	if (!macp->ctrl_urb) {
		usb_free_urb(macp->rx_urb);
		usb_free_urb(macp->tx_urb);
		usb_free_urb(macp->intr_urb);
		return 0;


	}


	macp->reg_urb = USB_ALLOC_URB(0, GFP_KERNEL);
	if (!macp->reg_urb) {
		usb_free_urb(macp->rx_urb);
		usb_free_urb(macp->tx_urb);
		usb_free_urb(macp->intr_urb);
		usb_free_urb(macp->ctrl_urb);
		return 0;
	}

#if 0//(LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
    #if 1 
    macp->IntEPBuffer = kmalloc(MAX_EPINT_BUFFER, GFP_KERNEL);

    #else //always failed? why???
    macp->IntEPBuffer = usb_buffer_alloc(macp->device,
                            MAX_EPINT_BUFFER,
                            GFP_KERNEL,
                            &macp->IntBufferHandle);
    #endif
    if (!macp->IntEPBuffer){
        FPRINT("usb_buffer_alloc failed");
        usb_free_urb(macp->rx_urb);
		usb_free_urb(macp->tx_urb);
		usb_free_urb(macp->intr_urb);
		usb_free_urb(macp->ctrl_urb);

   		usb_free_urb(macp->reg_urb);
        return 0;
    }
#endif        

	return 1;
}




void zd1211_free_all_urbs(struct zd1205_private *macp)

{


	if (macp->rx_urb)
 		usb_free_urb(macp->rx_urb);
	if (macp->tx_urb)	

		usb_free_urb(macp->tx_urb);
	if (macp->intr_urb)	

		usb_free_urb(macp->intr_urb);
	if 	(macp->ctrl_urb)
		usb_free_urb(macp->ctrl_urb);
	if 	(macp->reg_urb)
		usb_free_urb(macp->reg_urb);

#if 0//(LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
    if (macp->IntEPBuffer)
    #if 1
        kfree(macp->IntEPBuffer);
    #else    
        usb_buffer_free(macp->device,
            MAX_EPINT_BUFFER,
            (void *)macp->IntEPBuffer,

            macp->IntBufferHandle);
    #endif    
#endif         	
}


void zd1211_unlink_all_urbs(struct zd1205_private *macp)
{
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8))
        usb_kill_urb(macp->rx_urb);
        usb_kill_urb(macp->tx_urb);
        usb_kill_urb(macp->ctrl_urb);
        usb_kill_urb(macp->reg_urb);

    if (test_bit(ZD1211_UNPLUG, &macp->flags))
            usb_kill_urb(macp->intr_urb);

#else
	usb_unlink_urb(macp->rx_urb);
	usb_unlink_urb(macp->tx_urb);
	usb_unlink_urb(macp->ctrl_urb);
	usb_unlink_urb(macp->reg_urb);

    if (test_bit(ZD1211_UNPLUG, &macp->flags))
	    usb_unlink_urb(macp->intr_urb);
#endif


}

#define MAX_RX_MERGE_PACKET_NUM		3
void zd1211_rx_isr(unsigned long parm)
{
	struct zd1205_private *macp = (struct zd1205_private *)parm;
	struct urb *urb = macp->read_urb;
	struct rx_list_elem *rx_struct;
#if fMERGE_RX_FRAME 
	struct rx_list_elem *rx_struct_array[MAX_RX_MERGE_PACKET_NUM];
	int total_rx_struct = 1, rx_array_cnt = 0;
	int i;
	u32 tmpLen = 0;
	u16 last_pkt_len;
#endif
	u32 TotalLength = urb->actual_length;
	u8 *pRxBuffer;
	struct sk_buff *skb;
	zd1205_RFD_t *rfd = NULL;

	spin_lock(&macp->intr_lock);

	ZD1211DEBUG(4, "actual_length = %x\n", urb->actual_length);
	rx_struct = list_entry(macp->active_rx_list.next,
				struct rx_list_elem, list_elem);

	skb = rx_struct->skb;
	rfd = RFD_POINTER(skb, macp);
	pRxBuffer = &rfd->RxBuffer[macp->rxOffset];

#if 0    
	//for debug only
	zd1205_dump_data("pRxBuffer", (u8 *)pRxBuffer, TotalLength);
	//zd1211_submit_rx_urb(macp);
	//return;
#endif

#if fMERGE_RX_FRAME 
	if (rx_struct->UnFinishFrmLen){
		TotalLength += rx_struct->UnFinishFrmLen; 
		rx_struct->UnFinishFrmLen = 0;
		macp->CompLenInfoCnt++;
		//ZD1211DEBUG(0, "Got Rx Frames Length Info!!\n");
	}
    
	last_pkt_len = TotalLength & (macp->wMaxPacketSize - 1);

	if (last_pkt_len <= (macp->wMaxPacketSize - 4)){
        if (zd_get_LE_U16(pRxBuffer + (TotalLength/sizeof(u16)-1)*2 ) == 0x697E) {
		//if (((u16 *) pRxBuffer)[TotalLength / sizeof(u16) - 1] == 0x697E){
			total_rx_struct = 3;
			//ZD1211DEBUG(0, "Got merged Rx Frames!!\n");
			//zd1205_dump_data("pRxBuffer", (u8 *)pRxBuffer, TotalLength);            
			macp->Continue2Rx++;
		}
		else
			macp->NoMergedRxCnt++;
       
		//ZD1211DEBUG(3, "last_pkt_len = %x\n", last_pkt_len);
		//zd1205_dump_data("pRxBuffer", (u8 *)pRxBuffer, TotalLength);
       
		for (i=0; i<total_rx_struct; i++){
			int CurFrmLen;
			
			if (total_rx_struct> 1){
                CurFrmLen=zd_get_LE_U16(pRxBuffer+(TotalLength/sizeof(u16)+i-4)*2); 
				//ZD1211DEBUG(2, "CurFrmLen = %x\n", CurFrmLen);
			}
			else
				CurFrmLen = TotalLength;

			if (CurFrmLen == 0){
				break;
			}

			rx_struct_array[i] = list_entry(macp->active_rx_list.next,
								struct rx_list_elem, list_elem);
			list_del(&(rx_struct_array[i]->list_elem));
			rx_array_cnt++;

			ZD1211DEBUG(2, "CurFrmLen = %x\n", CurFrmLen);
			
			skb = rx_struct_array[i]->skb;
			rfd = RFD_POINTER(skb, macp);

			rfd->CbStatus = RFD_STATUS_COMPLETE;
			rfd->ActualCount = CurFrmLen;

			if (i > 0){
				memcpy(&rfd->RxBuffer[macp->rxOffset],
				pRxBuffer + tmpLen,
				rfd->ActualCount);
			}        

			tmpLen += (rfd->ActualCount & ~0x03);

			if (rfd->ActualCount & 0x03)
				tmpLen += 4;
			rfd->ActualCount += macp->rxOffset;
		}
	}
	else {
		// last_pkt_len = 509, 510, 511
		// wait next Rx
		//ZD1211DEBUG(0, "Wait Rx Frames Length Info!!\n");
		//ZD1211DEBUG(2, "last_pkt_len = %x\n", last_pkt_len);
		macp->WaitLenInfoCnt++;
		rx_struct->UnFinishFrmLen = ((TotalLength / macp->wMaxPacketSize) + 1) 
					* (macp->wMaxPacketSize);
		//zd1205_dump_data("pRxBuffer", (u8 *)pRxBuffer, TotalLength);
	}


	if(zd1211_submit_rx_urb(macp))
	{
		printk("No available buffer. Reallocate\n");
		zd1211_alloc_rx((unsigned long)macp);
		if(zd1211_submit_rx_urb(macp))
			printk("zd1211_submit_rx_urb fail. Abort\n");
	}

	if (!rx_struct->UnFinishFrmLen){
		macp->total_rx_cnt = rx_array_cnt;
		macp->rx_struct_array = rx_struct_array;
		zd1205_rx_isr(macp);
	}


#else
	rfd->CbStatus = RFD_STATUS_COMPLETE;
	rfd->ActualCount = TotalLength + macp->rxOffset;
	zd1205_rx_isr(macp);
#endif

	if (dot11Obj.QueueFlag & MGT_QUEUE_SET)
		defer_kevent(macp, KEVENT_PROCESS_SIGNAL);
	spin_unlock(&macp->intr_lock);
}	






#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
void zd1211_rx_comp_cb(struct urb *urb)
#else
void zd1211_rx_comp_cb(struct urb *urb, struct pt_regs *regs)
#endif




{
	struct zd1205_private *macp = urb->context;



    if ((!macp) || !test_bit(ZD1211_RUNNING, &macp->flags))

		return;
  

	if (!netif_device_present(macp->device))
		return;

    if (urb->status != 0){
        zd1211_DumpErrorCode(macp, urb->status);
		if ((urb->status != -ENOENT) &&

		    (urb->status != -ECONNRESET) &&

            (urb->status != -ESHUTDOWN)) {
			    //printk("nonzero read bulk status received: %d\n", urb->status);
            #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))    
                if (urb->status == USB_ST_INTERNALERROR)

                    return;

            #else

                if (urb->status == -EPIPE){
                    printk("nonzero read bulk status received: -EPIPE\n");
                    return;
                }

                if (urb->status == -EPROTO){
                    printk("nonzero read bulk status received: -EPROTO\n");
                    return;
                }                 



            #endif        
                    

				if(zd1211_submit_rx_urb(macp))
				{
						printk("No available buffer. Reallocate\n");
						zd1211_alloc_rx((unsigned long)macp);
						if(zd1211_submit_rx_urb(macp))
								printk("zd1211_submit_rx_urb fail. Abort\n");
				}
			    return;
 		}
		return;

	}


    if (urb->actual_length == 0){
        FPRINT("Got Length = 0");

		if(zd1211_submit_rx_urb(macp))
		{
				printk("No available buffer. Reallocate\n");
				zd1211_alloc_rx((unsigned long)macp);
				if(zd1211_submit_rx_urb(macp))
						printk("zd1211_submit_rx_urb fail. Abort\n");
		}
        return;
    }

       
	macp->read_urb = urb;
    zd1211_rx_isr((unsigned long) macp);

}	





//callback function for interrupt or response 
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
void zd1211_intr_cb(struct urb *urb)
#else
void zd1211_intr_cb(struct urb *urb, struct pt_regs *regs)
#endif
{
	struct zd1205_private *macp = urb->context;
	u16 intNum;
	int status;
	u32 actual_length = urb->actual_length;

	if (!macp)
		return;

	spin_lock(&macp->intr_lock);
    
	if (urb->status != 0){
		zd1211_DumpErrorCode(macp, urb->status);

		if (urb->status == -ENODEV){ //device was removed
			FPRINT("Device was removed!!!");
			macp->bUSBDeveiceAttached = 0;

            wake_up(&macp->regSet_wait);
            wake_up_interruptible(&macp->iorwRsp_wait);

            spin_unlock(&macp->intr_lock);
            return;
        }

        switch (urb->status){
            case -ECONNRESET:
            case -ENOENT:
            case -ESHUTDOWN:
        #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
            case -EPROTO:
        #endif
                macp->bUSBDeveiceAttached = 0;
                FPRINT("Device was down!!!");
        #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
                spin_unlock(&macp->intr_lock);
                return;
        #endif    

                break;

            default:
                //printk("nonzero intr status received: %d\n", urb->status);
                break;
        }             
 
	}
	else {
        if (macp->IntEPBuffer[0] != 0x01)
            FPRINT("Got unknown packet");
            
		switch (macp->IntEPBuffer[1]){
			case EPINT_IORDRsp:

				// this is USB_READ_REGISTER response
				macp->ReadRegCount = (u16)actual_length;

				//intNum = *(u16 *)(macp->IntEPBuffer+2);
                intNum = zd_get_LE_U16(macp->IntEPBuffer+2);

				if (intNum == (InterruptCtrl | macp->USBCSRAddress)){   
					// Handle non-RxTx interrupt
					if (macp->bHandleNonRxTxRunning){
						printk("Impossible, interrupt happen!!!!! %x\n", intNum);
						break;
					}

					// disable non-RxTx interrupt
					// No needed to diable interrupt, firmware will do it.
					macp->bHandleNonRxTxRunning = 1;
					memcpy(macp->IntEPBuffer3, macp->IntEPBuffer, MAX_EPINT_BUFFER);
					defer_kevent(macp, KEVENT_NON_TX_RX_INT);
 
				}
				else{
					// handle read register
					memcpy(macp->IntEPBuffer2, macp->IntEPBuffer, MAX_EPINT_BUFFER);
					set_bit(ZD1211_REQ_COMP, &macp->flags);        
					wake_up_interruptible(&macp->iorwRsp_wait);
				}
				break;

			case EPINT_RetryFial_Event:
			{
				u8 *pMacAddr = macp->IntEPBuffer + 4;
				//u8 NewRate = (u8)(*(u16 *)(macp->IntEPBuffer + 2));
				//u8 NewRate = macp->IntEPBuffer[2];
				u16 aid;

            #if fTX_PWR_CTRL
                if (macp->TxOFDMType >= cTX_48M)
                    macp->TxOFDMCnt = 0;
            #endif
				
				 if ( macp->IntEPBuffer[10] & BIT_0 )

					macp->bIBSS_Wakeup_Dest = 1;


                //ZD1211DEBUG(2, "Retry Failed!!!\n");
 		        //ZD1211DEBUG(2, "NewRate = %x\n", NewRate);
 		       	aid = zd_AidLookUp(pMacAddr);
	           	zd_EventNotify(EVENT_TX_COMPLETE, ZD_RETRY_FAILED, 0xff, (U32)aid);
				//macp->retryFailCnt +=  *(u16 *)(macp->IntEPBuffer + 10);
				macp->retryFailCnt +=  zd_get_LE_U16(macp->IntEPBuffer + 10);
				break;

			}


			default:
				FPRINT(