/************************************************************************************************************************** * RWIR.C SigmaTel STIR4200 USB, but not NDIS, module ************************************************************************************************************************** * (C) Unpublished Copyright of Sigmatel, Inc. All Rights Reserved. * * * Created: 04/06/2000 * Version 0.9 * Edited: 04/24/2000 * Version 0.91 * Edited: 04/27/2000 * Version 0.92 * Edited: 05/01/2000 * Version 0.93 * Edited: 05/12/2000 * Version 0.94 * Edited: 05/19/2000 * Version 0.95 * Edited: 05/24/2000 * Version 0.96 * Edited: 08/22/2000 * Version 1.02 * Edited: 09/25/2000 * Version 1.10 * Edited: 11/09/2000 * Version 1.12 * * **************************************************************************************************************************/ #include #include #include #include "usbdi.h" #include "usbdlib.h" #include "debug.h" #include "ircommon.h" #include "irusb.h" #include "diags.h" /***************************************************************************** * * Function: InitializeProcessing * * Synopsis: Initialize the driver processing (sending and receiving packets) functionality. * * Arguments: pThisDevice - pointer to current ir device object * InitPassiveThread - whether we must initialize the passive thread * * Returns: NDIS_STATUS_SUCCESS - if irp is successfully sent to USB * device object * NDIS_STATUS_RESOURCES - if mem can't be alloc'd * NDIS_STATUS_FAILURE - otherwise * * Notes: * * This routine must be called in IRQL PASSIVE_LEVEL. * *****************************************************************************/ NTSTATUS InitializeProcessing( IN OUT PIR_DEVICE pThisDev, IN BOOLEAN InitPassiveThread ) { NTSTATUS status = STATUS_SUCCESS; DEBUGMSG(DBG_FUNC, ("+InitializeProcessing\n")); if( InitPassiveThread ) { // // Create a thread to run at IRQL PASSIVE_LEVEL. // status = PsCreateSystemThread( &pThisDev->hPassiveThread, (ACCESS_MASK)0L, NULL, NULL, NULL, PassiveLevelThread, pThisDev ); if( status != STATUS_SUCCESS ) { DEBUGMSG(DBG_ERROR, (" PsCreateSystemThread PassiveLevelThread failed. Returned 0x%.8x\n", status)); status = STATUS_INSUFFICIENT_RESOURCES; goto done; } } // // Create a thread to run at IRQL PASSIVE_LEVEL to be always receiving. // status = PsCreateSystemThread( &pThisDev->hPollingThread, (ACCESS_MASK)0L, NULL, NULL, NULL, PollingThread, pThisDev ); if( status != STATUS_SUCCESS ) { DEBUGMSG(DBG_ERROR, (" PsCreateSystemThread PollingThread failed. Returned 0x%.8x\n", status)); status = STATUS_INSUFFICIENT_RESOURCES; goto done; } pThisDev->fProcessing = TRUE; done: DEBUGMSG(DBG_FUNC, ("-InitializeProcessing\n")); return status; } /***************************************************************************** * * Function: ScheduleWorkItem * * Synopsis: Preapares a work item in such a way that the passive thread can process it * * Arguments: pThisDev - pointer to IR device * Callback - function to call * pInfoBuf - context for the call * InfoBufLen - length of the context * * Returns: TRUE if successful * FALSE otherwise * * Notes: * *****************************************************************************/ BOOLEAN ScheduleWorkItem( IN OUT PIR_DEVICE pThisDev, WORK_PROC Callback, IN PVOID pInfoBuf, ULONG InfoBufLen ) { int i; PIR_WORK_ITEM pWorkItem = NULL; BOOLEAN ItemScheduled = FALSE; DEBUGMSG(DBG_FUNC, ("+ScheduleWorkItem\n")); // // Find an item that is available // for( i = 0; i < NUM_WORK_ITEMS; i++ ) { pWorkItem = &(pThisDev->WorkItems[i]); if( pWorkItem->fInUse == FALSE ) { InterlockedExchange( (PLONG)&pWorkItem->fInUse, TRUE ); ItemScheduled = TRUE; break; } } // // Can't fail because can only have one set and one query pending, // and no more than 8 packets to process // IRUSB_ASSERT( NULL != pWorkItem ); IRUSB_ASSERT( i < NUM_WORK_ITEMS ); InterlockedExchangePointer( &pWorkItem->pInfoBuf, pInfoBuf ); InterlockedExchange( (PLONG)&pWorkItem->InfoBufLen, InfoBufLen ); /* ** This interface was designed to use NdisScheduleWorkItem(), which ** would be good except that we're really only supposed to use that ** interface during startup and shutdown, due to the limited pool of ** threads available to service NdisScheduleWorkItem(). Therefore, ** instead of scheduling real work items, we simulate them, and use ** our own thread to process the calls. This also makes it easy to ** expand the size of our own thread pool, if we wish. ** ** Our version is slightly different from actual NDIS_WORK_ITEMs, ** because that is an NDIS 5.0 structure, and we want people to ** (at least temporarily) build this with NDIS 4.0 headers. */ InterlockedExchangePointer( (PVOID *)&pWorkItem->Callback, (PVOID)Callback ); /* ** Our worker thread checks this list for new jobs, whenever its event ** is signalled. */ // wake up worker thread KeSetEvent( &pThisDev->EventPassiveThread, 0, FALSE ); DEBUGMSG(DBG_FUNC, ("-ScheduleWorkItem\n")); return ItemScheduled; } /***************************************************************************** * * Function: FreeWorkItem * * Synopsis: Sets the work item to the reusable state. * * Arguments: pItem - pointer to work item * * Returns: None * * Notes: * *****************************************************************************/ VOID FreeWorkItem( IN OUT PIR_WORK_ITEM pItem ) { InterlockedExchange( (PLONG)&pItem->fInUse, FALSE ); } /***************************************************************************** * * Function: IrUsb_CancelPendingIo * * Synopsis: Cancels all the pending IO for the device * * Arguments: pThisDev - pointer to the IR device * * Returns: None * * Notes: * *****************************************************************************/ VOID IrUsb_CancelPendingIo( IN OUT PIR_DEVICE pThisDev ) { DEBUGMSG( DBG_FUNC, ("+IrUsb_CancelPendingIo(), fDeviceStarted =%d\n", pThisDev->fDeviceStarted)); // chag to FUNC later? IRUSB_ASSERT( KeGetCurrentIrql() <= DISPATCH_LEVEL ); if( pThisDev->fDeviceStarted ) { IrUsb_CancelPendingReadIo( pThisDev, TRUE ); IrUsb_CancelPendingWriteIo( pThisDev ); IrUsb_CancelPendingReadWriteIo( pThisDev ); } DEBUGMSG( DBG_FUNC, ("-IrUsb_CancelPendingIo()\n")); // chag to FUNC later? } /***************************************************************************** * * Function: IrUsb_CancelPendingReadIo * * Synopsis: Cancels the pending read IRPs * * Arguments: pThisDev - pointer to the IR device * fWaitCancelComplete - pointer to the IRP to cancel * * Returns: TRUE if cancelled any * FALSE otherwise * * Notes: * *****************************************************************************/ BOOLEAN IrUsb_CancelPendingReadIo( IN OUT PIR_DEVICE pThisDev, BOOLEAN fWaitCancelComplete ) { BOOLEAN CancelResult = FALSE; int i; DEBUGMSG( DBG_FUNC, ("+IrUsb_CancelPendingReadIo()\n")); IRUSB_ASSERT( KeGetCurrentIrql() <= DISPATCH_LEVEL ); if( ( RCV_STATE_PENDING == pThisDev->PreReadBuffer.BufferState ) && ( NULL != pThisDev->PreReadBuffer.pIrp ) ) { PIRP pIrp = (PIRP)pThisDev->PreReadBuffer.pIrp; // // Since IoCallDriver has been called on this request, we call IoCancelIrp // and let our completion routine handle it // DEBUGMSG( DBG_FUNC, (" IrUsb_CancelPendingReadIo() about to CANCEL a read IRP!\n")); KeClearEvent( &pThisDev->EventAsyncUrb ); CancelResult = IoCancelIrp( (PIRP)pThisDev->PreReadBuffer.pIrp ); DEBUGCOND( DBG_ERR, !CancelResult, (" IrUsb_CancelPendingReadIo() COULDN'T CANCEL IRP!\n")); DEBUGCOND( DBG_FUNC, CancelResult, (" IrUsb_CancelPendingReadIo() CANCELLED IRP SUCCESS!\n")); if( CancelResult && fWaitCancelComplete ) { MyKeWaitForSingleObject( pThisDev, &pThisDev->EventAsyncUrb, NULL, // irp to cancel; we did it above already, so pass NULL 0 ); IRUSB_ASSERT( pThisDev->PreReadBuffer.pIrp == NULL ); } } DEBUGMSG( DBG_FUNC, ("-IrUsb_CancelPendingReadIo()\n")); return CancelResult; } /***************************************************************************** * * Function: IrUsb_CancelPendingWriteIo * * Synopsis: Cancels the pending write IRPs * * Arguments: pThisDev - pointer to the IR device * * Returns: TRUE if cancelled any * FALSE otherwise * * Notes: * *****************************************************************************/ BOOLEAN IrUsb_CancelPendingWriteIo( IN OUT PIR_DEVICE pThisDev ) { BOOLEAN CancelResult = FALSE; PIRUSB_CONTEXT pThisContext; PLIST_ENTRY pListEntry; DEBUGMSG( DBG_FUNC, ("+IrUsb_CancelPendingWriteIo()\n")); IRUSB_ASSERT( KeGetCurrentIrql() < DISPATCH_LEVEL ); // // Free all resources for the SEND buffer queue. // while( pListEntry = ExInterlockedRemoveHeadList( &pThisDev->SendPendingQueue, &pThisDev->SendLock ) ) { InterlockedDecrement( &pThisDev->SendPendingCount ); pThisContext = CONTAINING_RECORD( pListEntry, IRUSB_CONTEXT, ListEntry ); // // Get the IRUSB_CONTEXT and cancel its IRP; the completion routine will itself // remove it from the HeadPendingSendList and NULL out HeadPendingSendList // when the last IRP on the list has been cancelled; that's how we exit this loop // IRUSB_ASSERT( NULL != pThisContext->pIrp ); DEBUGMSG( DBG_WARN, (" IrUsb_CancelPendingWriteIo() about to CANCEL a write IRP!\n")); // // Completion routine ( IrUsbCompleteWrite() )will free irps, mdls, buffers, etc as well // CancelResult = IoCancelIrp( pThisContext->pIrp ); DEBUGCOND( DBG_ERR, !CancelResult, (" IrUsb_CancelPendingWriteIo() COULDN'T CANCEL IRP! 0x%x\n", pThisContext->pIrp ) ); DEBUGCOND( DBG_FUNC, CancelResult, (" IrUsb_CancelPendingWriteIo() CANCELLED IRP SUCCESS! 0x%x\n\n", pThisContext->pIrp) ); // // Sleep 200 microsecs to give cancellation time to work // NdisMSleep( 200 ); } DEBUGMSG( DBG_FUNC, ("-IrUsb_CancelPendingWriteIo()\n")); return CancelResult; } /***************************************************************************** * * Function: IrUsb_CancelPendingReadWriteIo * * Synopsis: Cancels the pending register access IRPs * * Arguments: pThisDev - pointer to the IR device * * Returns: TRUE if cancelled any * FALSE otherwise * * Notes: * *****************************************************************************/ BOOLEAN IrUsb_CancelPendingReadWriteIo( IN OUT PIR_DEVICE pThisDev ) { BOOLEAN CancelResult = FALSE; PIRUSB_CONTEXT pThisContext; PLIST_ENTRY pListEntry; DEBUGMSG( DBG_FUNC, ("+IrUsb_CancelPendingReadWriteIo()\n")); IRUSB_ASSERT( KeGetCurrentIrql() < DISPATCH_LEVEL ); // // Free all resources for the SEND buffer queue. // while( pListEntry = ExInterlockedRemoveHeadList( &pThisDev->ReadWritePendingQueue, &pThisDev->SendLock ) ) { InterlockedDecrement( &pThisDev->ReadWritePendingCount ); pThisContext = CONTAINING_RECORD( pListEntry, IRUSB_CONTEXT, ListEntry ); // // Get the IRUSB_CONTEXT and cancel its IRP; the completion routine will itself // remove it from the HeadPendingSendList and NULL out HeadPendingSendList // when the last IRP on the list has been cancelled; that's how we exit this loop // IRUSB_ASSERT( NULL != pThisContext->pIrp ); DEBUGMSG( DBG_WARN, (" IrUsb_CancelPendingReadWriteIo() about to CANCEL a write IRP!\n")); // // Completion routine ( IrUsbCompleteWrite() )will free irps, mdls, buffers, etc as well // CancelResult = IoCancelIrp( pThisContext->pIrp ); DEBUGCOND( DBG_ERR, !CancelResult, (" IrUsb_CancelPendingReadWriteIo() COULDN'T CANCEL IRP! 0x%x\n", pThisContext->pIrp ) ); DEBUGCOND( DBG_WARN, CancelResult, (" IrUsb_CancelPendingReadWriteIo() CANCELLED IRP SUCCESS! 0x%x\n\n", pThisContext->pIrp) ); // // Sleep 200 microsecs to give cancellation time to work // NdisMSleep( 200 ); } DEBUGMSG( DBG_FUNC, ("-IrUsb_CancelPendingReadWriteIo()\n")); return CancelResult; } /***************************************************************************** * * Function: IrUsb_CancelIo * * Synopsis: Cancels a pending IRP * * Arguments: pThisDev - pointer to the IR device * pIrpToCancel - pointer to the IRP to cancel * pEventToClear - pointer to the event to wait on * * Returns: TRUE if cancelled, * FALSE otherwise * * Notes: * *****************************************************************************/ BOOLEAN IrUsb_CancelIo( IN PIR_DEVICE pThisDev, IN PIRP pIrpToCancel, IN PKEVENT pEventToClear ) { BOOLEAN CancelResult = FALSE; DEBUGMSG( DBG_FUNC, ("+IrUsb_CancelIo()\n")); IRUSB_ASSERT( KeGetCurrentIrql() <= DISPATCH_LEVEL ); KeClearEvent( pEventToClear ); CancelResult = IoCancelIrp( pIrpToCancel ); DEBUGCOND( DBG_ERR, !CancelResult, (" IrUsb_CancelIo() COULDN'T CANCEL IRP!\n")); DEBUGCOND( DBG_FUNC, CancelResult, (" IrUsb_CancelIo() CANCELLED IRP SUCCESS!\n")); if( CancelResult ) { MyKeWaitForSingleObject( pThisDev, pEventToClear, NULL, // irp to cancel; we did it above already, so pass NULL 0 ); } DEBUGMSG( DBG_FUNC, ("-IrUsb_CancelIo()\n")); return CancelResult; } /***************************************************************************** * * Function: MyIoCallDriver * * Synopsis: Calls a device driver and keeps track of the count * * Arguments: pThisDev - pointer to IR device * pDeviceObject - pointer to device driver to call * pIrp - pointer to Irp to submit * * Returns: NT status code * * Notes: * *****************************************************************************/ NTSTATUS MyIoCallDriver( IN PIR_DEVICE pThisDev, IN PDEVICE_OBJECT pDeviceObject, IN OUT PIRP pIrp ) { NTSTATUS ntStatus; DEBUGMSG( DBG_FUNC,("+MyIoCallDriver\n ")); // // We will track count of pending irps; // We May later add logic to actually save array of pending irps // IrUsb_IncIoCount( pThisDev ); ntStatus = IoCallDriver( pDeviceObject, pIrp ); DEBUGMSG( DBG_FUNC,("+MyIoCallDriver\n ")); return ntStatus; } /***************************************************************************** * * Function: IrUsb_CallUSBD * * Synopsis: Passes a URB to the USBD class driver * The client device driver passes USB request block (URB) structures * to the class driver as a parameter in an IRP with Irp->MajorFunction * set to IRP_MJ_INTERNAL_DEVICE_CONTROL and the next IRP stack location * Parameters.DeviceIoControl.IoControlCode field set to * IOCTL_INTERNAL_USB_SUBMIT_URB. * * Arguments: pThisDev - pointer to the IR device * pUrb - pointer to an already-formatted Urb request block * * Returns: STATUS_SUCCESS if successful, * STATUS_UNSUCCESSFUL otherwise * * Notes: * *****************************************************************************/ NTSTATUS IrUsb_CallUSBD( IN PIR_DEVICE pThisDev, IN PURB pUrb ) { NTSTATUS ntStatus; PDEVICE_OBJECT pUrbTargetDev; PIO_STACK_LOCATION pNextStack; DEBUGMSG( DBG_FUNC,("+IrUsb_CallUSBD\n")); IRUSB_ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL ); IRUSB_ASSERT( pThisDev ); IRUSB_ASSERT( NULL == ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ); //shouldn't be multiple control calls pending // // issue a synchronous request (we'll wait ) // pUrbTargetDev = pThisDev->pUsbDevObj; IRUSB_ASSERT( pUrbTargetDev ); // make an irp sending to usbhub ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb = IoAllocateIrp( (CCHAR)(pThisDev->pUsbDevObj->StackSize + 1), FALSE ); if( NULL == ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ) { DEBUGMSG(DBG_ERR, (" IrUsb_CallUsbd failed to alloc IRP\n")); ntStatus = STATUS_INSUFFICIENT_RESOURCES; goto done; } ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb->IoStatus.Status = STATUS_PENDING; ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb->IoStatus.Information = 0; // // Call the class driver to perform the operation. If the returned status // is PENDING, wait for the request to complete. // pNextStack = IoGetNextIrpStackLocation( ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->IrpSubmitUrb ); IRUSB_ASSERT( pNextStack != NULL ); // // pass the URB to the USB driver stack // pNextStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL; pNextStack->Parameters.Others.Argument1 = pUrb; pNextStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB; IoSetCompletionRoutine( ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->IrpSubmitUrb, // irp to use UsbIoCompleteControl, // routine to call when irp is done DEV_TO_CONTEXT(pThisDev), // context to pass routine TRUE, // call on success TRUE, // call on error TRUE // call on cancel ); KeClearEvent( &pThisDev->EventAsyncUrb ); ntStatus = MyIoCallDriver( pThisDev, pUrbTargetDev, ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ); DEBUGMSG( DBG_OUT,(" IrUsb_CallUSBD () return from IoCallDriver USBD %x\n", ntStatus)); if( (ntStatus == STATUS_PENDING) || (ntStatus == STATUS_SUCCESS) ) { // // wait, but dump out on timeout // if( ntStatus == STATUS_PENDING ) { ntStatus = MyKeWaitForSingleObject( pThisDev, &pThisDev->EventAsyncUrb, NULL, 0 ); if( ntStatus == STATUS_TIMEOUT ) { DEBUGMSG( DBG_ERR,(" IrUsb_CallUSBD () TIMED OUT! return from IoCallDriver USBD %x\n", ntStatus)); IrUsb_CancelIo( pThisDev, ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->IrpSubmitUrb, &pThisDev->EventAsyncUrb ); } else { // // Update the status to reflect the real return code // ntStatus = pThisDev->StatusControl; } } } else { DEBUGMSG( DBG_ERR, ("IrUsb_CallUSBD IoCallDriver FAILED(%x)\n",ntStatus)); } DEBUGMSG( DBG_OUT,("IrUsb_CallUSBD () URB status = %x IRP status = %x\n", pUrb->UrbHeader.Status, ntStatus )); done: ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->IrpSubmitUrb = NULL; DEBUGCOND( DBG_ERR, !NT_SUCCESS( ntStatus ), (" exit IrUsb_CallUSBD FAILED (%x)\n", ntStatus)); DEBUGMSG( DBG_FUNC,("-IrUsb_CallUSBD\n")); return ntStatus; } /***************************************************************************** * * Function: IrUsb_ResetUSBD * * Synopsis: Passes a URB to the USBD class driver, forcing the latter to reset or part * * Arguments: pThisDev - pointer to the IR device * ForceUnload - flag to perform a reset or an unload * * Returns: STATUS_SUCCESS if successful, * STATUS_UNSUCCESSFUL otherwise * * Notes: * *****************************************************************************/ NTSTATUS IrUsb_ResetUSBD( IN PIR_DEVICE pThisDev, BOOLEAN ForceUnload ) { NTSTATUS ntStatus; PDEVICE_OBJECT pUrbTargetDev; PIO_STACK_LOCATION pNextStack; DEBUGMSG( DBG_FUNC,("+IrUsb_ResetUSBD\n")); IRUSB_ASSERT( KeGetCurrentIrql() == PASSIVE_LEVEL ); IRUSB_ASSERT( pThisDev ); IRUSB_ASSERT( NULL == ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ); //shouldn't be multiple control calls pending // // issue a synchronous request (we'll wait ) // pUrbTargetDev = pThisDev->pUsbDevObj; IRUSB_ASSERT( pUrbTargetDev ); // make an irp sending to usbhub ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb = IoAllocateIrp( (CCHAR)(pThisDev->pUsbDevObj->StackSize + 1), FALSE ); if( NULL == ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ) { DEBUGMSG(DBG_ERR, (" IrUsb_ResetUSBD failed to alloc IRP\n")); ntStatus = STATUS_INSUFFICIENT_RESOURCES; goto done; } ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb->IoStatus.Status = STATUS_PENDING; ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb->IoStatus.Information = 0; // // Call the class driver to perform the operation. If the returned status // is PENDING, wait for the request to complete. // pNextStack = IoGetNextIrpStackLocation( ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->IrpSubmitUrb ); IRUSB_ASSERT( pNextStack != NULL ); // // pass the URB to the USB driver stack // pNextStack->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL; if( ForceUnload ) pNextStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_CYCLE_PORT; else pNextStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_RESET_PORT; IoSetCompletionRoutine( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb, // irp to use UsbIoCompleteControl, // routine to call when irp is done DEV_TO_CONTEXT(pThisDev), // context to pass routine TRUE, // call on success TRUE, // call on error TRUE // call on cancel ); KeClearEvent( &pThisDev->EventAsyncUrb ); ntStatus = MyIoCallDriver( pThisDev, pUrbTargetDev, ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ); DEBUGMSG( DBG_OUT,(" IrUsb_ResetUSBD () return from IoCallDriver USBD %x\n", ntStatus)); if( (ntStatus == STATUS_PENDING) || (ntStatus == STATUS_SUCCESS) ) { // // wait, but dump out on timeout // if( ntStatus == STATUS_PENDING ) { ntStatus = MyKeWaitForSingleObject( pThisDev, &pThisDev->EventAsyncUrb, NULL, 0 ); if( ntStatus == STATUS_TIMEOUT ) { DEBUGMSG( DBG_ERR,(" IrUsb_ResetUSBD () TIMED OUT! return from IoCallDriver USBD %x\n", ntStatus)); IrUsb_CancelIo( pThisDev, ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->IrpSubmitUrb, &pThisDev->EventAsyncUrb ); } else { // // Update the status to reflect the real return code // ntStatus = pThisDev->StatusControl; } } } else { DEBUGMSG( DBG_ERR, ("IrUsb_ResetUSBD IoCallDriver FAILED(%x)\n",ntStatus)); } done: ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->IrpSubmitUrb = NULL; DEBUGCOND( DBG_ERR, !NT_SUCCESS( ntStatus ), (" exit IrUsb_ResetUSBD FAILED (%x)\n", ntStatus)); DEBUGMSG( DBG_FUNC,("-IrUsb_ResetUSBD\n")); return ntStatus; } /***************************************************************************** * * Function: UsbIoCompleteControl * * Synopsis: General completetion routine just to insure cancel-ability of control calls * and keep track of pending irp count * * Arguments: pUsbDevObj - pointer to the device object which * completed the irp * pIrp - the irp which was completed by the device * object * Context - dev ext * * Returns: STATUS_MORE_PROCESSING_REQUIRED - allows the completion routine * (IofCompleteRequest) to stop working on the irp. * * *****************************************************************************/ NTSTATUS UsbIoCompleteControl( IN PDEVICE_OBJECT pUsbDevObj, IN PIRP pIrp, IN PVOID Context ) { PIR_DEVICE pThisDev; NTSTATUS status; DEBUGMSG(DBG_FUNC, ("+UsbIoCompleteControl\n")); // // The context given to IoSetCompletionRoutine is simply the the ir // device object pointer. // pThisDev = CONTEXT_TO_DEV( Context ); status = pIrp->IoStatus.Status; switch( status ) { case STATUS_SUCCESS: DEBUGMSG(DBG_OUT, (" UsbIoCompleteControl STATUS_SUCCESS\n")); break; // STATUS_SUCCESS case STATUS_TIMEOUT: DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_TIMEOUT\n")); break; case STATUS_PENDING: DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_PENDING\n")); break; case STATUS_DEVICE_DATA_ERROR: // can get during shutdown DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_DEVICE_DATA_ERROR\n")); break; case STATUS_UNSUCCESSFUL: DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_UNSUCCESSFUL\n")); break; case STATUS_INSUFFICIENT_RESOURCES: DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_INSUFFICIENT_RESOURCES\n")); break; case STATUS_INVALID_PARAMETER: DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_INVALID_PARAMETER\n")); break; case STATUS_CANCELLED: DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_CANCELLED\n")); break; case STATUS_DEVICE_NOT_CONNECTED: // can get during shutdown DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_DEVICE_NOT_CONNECTED\n")); break; case STATUS_DEVICE_POWER_FAILURE: // can get during shutdown DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl STATUS_DEVICE_POWER_FAILURE\n")); break; default: DEBUGMSG(DBG_ERR, (" UsbIoCompleteControl UNKNOWN WEIRD STATUS = 0x%x, dec %d\n",status,status )); break; } IrUsb_DecIoCount( pThisDev ); //we track pending irp count if( pIrp == ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ) { IRUSB_ASSERT( NULL != ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ); IoFreeIrp( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb ); pThisDev->StatusControl = status; // save status because can't use irp after completion routine is hit! KeSetEvent( &pThisDev->EventAsyncUrb, 0, FALSE ); //signal we're done } else { DEBUGMSG( DBG_ERR, (" UsbIoCompleteControl UNKNOWN IRP\n")); IRUSB_ASSERT( 0 ); } DEBUGCOND(DBG_ERR, !( NT_SUCCESS( status ) ), ("UsbIoCompleteControl BAD status = 0x%x\n", status)); DEBUGMSG(DBG_FUNC, ("-UsbIoCompleteControl\n")); // // We return STATUS_MORE_PROCESSING_REQUIRED so that the completion // routine (IofCompleteRequest) will stop working on the irp. // return STATUS_MORE_PROCESSING_REQUIRED; } /***************************************************************************** * * Function: IrUsb_ConfigureDevice * * Synopsis: Initializes a given instance of the device on the USB and * selects and saves the configuration. * * Arguments: pThisDev - pointer to the IR device * * Returns: NT status code * * Notes: * *****************************************************************************/ NTSTATUS IrUsb_ConfigureDevice( IN OUT PIR_DEVICE pThisDev ) { NTSTATUS ntStatus; PURB pUrb; ULONG UrbSize; DEBUGMSG(DBG_FUNC,("+IrUsb_ConfigureDevice()\n")); IRUSB_ASSERT( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor == NULL ); pUrb = (PURB)&((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->DescriptorUrb; // // When USB_CONFIGURATION_DESCRIPTOR_TYPE is specified for DescriptorType // in a call to UsbBuildGetDescriptorRequest(), // all interface, endpoint, class-specific, and vendor-specific descriptors // for the configuration also are retrieved. // The caller must allocate a buffer large enough to hold all of this // information or the data is truncated without error. // Therefore the 'siz' set below is just a 'good guess', and we may have to retry // UrbSize = sizeof(USB_CONFIGURATION_DESCRIPTOR) + 512; // Store size, may need to free // // We will break out of this 'retry loop' when UsbBuildGetDescriptorRequest() // has a big enough pThisDev->UsbConfigurationDescriptor buffer not to truncate // while( TRUE ) { ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor = MyMemAlloc( UrbSize ); if( !((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbConfigurationDescriptor ) { MyMemFree( pUrb, sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST) ); return STATUS_INSUFFICIENT_RESOURCES; } UsbBuildGetDescriptorRequest( pUrb, (USHORT) sizeof( struct _URB_CONTROL_DESCRIPTOR_REQUEST ), USB_CONFIGURATION_DESCRIPTOR_TYPE, 0, 0, ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor, NULL, UrbSize, NULL ); ntStatus = IrUsb_CallUSBD( pThisDev, pUrb ); //Get Usb Config Descriptor; done in main thread DEBUGMSG(DBG_OUT,(" IrUsb_ConfigureDevice() Configuration Descriptor = %x, len %x\n", ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbConfigurationDescriptor, pUrb->UrbControlDescriptorRequest.TransferBufferLength)); // // if we got some data see if it was enough. // NOTE: we may get an error in URB because of buffer overrun if( (pUrb->UrbControlDescriptorRequest.TransferBufferLength > 0) && (((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor->wTotalLength > UrbSize) && NT_SUCCESS(ntStatus) ) { MyMemFree( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor, UrbSize ); UrbSize = ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor->wTotalLength; ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor = NULL; } else { break; // we got it on the first try } } // end, while (retry loop ) IRUSB_ASSERT( ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbConfigurationDescriptor ); if( !NT_SUCCESS(ntStatus) ) { DEBUGMSG( DBG_ERR,(" IrUsb_ConfigureDevice() Get Config Descriptor FAILURE (%x)\n", ntStatus)); goto done; } // // We have the configuration descriptor for the configuration we want. // Now we issue the select configuration command to get // the pipes associated with this configuration. // ntStatus = IrUsb_SelectInterface( pThisDev, ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor ); if( !NT_SUCCESS(ntStatus) ) { DEBUGMSG( DBG_ERR,(" IrUsb_ConfigureDevice() IrUsb_SelectInterface() FAILURE (%x)\n", ntStatus)); } done: DEBUGMSG(DBG_FUNC,("-IrUsb_ConfigureDevice (%x)\n", ntStatus)); return ntStatus; } /***************************************************************************** * * Function: IrUsb_SelectInterface * * Synopsis: Initializes the ST4200 interfaces; * This minidriver only supports one interface (with multiple endpoints). * * Arguments: pThisDev - pointer to IR device * pConfigurationDescriptor - pointer to USB configuration descriptor * * Returns: NT status code * * Notes: * *****************************************************************************/ NTSTATUS IrUsb_SelectInterface( IN OUT PIR_DEVICE pThisDev, IN PUSB_CONFIGURATION_DESCRIPTOR pConfigurationDescriptor ) { NTSTATUS ntStatus; PURB pUrb = NULL; ULONG i; USHORT DescriptorSize; PUSB_INTERFACE_DESCRIPTOR pInterfaceDescriptor = NULL; PUSBD_INTERFACE_INFORMATION pInterface = NULL; DEBUGMSG(DBG_FUNC,("+IrUsb_SelectInterface\n")); IRUSB_ASSERT( pConfigurationDescriptor != NULL ); IRUSB_ASSERT( pThisDev != NULL ); // // IrUsb driver only supports one interface, we must parse // the configuration descriptor for the interface // and remember the pipes. Needs to be aupdated // pUrb = USBD_CreateConfigurationRequest( pConfigurationDescriptor, &DescriptorSize ); if( pUrb ) { DEBUGMSG(DBG_OUT,(" USBD_CreateConfigurationRequest created the urb\n")); // // USBD_ParseConfigurationDescriptorEx searches a given configuration // descriptor and returns a pointer to an interface that matches the // given search criteria. We only support one interface on this device // pInterfaceDescriptor = USBD_ParseConfigurationDescriptorEx( pConfigurationDescriptor, pConfigurationDescriptor, // search from start of config descriptor -1, // interface number not a criteria; we only support one interface -1, // not interested in alternate setting here either -1, // interface class not a criteria -1, // interface subclass not a criteria -1 // interface protocol not a criteria ); if( !pInterfaceDescriptor ) { DEBUGMSG(DBG_ERR,("IrUsb_SelectInterface() ParseConfigurationDescriptorEx() failed\n returning STATUS_INSUFFICIENT_RESOURCES\n")); // // don't call the MyMemFree since the buffer was // alloced by USBD_CreateConfigurationRequest, not MyMemAlloc() // ExFreePool( pUrb ); return STATUS_INSUFFICIENT_RESOURCES; } pInterface = &pUrb->UrbSelectConfiguration.Interface; DEBUGMSG(DBG_OUT,(" After USBD_CreateConfigurationRequest, before UsbBuildSelectConfigurationRequest\n" )); // // Now prepare the pipes // for( i=0; iNumberOfPipes; i++ ) { // // perform any pipe initialization here; mainly set max xfer size // But Watch out! USB may change these when you select the interface; // In general USB doesn;t seem to like differing max transfer sizes on the pipes // pInterface->Pipes[i].MaximumTransferSize = STIR4200_FIFO_SIZE; } // // Initialize the device with the pipe structure found // UsbBuildSelectConfigurationRequest( pUrb, DescriptorSize, pConfigurationDescriptor ); ntStatus = IrUsb_CallUSBD( pThisDev, pUrb ); //select config; done in main thread ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationHandle = pUrb->UrbSelectConfiguration.ConfigurationHandle; } else { DEBUGMSG(DBG_ERR,(" IrUsb_SelectInterface() USBD_CreateConfigurationRequest() failed\n returning STATUS_INSUFFICIENT_RESOURCES\n")); return STATUS_INSUFFICIENT_RESOURCES; } if( NT_SUCCESS(ntStatus) ) { // // Save the configuration handle for this device // ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbConfigurationHandle = pUrb->UrbSelectConfiguration.ConfigurationHandle; if( NULL == ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbInterface ) { ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbInterface = MyMemAlloc( pInterface->Length ); } if( NULL != ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbInterface ) { ULONG j; // // save a copy of the interface information returned // RtlCopyMemory( ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface, pInterface, pInterface->Length ); // // Dump the interface to the debugger // DEBUGMSG(DBG_FUNC,("---------After Select Config \n")); DEBUGMSG(DBG_FUNC,("NumberOfPipes 0x%x\n", ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface->NumberOfPipes)); DEBUGMSG(DBG_FUNC,("Length 0x%x\n", ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface->Length)); DEBUGMSG(DBG_FUNC,("Alt Setting 0x%x\n", ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface->AlternateSetting)); DEBUGMSG(DBG_FUNC,("Interface Number 0x%x\n", ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface->InterfaceNumber)); DEBUGMSG(DBG_FUNC,("Class, subclass, protocol 0x%x 0x%x 0x%x\n", ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface->Class, ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface->SubClass, ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface->Protocol)); // // Find our Bulk in and out pipes, save their handles, Dump the pipe info // for( j=0; jNumberOfPipes; j++ ) { PUSBD_PIPE_INFORMATION pipeInformation; pipeInformation = &((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbInterface->Pipes[j]; // // Find the Bulk In and Out pipes ( these are probably the only two pipes ) // if( UsbdPipeTypeBulk == pipeInformation->PipeType ) { // endpoint address with bit 0x80 set are input pipes, else output if( USB_ENDPOINT_DIRECTION_IN( pipeInformation->EndpointAddress ) ) { pThisDev->BulkInPipeHandle = pipeInformation->PipeHandle; } if( USB_ENDPOINT_DIRECTION_OUT( pipeInformation->EndpointAddress ) ) { pThisDev->BulkOutPipeHandle = pipeInformation->PipeHandle; } } DEBUGMSG(DBG_FUNC,("---------\n")); DEBUGMSG(DBG_FUNC,("PipeType 0x%x\n", pipeInformation->PipeType)); DEBUGMSG(DBG_FUNC,("EndpointAddress 0x%x\n", pipeInformation->EndpointAddress)); DEBUGMSG(DBG_FUNC,("MaxPacketSize 0x%x\n", pipeInformation->MaximumPacketSize)); DEBUGMSG(DBG_FUNC,("Interval 0x%x\n", pipeInformation->Interval)); DEBUGMSG(DBG_FUNC,("Handle 0x%x\n", pipeInformation->PipeHandle)); DEBUGMSG(DBG_FUNC,("MaximumTransferSize 0x%x\n", pipeInformation->MaximumTransferSize)); } DEBUGMSG(DBG_FUNC,("---------\n")); } } // // we better have found input and output bulk pipes! // IRUSB_ASSERT( pThisDev->BulkInPipeHandle && pThisDev->BulkOutPipeHandle ); if( !pThisDev->BulkInPipeHandle || !pThisDev->BulkOutPipeHandle ) { DEBUGMSG(DBG_ERR,("IrUsb_SelectInterface() failed to get pipes\n")); ntStatus = STATUS_UNSUCCESSFUL; } if( pUrb ) { // // don't call the MyMemFree since the buffer was // alloced by USBD_CreateConfigurationRequest, not MyMemAlloc() // ExFreePool( pUrb ); } DEBUGMSG(DBG_FUNC,("-IrUsb_SelectInterface (%x)\n", ntStatus)); return ntStatus; } /***************************************************************************** * * Function: IrUsb_StartDevice * * Synopsis: Initializes a given instance of the device on the USB. * USB client drivers such as us set up URBs (USB Request Packets) to send requests * to the host controller driver (HCD). The URB structure defines a format for all * possible commands that can be sent to a USB device. * Here, we request the device descriptor and store it, and configure the device. * * Arguments: pThisDev - pointer to IR device * * Returns: NT status code * * Notes: * *****************************************************************************/ NTSTATUS IrUsb_StartDevice( IN PIR_DEVICE pThisDev ) { NTSTATUS ntStatus; PUSB_DEVICE_DESCRIPTOR pDeviceDescriptor = NULL; PURB pUrb; ULONG DescriptorSize; DEBUGMSG( DBG_FUNC, ("+IrUsb_StartDevice()\n")); pUrb = MyMemAlloc( sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST)); DEBUGCOND( DBG_ERR,!pUrb, (" IrUsb_StartDevice() FAILED MyMemAlloc() for URB\n")); if( pUrb ) { DescriptorSize = sizeof( USB_DEVICE_DESCRIPTOR ); pDeviceDescriptor = MyMemAlloc( DescriptorSize ); DEBUGCOND( DBG_ERR, !pDeviceDescriptor, (" IrUsb_StartDevice() FAILED MyMemAlloc() for deviceDescriptor\n")); if( pDeviceDescriptor ) { // // Get all the USB descriptor data // UsbBuildGetDescriptorRequest( pUrb, (USHORT) sizeof (struct _URB_CONTROL_DESCRIPTOR_REQUEST), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, pDeviceDescriptor, NULL, DescriptorSize, NULL ); ntStatus = IrUsb_CallUSBD( pThisDev, pUrb ); // build get descripttor req; main thread DEBUGCOND( DBG_ERR, !NT_SUCCESS(ntStatus), (" IrUsb_StartDevice() FAILED IrUsb_CallUSBD (pThisDev, pUrb)\n")); if( NT_SUCCESS(ntStatus) ) { DEBUGMSG( DBG_FUNC,("Device Descriptor = %x, len %x\n", pDeviceDescriptor, pUrb->UrbControlDescriptorRequest.TransferBufferLength)); DEBUGMSG( DBG_FUNC,("IR Dongle Device Descriptor:\n")); DEBUGMSG( DBG_FUNC,("-------------------------\n")); DEBUGMSG( DBG_FUNC,("bLength %d\n", pDeviceDescriptor->bLength)); DEBUGMSG( DBG_FUNC,("bDescriptorType 0x%x\n", pDeviceDescriptor->bDescriptorType)); DEBUGMSG( DBG_FUNC,("bcdUSB 0x%x\n", pDeviceDescriptor->bcdUSB)); DEBUGMSG( DBG_FUNC,("bDeviceClass 0x%x\n", pDeviceDescriptor->bDeviceClass)); DEBUGMSG( DBG_FUNC,("bDeviceSubClass 0x%x\n", pDeviceDescriptor->bDeviceSubClass)); DEBUGMSG( DBG_FUNC,("bDeviceProtocol 0x%x\n", pDeviceDescriptor->bDeviceProtocol)); DEBUGMSG( DBG_FUNC,("bMaxPacketSize0 0x%x\n", pDeviceDescriptor->bMaxPacketSize0)); DEBUGMSG( DBG_FUNC,("idVendor 0x%x\n", pDeviceDescriptor->idVendor)); DEBUGMSG( DBG_FUNC,("idProduct 0x%x\n", pDeviceDescriptor->idProduct)); DEBUGMSG( DBG_FUNC,("bcdDevice 0x%x\n", pDeviceDescriptor->bcdDevice)); DEBUGMSG( DBG_FUNC,("iManufacturer 0x%x\n", pDeviceDescriptor->iManufacturer)); DEBUGMSG( DBG_FUNC,("iProduct 0x%x\n", pDeviceDescriptor->iProduct)); DEBUGMSG( DBG_FUNC,("iSerialNumber 0x%x\n", pDeviceDescriptor->iSerialNumber)); DEBUGMSG( DBG_FUNC,("bNumConfigurations 0x%x\n", pDeviceDescriptor->bNumConfigurations)); } } else { // if we got here we failed to allocate deviceDescriptor ntStatus = STATUS_INSUFFICIENT_RESOURCES; } if( NT_SUCCESS(ntStatus) ) { ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbDeviceDescriptor = pDeviceDescriptor; pThisDev->IdVendor = ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbDeviceDescriptor->idVendor; } MyMemFree( pUrb, sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST) ); } else { // // if we got here we failed to allocate the urb // ntStatus = STATUS_INSUFFICIENT_RESOURCES; } // // Now that we have the descriptors, we can configure the device // if( NT_SUCCESS(ntStatus) ) { ntStatus = IrUsb_ConfigureDevice( pThisDev ); DEBUGCOND( DBG_ERR,!NT_SUCCESS(ntStatus),(" IrUsb_StartDevice IrUsb_ConfigureDevice() FAILURE (%x)\n", ntStatus)); } // // Read all the initial registers // if( NT_SUCCESS(ntStatus) ) { ntStatus = St4200ReadRegisters( pThisDev, 0, STIR4200_MAX_REG ); DEBUGCOND( DBG_ERR,!NT_SUCCESS(ntStatus),(" IrUsb_StartDevice St4200ReadRegisters() FAILURE (%x)\n", ntStatus)); } // // Get the current chip revision // if( NT_SUCCESS(ntStatus) ) { pThisDev->ChipRevision = pThisDev->StIrTranceiver.SensitivityReg & STIR4200_SENS_IDMASK; } // // Next we must get the Class-Specific Descriptor // Get the IR USB dongle's Class-Specific descriptor; this has many // characterisitics we must tell Ndis about, such as supported speeds, // BOFS required, rate sniff-supported flag, turnaround time, window size, // data size. // if( NT_SUCCESS(ntStatus) ) { ntStatus = IrUsb_GetDongleCaps( pThisDev ); if( !NT_SUCCESS( ntStatus ) ) { DEBUGMSG( DBG_ERR,(" IrUsb_ConfigureDevice() IrUsb_GetClassDescriptor() FAILURE (%x)\n", ntStatus)); } else { // fill out dongleCaps struct from class-specific descriptor info IrUsb_SetDongleCaps( pThisDev ); } } // // Set the initial speed // if( NT_SUCCESS(ntStatus) ) { ntStatus = St4200SetSpeed( pThisDev ); DEBUGCOND( DBG_ERR,!NT_SUCCESS(ntStatus),(" IrUsb_StartDevice St4200SetSpeed() FAILURE (%x)\n", ntStatus)); } // // All set and ready to roll // if( NT_SUCCESS(ntStatus) ) { pThisDev->fDeviceStarted = TRUE; } DEBUGMSG( DBG_FUNC, ("-IrUsb_StartDevice (%x)\n", ntStatus)); return ntStatus; } /***************************************************************************** * * Function: IrUsb_StopDevice * * Synopsis: Stops a given instance of a ST4200 device on the USB. * We basically just tell USB this device is now 'unconfigured' * * Arguments: pThisDev - pointer to IR device * * Returns: NT status code * * Notes: * *****************************************************************************/ NTSTATUS IrUsb_StopDevice( IN PIR_DEVICE pThisDev ) { NTSTATUS ntStatus = STATUS_SUCCESS; PURB pUrb; ULONG DescriptorSize; DEBUGMSG( DBG_FUNC,("+IrUsb_StopDevice\n")); // // Send the select configuration urb with a NULL pointer for the configuration // handle. This closes the configuration and puts the device in the 'unconfigured' // state. // DescriptorSize = sizeof( struct _URB_SELECT_CONFIGURATION ); pUrb = MyMemAlloc( DescriptorSize ); if( pUrb ) { UsbBuildSelectConfigurationRequest( pUrb, (USHORT)DescriptorSize, NULL ); ntStatus = IrUsb_CallUSBD( pThisDev, pUrb ); // build select config req; main thread DEBUGCOND( DBG_ERR, !NT_SUCCESS(ntStatus),(" IrUsb_StopDevice() FAILURE Configuration Closed status = %x usb status = %x.\n", ntStatus, pUrb->UrbHeader.Status)); DEBUGCOND( DBG_WARN, NT_SUCCESS(ntStatus),(" IrUsb_StopDevice() SUCCESS Configuration Closed status = %x usb status = %x.\n", ntStatus, pUrb->UrbHeader.Status)); MyMemFree( pUrb, sizeof(struct _URB_SELECT_CONFIGURATION) ); } else { ntStatus = STATUS_INSUFFICIENT_RESOURCES; } DEBUGMSG( DBG_FUNC,("-IrUsb_StopDevice (%x) \n ", ntStatus)); return ntStatus; } /***************************************************************************** * * Function: ResetPipeCallback * * Synopsis: Callback for resetting a pipe * * Arguments: pWorkItem - pointer to the reset work item * * Returns: None * * Notes: * *****************************************************************************/ VOID ResetPipeCallback ( IN PIR_WORK_ITEM pWorkItem ) { PIR_DEVICE pThisDev; HANDLE Pipe; NTSTATUS ntStatus; pThisDev = (PIR_DEVICE)pWorkItem->pIrDevice; Pipe = (HANDLE)pWorkItem->pInfoBuf; if( Pipe == pThisDev->BulkInPipeHandle ) { IRUSB_ASSERT( TRUE == pThisDev->fPendingReadClearStall ); IrUsb_CancelPendingReadIo( pThisDev, TRUE ); IrUsb_ResetPipe( pThisDev, Pipe ); InterlockedExchange( &pThisDev->fPendingReadClearStall, FALSE ); } else if( Pipe == pThisDev->BulkOutPipeHandle ) { IRUSB_ASSERT( TRUE == pThisDev->fPendingWriteClearStall ); IrUsb_CancelPendingWriteIo( pThisDev ); IrUsb_ResetPipe( pThisDev, Pipe ); InterlockedExchange( &pThisDev->fPendingWriteClearStall, FALSE ); } #if DBG else { IRUSB_ASSERT( 0 ); } #endif FreeWorkItem( pWorkItem ); } /***************************************************************************** * * Function: IrUsb_ResetPipe * * Synopsis: This will reset the host pipe to Data0 and should also reset the device * endpoint to Data0 for Bulk and Interrupt pipes by issuing a Clear_Feature * Endpoint_Stall to the device endpoint. * * Arguments: pThisDev - pointer to IR device * Pipe - handle to the pipe to reset * * Returns: NTSTATUS * * Notes: Must be called at IRQL PASSIVE_LEVEL * *****************************************************************************/ NTSTATUS IrUsb_ResetPipe ( IN PIR_DEVICE pThisDev, IN HANDLE Pipe ) { PURB pUrb; NTSTATUS ntStatus; DEBUGMSG(DBG_ERR, ("+IrUsb_ResetPipe()\n")); // // Allocate URB for RESET_PIPE request // pUrb = MyMemAlloc( sizeof(struct _URB_PIPE_REQUEST) ); if( pUrb != NULL ) { #if 0 NdisZeroMemory( pUrb, sizeof (struct _URB_PIPE_REQUEST) ); DEBUGMSG(DBG_ERR, (" IrUsb_ResetPipe before ABORT PIPE \n")); // // Initialize ABORT_PIPE request URB // pUrb->UrbHeader.Length = sizeof (struct _URB_PIPE_REQUEST); pUrb->UrbHeader.Function = URB_FUNCTION_ABORT_PIPE; pUrb->UrbPipeRequest.PipeHandle = (USBD_PIPE_HANDLE)Pipe; ntStatus = IrUsb_CallUSBD( pThisDev, pUrb ); DEBUGCOND(DBG_ERR, !NT_SUCCESS(ntStatus), (" IrUsb_ResetPipe ABORT PIPE FAILED \n")); DEBUGMSG(DBG_ERR, (" IrUsb_ResetPipe before RESET_PIPE \n")); #endif NdisZeroMemory( pUrb, sizeof (struct _URB_PIPE_REQUEST) ); // // Initialize RESET_PIPE request URB // pUrb->UrbHeader.Length = sizeof (struct _URB_PIPE_REQUEST); pUrb->UrbHeader.Function = URB_FUNCTION_RESET_PIPE; pUrb->UrbPipeRequest.PipeHandle = (USBD_PIPE_HANDLE)Pipe; // // Submit RESET_PIPE request URB // ntStatus = IrUsb_CallUSBD( pThisDev, pUrb ); DEBUGCOND(DBG_ERR, !NT_SUCCESS(ntStatus), (" IrUsb_ResetPipe RESET PIPE FAILED \n")); DEBUGCOND(DBG_ERR, NT_SUCCESS(ntStatus), (" IrUsb_ResetPipe RESET PIPE SUCCEEDED \n")); // // Done with URB for RESET_PIPE request, free urb // MyMemFree( pUrb, sizeof(struct _URB_PIPE_REQUEST) ); } else { ntStatus = STATUS_INSUFFICIENT_RESOURCES; } DEBUGMSG(DBG_ERR, ("-IrUsb_ResetPipe %08X\n", ntStatus)); return ntStatus; } /***************************************************************************** * * Function: MyKeWaitForSingleObject * * Synopsis: Wait with a timeout in a loop * so we will never hang if we are asked to halt/reset the driver while * pollingthread is waiting for something. * If input IRP is not null, also cancel it on timeout * * Arguments: pThisDev - pointer to IR device * pEventWaitingFor - pointer to event to wait for * pIrpWaitingFor - pointer to Irp to cancel if timing out * timeout100ns - timeout * * Returns: NT status code * * Notes: THIS FUNCTION MUST BE RE-ENTERABLE! * *****************************************************************************/ NTSTATUS MyKeWaitForSingleObject( IN PIR_DEVICE pThisDev, IN PVOID pEventWaitingFor, IN OUT PIRP pIrpWaitingFor, LONGLONG timeout100ns ) { NTSTATUS status = STATUS_SUCCESS; LARGE_INTEGER Timeout; DEBUGMSG( DBG_FUNC,("+MyKeWaitForSingleObject\n ")); if( timeout100ns ) { // //if a non-zero timeout was passed in, use it // Timeout.QuadPart = - ( timeout100ns ); } else { //Timeout.QuadPart = -10000 * 1000 * 3; // default to 3 second relative delay Timeout.QuadPart = -10000 * 1000; // default to 1 second relative delay } status = KeWaitForSingleObject( //keep this as standard wait pEventWaitingFor, Suspended, KernelMode, FALSE, &Timeout ); if( pIrpWaitingFor && (status != STATUS_SUCCESS) ) { BOOLEAN CancelResult; // // if we get here we timed out and we were passed a PIRP to cancel // CancelResult = IoCancelIrp( pIrpWaitingFor ); DEBUGCOND( DBG_FUNC, CancelResult,(" MyKeWaitForSingleObject successfully cancelled IRP (%x),CancelResult = %x\n",pIrpWaitingFor, CancelResult)); DEBUGCOND( DBG_ERR, !CancelResult,(" MyKeWaitForSingleObject FAILED to cancel IRP (%x),CancelResult = %x\n",pIrpWaitingFor, CancelResult)); } DEBUGCOND( DBG_OUT,( STATUS_TIMEOUT == status ),(" MyKeWaitForSingleObject TIMED OUT\n")); DEBUGCOND( DBG_OUT,( STATUS_ALERTED == status ),(" MyKeWaitForSingleObject ALERTED\n")); DEBUGCOND( DBG_OUT,( STATUS_USER_APC == status ),(" MyKeWaitForSingleObject USER APC\n")); DEBUGMSG( DBG_FUNC,("-MyKeWaitForSingleObject (%x)\n", status)); return status; } /***************************************************************************** * * Function: PassiveLevelThread * * Synopsis: Thread running at IRQL PASSIVE_LEVEL. * * Arguments: Context - pointer to IR device * * Returns: None * * Notes: * * Any work item that can be called must be serialized. * i.e. when IrUsbReset is called, NDIS will not make any other * requests of the miniport until NdisMResetComplete is called. * *****************************************************************************/ VOID PassiveLevelThread( IN OUT PVOID Context ) { LARGE_INTEGER Timeout; int i; PIR_WORK_ITEM pWorkItem; PIR_DEVICE pThisDev = (PIR_DEVICE)Context; DEBUGMSG(DBG_WARN, ("+PassiveLevelThread\n")); // change to FUNC later? DEBUGMSG(DBG_ERR, (" PassiveLevelThread: Starting\n")); KeSetPriorityThread( KeGetCurrentThread(), LOW_REALTIME_PRIORITY+1 ); Timeout.QuadPart = -10000 * 1000 * 3; // 3 second relative delay while ( !pThisDev->fKillPassiveLevelThread ) { // // The eventPassiveThread is an auto-clearing event, so // we don't need to reset the event. // KeWaitForSingleObject( //keep this as standard wait &pThisDev->EventPassiveThread, Suspended, KernelMode, FALSE, &Timeout ); for( i = 0; i < NUM_WORK_ITEMS; i++ ) { if( pThisDev->WorkItems[i].fInUse ) { pThisDev->WorkItems[i].Callback( &(pThisDev->WorkItems[i]) ); } } } // while !fKill DEBUGMSG(DBG_ERR, (" PassiveLevelThread: HALT\n")); pThisDev->hPassiveThread = NULL; DEBUGMSG(DBG_WARN, ("-PassiveLevelThread\n")); // change to FUNC later? PsTerminateSystemThread( STATUS_SUCCESS ); } /***************************************************************************** * * Function: PollingThread * * Synopsis: Thread running at IRQL PASSIVE_LEVEL. * * Arguments: Context - Pointer to IR device * * Returns: None * * Algorithm: * 1) Call USBD for input data; * 2) Call USBD for output data or sets a new speed; * * Notes: * *****************************************************************************/ VOID PollingThread( IN OUT PVOID Context ) { PIR_DEVICE pThisDev = (PIR_DEVICE)Context; NTSTATUS Status; PLIST_ENTRY pListEntry; DEBUGMSG(DBG_WARN, ("+PollingThread\n")); // change to FUNC later? DEBUGMSG(DBG_ERR, (" PollingThread: Starting\n")); KeSetPriorityThread( KeGetCurrentThread(), LOW_REALTIME_PRIORITY ); while( !pThisDev->fKillPollingThread ) { if( pThisDev->fProcessing ) { ULONG FifoCount; PIRUSB_CONTEXT pThisContext; BOOLEAN SentPackets; // // First process the receive // if( ReceivePreprocessFifo( pThisDev, &FifoCount ) != STATUS_SUCCESS ) { // // There is a USB error, stop banging on the chip for a while // NdisMSleep( 1000 ); } else if( FifoCount ) { // // Indicate that we are now receiving // InterlockedExchange( (PLONG)&pThisDev->fCurrentlyReceiving, TRUE ); // // Tell the protocol that the media is now busy // if( pThisDev->fIndicatedMediaBusy == FALSE ) { InterlockedExchange( &pThisDev->fMediaBusy, TRUE ); InterlockedExchange( &pThisDev->fIndicatedMediaBusy, TRUE ); IndicateMediaBusy( pThisDev ); } ReceiveProcessFifoData( pThisDev ); } else if( pThisDev->currentSpeed == SPEED_9600 ) { NdisMSleep( 10*1000 ); } // // Then process the contexts that are ready // SentPackets = FALSE; do { pListEntry = ExInterlockedRemoveHeadList( &pThisDev->SendBuiltQueue, &pThisDev->SendLock ); if( pListEntry ) { InterlockedDecrement( &pThisDev->SendBuiltCount ); pThisContext = CONTAINING_RECORD( pListEntry, IRUSB_CONTEXT, ListEntry ); switch( pThisContext->ContextType ) { // // Packet to send // case CONTEXT_NDIS_PACKET: // // make sure the receive is cleaned // ReceiveResetPointers( pThisDev ); // // Send // SendPreprocessedPacketSend( pThisDev, pThisContext ); if( (pThisDev->ChipRevision >= CHIP_REVISION_7) && (pThisDev->currentSpeed > MAX_MIR_SPEED) ) { SentPackets = TRUE; SendCheckForOverflow( pThisDev ); } else SendWaitCompletion( pThisDev ); break; // // Set the new speed // case CONTEXT_SET_SPEED: // // make sure the receive is cleaned // ReceiveResetPointers( pThisDev ); // // Force completion and set // if( SentPackets ) { SentPackets = TRUE; SendWaitCompletion( pThisDev ); } if( !pThisDev->fPendingHalt && !pThisDev->fPendingReset ) { DEBUGMSG( DBG_ERR, (" Changing speed to: %d\n", pThisDev->linkSpeedInfo->BitsPerSec)); St4200SetSpeed( pThisDev ); InterlockedExchange( (PLONG)&pThisDev->currentSpeed, pThisDev->linkSpeedInfo->BitsPerSec ); #if defined(DIAGS) if( !pThisDev->DiagsActive ) #endif MyNdisMSetInformationComplete( pThisDev, STATUS_SUCCESS ); } else { DEBUGMSG( DBG_ERR , (" St4200SetSpeed DUMPING OUT on TIMEOUT,HALT OR RESET\n")); #if defined(DIAGS) if( !pThisDev->DiagsActive ) #endif MyNdisMSetInformationComplete( pThisDev, STATUS_UNSUCCESSFUL ); } ExInterlockedInsertTailList( &pThisDev->SendAvailableQueue, &pThisContext->ListEntry, &pThisDev->SendLock ); InterlockedIncrement( &pThisDev->SendAvailableCount ); break; #if defined(DIAGS) // // Diagnostic state is enabled // case CONTEXT_DIAGS_ENABLE: Diags_CompleteEnable( pThisDev, pThisContext ); break; // // Diagnostic read of the registers // case CONTEXT_DIAGS_READ_REGISTERS: Diags_CompleteReadRegisters( pThisDev, pThisContext ); break; // // Diagnostic write of the registers // case CONTEXT_DIAGS_WRITE_REGISTER: Diags_CompleteWriteRegister( pThisDev, pThisContext ); break; // // Diagnostic bulk out // case CONTEXT_DIAGS_BULK_OUT: Diags_Bulk( pThisDev, pThisContext, TRUE ); break; // // Diagnostic bulk in // case CONTEXT_DIAGS_BULK_IN: Diags_Bulk( pThisDev, pThisContext, FALSE ); break; // // Diagnostic bulk out // case CONTEXT_DIAGS_SEND: Diags_Send( pThisDev, pThisContext ); break; #endif } } } while( pListEntry ); // // Force to wait // if( SentPackets ) SendWaitCompletion( pThisDev ); } // end if else { NdisMSleep( 10*1000 ); } } // end while DEBUGMSG(DBG_ERR, (" PollingThread: HALT\n")); pThisDev->hPollingThread = NULL; // // this thread will finish here // if the terminate flag is TRUE // DEBUGMSG(DBG_WARN, ("-PollingThread\n")); // change to FUNC later? PsTerminateSystemThread( STATUS_SUCCESS ); } /***************************************************************************** * * Function: AllocUsbInfo * * Synopsis: Allocates the USB portion of the device context. * * Arguments: pThisDev - pointer to current ir device object * * Returns: TRUE - Success * FALSE - Failure * * Notes: * *****************************************************************************/ BOOLEAN AllocUsbInfo( IN OUT PIR_DEVICE pThisDev ) { UINT Size = sizeof( IRUSB_USB_INFO ); pThisDev->pUsbInfo = MyMemAlloc( Size ); if( NULL == pThisDev->pUsbInfo ) { return FALSE; } NdisZeroMemory( (PVOID)pThisDev->pUsbInfo, Size ); return TRUE; } /***************************************************************************** * * Function: AllocUsbInfo * * Synopsis: Deallocates the USB portion of the device context. * * Arguments: pThisDev - pointer to current ir device object * * Returns: None * * Notes: * *****************************************************************************/ VOID FreeUsbInfo( IN OUT PIR_DEVICE pThisDev ) { if( NULL != pThisDev->pUsbInfo ) { // // Free device descriptor structure // if ( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbDeviceDescriptor ) { MyMemFree( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbDeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR) ); } // // Free up the Usb Interface structure // if( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbInterface ) { MyMemFree( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbInterface, ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbInterface->Length ); } // // free up the USB config discriptor // if( ((PIRUSB_USB_INFO) pThisDev->pUsbInfo)->UsbConfigurationDescriptor ) { MyMemFree( ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->UsbConfigurationDescriptor, sizeof(USB_CONFIGURATION_DESCRIPTOR) + 512 ); } MyMemFree( (PVOID)pThisDev->pUsbInfo, sizeof(IRUSB_USB_INFO) ); } } /***************************************************************************** * * Function: IrUsb_InitSendStructures * * Synopsis: Allocates the send stuff * * Arguments: pThisDev - pointer to IR device * * Returns: TRUE if successful * FALSE otherwise * * Notes: * *****************************************************************************/ BOOLEAN IrUsb_InitSendStructures( IN OUT PIR_DEVICE pThisDev ) { BOOLEAN InitResult = TRUE; PUCHAR pThisContext; PIRUSB_CONTEXT pCont; int i; DEBUGMSG(DBG_FUNC, ("+IrUsb_InitSendStructures\n")); // // Initialize a notification event for signalling PassiveLevelThread. // KeInitializeEvent( &pThisDev->EventPassiveThread, SynchronizationEvent, // auto-clearing event FALSE // event initially non-signalled ); #if defined(DIAGS) KeInitializeEvent( &pThisDev->EventDiags, NotificationEvent, // non-auto-clearing event FALSE // event initially non-signalled ); #endif ((PIRUSB_USB_INFO)pThisDev->pUsbInfo)->IrpSubmitUrb = NULL; // // set urblen to max possible urb size // pThisDev->UrbLen = sizeof( struct _URB_BULK_OR_INTERRUPT_TRANSFER ); pThisDev->UrbLen = MAX( pThisDev->UrbLen, sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST)); pThisDev->UrbLen = MAX( pThisDev->UrbLen, sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST )); pThisDev->UrbLen = MAX( pThisDev->UrbLen, sizeof(struct _URB_SELECT_CONFIGURATION)); // // allocate our send context structs // pThisDev->pSendContexts = MyMemAlloc( NUM_SEND_CONTEXTS * sizeof(IRUSB_CONTEXT) ); if( NULL == pThisDev->pSendContexts ) { InitResult = FALSE; goto done; } NdisZeroMemory( pThisDev->pSendContexts, NUM_SEND_CONTEXTS * sizeof(IRUSB_CONTEXT) ); // // Initialize list for holding pending read requests // InitializeListHead( &pThisDev->SendAvailableQueue ); InitializeListHead( &pThisDev->SendBuiltQueue ); InitializeListHead( &pThisDev->SendPendingQueue ); KeInitializeSpinLock( &pThisDev->SendLock ); // // Prepare the read/write specific queue // InitializeListHead( &pThisDev->ReadWritePendingQueue ); pThisContext = pThisDev->pSendContexts; for ( i= 0; i < NUM_SEND_CONTEXTS; i++ ) { pCont = (PIRUSB_CONTEXT)pThisContext; pCont->pThisDev = pThisDev; // Also put in the available queue ExInterlockedInsertTailList( &pThisDev->SendAvailableQueue, &pCont->ListEntry, &pThisDev->SendLock ); pThisContext += sizeof( IRUSB_CONTEXT ); } // for // // URB descriptor // pThisDev->pUrb = MyMemAlloc( pThisDev->UrbLen ); if( NULL == pThisDev->pUrb ) { DEBUGMSG(DBG_ERR, (" IrUsb_InitSendStructures failed to alloc urb\n")); InitResult = FALSE; goto done; } NdisZeroMemory( pThisDev->pUrb, pThisDev->UrbLen ); // // Send buffers // pThisDev->pBuffer = MyMemAlloc( MAX_IRDA_DATA_SIZE ); if( NULL == pThisDev->pBuffer ) { DEBUGMSG(DBG_ERR, (" IrUsb_InitSendStructures failed to alloc info buf\n")); InitResult = FALSE; goto done; } pThisDev->pStagingBuffer = MyMemAlloc( MAX_TOTAL_SIZE_WITH_ALL_HEADERS + FAST_IR_FCS_SIZE ); if( NULL == pThisDev->pStagingBuffer ) { DEBUGMSG(DBG_ERR, (" IrUsb_InitSendStructures failed to alloc staging buf\n")); InitResult = FALSE; goto done; } // // and send counts // pThisDev->SendAvailableCount = NUM_SEND_CONTEXTS; pThisDev->SendBuiltCount = 0; pThisDev->SendPendingCount = 0; pThisDev->ReadWritePendingCount = 0; pThisDev->SendFifoCount = 0; done: DEBUGMSG(DBG_FUNC, ("-IrUsb_InitSendStructures\n")); return InitResult; } /***************************************************************************** * * Function: IrUsb_FreeSendStructures * * Synopsis: Deallocates the send stuff * * Arguments: pThisDev - pointer to IR device * * Returns: None * * Notes: * *****************************************************************************/ VOID IrUsb_FreeSendStructures( IN OUT PIR_DEVICE pThisDev ) { DEBUGMSG(DBG_FUNC, ("+IrUsb_FreeSendStructures\n")); if( NULL != pThisDev->pSendContexts ) { MyMemFree( pThisDev->pSendContexts, NUM_SEND_CONTEXTS * sizeof(IRUSB_CONTEXT) ); pThisDev->pSendContexts = NULL; } if( NULL != pThisDev->pUrb ) { MyMemFree( pThisDev->pUrb, pThisDev->UrbLen ); pThisDev->pUrb = NULL; } if( NULL != pThisDev->pBuffer ) { MyMemFree( pThisDev->pBuffer, MAX_IRDA_DATA_SIZE ); pThisDev->pBuffer = NULL; } if( NULL != pThisDev->pStagingBuffer ) { MyMemFree( pThisDev->pStagingBuffer, MAX_TOTAL_SIZE_WITH_ALL_HEADERS + FAST_IR_FCS_SIZE ); pThisDev->pStagingBuffer = NULL; } DEBUGMSG(DBG_FUNC, ("-IrUsb_FreeSendStructures\n")); } /***************************************************************************** * * Function: IrUsb_PrepareSetSpeed * * Synopsis: Prepares a context to set the new speed * * Arguments: pThisDev - pointer to IR device * * Returns: None * * Notes: * *****************************************************************************/ VOID IrUsb_PrepareSetSpeed( IN OUT PIR_DEVICE pThisDev ) { PIRUSB_CONTEXT pThisContext; PLIST_ENTRY pListEntry; DEBUGMSG( DBG_FUNC, ("+IrUsb_PrepareSetSpeed()\n")); // // Get a context to queue // pListEntry = ExInterlockedRemoveHeadList( &pThisDev->SendAvailableQueue, &pThisDev->SendLock ); if( NULL == pListEntry ) { // // This must not happen // DEBUGMSG(DBG_ERR, (" IrUsb_PrepareSetSpeed failed to find a free context struct\n")); IRUSB_ASSERT( 0 ); goto done; } InterlockedDecrement( &pThisDev->SendAvailableCount ); pThisContext = CONTAINING_RECORD( pListEntry, IRUSB_CONTEXT, ListEntry ); pThisContext->ContextType = CONTEXT_SET_SPEED; // // Queue the context and nothing else has to be done // ExInterlockedInsertTailList( &pThisDev->SendBuiltQueue, &pThisContext->ListEntry, &pThisDev->SendLock ); InterlockedIncrement( &pThisDev->SendBuiltCount ); done: DEBUGMSG( DBG_FUNC, ("-IrUsb_PrepareSetSpeed()\n")); } /***************************************************************************** * * Function: IrUsb_IncIoCount * * Synopsis: Tracks count of pending irps * * Arguments: pThisDev - pointer to IR device * * Returns: None * * Notes: * *****************************************************************************/ VOID IrUsb_IncIoCount( IN OUT PIR_DEVICE pThisDev ) { InterlockedIncrement( &pThisDev->PendingIrpCount ); } /***************************************************************************** * * Function: IrUsb_DecIoCount * * Synopsis: Tracks count of pending irps * * Arguments: pThisDev - pointer to IR device * * Returns: None * * Notes: * *****************************************************************************/ VOID IrUsb_DecIoCount( IN OUT PIR_DEVICE pThisDev ) { InterlockedDecrement( &pThisDev->PendingIrpCount ); } /***************************************************************************** * * Function: AllocXferUrb * * Synopsis: Allocates the transfer Urb for a USB transaction * * Arguments: None * * Returns: Pointer to Urb * * Notes: * *****************************************************************************/ PVOID AllocXferUrb( VOID ) { return MyMemAlloc( sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER) ); } /***************************************************************************** * * Function: FreeXferUrb * * Synopsis: Deallocates the transfer Urb for a USB transaction * * Arguments: pUrb - pointer to Urb * * Returns: Pointer to Urb * * Notes: * *****************************************************************************/ VOID FreeXferUrb( IN OUT PVOID pUrb ) { MyMemFree( pUrb, sizeof(struct _URB_BULK_OR_INTERRUPT_TRANSFER) ); }