如何编写Windows CE.net的usb驱动程序(2)

绝地灬酷狼 2022-08-24 06:13 138阅读 0赞

上述讲了堆理论，可能读者脑袋都已经大了，为此，我们举个简单的例子来详细说明一下驱动程序的开发过程。  
  
例如我们有个USB Mouse设备，设备信息描述如下：  
Device Descriptor:  
bcdUSB: 0x0100  
bDeviceClass: 0x00  
bDeviceSubClass: 0x00  
bDeviceProtocol: 0x00  
bMaxPacketSize0: 0x08 (8)  
idVendor: 0x05E3 (Genesys Logic Inc.)  
idProduct: 0x0001  
bcdDevice: 0x0101  
iManufacturer: 0x00  
iProduct: 0x01  
iSerialNumber: 0x00  
bNumConfigurations: 0x01  
  
ConnectionStatus: DeviceConnected  
Current Config *value*: 0x01  
Device Bus Speed: Low  
Device Address: 0x02  
Open Pipes: 1  
  
Endpoint Descriptor:  
bEndpointAddress: 0x81  
Transfer Type: Interrupt  
wMaxPacketSize: 0x0003 (3)  
bInterval: 0x0A  
  
可以看出上述设备有一个中断PIPE，包的最大值为3。可能有人问上述的值怎么得到的，win2k 的DDK中有个usbview的例程，编译一下，将你的USB设备插到PC机的USB口中，运行usbview.exe即可看得相应的设备信息。  
  
有了这些基本信息，就可以编写USB设备了，首先声明一下，下面的代码取自微软的USB鼠标样本程序，版权归微软所有，此处仅仅借用来描述一下USB鼠标驱动的开发过程，读者如需要引用此代码，需要得到微软的同意。  
  
首先，必须输出USBD要求调用的三个函数，首先到设备插入到USB端口时，USBD会调用USBDeviceAttach()函数，相应的代码如下：  
extern "C" BOOL  
USBDeviceAttach(  
USB\_HANDLE hDevice, // USB设备句柄  
LPCUSB\_FUNCS lpUsbFuncs, // USBDI的函数集合  
LPCUSB\_INTERFACE lpInterface, // 设备接口描述信息  
LPCWSTR szUniqueDriverId, // 设备ID描述字符串。  
LPBOOL fAcceptControl, // 返回TRUE，标识我们可以控制此设备， 反之表示不能控制  
DWORD dwUnused)  
\{  
\*fAcceptControl = FALSE;  
// 我们的鼠标设备有特定的描述信息，要检测是否是我们的设备。  
if (lpInterface == NULL)  
return FALSE;  
// 打印相关的USB设备接口描述信息。  
DEBUGMSG(ZONE\_INIT,(TEXT("USBMouse: DeviceAttach, IF %u, \#EP:%u, Class:%u, Sub:%u,Prot:%u/r/n"), lpInterface->Descriptor.bInterfaceNumber,lpInterface->Descriptor.bNumEndpoints, lpInterface->Descriptor.bInterfaceClass,lpInterface->Descriptor.bInterfaceSubClass,lpInterface->Descriptor.bInterfaceProtocol));  
// 初试数据USB鼠标类，产生一个接受USB鼠标数据的线程  
CMouse \* pMouse = new CMouse(hDevice, lpUsbFuncs, lpInterface);  
if (pMouse == NULL)  
return FALSE;  
  
if (!pMouse->Initialize())  
\{  
delete pMouse;  
return FALSE;  
\}  
  
// 注册一个监控USB设备事件的回调函数，用于监控USB设备是否已经拔掉。  
(\*lpUsbFuncs->lpRegisterNotificationRoutine)(hDevice,  
USBDeviceNotifications, pMouse);  
  
\*fAcceptControl = TRUE;  
return TRUE;  
\}  
  
第二个函数是 USBInstallDriver（）函数，  
一些基本定义如下：  
const WCHAR gcszRegisterClientDriverId\[\] = L"RegisterClientDriverID";  
const WCHAR gcszRegisterClientSettings\[\] = L"RegisterClientSettings";  
const WCHAR gcszUnRegisterClientDriverId\[\] = L"UnRegisterClientDriverID";  
const WCHAR gcszUnRegisterClientSettings\[\] = L"UnRegisterClientSettings";  
const WCHAR gcszMouseDriverId\[\] = L"Generic\_Sample\_Mouse\_Driver";  
  
