Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d9811b79 authored by Daniele Boncompagni's avatar Daniele Boncompagni Committed by Greg Kroah-Hartman
Browse files

Staging: comedi : fix brace coding style issue in wwrap.c 



This is a patch to the wwrap.c file that fixes up a brace warnings and
other errors found by the checkpatch.pl tool.

Signed-off-by: default avatarDaniele Boncompagni <daniele.boncompagni@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 3457912e

drivers/staging/otus/wwrap.c

+446 −522
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ extern void zfIdlRsp(zdev_t* dev, u32_t *rsp, u16_t rspLen); 






//extern struct zsWdsStruct wds[ZM_WDS_PORT_NUMBER];

/*extern struct zsWdsStruct wds[ZM_WDS_PORT_NUMBER];*/

extern struct zsVapStruct vap[ZM_VAP_PORT_NUMBER];



u32_t zfLnxUsbSubmitTxData(zdev_t *dev);
@@ -56,18 +56,15 @@ u16_t zfLnxGetFreeTxUrb(zdev_t *dev) 


    spin_lock_irqsave(&macp->cs_lock, irqFlag);



    //idx = ((macp->TxUrbTail + 1) & (ZM_MAX_TX_URB_NUM - 1));

    /*idx = ((macp->TxUrbTail + 1) & (ZM_MAX_TX_URB_NUM - 1));*/



    //if (idx != macp->TxUrbHead)

    if (macp->TxUrbCnt != 0)

    {

    /*if (idx != macp->TxUrbHead)*/

    if (macp->TxUrbCnt != 0) {

	idx = macp->TxUrbTail;

	macp->TxUrbTail = ((macp->TxUrbTail + 1) & (ZM_MAX_TX_URB_NUM - 1));

	macp->TxUrbCnt--;

    }

    else

    {

        //printk(KERN_ERR "macp->TxUrbCnt: %d\n", macp->TxUrbCnt);

	} else {

	/*printk(KERN_ERR "macp->TxUrbCnt: %d\n", macp->TxUrbCnt);*/

	idx = 0xffff;

	}
@@ -85,14 +82,11 @@ void zfLnxPutTxUrb(zdev_t *dev) 


    idx = ((macp->TxUrbHead + 1) & (ZM_MAX_TX_URB_NUM - 1));



    //if (idx != macp->TxUrbTail)

    if (macp->TxUrbCnt < ZM_MAX_TX_URB_NUM)

    {

    /*if (idx != macp->TxUrbTail)*/

    if (macp->TxUrbCnt < ZM_MAX_TX_URB_NUM) {

	macp->TxUrbHead = idx;

	macp->TxUrbCnt++;

    }

    else

    {

    } else {

	printk("UsbTxUrbQ inconsistent: TxUrbHead: %d, TxUrbTail: %d\n",

	macp->TxUrbHead, macp->TxUrbTail);

    }
@@ -125,18 +119,14 @@ UsbTxQ_t *zfLnxGetUsbTxBuffer(zdev_t *dev) 


    idx = ((macp->TxBufHead+1) & (ZM_MAX_TX_BUF_NUM - 1));



    //if (idx != macp->TxBufTail)

    if (macp->TxBufCnt > 0)

    {

        //printk("CWY - zfwGetUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);

    /*if (idx != macp->TxBufTail)*/

    if (macp->TxBufCnt > 0) {

	/*printk("CWY - zfwGetUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);*/

	TxQ = (UsbTxQ_t *)&(macp->UsbTxBufQ[macp->TxBufHead]);

	macp->TxBufHead = ((macp->TxBufHead+1) & (ZM_MAX_TX_BUF_NUM - 1));

	macp->TxBufCnt--;

    }

    else

    {

        if (macp->TxBufHead != macp->TxBufTail)

        {

	} else {

	if (macp->TxBufHead != macp->TxBufTail) {

		printk(KERN_ERR "zfwGetUsbTxBuf UsbTxBufQ inconsistent: TxBufHead: %d, TxBufTail: %d\n",

		macp->TxBufHead, macp->TxBufTail);

	}
@@ -163,12 +153,11 @@ u16_t zfLnxPutUsbTxBuffer(zdev_t *dev, u8_t *hdr, u16_t hdrlen, 
    idx = ((macp->TxBufTail+1) & (ZM_MAX_TX_BUF_NUM - 1));



    /* For Tx debug */

    //zm_assert(macp->TxBufCnt >= 0); // deleted because of always true

    /*zm_assert(macp->TxBufCnt >= 0); // deleted because of always true*/



    //if (idx != macp->TxBufHead)

    if (macp->TxBufCnt < ZM_MAX_TX_BUF_NUM)

    {

        //printk("CWY - zfwPutUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);

    /*if (idx != macp->TxBufHead)*/

    if (macp->TxBufCnt < ZM_MAX_TX_BUF_NUM) {

	/*printk("CWY - zfwPutUsbTxBuffer ,macp->TxBufCnt = %d\n", macp->TxBufCnt);*/

	TxQ = (UsbTxQ_t *)&(macp->UsbTxBufQ[macp->TxBufTail]);

	memcpy(TxQ->hdr, hdr, hdrlen);

	TxQ->hdrlen = hdrlen;
@@ -181,9 +170,7 @@ u16_t zfLnxPutUsbTxBuffer(zdev_t *dev, u8_t *hdr, u16_t hdrlen, 


	macp->TxBufTail = ((macp->TxBufTail+1) & (ZM_MAX_TX_BUF_NUM - 1));

	macp->TxBufCnt++;

    }

    else

    {

	} else {

	printk(KERN_ERR "zfLnxPutUsbTxBuffer UsbTxBufQ inconsistent: TxBufHead: %d, TxBufTail: %d, TxBufCnt: %d\n",

		macp->TxBufHead, macp->TxBufTail, macp->TxBufCnt);

	spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
@@ -197,23 +184,20 @@ u16_t zfLnxPutUsbTxBuffer(zdev_t *dev, u8_t *hdr, u16_t hdrlen, 
zbuf_t *zfLnxGetUsbRxBuffer(zdev_t *dev)

{

    struct usbdrv_private *macp = dev->ml_priv;

    //u16_t idx;

    /*u16_t idx;*/

    zbuf_t *buf;

    unsigned long irqFlag;



    spin_lock_irqsave(&macp->cs_lock, irqFlag);



    //idx = ((macp->RxBufHead+1) & (ZM_MAX_RX_URB_NUM - 1));

    /*idx = ((macp->RxBufHead+1) & (ZM_MAX_RX_URB_NUM - 1));*/



    //if (idx != macp->RxBufTail)

    if (macp->RxBufCnt != 0)

    {

    /*if (idx != macp->RxBufTail)*/

    if (macp->RxBufCnt != 0) {

	buf = macp->UsbRxBufQ[macp->RxBufHead];

	macp->RxBufHead = ((macp->RxBufHead+1) & (ZM_MAX_RX_URB_NUM - 1));

	macp->RxBufCnt--;

    }

    else

    {

    } else {

	printk("RxBufQ inconsistent: RxBufHead: %d, RxBufTail: %d\n",

		macp->RxBufHead, macp->RxBufTail);

	spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
@@ -234,15 +218,12 @@ u32_t zfLnxPutUsbRxBuffer(zdev_t *dev, zbuf_t *buf) 


    idx = ((macp->RxBufTail+1) & (ZM_MAX_RX_URB_NUM - 1));



    //if (idx != macp->RxBufHead)

    if (macp->RxBufCnt != ZM_MAX_RX_URB_NUM)

    {

    /*if (idx != macp->RxBufHead)*/

    if (macp->RxBufCnt != ZM_MAX_RX_URB_NUM) {

	macp->UsbRxBufQ[macp->RxBufTail] = buf;

	macp->RxBufTail = idx;

	macp->RxBufCnt++;

    }

    else

    {

    } else {

	printk("RxBufQ inconsistent: RxBufHead: %d, RxBufTail: %d\n",

		macp->RxBufHead, macp->RxBufTail);

	spin_unlock_irqrestore(&macp->cs_lock, irqFlag);
@@ -256,17 +237,15 @@ u32_t zfLnxPutUsbRxBuffer(zdev_t *dev, zbuf_t *buf) 
void zfLnxUsbDataOut_callback(urb_t *urb)

{

    zdev_t *dev = urb->context;

    //UsbTxQ_t *TxData;

    /*UsbTxQ_t *TxData;*/



    /* Give the urb back */

    zfLnxPutTxUrb(dev);



    /* Check whether there is any pending buffer needed */

    /* to be sent */

    if (zfLnxCheckTxBufferCnt(dev) != 0)

    {

        //TxData = zfwGetUsbTxBuffer(dev);



    if (zfLnxCheckTxBufferCnt(dev) != 0) {

	/*TxData = zfwGetUsbTxBuffer(dev);

	//if (TxData == NULL)

	//{

	//    printk("Get a NULL buffer from zfwGetUsbTxBuffer\n");
@@ -275,7 +254,7 @@ void zfLnxUsbDataOut_callback(urb_t *urb) 
	//else

	//{

		zfLnxUsbSubmitTxData(dev);

        //}

	//}*/

    }

}
@@ -288,7 +267,7 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
    int status;



#if ZM_USB_STREAM_MODE == 1

    static int remain_len = 0, check_pad = 0, check_len = 0;

    static int remain_len, check_pad, check_len;

    int index = 0;

    int chk_idx;

    u16_t pkt_len;
@@ -302,20 +281,19 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
    if (urb->status != 0) {

	printk("zfLnxUsbDataIn_callback() : status=0x%x\n", urb->status);

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

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

        {

		&& (urb->status != -ESHUTDOWN)) {

		if (urb->status == -EPIPE) {

                    //printk(KERN_ERR "nonzero read bulk status received: -EPIPE");

			/*printk(KERN_ERR "nonzero read bulk status received: -EPIPE");*/

			status = -1;

		}



		if (urb->status == -EPROTO) {

                    //printk(KERN_ERR "nonzero read bulk status received: -EPROTO");

			/*printk(KERN_ERR "nonzero read bulk status received: -EPROTO");*/

			status = -1;

		}

	}



        //printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);

	/*printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);*/



	/* Dequeue skb buffer */

	buf = zfLnxGetUsbRxBuffer(dev);
@@ -330,8 +308,7 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
	return;

	}



    if (urb->actual_length == 0)

    {

    if (urb->actual_length == 0) {

	printk(KERN_ERR "Get an URB whose length is zero");

	status = -1;

    }
@@ -339,7 +316,7 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
    /* Dequeue skb buffer */

    buf = zfLnxGetUsbRxBuffer(dev);



    //zfwBufSetSize(dev, buf, urb->actual_length);

    /*zfwBufSetSize(dev, buf, urb->actual_length);*/

#ifdef NET_SKBUFF_DATA_USES_OFFSET

    buf->tail = 0;

    buf->len = 0;
@@ -353,8 +330,7 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
    skb_put(buf, urb->actual_length);



#if ZM_USB_STREAM_MODE == 1

    if (remain_len != 0)

    {

    if (remain_len != 0) {

	zbuf_t *remain_buf = macp->reamin_buf;



	index = remain_len;
@@ -368,20 +344,17 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
	rxBufPool[rxBufPoolIndex++] = remain_buf;

    }



    while(index < urb->actual_length)

    {

    while (index < urb->actual_length) {

	pkt_len = buf->data[index] + (buf->data[index+1] << 8);

	pkt_tag = buf->data[index+2] + (buf->data[index+3] << 8);



        if (pkt_tag == 0x4e00)

        {

	if (pkt_tag == 0x4e00) {

		int pad_len;



            //printk("Get a packet, index: %d, pkt_len: 0x%04x\n", index, pkt_len);

		/*printk("Get a packet, index: %d, pkt_len: 0x%04x\n", index, pkt_len);*/

		#if 0

		/* Dump data */

            for (ii = index; ii < pkt_len+4;)

            {

		for (ii = index; ii < pkt_len+4;) {

			printk("%02x ", (buf->data[ii] & 0xff));



			if ((++ii % 16) == 0)
@@ -399,14 +372,13 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
		chk_idx = index;

		index = index + 4 + pkt_len + pad_len;



            if (index > ZM_MAX_RX_BUFFER_SIZE)

            {

                remain_len = index - ZM_MAX_RX_BUFFER_SIZE; // - pad_len;

		if (index > ZM_MAX_RX_BUFFER_SIZE) {

			remain_len = index - ZM_MAX_RX_BUFFER_SIZE; /* - pad_len;*/

			check_len = ZM_MAX_RX_BUFFER_SIZE - chk_idx - 4;

			check_pad = pad_len;



			/* Allocate a skb buffer */

                //new_buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);

			/*new_buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);*/

			new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);



			/* Set skb buffer length */
@@ -425,19 +397,14 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 


			/* Record the buffer pointer */

			macp->reamin_buf = new_buf;

            }

            else

            {

		} else  {

			#ifdef ZM_DONT_COPY_RX_BUFFER

                if (rxBufPoolIndex == 0)

                {

			if (rxBufPoolIndex == 0) {

				new_buf = skb_clone(buf, GFP_ATOMIC);



				new_buf->data = &(buf->data[chk_idx+4]);

				new_buf->len = pkt_len;

                }

                else

                {

			} else  {

				#endif

				/* Allocate a skb buffer */

				new_buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);
@@ -461,9 +428,7 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
			#endif

			rxBufPool[rxBufPoolIndex++] = new_buf;

			}

        }

        else

        {

		} else {

			printk(KERN_ERR "Can't find tag, pkt_len: 0x%04x, tag: 0x%04x\n", pkt_len, pkt_tag);



			/* Free buffer */
@@ -496,8 +461,7 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 
    zfLnxUsbIn(dev, urb, new_buf);



#if ZM_USB_STREAM_MODE == 1

    for(ii = 0; ii < rxBufPoolIndex; ii++)

    {

    for (ii = 0; ii < rxBufPoolIndex; ii++) {

	macp->usbCbFunctions.zfcbUsbRecv(dev, rxBufPool[ii]);

    }

#else
@@ -508,9 +472,9 @@ void zfLnxUsbDataIn_callback(urb_t *urb) 


void zfLnxUsbRegOut_callback(urb_t *urb)

{

    //dev_t* dev = urb->context;

    /*dev_t* dev = urb->context;*/



    //printk(KERN_ERR "zfwUsbRegOut_callback\n");

	/*printk(KERN_ERR "zfwUsbRegOut_callback\n");*/

}



void zfLnxUsbRegIn_callback(urb_t *urb)
@@ -523,26 +487,23 @@ void zfLnxUsbRegIn_callback(urb_t *urb) 
    /* Check status for URB */

    if (urb->status != 0) {

	printk("zfLnxUsbRegIn_callback() : status=0x%x\n", urb->status);

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

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

        {

	if ((urb->status != -ENOENT) && (urb->status != -ECONNRESET) && (urb->status != -ESHUTDOWN)) {

		if (urb->status == -EPIPE) {

                    //printk(KERN_ERR "nonzero read bulk status received: -EPIPE");

			/*printk(KERN_ERR "nonzero read bulk status received: -EPIPE");*/

			status = -1;

		}



		if (urb->status == -EPROTO) {

                    //printk(KERN_ERR "nonzero read bulk status received: -EPROTO");

			/*printk(KERN_ERR "nonzero read bulk status received: -EPROTO");*/

			status = -1;

		}

	}



        //printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);

	/*printk(KERN_ERR "urb->status: 0x%08x\n", urb->status);*/

	return;

	}



    if (urb->actual_length == 0)

    {

    if (urb->actual_length == 0) {

	printk(KERN_ERR "Get an URB whose length is zero");

	status = -1;

    }
@@ -551,8 +512,8 @@ void zfLnxUsbRegIn_callback(urb_t *urb) 
    memcpy(rsp, macp->regUsbReadBuf, urb->actual_length);



    /* Notify to upper layer */

    //zfIdlChkRsp(dev, rsp, (u16_t)urb->actual_length);

    //zfiUsbRegIn(dev, rsp, (u16_t)urb->actual_length);

    /*zfIdlChkRsp(dev, rsp, (u16_t)urb->actual_length);*/

    /*zfiUsbRegIn(dev, rsp, (u16_t)urb->actual_length);*/

    macp->usbCbFunctions.zfcbUsbRegIn(dev, rsp, (u16_t)urb->actual_length);



    /* Issue another USB IN URB */
@@ -564,13 +525,13 @@ u32_t zfLnxSubmitRegInUrb(zdev_t *dev) 
    u32_t ret;

    struct usbdrv_private *macp = dev->ml_priv;



    /* Submit a rx urb */

    /* Submit a rx urb

    //ret = zfLnxUsbSubmitBulkUrb(macp->RegInUrb, macp->udev,

    //        USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,

    //        ZM_USB_REG_MAX_BUF_SIZE, zfLnxUsbRegIn_callback, dev);

    //CWYang(-)

    //if (ret != 0)

    //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);

    //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/



    ret = zfLnxUsbSubmitIntUrb(macp->RegInUrb, macp->udev,

	USB_REG_IN_PIPE, USB_DIR_IN, macp->regUsbReadBuf,
@@ -600,36 +561,30 @@ u32_t zfLnxUsbSubmitTxData(zdev_t* dev) 
    freeTxUrb = zfLnxGetFreeTxUrb(dev);



    /* If there is no any free Tx Urb */

    if (freeTxUrb == 0xffff)

    {

        //printk(KERN_ERR "Can't get free Tx Urb\n");

        //printk("CWY - Can't get free Tx Urb\n");

    if (freeTxUrb == 0xffff) {

	/*printk(KERN_ERR "Can't get free Tx Urb\n");

	//printk("CWY - Can't get free Tx Urb\n");*/

	return 0xffff;

    }



#if ZM_USB_TX_STREAM_MODE == 1

    usbTxAggCnt = zfLnxCheckTxBufferCnt(dev);



    if (usbTxAggCnt >= ZM_MAX_TX_AGGREGATE_NUM)

    {

    if (usbTxAggCnt >= ZM_MAX_TX_AGGREGATE_NUM) {

	usbTxAggCnt = ZM_MAX_TX_AGGREGATE_NUM;

    }

    else

    {

    } else {

	usbTxAggCnt = 1;

    }



    //printk("usbTxAggCnt: %d\n", usbTxAggCnt);

    /*printk("usbTxAggCnt: %d\n", usbTxAggCnt);*/

#endif



#if ZM_USB_TX_STREAM_MODE == 1

    for(ii = 0; ii < usbTxAggCnt; ii++)

    {

    for (ii = 0; ii < usbTxAggCnt; ii++) {

#endif

    /* Dequeue the packet from UsbTxBufQ */

    TxData = zfLnxGetUsbTxBuffer(dev);

    if (TxData == NULL)

    {

    if (TxData == NULL) {

	/* Give the urb back */

	zfLnxPutTxUrb(dev);

	return 0xffff;
@@ -649,41 +604,35 @@ u32_t zfLnxUsbSubmitTxData(zdev_t* dev) 
    *pUsbTxHdr++ = 0x697e;



    puTxBuf += 4;

#endif // #ifdef ZM_USB_TX_STREAM_MODE

#endif /* #ifdef ZM_USB_TX_STREAM_MODE*/



    /* Copy WLAN header and packet buffer into USB buffer */

    for(i = 0; i < TxData->hdrlen; i++)

    {

    for (i = 0; i < TxData->hdrlen; i++) {

	*puTxBuf++ = TxData->hdr[i];

    }



    /* Copy SNAP header */

    for(i = 0; i < TxData->snapLen; i++)

    {

    for (i = 0; i < TxData->snapLen; i++) {

	*puTxBuf++ = TxData->snap[i];

    }



    /* Copy packet buffer */

    for(i = 0; i < TxData->buf->len - TxData->offset; i++)

    {

    	//*puTxBuf++ = zmw_rx_buf_readb(dev, TxData->buf, i);

    for (i = 0; i < TxData->buf->len - TxData->offset; i++) {

	/*puTxBuf++ = zmw_rx_buf_readb(dev, TxData->buf, i);*/

	*puTxBuf++ = *(u8_t *)((u8_t *)TxData->buf->data+i+TxData->offset);

    }



    /* Copy tail */

    for(i = 0; i < TxData->tailLen; i++)

    {

    for (i = 0; i < TxData->tailLen; i++) {

	*puTxBuf++ = TxData->tail[i];

    }



    len = TxData->hdrlen+TxData->snapLen+TxData->buf->len+TxData->tailLen-TxData->offset;



    #if 0

    if (TxData->hdrlen != 0)

    {

    if (TxData->hdrlen != 0) {

	puTxBuf = macp->txUsbBuf[freeTxUrb];

        for (i = 0; i < len; i++)

        {

	for (i = 0; i < len; i++) {

		printk("%02x ", puTxBuf[i]);

		if (i % 16 == 15)

		printk("\n");
@@ -693,16 +642,13 @@ u32_t zfLnxUsbSubmitTxData(zdev_t* dev) 
    #endif

    #if 0

    /* For debug purpose */

    if(TxData->hdr[9] & 0x40)

    {

    if (TxData->hdr[9] & 0x40) {

	int i;

	u16_t ctrlLen = TxData->hdr[0] + (TxData->hdr[1] << 8);



        if (ctrlLen != len + 4)

        {

	if (ctrlLen != len + 4) {

	/* Dump control setting */

        for(i = 0; i < 8; i++)

        {

	for (i = 0; i < 8; i++) {

		printk(KERN_ERR "0x%02x ", TxData->hdr[i]);

	}

	printk(KERN_ERR "\n");
@@ -714,41 +660,39 @@ u32_t zfLnxUsbSubmitTxData(zdev_t* dev) 
    #endif



#if ZM_USB_TX_STREAM_MODE == 1

    // Add the Length and Tag

    /* Add the Length and Tag*/

    len += 4;



    //printk("%d packet, length: %d\n", ii+1, len);

    /*printk("%d packet, length: %d\n", ii+1, len);*/



    if (ii < (ZM_MAX_TX_AGGREGATE_NUM-1))

    {

    if (ii < (ZM_MAX_TX_AGGREGATE_NUM-1)) {

	/* Pad the buffer to firmware descriptor boundary */

	offset += (((len-1) / 4) + 1) * 4;

    }



    if (ii == (ZM_MAX_TX_AGGREGATE_NUM-1))

    {

    if (ii == (ZM_MAX_TX_AGGREGATE_NUM-1)) {

	len += offset;

    }



    TxQPool[ii] = TxData;



    //DbgPrint("%d packet, offset: %d\n", ii+1, pUsbTxTransfer->offset);

    /*DbgPrint("%d packet, offset: %d\n", ii+1, pUsbTxTransfer->offset);*/



    /* free packet */

    //zfBufFree(dev, txData->buf);

    /*zfBufFree(dev, txData->buf);*/

    }

#endif

    //printk("CWY - call zfwUsbSubmitBulkUrb(), len = 0x%d\n", len);

    /*printk("CWY - call zfwUsbSubmitBulkUrb(), len = 0x%d\n", len);*/

    /* Submit a tx urb */

    ret = zfLnxUsbSubmitBulkUrb(macp->WlanTxDataUrb[freeTxUrb], macp->udev,

	USB_WLAN_TX_PIPE, USB_DIR_OUT, macp->txUsbBuf[freeTxUrb],

	len, zfLnxUsbDataOut_callback, dev);

    //CWYang(-)

    /*CWYang(-)

    //if (ret != 0)

    //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);

    //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/



    /* free packet */

    //dev_kfree_skb_any(TxData->buf);

    /*dev_kfree_skb_any(TxData->buf);*/

#if ZM_USB_TX_STREAM_MODE == 1

    for (ii = 0; ii < usbTxAggCnt; ii++)

	macp->usbCbFunctions.zfcbUsbOutComplete(dev, TxQPool[ii]->buf, 1, TxQPool[ii]->hdr);
@@ -770,9 +714,9 @@ u32_t zfLnxUsbIn(zdev_t* dev, urb_t *urb, zbuf_t *buf) 
    ret = zfLnxUsbSubmitBulkUrb(urb, macp->udev, USB_WLAN_RX_PIPE,

	USB_DIR_IN, buf->data, ZM_MAX_RX_BUFFER_SIZE,

	zfLnxUsbDataIn_callback, dev);

    //CWYang(-)

    /*CWYang(-)

    //if (ret != 0)

    //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);

    //    printk("zfwUsbSubmitBulkUrb fail, status: 0x%08x\n", (int)ret);*/



    return ret;

}
@@ -808,20 +752,19 @@ u32_t zfLnxUsbOut(zdev_t* dev, u8_t *hdr, u16_t hdrlen, u8_t *snap, u16_t snapLe 
    struct usbdrv_private *macp = dev->ml_priv;



    /* Check length of tail buffer */

    //zm_assert((tailLen <= 16));

    /*zm_assert((tailLen <= 16));*/



    /* Enqueue the packet into UsbTxBufQ */

    if (zfLnxPutUsbTxBuffer(dev, hdr, hdrlen, snap, snapLen, tail, tailLen, buf, offset) == 0xffff)

    {

    if (zfLnxPutUsbTxBuffer(dev, hdr, hdrlen, snap, snapLen, tail, tailLen, buf, offset) == 0xffff) {

	/* free packet */

        //printk("CWY - zfwPutUsbTxBuffer Error, free packet\n");

        //dev_kfree_skb_any(buf);

	/*printk("CWY - zfwPutUsbTxBuffer Error, free packet\n");

	//dev_kfree_skb_any(buf);*/

	macp->usbCbFunctions.zfcbUsbOutComplete(dev, buf, 0, hdr);

	return 0xffff;

	}



    //return 0;

    //printk("CWY - call zfwUsbSubmitTxData()\n");

    /*return 0;

    //printk("CWY - call zfwUsbSubmitTxData()\n");*/

    ret = zfLnxUsbSubmitTxData(dev);

    return ret;

}
@@ -853,19 +796,17 @@ void zfLnxInitUsbRxQ(zdev_t* dev) 


    macp->RxBufHead = 0;



    for (i = 0; i < ZM_MAX_RX_URB_NUM; i++)

    {

        //buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);

    for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) {

	/*buf = zfwBufAllocate(dev, ZM_MAX_RX_BUFFER_SIZE);*/

	buf = dev_alloc_skb(ZM_MAX_RX_BUFFER_SIZE);

	macp->UsbRxBufQ[i] = buf;

	}



    //macp->RxBufTail = ZM_MAX_RX_URB_NUM - 1;

    /*macp->RxBufTail = ZM_MAX_RX_URB_NUM - 1;*/

    macp->RxBufTail = 0;



    /* Submit all Rx urbs */

    for (i = 0; i < ZM_MAX_RX_URB_NUM; i++)

    {

    for (i = 0; i < ZM_MAX_RX_URB_NUM; i++) {

	zfLnxPutUsbRxBuffer(dev, macp->UsbRxBufQ[i]);

	zfLnxUsbIn(dev, macp->WlanRxDataUrb[i], macp->UsbRxBufQ[i]);

	}
@@ -878,32 +819,26 @@ u32_t zfLnxUsbSubmitBulkUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16 
{

    u32_t ret;



    if(direction == USB_DIR_OUT)

    {

    if (direction == USB_DIR_OUT) {

	usb_fill_bulk_urb(urb, usb, usb_sndbulkpipe(usb, epnum),

		transfer_buffer, buffer_length, complete, context);



	urb->transfer_flags |= URB_ZERO_PACKET;

    }

    else

    {

    } else {

	usb_fill_bulk_urb(urb, usb, usb_rcvbulkpipe(usb, epnum),

		transfer_buffer, buffer_length, complete, context);

    }



    if (epnum == 4)

    {

        if (urb->hcpriv)

        {

            //printk("CWY - urb->hcpriv set by unknown reason, reset it\n");

            //urb->hcpriv = 0;

    if (epnum == 4) {

	if (urb->hcpriv) {

		/*printk("CWY - urb->hcpriv set by unknown reason, reset it\n");

		//urb->hcpriv = 0;*/

		}

	}



    ret = usb_submit_urb(urb, GFP_ATOMIC);

    if ((epnum == 4) & (ret != 0))

    {

        //printk("CWY - ret = %x\n", ret);

    if ((epnum == 4) & (ret != 0)) {

	/*printk("CWY - ret = %x\n", ret);*/

    }

    return ret;

}
@@ -914,13 +849,10 @@ u32_t zfLnxUsbSubmitIntUrb(urb_t *urb, struct usb_device *usb, u16_t epnum, u16_ 
{

    u32_t ret;



    if(direction == USB_DIR_OUT)

    {

    if (direction == USB_DIR_OUT) {

	usb_fill_int_urb(urb, usb, usb_sndbulkpipe(usb, epnum),

		transfer_buffer, buffer_length, complete, context, interval);

    }

    else

    {

    } else {

	usb_fill_int_urb(urb, usb, usb_rcvbulkpipe(usb, epnum),

	transfer_buffer, buffer_length, complete, context, interval);

    }
@@ -946,44 +878,41 @@ int zfLnxCencSendMsg(struct sock *netlink_sk, u_int8_t *msg, int len) 
	size = NLMSG_SPACE(len);

	skb = alloc_skb(size, GFP_ATOMIC);



	if(skb == NULL)

	{

	if (skb == NULL) {

		printk("dev_alloc_skb failure \n");

		goto out;

	}

	old_tail = skb->tail;



	/*填写数据报相关信息*/

	/* */

	nlh = NLMSG_PUT(skb, 0, 0, WAI_K_MSG, size-sizeof(*nlh));

	pos = NLMSG_DATA(nlh);



	/*传输到用户空间的数据*/

	/* */

	memcpy(pos, msg,  len);

	/*计算经过字节对其后的数据实际长度*/

	/* */

	nlh->nlmsg_len = skb->tail - old_tail;

	NETLINK_CB(skb).dst_group = COMMTYPE_GROUP;

	netlink_broadcast(netlink_sk, skb, 0, COMMTYPE_GROUP, GFP_ATOMIC);

	ret = 0;

out:

	return ret;

nlmsg_failure: /*NLMSG_PUT 失败，则撤销套接字缓存*/

nlmsg_failure: /* */

	kfree_skb(skb);

	goto out;



#undef COMMTYPE_GROUP

#undef WAI_K_MSG

}

#endif //ZM_ENABLE_CENC

#endif /*ZM_ENABLE_CENC*/



/* Simply return 0xffff if VAP function is not supported */

u16_t zfLnxGetVapId(zdev_t *dev)

{

    u16_t i;



    for (i=0; i<ZM_VAP_PORT_NUMBER; i++)

    {

        if (vap[i].dev == dev)

        {

    for (i = 0; i < ZM_VAP_PORT_NUMBER; i++) {

	if (vap[i].dev == dev) {

		return i;

		}

	}
@@ -1015,18 +944,16 @@ void kevent(struct work_struct *work) 
	container_of(work, struct usbdrv_private, kevent);

	zdev_t *dev = macp->device;



    if (test_and_set_bit(0, (void *)&smp_kevent_Lock))

    {

        //schedule_work(&macp->kevent);

    if (test_and_set_bit(0, (void *)&smp_kevent_Lock)) {

	/*schedule_work(&macp->kevent);*/

	return;

    }



    down(&macp->ioctl_sem);



    if (test_and_clear_bit(KEVENT_WATCHDOG, &macp->kevent_flags))

    {

    if (test_and_clear_bit(KEVENT_WATCHDOG, &macp->kevent_flags)) {

    extern u16_t zfHpStartRecv(zdev_t *dev);

        //zfiHwWatchDogReinit(dev);

	/*zfiHwWatchDogReinit(dev);*/

	printk(("\n ************ Hw watchDog occur!! ************** \n"));

	zfiWlanSuspend(dev);

	zfiWlanResume(dev , 0);
@@ -1083,24 +1010,21 @@ void zfLnxSignalThread(zdev_t *dev, int flag) 
{

    struct usbdrv_private *macp = dev->ml_priv;



    if (macp == NULL)

    {

    if (macp == NULL) {

	printk("macp is NULL\n");

	return;

    }



    if (0 && macp->kevent_ready != 1)

    {

    if (0 && macp->kevent_ready != 1) {

	printk("Kevent not ready\n");

	return;

    }



    set_bit(flag, &macp->kevent_flags);



    if (!schedule_work(&macp->kevent))

    {

        //Fails is Normal

        //printk(KERN_ERR "schedule_task failed, flag = %x\n", flag);

    if (!schedule_work(&macp->kevent)) {

	/*Fails is Normal

	//printk(KERN_ERR "schedule_task failed, flag = %x\n", flag);*/

	}

}
@@ -1114,7 +1038,7 @@ void zfLnxWatchDogNotify(zdev_t* dev) 
/* Query Durantion of Active Scan */

void zfwGetActiveScanDur(zdev_t *dev, u8_t *Dur)

{

    *Dur = 30; // default 30 ms

    *Dur = 30; /* default 30 ms*/

}



void zfwGetShowZeroLengthSSID(zdev_t *dev, u8_t *Dur)