2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
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.
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.
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.
22 * Purpose: Handle USB control endpoint
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
36 * 04-05-2004 Jerry Chen: Initial release
37 * 11-24-2004 Warren Hsu: Add ControlvWriteByte,ControlvReadByte,ControlvMaskByte
50 //endpoint 1: interrupt
51 //endpoint 2: read bulk
52 //endpoint 3: write bulk
54 //static int msglevel =MSG_LEVEL_DEBUG;
55 static int msglevel =MSG_LEVEL_INFO;
57 #define USB_CTL_WAIT 500 //ms
59 #ifndef URB_ASYNC_UNLINK
60 #define URB_ASYNC_UNLINK 0
63 static void s_nsInterruptUsbIoCompleteRead(struct urb *urb);
64 static void s_nsBulkInUsbIoCompleteRead(struct urb *urb);
65 static void s_nsBulkOutIoCompleteWrite(struct urb *urb);
66 static void s_nsControlInUsbIoCompleteRead(struct urb *urb);
67 static void s_nsControlInUsbIoCompleteWrite(struct urb *urb);
69 int PIPEnsControlOutAsyn(struct vnt_private *pDevice, u8 byRequest,
70 u16 wValue, u16 wIndex, u16 wLength, u8 *pbyBuffer)
74 if (pDevice->Flags & fMP_DISCONNECTED)
75 return STATUS_FAILURE;
77 if (pDevice->Flags & fMP_CONTROL_WRITES)
78 return STATUS_FAILURE;
81 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"in_interrupt return ..byRequest %x\n", byRequest);
82 return STATUS_FAILURE;
85 ntStatus = usb_control_msg(
87 usb_sndctrlpipe(pDevice->usb , 0),
97 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"usb_sndctrlpipe ntStatus= %d\n", ntStatus);
100 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"usb_sndctrlpipe fail, ntStatus= %d\n", ntStatus);
106 int PIPEnsControlOut(struct vnt_private *pDevice, u8 byRequest, u16 wValue,
107 u16 wIndex, u16 wLength, u8 *pbyBuffer)
112 if (pDevice->Flags & fMP_DISCONNECTED)
113 return STATUS_FAILURE;
115 if (pDevice->Flags & fMP_CONTROL_WRITES)
116 return STATUS_FAILURE;
118 if (pDevice->Flags & fMP_CONTROL_READS)
119 return STATUS_FAILURE;
121 if (pDevice->pControlURB->hcpriv)
122 return STATUS_FAILURE;
124 MP_SET_FLAG(pDevice, fMP_CONTROL_WRITES);
126 pDevice->sUsbCtlRequest.bRequestType = 0x40;
127 pDevice->sUsbCtlRequest.bRequest = byRequest;
128 pDevice->sUsbCtlRequest.wValue = cpu_to_le16p(&wValue);
129 pDevice->sUsbCtlRequest.wIndex = cpu_to_le16p(&wIndex);
130 pDevice->sUsbCtlRequest.wLength = cpu_to_le16p(&wLength);
131 pDevice->pControlURB->transfer_flags |= URB_ASYNC_UNLINK;
132 pDevice->pControlURB->actual_length = 0;
133 // Notice, pbyBuffer limited point to variable buffer, can't be constant.
134 usb_fill_control_urb(pDevice->pControlURB, pDevice->usb,
135 usb_sndctrlpipe(pDevice->usb , 0), (char *) &pDevice->sUsbCtlRequest,
136 pbyBuffer, wLength, s_nsControlInUsbIoCompleteWrite, pDevice);
138 ntStatus = usb_submit_urb(pDevice->pControlURB, GFP_ATOMIC);
140 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO
141 "control send request submission failed: %d\n",
143 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
144 return STATUS_FAILURE;
147 spin_unlock_irq(&pDevice->lock);
148 for (ii = 0; ii <= USB_CTL_WAIT; ii ++) {
150 if (pDevice->Flags & fMP_CONTROL_WRITES)
155 if (ii >= USB_CTL_WAIT) {
156 DBG_PRT(MSG_LEVEL_DEBUG,
157 KERN_INFO "control send request submission timeout\n");
158 spin_lock_irq(&pDevice->lock);
159 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
160 return STATUS_FAILURE;
163 spin_lock_irq(&pDevice->lock);
165 return STATUS_SUCCESS;
168 int PIPEnsControlIn(struct vnt_private *pDevice, u8 byRequest, u16 wValue,
169 u16 wIndex, u16 wLength, u8 *pbyBuffer)
174 if (pDevice->Flags & fMP_DISCONNECTED)
175 return STATUS_FAILURE;
177 if (pDevice->Flags & fMP_CONTROL_READS)
178 return STATUS_FAILURE;
180 if (pDevice->Flags & fMP_CONTROL_WRITES)
181 return STATUS_FAILURE;
183 if (pDevice->pControlURB->hcpriv)
184 return STATUS_FAILURE;
186 MP_SET_FLAG(pDevice, fMP_CONTROL_READS);
188 pDevice->sUsbCtlRequest.bRequestType = 0xC0;
189 pDevice->sUsbCtlRequest.bRequest = byRequest;
190 pDevice->sUsbCtlRequest.wValue = cpu_to_le16p(&wValue);
191 pDevice->sUsbCtlRequest.wIndex = cpu_to_le16p(&wIndex);
192 pDevice->sUsbCtlRequest.wLength = cpu_to_le16p(&wLength);
193 pDevice->pControlURB->transfer_flags |= URB_ASYNC_UNLINK;
194 pDevice->pControlURB->actual_length = 0;
195 usb_fill_control_urb(pDevice->pControlURB, pDevice->usb,
196 usb_rcvctrlpipe(pDevice->usb , 0), (char *) &pDevice->sUsbCtlRequest,
197 pbyBuffer, wLength, s_nsControlInUsbIoCompleteRead, pDevice);
199 ntStatus = usb_submit_urb(pDevice->pControlURB, GFP_ATOMIC);
201 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO
202 "control request submission failed: %d\n", ntStatus);
203 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
204 return STATUS_FAILURE;
207 spin_unlock_irq(&pDevice->lock);
208 for (ii = 0; ii <= USB_CTL_WAIT; ii ++) {
210 if (pDevice->Flags & fMP_CONTROL_READS)
215 if (ii >= USB_CTL_WAIT) {
216 DBG_PRT(MSG_LEVEL_DEBUG,
217 KERN_INFO "control rcv request submission timeout\n");
218 spin_lock_irq(&pDevice->lock);
219 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
220 return STATUS_FAILURE;
223 spin_lock_irq(&pDevice->lock);
228 static void s_nsControlInUsbIoCompleteWrite(struct urb *urb)
230 struct vnt_private *pDevice = (struct vnt_private *)urb->context;
232 pDevice = urb->context;
233 switch (urb->status) {
237 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl write urb status EINPROGRESS%d\n", urb->status);
240 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl write urb status ENOENT %d\n", urb->status);
243 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl write urb status %d\n", urb->status);
246 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
251 * Complete function of usb Control callback
255 * pDevice - Pointer to the adapter
260 * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
264 static void s_nsControlInUsbIoCompleteRead(struct urb *urb)
266 struct vnt_private *pDevice = (struct vnt_private *)urb->context;
268 switch (urb->status) {
272 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl read urb status EINPROGRESS%d\n", urb->status);
275 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl read urb status = ENOENT %d\n", urb->status);
278 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ctrl read urb status %d\n", urb->status);
281 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
286 * Allocates an usb interrupt in irp and calls USBD.
290 * pDevice - Pointer to the adapter
294 * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
298 int PIPEnsInterruptRead(struct vnt_private *pDevice)
300 int ntStatus = STATUS_FAILURE;
302 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsStartInterruptUsbRead()\n");
304 if(pDevice->intBuf.bInUse == true){
305 return (STATUS_FAILURE);
307 pDevice->intBuf.bInUse = true;
308 // pDevice->bEventAvailable = false;
309 pDevice->ulIntInPosted++;
312 // Now that we have created the urb, we will send a
313 // request to the USB device object.
315 pDevice->pInterruptURB->interval = pDevice->int_interval;
317 usb_fill_bulk_urb(pDevice->pInterruptURB,
319 usb_rcvbulkpipe(pDevice->usb, 1),
320 (void *) pDevice->intBuf.pDataBuf,
322 s_nsInterruptUsbIoCompleteRead,
325 ntStatus = usb_submit_urb(pDevice->pInterruptURB, GFP_ATOMIC);
327 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Submit int URB failed %d\n", ntStatus);
330 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----s_nsStartInterruptUsbRead Return(%x)\n",ntStatus);
336 * Complete function of usb interrupt in irp.
340 * pDevice - Pointer to the adapter
345 * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
349 static void s_nsInterruptUsbIoCompleteRead(struct urb *urb)
351 struct vnt_private *pDevice = (struct vnt_private *)urb->context;
354 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsInterruptUsbIoCompleteRead\n");
356 // The context given to IoSetCompletionRoutine is the receive buffer object
360 // We have a number of cases:
361 // 1) The USB read timed out and we received no data.
362 // 2) The USB read timed out and we received some data.
363 // 3) The USB read was successful and fully filled our irp buffer.
364 // 4) The irp was cancelled.
365 // 5) Some other failure from the USB device object.
367 ntStatus = urb->status;
369 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_nsInterruptUsbIoCompleteRead Status %d\n", ntStatus);
371 // if we were not successful, we need to free the int buffer for future use right here
372 // otherwise interrupt data handler will free int buffer after it handle it.
373 if (( ntStatus != STATUS_SUCCESS )) {
374 pDevice->ulBulkInError++;
375 pDevice->intBuf.bInUse = false;
377 // if (ntStatus == USBD_STATUS_CRC) {
378 // pDevice->ulIntInContCRCError++;
381 // if (ntStatus == STATUS_NOT_CONNECTED )
383 pDevice->fKillEventPollingThread = true;
385 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"IntUSBIoCompleteControl STATUS = %d\n", ntStatus );
387 pDevice->ulIntInBytesRead += (unsigned long) urb->actual_length;
388 pDevice->ulIntInContCRCError = 0;
389 pDevice->bEventAvailable = true;
390 INTnsProcessData(pDevice);
393 STAvUpdateUSBCounter(&pDevice->scStatistic.USB_InterruptStat, ntStatus);
395 if (pDevice->fKillEventPollingThread != true) {
396 usb_fill_bulk_urb(pDevice->pInterruptURB,
398 usb_rcvbulkpipe(pDevice->usb, 1),
399 (void *) pDevice->intBuf.pDataBuf,
401 s_nsInterruptUsbIoCompleteRead,
404 ntStatus = usb_submit_urb(pDevice->pInterruptURB, GFP_ATOMIC);
406 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Submit int URB failed %d\n", ntStatus);
410 // We return STATUS_MORE_PROCESSING_REQUIRED so that the completion
411 // routine (IofCompleteRequest) will stop working on the irp.
418 * Allocates an usb BulkIn irp and calls USBD.
422 * pDevice - Pointer to the adapter
426 * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
430 int PIPEnsBulkInUsbRead(struct vnt_private *pDevice, struct vnt_rcb *pRCB)
435 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsStartBulkInUsbRead\n");
437 if (pDevice->Flags & fMP_DISCONNECTED)
438 return STATUS_FAILURE;
440 pDevice->ulBulkInPosted++;
444 // Now that we have created the urb, we will send a
445 // request to the USB device object.
447 if (pRCB->skb == NULL) {
448 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"pRCB->skb is null \n");
452 usb_fill_bulk_urb(pUrb,
454 usb_rcvbulkpipe(pDevice->usb, 2),
455 (void *) (pRCB->skb->data),
456 MAX_TOTAL_SIZE_WITH_ALL_HEADERS,
457 s_nsBulkInUsbIoCompleteRead,
460 ntStatus = usb_submit_urb(pUrb, GFP_ATOMIC);
462 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Submit Rx URB failed %d\n", ntStatus);
463 return STATUS_FAILURE ;
466 pRCB->bBoolInUse= true;
473 * Complete function of usb BulkIn irp.
477 * pDevice - Pointer to the adapter
482 * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
486 static void s_nsBulkInUsbIoCompleteRead(struct urb *urb)
488 struct vnt_rcb *pRCB = (struct vnt_rcb *)urb->context;
489 struct vnt_private *pDevice = pRCB->pDevice;
490 unsigned long bytesRead;
491 int bIndicateReceive = false;
492 int bReAllocSkb = false;
495 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsBulkInUsbIoCompleteRead\n");
496 status = urb->status;
497 bytesRead = urb->actual_length;
500 pDevice->ulBulkInError++;
501 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BULK In failed %d\n", status);
503 pDevice->scStatistic.RxFcsErrCnt ++;
505 // if (status == USBD_STATUS_CRC) {
506 // pDevice->ulBulkInContCRCError++;
508 // if (status == STATUS_DEVICE_NOT_CONNECTED )
510 // MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
514 bIndicateReceive = true;
515 pDevice->ulBulkInContCRCError = 0;
516 pDevice->ulBulkInBytesRead += bytesRead;
518 pDevice->scStatistic.RxOkCnt ++;
521 STAvUpdateUSBCounter(&pDevice->scStatistic.USB_BulkInStat, status);
523 if (bIndicateReceive) {
524 spin_lock(&pDevice->lock);
525 if (RXbBulkInProcessData(pDevice, pRCB, bytesRead) == true)
527 spin_unlock(&pDevice->lock);
532 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RxvFreeNormal %d \n",pDevice->NumRecvFreeList);
533 spin_lock(&pDevice->lock);
534 RXvFreeRCB(pRCB, bReAllocSkb);
535 spin_unlock(&pDevice->lock);
543 * Allocates an usb BulkOut irp and calls USBD.
547 * pDevice - Pointer to the adapter
551 * Return Value: STATUS_INSUFFICIENT_RESOURCES or result of IoCallDriver
555 int PIPEnsSendBulkOut(struct vnt_private *pDevice,
556 struct vnt_usb_send_context *pContext)
561 pDevice->bPWBitOn = false;
564 if (pDevice->pPendingBulkOutContext != NULL) {
565 pDevice->NumContextsQueued++;
566 EnqueueContext(pDevice->FirstTxContextQueue, pDevice->LastTxContextQueue, pContext);
567 status = STATUS_PENDING;
568 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Send pending!\n");
573 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"s_nsSendBulkOut\n");
575 if (MP_IS_READY(pDevice) && (pDevice->Flags & fMP_POST_WRITES)) {
577 pUrb = pContext->pUrb;
578 pDevice->ulBulkOutPosted++;
579 // pDevice->pPendingBulkOutContext = pContext;
583 usb_sndbulkpipe(pDevice->usb, 3),
584 (void *) &(pContext->Data[0]),
586 s_nsBulkOutIoCompleteWrite,
589 status = usb_submit_urb(pUrb, GFP_ATOMIC);
592 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Submit Tx URB failed %d\n", status);
593 pContext->bBoolInUse = false;
594 return STATUS_FAILURE;
596 return STATUS_PENDING;
599 pContext->bBoolInUse = false;
600 return STATUS_RESOURCES;
605 * Description: s_nsBulkOutIoCompleteWrite
606 * 1a) Indicate to the protocol the status of the write.
607 * 1b) Return ownership of the packet to the protocol.
609 * 2) If any more packets are queue for sending, send another packet
611 * If the attempt to send the packet to the driver fails,
612 * return ownership of the packet to the protocol and
613 * try another packet (until one succeeds).
617 * pdoUsbDevObj - pointer to the USB device object which
619 * pIrp - the irp which was completed by the
621 * pContext - the context given to IoSetCompletionRoutine
622 * before calling IoCallDriver on the irp
623 * The pContext is a pointer to the USB device object.
627 * Return Value: STATUS_MORE_PROCESSING_REQUIRED - allows the completion routine
628 * (IofCompleteRequest) to stop working on the irp.
632 static void s_nsBulkOutIoCompleteWrite(struct urb *urb)
634 struct vnt_private *pDevice;
636 CONTEXT_TYPE ContextType;
637 unsigned long ulBufLen;
638 struct vnt_usb_send_context *pContext;
640 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"---->s_nsBulkOutIoCompleteWrite\n");
642 // The context given to IoSetCompletionRoutine is an USB_CONTEXT struct
644 pContext = (struct vnt_usb_send_context *)urb->context;
646 pDevice = pContext->pDevice;
647 ContextType = pContext->Type;
648 ulBufLen = pContext->uBufLen;
650 if (!netif_device_present(pDevice->dev))
654 // Perform various IRP, URB, and buffer 'sanity checks'
657 status = urb->status;
658 //we should have failed, succeeded, or cancelled, but NOT be pending
659 STAvUpdateUSBCounter(&pDevice->scStatistic.USB_BulkOutStat, status);
661 if(status == STATUS_SUCCESS) {
662 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Write %d bytes\n",(int)ulBufLen);
663 pDevice->ulBulkOutBytesWrite += ulBufLen;
664 pDevice->ulBulkOutContCRCError = 0;
666 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"BULK Out failed %d\n", status);
667 pDevice->ulBulkOutError++;
670 // pDevice->ulCheckForHangCount = 0;
671 // pDevice->pPendingBulkOutContext = NULL;
673 if ( CONTEXT_DATA_PACKET == ContextType ) {
674 // Indicate to the protocol the status of the sent packet and return
675 // ownership of the packet.
676 if (pContext->pPacket != NULL) {
677 dev_kfree_skb_irq(pContext->pPacket);
678 pContext->pPacket = NULL;
679 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"tx %d bytes\n",(int)ulBufLen);
682 pDevice->dev->trans_start = jiffies;
684 if (status == STATUS_SUCCESS) {
685 pDevice->packetsSent++;
688 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Send USB error! [%08xh]\n", status);
689 pDevice->packetsSentDropped++;
693 if (pDevice->bLinkPass == true) {
694 if (netif_queue_stopped(pDevice->dev))
695 netif_wake_queue(pDevice->dev);
697 pContext->bBoolInUse = false;