cusbintf.h

完整的基于Conxant平台的USB电视棒的WIN驱动程序。

/*+++ *******************************************************************\ 
* 
*  Copyright and Disclaimer: 
*  
*     --------------------------------------------------------------- 
*     This software is provided "AS IS" without warranty of any kind, 
*     either expressed or implied, including but not limited to the 
*     implied warranties of noninfringement, merchantability and/or 
*     fitness for a particular purpose.
*     --------------------------------------------------------------- 
*   
*     Copyright (c) 2008 Conexant Systems, Inc. 
*     All rights reserved. 
*
\******************************************************************* ---*/ 
#ifndef __CUSBINTF_H__
#define __CUSBINTF_H__

extern "C" 
{
#include "usb.h"
}

#include <ntverp.h>
#include "debug.h"

#if(VER_PRODUCTBUILD < 5384)
typedef NTSTATUS IO_COMPLETION_ROUTINE(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP irp,
IN PVOID Context);
typedef IO_COMPLETION_ROUTINE *PIO_COMPLETION_ROUTINE;
#endif

extern "C"
{

   IO_COMPLETION_ROUTINE staticUsbCallCompletion;
   IO_COMPLETION_ROUTINE staticIsoTransferComplete;
   IO_COMPLETION_ROUTINE staticUsbReadComplete;		  	
}	

typedef void (__stdcall *USBCOMPLETION)(void *UserContext, NTSTATUS ntStatus, ULONG transferSize, void *pUserContext2);


typedef struct _VENDOR_REQUEST_IN
{
	BYTE					bRequest;
	WORD					wValue;
	WORD					wIndex;
	WORD					wLength;
	BYTE					direction;
	BYTE					bData;
	BYTE					*pBuff;
} VENDOR_REQUEST_IN, *PVENDOR_REQUEST_IN;



class CUsbInterface;


//Context information for asynchronous read/writes.
typedef struct _READ_CONTEXT
{
	CUsbInterface*          pUsb;			// Ptr to the USB context used for the operation.
	DWORD					Pipe;			// Pipe index.
	DWORD					Interface;		// Interface index
	USBCOMPLETION			pCompletion;	// Pointer to the caller's completion routine.
	void*                   UserContext;	// Caller's completion context.
	IRP*                    pIrp;			// IRP containing the URB.
	URB*                    pUrb;			// URB containing the request.
	ULONGLONG				ullStartTime;
	DWORD					dwXferSize;		// Amount of data transferred
	PVOID					pEntry;
} READ_CONTEXT, *PREAD_CONTEXT;

#define USB_INVALID_INTERFACE					0xFF



/////////////////////////////////////////////////////////////////////////////
//
//

class CUsbInterface
{
public:

    //Constructor/destructor
	CUsbInterface(PDEVICE_OBJECT pdo);
	virtual ~CUsbInterface();

    //Init/Release
    NTSTATUS InitDevice();
	NTSTATUS Release(void);

	// wait and clear functions for Config Device
	NTSTATUS waitForConfigDevice();
	void setUsbConfigEvent();

	// Usb Device Configuration is completed or not
	BOOL IsUsbConfigured() { return _is_initialized; }

	NTSTATUS UsbConfigSelect(ULONG configuration_number);
	NTSTATUS UsbInterfaceSelect(UCHAR interface_number, UCHAR alternate_setting);

    //Send a URB to the USB bus driver (synchronous)
    NTSTATUS UsbCall_GSPN(URB* p_urb);
	
    //Send a vendor-specific request to the EZ-USB or FX2
    NTSTATUS Ezusb_VendorRequest(PVENDOR_REQUEST_IN p_request);
  
    //Send a bulk (or interrupt) data transfer.
    NTSTATUS UsbSendMcCmd(
        DWORD pipe_number, 
        UCHAR interface_number,
        void* p_data, 
        DWORD transfer_size);

    //Send a bulk (or interrupt) data transfer.
    NTSTATUS UsbSendRecvCmd(
        DWORD pipe_number, 
        UCHAR interface_number,
        void* p_data, 
        DWORD transfer_size);
	
    //Start an asynchronous data transfer (bulk, interrupt, or isochronous)
    NTSTATUS UsbAsyncIo(
        DWORD pipe_number, 
        UCHAR interface_number,
        PBYTE p_data, 
        DWORD data_size, 
        PMDL p_mdl, 
        PREAD_CONTEXT p_read_context);

    //Reset a pipe
	NTSTATUS UsbResetPipe(DWORD pipe_number, UCHAR interface_number);

    //Abort all data transfers in progress on a pipe
    NTSTATUS UsbAbortPipe(DWORD pipe_number, UCHAR interface_number);

    //Get the status of a pipe
    NTSTATUS UsbGetStatusPipe(DWORD pipe_number, UCHAR interface_number);

	PUSB_CONFIGURATION_DESCRIPTOR getConfigDescriptor() {return (_p_configs ? _p_configs[_config_index] : NULL);}

    UCHAR getNumberOfInterfaces(); 
	DWORD getNumberOfPipes(UCHAR iterface_number); 

    UCHAR getInterfaceWithSubClass(UCHAR sub_class); 
	DWORD getMaximumTransferSize(DWORD pipe_number, UCHAR interface_number);
	DWORD getMaximumPaketSize(DWORD pipe_number, UCHAR interface_number);

    BOOL isInterfaceValid(UCHAR interface_num);
    BOOL isPipeValid(UCHAR interface_num, DWORD pipe_num);

    USBD_PIPE_INFORMATION* getPipe(UCHAR interface_number, DWORD pipe_number);

    void SetSurpriseRemovalFlag(BOOL bFlag) { _bSurpriseRemoval = bFlag; }