函数接口如下：  
extern "C" BOOL  
USBInstallDriver(  
LPCWSTR szDriverLibFile) // @parm \[IN\] - Contains client driver DLL name  
\{  
BOOL fRet = FALSE;  
HINSTANCE hInst = LoadLibrary(L"USBD.DLL");  
  
// 注册USB设备信息  
if(hInst)  
\{  
LPREGISTER\_CLIENT\_DRIVER\_ID pRegisterId = (LPREGISTER\_CLIENT\_DRIVER\_ID)  
GetProcAddress(hInst, gcszRegisterClientDriverId);  
  
LPREGISTER\_CLIENT\_SETTINGS pRegisterSettings =  
(LPREGISTER\_CLIENT\_SETTINGS) GetProcAddress(hInst,  
gcszRegisterClientSettings);  
  
if(pRegisterId && pRegisterSettings)  
\{  
USB\_DRIVER\_SETTINGS DriverSettings;  
  
DriverSettings.dwCount = sizeof(DriverSettings);  
  
// 设置我们的特定的信息。  
DriverSettings.dwVendorId = USB\_NO\_INFO;  
DriverSettings.dwProductId = USB\_NO\_INFO;  
DriverSettings.dwReleaseNumber = USB\_NO\_INFO;  
  
DriverSettings.dwDeviceClass = USB\_NO\_INFO;  
DriverSettings.dwDeviceSubClass = USB\_NO\_INFO;  
DriverSettings.dwDeviceProtocol = USB\_NO\_INFO;  
  
DriverSettings.dwInterfaceClass = 0x03; // HID  
DriverSettings.dwInterfaceSubClass = 0x01; // boot device  
DriverSettings.dwInterfaceProtocol = 0x02; // mouse  
  
fRet = (\*pRegisterId)(gcszMouseDriverId);  
  
if(fRet)  
\{  
fRet = (\*pRegisterSettings)(szDriverLibFile,  
gcszMouseDriverId, NULL, &DriverSettings);  
  
if(!fRet)  
\{  
//BUGBUG unregister the Client Driver’s ID  
\}  
\}  
\}  
else  
\{  
RETAILMSG(1,(TEXT("!USBMouse: Error getting USBD function pointers/r/n")));  
\}  
FreeLibrary(hInst);  
\}  
return fRet;  
\}  
上述代码主要用于产生USB设备驱动程序需要的注册表信息，需要注意的是：USB设备驱动程序不使用标准的注册表函数，而是使用RegisterClientDriverID（）和RegisterClientSettings来注册相应的设备信息。  
  
另外一个函数是USBUninstallDriver()函数，具体代码如下：  
extern "C" BOOL  
USBUnInstallDriver()  
\{  
BOOL fRet = FALSE;  
HINSTANCE hInst = LoadLibrary(L"USBD.DLL");  
  
if(hInst)  
\{  
LPUN\_REGISTER\_CLIENT\_DRIVER\_ID pUnRegisterId =  
(LPUN\_REGISTER\_CLIENT\_DRIVER\_ID)  
GetProcAddress(hInst, gcszUnRegisterClientDriverId);  
  
LPUN\_REGISTER\_CLIENT\_SETTINGS pUnRegisterSettings =  
(LPUN\_REGISTER\_CLIENT\_SETTINGS) GetProcAddress(hInst,  
gcszUnRegisterClientSettings);  
  
if(pUnRegisterSettings)  
\{  
USB\_DRIVER\_SETTINGS DriverSettings;  
  
DriverSettings.dwCount = sizeof(DriverSettings);  
// 必须填入与注册时相同的信息。  
DriverSettings.dwVendorId = USB\_NO\_INFO;  
DriverSettings.dwProductId = USB\_NO\_INFO;  
DriverSettings.dwReleaseNumber = USB\_NO\_INFO;  
  
DriverSettings.dwDeviceClass = USB\_NO\_INFO;  
DriverSettings.dwDeviceSubClass = USB\_NO\_INFO;  
DriverSettings.dwDeviceProtocol = USB\_NO\_INFO;  
  
DriverSettings.dwInterfaceClass = 0x03; // HID  
DriverSettings.dwInterfaceSubClass = 0x01; // boot device  
DriverSettings.dwInterfaceProtocol = 0x02; // mouse  
  
fRet = (\*pUnRegisterSettings)(gcszMouseDriverId, NULL,  
&DriverSettings);  
\}  
  
if(pUnRegisterId)  
\{  
BOOL fRetTemp = (\*pUnRegisterId)(gcszMouseDriverId);  
fRet = fRet ? fRetTemp : fRet;  
\}  
FreeLibrary(hInst);  
\}  
return fRet;  
\}  
此函数主要用于删除USBInstallDriver()时创建的注册表信息，同样的它使用自己的函数接口UnRegisterClientDriverID（）和UnRegisterClientSettings（）来做相应的处理。  
  
