xref: /openbmc/linux/drivers/staging/vt6656/usbpipe.c (revision 1ab142d4) 
1 /*
2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3  * All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  *
20  * File: usbpipe.c
21  *
22  * Purpose: Handle USB control endpoint
23  *
24  * Author: Warren Hsu
25  *
26  * Date: Mar. 29, 2005
27  *
28  * Functions:
29  *      CONTROLnsRequestOut - Write variable length bytes to MEM/BB/MAC/EEPROM
30  *      CONTROLnsRequestIn - Read variable length bytes from MEM/BB/MAC/EEPROM
31  *      ControlvWriteByte - Write one byte to MEM/BB/MAC/EEPROM
32  *      ControlvReadByte - Read one byte from MEM/BB/MAC/EEPROM
33  *      ControlvMaskByte - Read one byte from MEM/BB/MAC/EEPROM and clear/set some bits in the same address
34  *
35  * Revision History:
36  *      04-05-2004 Jerry Chen:  Initial release
37  *      11-24-2004 Warren Hsu: Add ControlvWriteByte,ControlvReadByte,ControlvMaskByte
38  *
39  */
40 
41 #include "int.h"
42 #include "rxtx.h"
43 #include "dpc.h"
44 #include "control.h"
45 #include "desc.h"
46 #include "device.h"
47 
48 /*---------------------  Static Definitions -------------------------*/
49 //endpoint def
50 //endpoint 0: control
51 //endpoint 1: interrupt
52 //endpoint 2: read bulk
53 //endpoint 3: write bulk
54 
55 //RequestType:
56 //#define REQUEST_OUT       (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE) // 0x40
57 //#define REQUEST_IN        (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE )  //0xc0
58 //static int          msglevel                =MSG_LEVEL_DEBUG;
59 static int          msglevel                =MSG_LEVEL_INFO;
60 
61 
62 #define USB_CTL_WAIT   500 //ms
63 
64 #ifndef URB_ASYNC_UNLINK
65 #define URB_ASYNC_UNLINK    0
66 #endif
67 
68 /*---------------------  Static Classes  ----------------------------*/
69 
70 /*---------------------  Static Variables  --------------------------*/
71 
72 /*---------------------  Static Functions  --------------------------*/
73 static
74 void
75 s_nsInterruptUsbIoCompleteRead(
76      struct urb *urb
77     );
78 
79 
80 static
81 void
82 s_nsBulkInUsbIoCompleteRead(
83      struct urb *urb
84     );
85 
86 
87 static
88 void
89 s_nsBulkOutIoCompleteWrite(
90      struct urb *urb
91     );
92 
93 
94 static
95 void
96 s_nsControlInUsbIoCompleteRead(
97      struct urb *urb
98     );
99 
100 static
101 void
102 s_nsControlInUsbIoCompleteWrite(
103      struct urb *urb
104     );
105 
106 /*---------------------  Export Variables  --------------------------*/
107 
108 /*---------------------  Export Functions  --------------------------*/
109 
110 int PIPEnsControlOutAsyn(
111      PSDevice     pDevice,
112      BYTE         byRequest,
113      WORD         wValue,
114      WORD         wIndex,
115      WORD         wLength,
116      PBYTE        pbyBuffer
117     )
118 {
119 	int ntStatus;
120 
121     if (pDevice->Flags & fMP_DISCONNECTED)
122         return STATUS_FAILURE;
123 
124     if (pDevice->Flags & fMP_CONTROL_WRITES)
125         return STATUS_FAILURE;
126 
127     if (in_interrupt()) {
128         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"in_interrupt return ..byRequest %x\n", byRequest);
129         return STATUS_FAILURE;
130     }
131 
132     ntStatus = usb_control_msg(
133                             pDevice->usb,
134                             usb_sndctrlpipe(pDevice->usb , 0),
135                             byRequest,
136                             0x40, // RequestType
137                             wValue,
138                             wIndex,
139 			    (void *) pbyBuffer,
140                             wLength,
141                             HZ
142                           );
143     if (ntStatus >= 0) {
144         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"usb_sndctrlpipe ntStatus= %d\n", ntStatus);
145         ntStatus = 0;
146     } else {
147         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"usb_sndctrlpipe fail, ntStatus= %d\n", ntStatus);
148     }
149 
150     return ntStatus;
151 }
152 
153 int PIPEnsControlOut(
154      PSDevice     pDevice,
155      BYTE         byRequest,
156      WORD         wValue,
157      WORD         wIndex,
158      WORD         wLength,
159      PBYTE        pbyBuffer
160     )
161 {
162 	int ntStatus = 0;
163     int ii;
164 
165     if (pDevice->Flags & fMP_DISCONNECTED)
166         return STATUS_FAILURE;
167 
168     if (pDevice->Flags & fMP_CONTROL_WRITES)
169         return STATUS_FAILURE;
170 
171 	pDevice->sUsbCtlRequest.bRequestType = 0x40;
172 	pDevice->sUsbCtlRequest.bRequest = byRequest;
173 	pDevice->sUsbCtlRequest.wValue = cpu_to_le16p(&wValue);
174 	pDevice->sUsbCtlRequest.wIndex = cpu_to_le16p(&wIndex);
175 	pDevice->sUsbCtlRequest.wLength = cpu_to_le16p(&wLength);
176 	pDevice->pControlURB->transfer_flags |= URB_ASYNC_UNLINK;
177     pDevice->pControlURB->actual_length = 0;
178     // Notice, pbyBuffer limited point to variable buffer, can't be constant.
179   	usb_fill_control_urb(pDevice->pControlURB, pDevice->usb,
180 			 usb_sndctrlpipe(pDevice->usb , 0), (char *) &pDevice->sUsbCtlRequest,
181 			 pbyBuffer, wLength, s_nsControlInUsbIoCompleteWrite, pDevice);
182 
183 	ntStatus = usb_submit_urb(pDevice->pControlURB, GFP_ATOMIC);
184 	if (ntStatus != 0) {
185 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"control send request submission failed: %d\n", ntStatus);
186 		return STATUS_FAILURE;
187 	}
188 	else {
189 	    MP_SET_FLAG(pDevice, fMP_CONTROL_WRITES);
190 	}
191 	spin_unlock_irq(&pDevice->lock);
192     for (ii = 0; ii <= USB_CTL_WAIT; ii ++) {
193 
194 	if (pDevice->Flags & fMP_CONTROL_WRITES)
195 		mdelay(1);
196         else
197 		break;
198 
199         if (ii >= USB_CTL_WAIT) {
200 		DBG_PRT(MSG_LEVEL_DEBUG,
201 			KERN_INFO "control send request submission timeout\n");
202             spin_lock_irq(&pDevice->lock);
203             MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
204             return STATUS_FAILURE;
205         }
206     }
207 	spin_lock_irq(&pDevice->lock);
208 
209     return STATUS_SUCCESS;
210 }
211 
212 int PIPEnsControlIn(
213      PSDevice     pDevice,
214      BYTE         byRequest,
215      WORD         wValue,
216      WORD         wIndex,
217      WORD         wLength,
218        PBYTE   pbyBuffer
219     )
220 {
221 	int ntStatus = 0;
222     int ii;
223 
224     if (pDevice->Flags & fMP_DISCONNECTED)
225         return STATUS_FAILURE;
226 
227     if (pDevice->Flags & fMP_CONTROL_READS)
228 	return STATUS_FAILURE;
229 
230 	pDevice->sUsbCtlRequest.bRequestType = 0xC0;
231 	pDevice->sUsbCtlRequest.bRequest = byRequest;
232 	pDevice->sUsbCtlRequest.wValue = cpu_to_le16p(&wValue);
233 	pDevice->sUsbCtlRequest.wIndex = cpu_to_le16p(&wIndex);
234 	pDevice->sUsbCtlRequest.wLength = cpu_to_le16p(&wLength);
235 	pDevice->pControlURB->transfer_flags |= URB_ASYNC_UNLINK;
236     pDevice->pControlURB->actual_length = 0;
237 	usb_fill_control_urb(pDevice->pControlURB, pDevice->usb,
238 			 usb_rcvctrlpipe(pDevice->usb , 0), (char *) &pDevice->sUsbCtlRequest,
239 			 pbyBuffer, wLength, s_nsControlInUsbIoCompleteRead, pDevice);
240 
241 	ntStatus = usb_submit_urb(pDevice->pControlURB, GFP_ATOMIC);
242 	if (ntStatus != 0) {
243 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"control request submission failed: %d\n", ntStatus);
244 	}else {
245 		MP_SET_FLAG(pDevice, fMP_CONTROL_READS);
246     }
247 
248 	spin_unlock_irq(&pDevice->lock);
249     for (ii = 0; ii <= USB_CTL_WAIT; ii ++) {
250 
251 	if (pDevice->Flags & fMP_CONTROL_READS)
252 		mdelay(1);
253 	else
254 		break;
255 
256 	if (ii >= USB_CTL_WAIT) {
257 		DBG_PRT(MSG_LEVEL_DEBUG,
258 			KERN_INFO "control rcv request submission timeout\n");
259             spin_lock_irq(&pDevice->lock);
260             MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
261             return STATUS_FAILURE;
262         }
263     }
264 	spin_lock_irq(&pDevice->lock);
265 
266     return ntStatus;
267 }
268 
269 static
270 void
271 s_nsControlInUsbIoCompleteWrite(
272      struct urb *urb
273     )
274 {
275     PSDevice        pDevice;
276 
277 	pDevice = urb->context;
278 	switch (urb->status) {
279 	case 0:
280 		break;
281 	case -EINPROGRESS:
282 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl write urb status EINPROGRESS%d\n", urb->status);
283 		break;
284 	case -ENOENT:
285 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl write urb status ENOENT %d\n", urb->status);
286 		break;
287 	default:
288 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl write urb status %d\n", urb->status);
289 	}
290 
291     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
292 }
293 
294 
295 
296 /*
297  * Description:
298  *      Complete function of usb Control callback
299  *
300  * Parameters:
301  *  In:
302  *      pDevice     - Pointer to the adapter
303  *
304  *  Out:
305  *      none
306  *
307  * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
308  *
309  */
310 static
311 void
312 s_nsControlInUsbIoCompleteRead(
313      struct urb *urb
314     )
315 {
316     PSDevice        pDevice;
317 
318 	pDevice = urb->context;
319 	switch (urb->status) {
320 	case 0:
321 		break;
322 	case -EINPROGRESS:
323 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl read urb status EINPROGRESS%d\n", urb->status);
324 		break;
325 	case -ENOENT:
326 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl read urb status = ENOENT %d\n", urb->status);
327 		break;
328 	default:
329 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl read urb status %d\n", urb->status);
330 	}
331 
332     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
333 }
334 
335 
336 
337 
338 /*
339  * Description:
340  *      Allocates an usb interrupt in irp and calls USBD.
341  *
342  * Parameters:
343  *  In:
344  *      pDevice     - Pointer to the adapter
345  *  Out:
346  *      none
347  *
348  * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
349  *
350  */
351 int PIPEnsInterruptRead(PSDevice pDevice)
352 {
353     int ntStatus = STATUS_FAILURE;
354 
355     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsStartInterruptUsbRead()\n");
356 
357     if(pDevice->intBuf.bInUse == TRUE){
358         return (STATUS_FAILURE);
359     }
360     pDevice->intBuf.bInUse = TRUE;
361 //    pDevice->bEventAvailable = FALSE;
362     pDevice->ulIntInPosted++;
363 
364     //
365     // Now that we have created the urb, we will send a
366     // request to the USB device object.
367     //
368     pDevice->pInterruptURB->interval = pDevice->int_interval;
369 
370 usb_fill_bulk_urb(pDevice->pInterruptURB,
371 		pDevice->usb,
372 		usb_rcvbulkpipe(pDevice->usb, 1),
373 		(void *) pDevice->intBuf.pDataBuf,
374 		MAX_INTERRUPT_SIZE,
375 		s_nsInterruptUsbIoCompleteRead,
376 		pDevice);
377 
378 	ntStatus = usb_submit_urb(pDevice->pInterruptURB, GFP_ATOMIC);
379 	if (ntStatus != 0) {
380 	    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Submit int URB failed %d\n", ntStatus);
381     }
382 
383     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----s_nsStartInterruptUsbRead Return(%x)\n",ntStatus);
384     return ntStatus;
385 }
386 
387 
388 /*
389  * Description:
390  *      Complete function of usb interrupt in irp.
391  *
392  * Parameters:
393  *  In:
394  *      pDevice     - Pointer to the adapter
395  *
396  *  Out:
397  *      none
398  *
399  * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
400  *
401  */
402 static
403 void
404 s_nsInterruptUsbIoCompleteRead(
405      struct urb *urb
406     )
407 
408 {
409     PSDevice        pDevice;
410     int ntStatus;
411 
412     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsInterruptUsbIoCompleteRead\n");
413     //
414     // The context given to IoSetCompletionRoutine is the receive buffer object
415     //
416     pDevice = (PSDevice)urb->context;
417 
418     //
419     // We have a number of cases:
420     //      1) The USB read timed out and we received no data.
421     //      2) The USB read timed out and we received some data.
422     //      3) The USB read was successful and fully filled our irp buffer.
423     //      4) The irp was cancelled.
424     //      5) Some other failure from the USB device object.
425     //
426     ntStatus = urb->status;
427 
428     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_nsInterruptUsbIoCompleteRead Status %d\n", ntStatus);
429 
430     // if we were not successful, we need to free the int buffer for future use right here
431     // otherwise interrupt data handler will free int buffer after it handle it.
432     if (( ntStatus != STATUS_SUCCESS )) {
433         pDevice->ulBulkInError++;
434         pDevice->intBuf.bInUse = FALSE;
435 
436 //        if (ntStatus == USBD_STATUS_CRC) {
437 //            pDevice->ulIntInContCRCError++;
438 //        }
439 
440 //        if (ntStatus == STATUS_NOT_CONNECTED )
441 //        {
442             pDevice->fKillEventPollingThread = TRUE;
443 //        }
444         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"IntUSBIoCompleteControl STATUS = %d\n", ntStatus );
445     } else {
446 	    pDevice->ulIntInBytesRead += (unsigned long) urb->actual_length;
447 	    pDevice->ulIntInContCRCError = 0;
448 	    pDevice->bEventAvailable = TRUE;
449 	    INTnsProcessData(pDevice);
450     }
451 
452     STAvUpdateUSBCounter(&pDevice->scStatistic.USB_InterruptStat, ntStatus);
453 
454 
455     if (pDevice->fKillEventPollingThread != TRUE) {
456        usb_fill_bulk_urb(pDevice->pInterruptURB,
457 		      pDevice->usb,
458 		      usb_rcvbulkpipe(pDevice->usb, 1),
459 		     (void *) pDevice->intBuf.pDataBuf,
460 		     MAX_INTERRUPT_SIZE,
461 		     s_nsInterruptUsbIoCompleteRead,
462 		     pDevice);
463 
464 	ntStatus = usb_submit_urb(pDevice->pInterruptURB, GFP_ATOMIC);
465 	if (ntStatus != 0) {
466 	    DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Submit int URB failed %d\n", ntStatus);
467            }
468     }
469     //
470     // We return STATUS_MORE_PROCESSING_REQUIRED so that the completion
471     // routine (IofCompleteRequest) will stop working on the irp.
472     //
473     return ;
474 }
475 
476 /*
477  * Description:
478  *      Allocates an usb BulkIn  irp and calls USBD.
479  *
480  * Parameters:
481  *  In:
482  *      pDevice     - Pointer to the adapter
483  *  Out:
484  *      none
485  *
486  * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
487  *
488  */
489 int PIPEnsBulkInUsbRead(PSDevice pDevice, PRCB pRCB)
490 {
491 	int ntStatus = 0;
492     struct urb          *pUrb;
493 
494 
495     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsStartBulkInUsbRead\n");
496 
497     if (pDevice->Flags & fMP_DISCONNECTED)
498         return STATUS_FAILURE;
499 
500     pDevice->ulBulkInPosted++;
501 
502 
503 	pUrb = pRCB->pUrb;
504     //
505     // Now that we have created the urb, we will send a
506     // request to the USB device object.
507     //
508     if (pRCB->skb == NULL) {
509         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pRCB->skb is null \n");
510         return ntStatus;
511     }
512 
513 	usb_fill_bulk_urb(pUrb,
514 		pDevice->usb,
515 		usb_rcvbulkpipe(pDevice->usb, 2),
516 		(void *) (pRCB->skb->data),
517 		MAX_TOTAL_SIZE_WITH_ALL_HEADERS,
518 		s_nsBulkInUsbIoCompleteRead,
519 		pRCB);
520 
521 	ntStatus = usb_submit_urb(pUrb, GFP_ATOMIC);
522 	if (ntStatus != 0) {
523 		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Submit Rx URB failed %d\n", ntStatus);
524 		return STATUS_FAILURE ;
525 	}
526     pRCB->Ref = 1;
527     pRCB->bBoolInUse= TRUE;
528 
529     return ntStatus;
530 }
531 
532 
533 
534 
535 /*
536  * Description:
537  *      Complete function of usb BulkIn irp.
538  *
539  * Parameters:
540  *  In:
541  *      pDevice     - Pointer to the adapter
542  *
543  *  Out:
544  *      none
545  *
546  * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
547  *
548  */
549 static
550 void
551 s_nsBulkInUsbIoCompleteRead(
552      struct urb *urb
553     )
554 
555 {
556     PRCB    pRCB = (PRCB)urb->context;
557     PSDevice pDevice = (PSDevice)pRCB->pDevice;
558     unsigned long   bytesRead;
559     BOOL    bIndicateReceive = FALSE;
560     BOOL    bReAllocSkb = FALSE;
561     int status;
562 
563     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsBulkInUsbIoCompleteRead\n");
564     status = urb->status;
565     bytesRead = urb->actual_length;
566 
567     if (status) {
568         pDevice->ulBulkInError++;
569         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BULK In failed %d\n", status);
570 
571            pDevice->scStatistic.RxFcsErrCnt ++;
572 //todo...xxxxxx
573 //        if (status == USBD_STATUS_CRC) {
574 //            pDevice->ulBulkInContCRCError++;
575 //        }
576 //        if (status == STATUS_DEVICE_NOT_CONNECTED )
577 //        {
578 //            MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
579 //        }
580     } else {
581         bIndicateReceive = TRUE;
582         pDevice->ulBulkInContCRCError = 0;
583         pDevice->ulBulkInBytesRead += bytesRead;
584 
585            pDevice->scStatistic.RxOkCnt ++;
586     }
587 
588 
589     STAvUpdateUSBCounter(&pDevice->scStatistic.USB_BulkInStat, status);
590 
591     if (bIndicateReceive) {
592         spin_lock(&pDevice->lock);
593         if (RXbBulkInProcessData(pDevice, pRCB, bytesRead) == TRUE)
594             bReAllocSkb = TRUE;
595         spin_unlock(&pDevice->lock);
596     }
597     pRCB->Ref--;
598     if (pRCB->Ref == 0)
599     {
600         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RxvFreeNormal %d \n",pDevice->NumRecvFreeList);
601         spin_lock(&pDevice->lock);
602         RXvFreeRCB(pRCB, bReAllocSkb);
603         spin_unlock(&pDevice->lock);
604     }
605 
606 
607     return;
608 }
609 
610 /*
611  * Description:
612  *      Allocates an usb BulkOut  irp and calls USBD.
613  *
614  * Parameters:
615  *  In:
616  *      pDevice     - Pointer to the adapter
617  *  Out:
618  *      none
619  *
620  * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
621  *
622  */
623 int
624 PIPEnsSendBulkOut(
625       PSDevice pDevice,
626       PUSB_SEND_CONTEXT pContext
627     )
628 {
629     int status;
630     struct urb          *pUrb;
631 
632 
633 
634     pDevice->bPWBitOn = FALSE;
635 
636 /*
637     if (pDevice->pPendingBulkOutContext != NULL) {
638         pDevice->NumContextsQueued++;
639         EnqueueContext(pDevice->FirstTxContextQueue, pDevice->LastTxContextQueue, pContext);
640         status = STATUS_PENDING;
641         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Send pending!\n");
642         return status;
643     }
644 */
645 
646     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_nsSendBulkOut\n");
647 
648     if (MP_IS_READY(pDevice) && (pDevice->Flags & fMP_POST_WRITES)) {
649 
650         pUrb = pContext->pUrb;
651         pDevice->ulBulkOutPosted++;
652 //        pDevice->pPendingBulkOutContext = pContext;
653         usb_fill_bulk_urb(
654         	    pUrb,
655         		pDevice->usb,
656 		    usb_sndbulkpipe(pDevice->usb, 3),
657 		    (void *) &(pContext->Data[0]),
658         		pContext->uBufLen,
659         		s_nsBulkOutIoCompleteWrite,
660         		pContext);
661 
662     	status = usb_submit_urb(pUrb, GFP_ATOMIC);
663     	if (status != 0)
664     	{
665     		DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Submit Tx URB failed %d\n", status);
666     		return STATUS_FAILURE;
667     	}
668         return STATUS_PENDING;
669     }
670     else {
671         pContext->bBoolInUse = FALSE;
672         return STATUS_RESOURCES;
673     }
674 }
675 
676 /*
677  * Description: s_nsBulkOutIoCompleteWrite
678  *     1a) Indicate to the protocol the status of the write.
679  *     1b) Return ownership of the packet to the protocol.
680  *
681  *     2)  If any more packets are queue for sending, send another packet
682  *         to USBD.
683  *         If the attempt to send the packet to the driver fails,
684  *         return ownership of the packet to the protocol and
685  *         try another packet (until one succeeds).
686  *
687  * Parameters:
688  *  In:
689  *      pdoUsbDevObj  - pointer to the USB device object which
690  *                      completed the irp
691  *      pIrp          - the irp which was completed by the
692  *                      device object
693  *      pContext      - the context given to IoSetCompletionRoutine
694  *                      before calling IoCallDriver on the irp
695  *                      The pContext is a pointer to the USB device object.
696  *  Out:
697  *      none
698  *
699  * Return Value: STATUS_MORE_PROCESSING_REQUIRED - allows the completion routine
700  *               (IofCompleteRequest) to stop working on the irp.
701  *
702  */
703 static
704 void
705 s_nsBulkOutIoCompleteWrite(
706      struct urb *urb
707     )
708 {
709     PSDevice            pDevice;
710     int status;
711     CONTEXT_TYPE        ContextType;
712     unsigned long               ulBufLen;
713     PUSB_SEND_CONTEXT   pContext;
714 
715 
716     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsBulkOutIoCompleteWrite\n");
717     //
718     // The context given to IoSetCompletionRoutine is an USB_CONTEXT struct
719     //
720     pContext = (PUSB_SEND_CONTEXT) urb->context;
721     ASSERT( NULL != pContext );
722 
723     pDevice = pContext->pDevice;
724     ContextType = pContext->Type;
725     ulBufLen = pContext->uBufLen;
726 
727     if (!netif_device_present(pDevice->dev))
728 	    return;
729 
730    //
731     // Perform various IRP, URB, and buffer 'sanity checks'
732     //
733 
734     status = urb->status;
735     //we should have failed, succeeded, or cancelled, but NOT be pending
736     STAvUpdateUSBCounter(&pDevice->scStatistic.USB_BulkOutStat, status);
737 
738     if(status == STATUS_SUCCESS) {
739         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Write %d bytes\n",(int)ulBufLen);
740         pDevice->ulBulkOutBytesWrite += ulBufLen;
741         pDevice->ulBulkOutContCRCError = 0;
742 	pDevice->nTxDataTimeCout = 0;
743 
744     } else {
745         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BULK Out failed %d\n", status);
746         pDevice->ulBulkOutError++;
747     }
748 
749 //    pDevice->ulCheckForHangCount = 0;
750 //    pDevice->pPendingBulkOutContext = NULL;
751 
752     if ( CONTEXT_DATA_PACKET == ContextType ) {
753         // Indicate to the protocol the status of the sent packet and return
754         // ownership of the packet.
755 	    if (pContext->pPacket != NULL) {
756 	        dev_kfree_skb_irq(pContext->pPacket);
757 	        pContext->pPacket = NULL;
758             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"tx  %d bytes\n",(int)ulBufLen);
759 	    }
760 
761         pDevice->dev->trans_start = jiffies;
762 
763 
764         if (status == STATUS_SUCCESS) {
765             pDevice->packetsSent++;
766         }
767         else {
768             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Send USB error! [%08xh]\n", status);
769             pDevice->packetsSentDropped++;
770         }
771 
772     }
773     if (pDevice->bLinkPass == TRUE) {
774         if (netif_queue_stopped(pDevice->dev))
775             netif_wake_queue(pDevice->dev);
776     }
777     pContext->bBoolInUse = FALSE;
778 
779     return;
780 }
781