    NTSTATUS getUsbSerialNumber(PWCHAR serialNumber, DWORD size, DWORD *p_actual_size);
    
     //Completion routine for asynchronous isochronous tranfers
	NTSTATUS IsoTransferComplete(PIRP p_irp, PREAD_CONTEXT p_read_context);

    //Completion routine for asynchronous bulk transfers
    NTSTATUS UsbReadComplete(IRP* p_irp, PREAD_CONTEXT p_read_context);
	NTSTATUS UsbClearFeature(DWORD dwPipeNum,
									 UCHAR ucInterface
									 );
    USHORT getRevID();
private:
	NTSTATUS ConfigDevice();
	void UnConfigDevice();
	
    //Get USB device descriptor and USB configuratio descriptors
	NTSTATUS UsbDeviceGetDescriptor();
	NTSTATUS UsbConfigGetDescriptor(DWORD config_count);

    //Start an asynchronous isochrounous transfer
    NTSTATUS UsbAsyncIo_ISO(
        DWORD pipe_number, 
        UCHAR interface_number,
        PBYTE p_buffer, 
        DWORD buffer_size, 
        PREAD_CONTEXT p_read_context);

    //Start a synchronous bulk transfer using the asynchronous call protocol
    NTSTATUS UsbAsyncIo_BULK_SYNC(
        DWORD pipe_number, 
        UCHAR interface_number,
        PBYTE p_buffer, 
        DWORD buffer_size, 
        PREAD_CONTEXT p_read_context);

    //Start an asynchronous bulk transfer
    NTSTATUS UsbAsyncIo_BULK(
        DWORD pipe_number, 
        UCHAR interface_number,
        PBYTE p_buffer, 
        DWORD buffer_size, 
        PREAD_CONTEXT p_read_context);

    //Helper functions to allocate and free interface descriptors
    void freeInterfaces();
    VOID assignInterface(USBD_INTERFACE_INFORMATION* p_interface, DWORD index);

    //Debug print functions
	void DumpUsbDevDescriptor(USB_DEVICE_DESCRIPTOR* p_descriptor);
	void DumpUsbConfigDescriptor(USB_CONFIGURATION_DESCRIPTOR* p_config);
	void DumpUrbSelectConfig(struct _URB_SELECT_CONFIGURATION* p_config);
	void DumpUsbInterfaceInfo(USBD_INTERFACE_INFORMATION* p_interface);
	void DumpUsbPipeInfo(USBD_PIPE_INFORMATION* p_pipe); 
    
    NTSTATUS ResetParentPort();
    NTSTATUS GetPortStatus(IN OUT PULONG     PortStatus);
    NTSTATUS ResetDevice();
    NTSTATUS SendCmdAndWait(PURB p_urb);

private:
	PDEVICE_OBJECT					_pdo;				    // device PDO

	USB_DEVICE_DESCRIPTOR			_device_descriptor;		// Device descriptor
	USB_CONFIGURATION_DESCRIPTOR**  _p_configs;		        // Configuration descriptor (allocated)
	ULONG							_config_index;			// Configuration index
	USBD_INTERFACE_INFORMATION**    _p_interfaces;	        // USBD interface (allocated)
	HANDLE							_config_handle;		    // This is the USBD configuration handle

	BOOL							_error_occured;         //error flag

	PIRP							_p_irp;
	KEVENT							_event;

    BOOL                            _is_initialized;
    BOOL                            _is_descriptor_available;
    KMUTEX                          _mutex;
    BOOL                            _bSurpriseRemoval;
    PURB                            _p_cmd_urb;
	KEVENT							_usb_config_event;
};


/////////////////////////////////////////////////////////////////////////////////////////
inline USBD_PIPE_INFORMATION* CUsbInterface::getPipe(UCHAR interface_number, DWORD pipe_number)
{
//	KdPrint(("CUsbInterface::getPipe(%x,%x)", interface_number, pipe_number));
	if (isPipeValid(interface_number, pipe_number)) 
	{
        if(_p_interfaces)
        {
		    return &(_p_interfaces[interface_number]->Pipes[pipe_number]);
        }
        else
        {
            return NULL;
        }
	}
    
    return NULL;
}

/////////////////////////////////////////////////////////////////////////////////////////
inline UCHAR CUsbInterface::getNumberOfInterfaces() 
{
    if (_p_configs && 
        (_config_index < _device_descriptor.bNumConfigurations) &&
        _p_configs[_config_index])
    {
        return (_p_configs[_config_index]->bNumInterfaces);
    }
    else
    {
        return (0);
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
inline DWORD CUsbInterface::getNumberOfPipes(UCHAR interface_number) 
{
    if (isInterfaceValid(interface_number)) 
    {
        if(_p_interfaces)
        {
            return (_p_interfaces[interface_number]->NumberOfPipes);
        }
        else
        {
            return (0);
        }
    }
    else
    {
        return (0);
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
inline BOOL CUsbInterface::isInterfaceValid(UCHAR interface_num)
{
    if(_p_interfaces && 
		(interface_num < _p_configs[_config_index]->bNumInterfaces) &&
		_p_interfaces[interface_num])
    {
        return TRUE;
    }

    KdPrint(("Invalid USB interface %x\n", interface_num));

    return FALSE;
}

/////////////////////////////////////////////////////////////////////////////////////////
inline BOOL CUsbInterface::isPipeValid(UCHAR interface_num, DWORD pipe_num)
{
    if(_p_interfaces)
    {
        return (isInterfaceValid(interface_num) &&
		    (_p_interfaces[interface_num]->NumberOfPipes > pipe_num)); 
    }
    else
    {
        return FALSE;
    }
}


#endif //__CUSBINTF_H__