另外一个需要处理的注册的监控通知函数USBDeviceNotifications（）：  
extern "C" BOOL USBDeviceNotifications(LPVOID lpvNotifyParameter, DWORD dwCode,  
LPDWORD \* dwInfo1, LPDWORD \* dwInfo2, LPDWORD \* dwInfo3,  
LPDWORD \* dwInfo4)  
\{  
CMouse \* pMouse = (CMouse \*)lpvNotifyParameter;  
  
switch(dwCode)  
\{  
case USB\_CLOSE\_DEVICE:  
//删除相关的资源。  
delete pMouse;  
return TRUE;  
\}  
return FALSE;  
\}  
  
  
USB鼠标的类的定义如下：  
class CMouse  
\{  
public:  
CMouse::CMouse(USB\_HANDLE hDevice, LPCUSB\_FUNCS lpUsbFuncs,  
LPCUSB\_INTERFACE lpInterface);  
~CMouse();  
  
BOOL Initialize();  
private:  
// 传输完毕调用的回调函数  
static DWORD CALLBACK MouseTransferCompleteStub(LPVOID lpvNotifyParameter);  
// 中断处理函数  
static ULONG CALLBACK CMouse::MouseThreadStub(PVOID context);  
DWORD MouseTransferComplete();  
DWORD MouseThread();  
  
BOOL SubmitInterrupt();  
BOOL HandleInterrupt();  
  
BOOL m\_fClosing;  
BOOL m\_fReadyForMouseEvents;  
  
HANDLE m\_hEvent;  
HANDLE m\_hThread;  
  
USB\_HANDLE m\_hDevice;  
USB\_PIPE m\_hInterruptPipe;  
USB\_TRANSFER m\_hInterruptTransfer;  
  
LPCUSB\_FUNCS m\_lpUsbFuncs;  
LPCUSB\_INTERFACE m\_pInterface;  
  
BOOL m\_fPrevButton1;  
BOOL m\_fPrevButton2;  
BOOL m\_fPrevButton3;  
  
// 数据接受缓冲区。  
BYTE m\_pbDataBuffer\[8\];  
\};  
  
具体实现如下：  
  
// 构造函数，初始化时调用  
CMouse::CMouse(USB\_HANDLE hDevice, LPCUSB\_FUNCS lpUsbFuncs,  
LPCUSB\_INTERFACE lpInterface)  
\{  
m\_fClosing = FALSE;  
m\_fReadyForMouseEvents = FALSE;  
m\_hEvent = NULL;  
m\_hThread = NULL;  
  
m\_hDevice = hDevice;  
m\_hInterruptPipe = NULL;  
m\_hInterruptTransfer = NULL;  
  
m\_lpUsbFuncs = lpUsbFuncs;  
m\_pInterface = lpInterface;  
  
m\_fPrevButton1 = FALSE;  
m\_fPrevButton2 = FALSE;  
m\_fPrevButton3 = FALSE;  
  
memset(m\_pbDataBuffer, 0, sizeof(m\_pbDataBuffer));  
\}  
  
