zd1211.c

该代码为linux下通过usb驱动实现的无线网络驱动程序,在2.6.18的内核下调试通过

	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
		endpoint = &iface_desc->endpoint[i].desc;
#endif		

		if ((endpoint->bEndpointAddress & 0x80) &&


		    ((endpoint->bmAttributes & 3) == 0x02)) {

			/* we found a bulk in endpoint */
			bulk_in_endpoint[num_bulk_in] = endpoint;
			++num_bulk_in;


			macp->wMaxPacketSize = zd_le16_to_cpu(endpoint->wMaxPacketSize);
            if(macp->wMaxPacketSize != 64 && macp->wMaxPacketSize!= 512)
            {
                printk("Something wrong. Mostly, it's a endian issue\n");
            }
            ZD1211DEBUG(0, "bulk in: wMaxPacketSize = %x\n", zd_le16_to_cpu(endpoint->wMaxPacketSize));
		}



		if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
		    ((endpoint->bmAttributes & 3) == 0x02)) {
			/* we found a bulk out endpoint */
			bulk_out_endpoint[num_bulk_out] = endpoint;
			++num_bulk_out;
            ZD1211DEBUG(0, "bulk out: wMaxPacketSize = %x\n", zd_le16_to_cpu(endpoint->wMaxPacketSize));

		}
		
		if ((endpoint->bEndpointAddress & 0x80) &&


		    ((endpoint->bmAttributes & 3) == 0x03)) {
			/* we found a interrupt in endpoint */
			interrupt_in_endpoint[num_interrupt_in] = endpoint;
			++num_interrupt_in;
            macp->in_interval = endpoint->bInterval;
            ZD1211DEBUG(0, "interrupt in: wMaxPacketSize = %x\n", zd_le16_to_cpu(endpoint->wMaxPacketSize));

            ZD1211DEBUG(0, "interrupt in: int_interval = %d\n", endpoint->bInterval);

		}
		
		if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
		    ((endpoint->bmAttributes & 3) == 0x03)) {
			/* we found a interrupt out endpoint */
			interrupt_out_endpoint[num_interrupt_out] = endpoint;
			++num_interrupt_out;
            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;


    macp->lastRxComp = jiffies;
    if ((!macp) || !test_bit(ZD1211_RUNNING, &macp->flags))
    {
        if(!macp)
            printk("Error1 in %s\n", __FUNCTION__);
		return;
    }
  

	if (!netif_device_present(macp->device))
    {
        printk("Error2 in %s\n", __FUNCTION__);
		return;
    }

    if (urb->status != 0){
        printk("Error Occur in %s\n", __FUNCTION__);
        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)
                {
                    printk("Error3 in %s\n", __FUNCTION__);
                    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]