// 析构函数，用于清除申请的资源。  
CMouse::~CMouse()  
\{  
// 通知系统去关闭相关的函数接口。  
m\_fClosing = TRUE;  
  
// Wake up the connection thread again and give it time to die.  
if (m\_hEvent != NULL)  
\{  
// 通知关闭数据接受线程。  
SetEvent(m\_hEvent);  
  
if (m\_hThread != NULL)  
\{  
DWORD dwWaitReturn;  
  
dwWaitReturn = WaitForSingleObject(m\_hThread, 1000);  
if (dwWaitReturn != WAIT\_OBJECT\_0)  
\{  
TerminateThread(m\_hThread, DWORD(-1));  
\}  
CloseHandle(m\_hThread);  
m\_hThread = NULL;  
\}  
CloseHandle(m\_hEvent);  
m\_hEvent = NULL;  
\}  
  
if(m\_hInterruptTransfer)  
(\*m\_lpUsbFuncs->lpCloseTransfer)(m\_hInterruptTransfer);  
  
if(m\_hInterruptPipe)  
(\*m\_lpUsbFuncs->lpClosePipe)(m\_hInterruptPipe);  
\}  
  
  
// 初始化USB鼠标驱动程序  
BOOL CMouse::Initialize()  
\{  
LPCUSB\_DEVICE lpDeviceInfo = (\*m\_lpUsbFuncs->lpGetDeviceInfo)(m\_hDevice);  
  
// 检测配置：USB鼠标应该只有一个中断管道  
if ((m\_pInterface->lpEndpoints\[0\].Descriptor.bmAttributes & USB\_ENDPOINT\_TYPE\_MASK) != USB\_ENDPOINT\_TYPE\_INTERRUPT)  
\{  
RETAILMSG(1,(TEXT("!USBMouse: EP 0 wrong type (%u)!/r/n"),  
m\_pInterface->lpEndpoints\[0\].Descriptor.bmAttributes));  
return FALSE;  
\}  
DEBUGMSG(ZONE\_INIT,(TEXT("USBMouse: EP 0:MaxPacket: %u, Interval: %u/r/n"),  
m\_pInterface->lpEndpoints\[0\].Descriptor.wMaxPacketSize,  
m\_pInterface->lpEndpoints\[0\].Descriptor.bInterval));  
  
m\_hInterruptPipe = (\*m\_lpUsbFuncs->lpOpenPipe)(m\_hDevice,  
&m\_pInterface->lpEndpoints\[0\].Descriptor);  
  
if (m\_hInterruptPipe == NULL) \{  
RETAILMSG(1,(TEXT("Mouse: Error opening interrupt pipe/r/n")));  
return (FALSE);  
\}  
m\_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);  
if (m\_hEvent == NULL)  
\{  
RETAILMSG(1,(TEXT("USBMouse: Error on CreateEvent for connect event/r/n")));  
return(FALSE);  
\}  
// 创建数据接受线程  
m\_hThread = CreateThread(0, 0, MouseThreadStub, this, 0, NULL);  
if (m\_hThread == NULL)  
\{  
RETAILMSG(1,(TEXT("USBMouse: Error on CreateThread/r/n")));  
return(FALSE);  
\}  
  
return(TRUE);  
\}  
  
// 从USB鼠标设备中读出数据，产生相应的鼠标事件。  
BOOL CMouse::SubmitInterrupt()  
\{  
if(m\_hInterruptTransfer)  
(\*m\_lpUsbFuncs->lpCloseTransfer)(m\_hInterruptTransfer);  
  
// 从USB鼠标PIPE中读数据  
m\_hInterruptTransfer = (\*m\_lpUsbFuncs->lpIssueInterruptTransfer)  
(m\_hInterruptPipe, MouseTransferCompleteStub, this,  
USB\_IN\_TRANSFER | USB\_SHORT\_TRANSFER\_OK, // 表示读数据  
min(m\_pInterface->lpEndpoints\[0\].Descriptor.wMaxPacketSize,  
sizeof(m\_pbDataBuffer)),  
m\_pbDataBuffer,  
NULL);  
  
if (m\_hInterruptTransfer == NULL)  
\{  
DEBUGMSG(ZONE\_ERROR，（L "!USBMouse: Error in IssueInterruptTransfer/r/n"));  
return FALSE;  
\}  
else  
\{  
DEBUGMSG(ZONE\_TRANSFER,(L"USBMouse::SubmitInterrupt,Transfer:0x%X/r/n",  
m\_hInterruptTransfer));  
\}  
return TRUE;  
\}  
  
// 处理鼠标中断传输的数据  
BOOL CMouse::HandleInterrupt()  
\{  
DWORD dwError;  
DWORD dwBytes;  
  
DWORD dwFlags = 0;  
INT dx = (signed char)m\_pbDataBuffer\[1\];  
INT dy = (signed char)m\_pbDataBuffer\[2\];  
  
BOOL fButton1 = m\_pbDataBuffer\[0\] & 0x01 ? TRUE : FALSE;  
BOOL fButton2 = m\_pbDataBuffer\[0\] & 0x02 ? TRUE : FALSE;  
BOOL fButton3 = m\_pbDataBuffer\[0\] & 0x04 ? TRUE : FALSE;  
  
if (!(\*m\_lpUsbFuncs->lpGetTransferStatus)(m\_hInterruptTransfer, &dwBytes,&dwError))  
\{  
DEBUGMSG(ZONE\_ERROR,(TEXT("!USBMouse: Error in GetTransferStatus(0x%X)/r/n"),  
m\_hInterruptTransfer));  
return FALSE;  
\}  
else  
\{  
DEBUGMSG(ZONE\_TRANSFER,(TEXT("USBMouse::HandleInterrupt, hTransfer 0x%X complete (%u bytes, Error:%X)/r/n"),  
m\_hInterruptTransfer,dwBytes,dwError));  
\}  
  
if (!SubmitInterrupt())  
return FALSE;  
  
if(dwError != USB\_NO\_ERROR)  
\{  
DEBUGMSG(ZONE\_ERROR,(TEXT("!USBMouse: Error 0x%X in interrupt transfer/r/n"),dwError));  
return TRUE;  
\}  
  
if(dwBytes < 3)  
\{  
DEBUGMSG(ZONE\_ERROR,(TEXT("!USBMouse: Invalid byte cnt %u from interrupt transfer/r/n"),dwBytes));  
return TRUE;  
\}  
  
if(dx || dy)  
dwFlags |= MOUSEEVENTF\_MOVE;  
  
if(fButton1 != m\_fPrevButton1)  
\{  
if(fButton1)  
dwFlags |= MOUSEEVENTF\_LEFTDOWN;  
else  
dwFlags |= MOUSEEVENTF\_LEFTUP;  
\}  
  
if(fButton2 != m\_fPrevButton2)  
\{  
if(fButton2)  
dwFlags |= MOUSEEVENTF\_RIGHTDOWN;  
else  
dwFlags |= MOUSEEVENTF\_RIGHTUP;  
\}  
  
if(fButton3 != m\_fPrevButton3)  
\{  
if(fButton3)  
dwFlags |= MOUSEEVENTF\_MIDDLEDOWN;  
else  
dwFlags |= MOUSEEVENTF\_MIDDLEUP;  
\}  
  
m\_fPrevButton1 = fButton1;  
m\_fPrevButton2 = fButton2;  
m\_fPrevButton3 = fButton3;  
  
DEBUGMSG(ZONE\_EVENTS,  
(TEXT("USBMouse event: dx:%d, dy:%d, dwFlags:0x%X (B1:%u, B2:%u, B3:%u)/r/n"),  
dx,dy,dwFlags,fButton1,fButton2,fButton3));  
  
// 通知系统产生鼠标事件  
if (m\_fReadyForMouseEvents)  
mouse\_event(dwFlags, dx, dy, 0, 0);  
else  
m\_fReadyForMouseEvents = IsAPIReady(SH\_WMGR);  
  
return TRUE;  
\}  
  
  
DWORD CALLBACK CMouse::MouseTransferCompleteStub(LPVOID lpvNotifyParameter)  
\{  
CMouse \* pMouse = (CMouse \*)lpvNotifyParameter;  
return(pMouse->MouseTransferComplete());  
\}  
  
// 数据传输完毕回调函数  
DWORD CMouse::MouseTransferComplete()  
\{  
if (m\_hEvent)  
SetEvent(m\_hEvent);  
return 0;  
\}  
  
  
ULONG CALLBACK CMouse::MouseThreadStub(PVOID context)  
\{  
CMouse \* pMouse = (CMouse \*)context;  
return(pMouse->MouseThread());  
\}  
  
// USB鼠标线程  
DWORD CMouse::MouseThread()  
\{  
DEBUGMSG(ZONE\_INIT,(TEXT("USBMouse: Worker thread started/r/n")));  
SetThreadPriority(GetCurrentThread(), THREAD\_PRIORITY\_HIGHEST);  
  
if (SubmitInterrupt())  
\{  
while (!m\_fClosing)  
\{  
WaitForSingleObject(m\_hEvent, INFINITE);  
  
if (m\_fClosing)  
break;  
  
if ((\*m\_lpUsbFuncs->lpIsTransferComplete)(m\_hInterruptTransfer))  
\{  
if (!HandleInterrupt())  
break;  
\}  
else  
\{  
RETAILMSG(1,(TEXT("!USBMouse: Event signalled, but transfer not complete/r/n")));  
// The only time this should happen is if we get an error on the transfer  
ASSERT(m\_fClosing || (m\_hInterruptTransfer == NULL));  
break;  
\}  
\}  
\}  
RETAILMSG(1,(TEXT("USBMouse: Worker thread exiting/r/n")));  
return(0);  
\}  
  
看到了没有，其实USB的驱动程序编写就这么简单，类似的其他设备，例如打印机设备，就有Bulk OUT PIPE，需要Bulk传输，那就需要了解一下IssueBulkTransfer（）的应用。当然如果是开发USB Mass Storage Disk的驱动，那就需要了解更多的协议，例如Bulk-Only Transport协议等。  
  
微软的Windows CE.NET的Platform Build中已经带有USB Printer和USB Mass Storage Disk的驱动的源代码了，好好研究一下，你一定回受益非浅的。  
  
  
  
参考资料：  
1． 微软出版社 <<Windows Ce Device Driver Kit>>  
2． <<Universal Serial Bus Specification 1.1>> 来自http:://www.usb.org