[Version]
Signature = "$Windows NT$"
Class     = USB Device
ClassGUID = {745a17a0-74d3-11d0-b6fe-00a0c90f57da}
Provider = %ManufacturerName%
CatalogFile=mbed_Kitty.cat
DriverVer=04/15/2012,6.2.8181.0

; ========== Manufacturer/Models sections ===========

[Manufacturer]
%ManufacturerName% = Standard,NTamd64

[Standard.NTamd64]
%DeviceName% =USB_Install, USB\VID_1337&PID_1234

; =================== Installation ===================

[USB_Install]
Include=winusb.inf
Needs=WINUSB.NT

[USB_Install.Services]
Include=winusb.inf
AddService=WinUsb,0x00000002,WinUsb_ServiceInstall

[WinUsb_ServiceInstall]
DisplayName     = %WinUsb_SvcDesc%
ServiceType     = 1
StartType       = 3
ErrorControl    = 1
ServiceBinary   = %12%\WinUSB.sys

[USB_Install.Wdf]
KmdfService=WINUSB, WinUsb_Install

[WinUsb_Install]
KmdfLibraryVersion=1.11

[USB_Install.HW]
AddReg=Dev_AddReg

[Dev_AddReg]
HKR,,DeviceInterfaceGUIDs,0x10000,"{f167724d-74d3-430e-86b5-f0368910eb22}"

[USB_Install.CoInstallers]
AddReg=CoInstallers_AddReg
CopyFiles=CoInstallers_CopyFiles

[CoInstallers_AddReg]
HKR,,CoInstallers32,0x00010000,"WdfCoInstaller01009.dll,WdfCoInstaller","WinUsbCoInstaller2.dll"

[CoInstallers_CopyFiles]
WinUsbCoInstaller2.dll
WdfCoInstaller01009.dll

[DestinationDirs]
CoInstallers_CopyFiles=11

; ================= Source Media Section =====================

[SourceDisksNames]
1 = %DiskName%

[SourceDisksFiles]
WinUsbCoInstaller2.dll=1
WdfCoInstaller01009.dll=1

; =================== Strings ===================

[Strings]
ManufacturerName="FuzCo"
ClassName="Data Acquisition Devices"
DiskName="USB Installation Disk"
WinUsb_SvcDesc="WinUSB Driver"
DeviceName="myAwesomeDevice"

// File:	"USB_Functions.h"
// Author:	Chris Yan
// Date:	April 15, 2012
// Desc:	Function Declarations for USB Data Project

/* Include Windows headers */
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <strsafe.h>

/* Include WinUSB headers */
#include <winusb.h>
#include <Usb100.h>
#include <Setupapi.h>

/* Project headers */
#include "stdafx.h"

// Constant for {f167724d-74d3-430e-86b5-f0368910eb22}
static const GUID FC_DEVICE_INTERFACE = 
{ 0xf167724d, 0x74d3, 0x430e, { 0x86, 0xb5, 0xf0, 0x36, 0x89, 0x10, 0xeb, 0x22 } };

/* Structures */
struct PIPE
{
    UCHAR  PipeInId;
    UCHAR  PipeOutId;
	UCHAR  PipeInterruptFirst;
	UCHAR  PipeInterruptLast;
	UCHAR  PipeControl;
};

/* Functions */
// PRE:		Function is called from main loop as the return value
// POST:	User is bid farewell before exiting and errors are reported if errorFlag != 0
int ExitProgram( bool errorFlag );

// PRE:		phWinUsbHandle must not represent -log(H) ... :)
// POST:	WinUSB fills out the interface handle using the device handle provided.
//				Errors are returned as any non-zero value
bool StartWinUSB( HANDLE hDeviceHandle, PWINUSB_INTERFACE_HANDLE phWinUsbHandle );

bool FindEndpoints(WINUSB_INTERFACE_HANDLE hDeviceHandle, PIPE* pipeid);

bool ReadPipe(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pID, ULONG cbSize);

bool WritePipe(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pID, ULONG* pcbWritten);

// PRE:		hDeviceHandle must be unused and NULL
// POST:	WinUsb will search the registry for matching devices installed with the GUID.
//				If a matching device is found, the provided PHANDLE will be filled with
//				the matching device's information (location, name, etc...).
bool SearchGUID(GUID guidDeviceInterface, PHANDLE hDeviceHandle);

// File:	"USB_Functions.cpp"
// Author:	Chris Yan
// Date:	April 15, 2012
// Desc:	Functions for USB Data Project
//			Based off of examples from the MSDN avaliable at:
//			http://msdn.microsoft.com/en-us/library/windows/hardware/ff540174(v=vs.85).aspx


// Project headers
#include "stdafx.h"
#include "USB_Functions.h"

int ExitProgram( bool errorFlag )
{
	if(errorFlag)
		printf("\n\nProgram aborted. ");
	else
		printf("\n\nProgram finished. ");

	system("PAUSE");

	return errorFlag;
}

bool StartWinUSB( HANDLE hDeviceHandle, PWINUSB_INTERFACE_HANDLE phWinUSBHandle )
{
	printf("\n\nInitializing WinUSB Interface for the device...");
	if( hDeviceHandle == INVALID_HANDLE_VALUE )
	{
		printf(" error.\n    Device Handle is invalid.");
		return 1;
	}

	if( !(WinUsb_Initialize(hDeviceHandle, phWinUSBHandle)) )
	{
		printf(" error.\n    Unable to start WinUSB for the device.");
		return 1;
	} else
		printf(" done.");
	
	return 0;
}

bool FindEndpoints(WINUSB_INTERFACE_HANDLE hDeviceHandle, PIPE* pipeid)
{
	// Variable Declarations
	USB_INTERFACE_DESCRIPTOR interfaceDesc;
	WINUSB_PIPE_INFORMATION pipeInfo;
	bool ef = 0;

	// Variable Setup
	ZeroMemory( &interfaceDesc, sizeof(USB_INTERFACE_DESCRIPTOR) );
	ZeroMemory( &pipeInfo, sizeof(WINUSB_PIPE_INFORMATION) );

	// Setup our query for the specified device
	printf("\nCreating and sending device query...");
	if( !WinUsb_QueryInterfaceSettings(hDeviceHandle, 0, &interfaceDesc) )
	{
		printf(" Error.\n    USB Interface query failed.\n");
		return 1;
	}
	printf("\n#Descriptor type   : %d", interfaceDesc.bDescriptorType);
	printf("\n#Interface Class   : %d", interfaceDesc.bInterfaceClass);
	printf("\n#Interface Number  : %d", interfaceDesc.bInterfaceNumber);
	printf("\n#Interface Protocol: %d", interfaceDesc.bInterfaceProtocol);
	printf("\n#Interface SubClass: %d", interfaceDesc.bInterfaceSubClass);
	printf("\n#iInterface        : %d", interfaceDesc.iInterface);
	printf("\n#Endpoints Found   : %d", interfaceDesc.bNumEndpoints);
	
	printf("\nFinished device query.");

	printf("\n\nCreating and sending endpoint queries...");
	for(int idx = 0; idx < interfaceDesc.bNumEndpoints; idx++)
	{
		if( WinUsb_QueryPipe(hDeviceHandle,0,idx,&pipeInfo) )
		{
			if(pipeInfo.PipeType == UsbdPipeTypeControl)
				printf("\n    Endpoint %d:\n      Type: Control\n      PipeID: %d",idx,pipeInfo.PipeId);
			if(pipeInfo.PipeType == UsbdPipeTypeIsochronous)
				printf("\n    Endpoint %d:\n      Type: Isochronous\n      PipeID: %d",idx,pipeInfo.PipeId);
			if(pipeInfo.PipeType == UsbdPipeTypeBulk)
			{
				if( USB_ENDPOINT_DIRECTION_IN(pipeInfo.PipeId) )
				{
					printf("\n    Endpoint %d:\n      Type: Bulk-In\n      PipeID: %c",idx,pipeInfo.PipeId);
					pipeid->PipeInId = pipeInfo.PipeId;
				}
				if( USB_ENDPOINT_DIRECTION_OUT(pipeInfo.PipeId) )
				{
					printf("\n    Endpoint %d:\n      Type: Bulk-Out\n      PipeID: %c",idx,pipeInfo.PipeId);
					pipeid->PipeOutId = pipeInfo.PipeId;
				}
			}
			if(pipeInfo.PipeType == UsbdPipeTypeInterrupt)
			{
				printf("\n    Endpoint %d:\n      Type: Interrupt\n      PipeID: %d",idx,pipeInfo.PipeId);
				if(pipeid->PipeInterruptFirst != 0)
				{
					pipeid->PipeInterruptLast = pipeInfo.PipeId;
					printf("\n      PipeInterruptLast set to this pipe.");
				}
				else
				{
					pipeid->PipeInterruptFirst = pipeInfo.PipeId;
					printf("\n      PipeInterruptFirst set to this pipe.");
				}
			}
			printf("\n      MaxPacket: %d", pipeInfo.MaximumPacketSize);
		}
	}
	printf("\nEndpoint query complete.");

	return ef;
}

bool ReadPipe(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pID, ULONG cbSize)
{
	if( hDeviceHandle == INVALID_HANDLE_VALUE )
		return 1;

	printf("\n\nAttempting to read from pipe %d...", *pID);
	UCHAR* szBuffer = (UCHAR*)LocalAlloc(LPTR, sizeof(UCHAR)*cbSize);
    
    ULONG cbRead = 0;

    if( !WinUsb_ReadPipe(hDeviceHandle, *pID, szBuffer, cbSize, &cbRead, 0) )
	{
		printf(" error.\n    Unable to read from pipe %d.", *pID);
		LocalFree(szBuffer);
		return 1;
	}

    printf("Read from pipe %d: 0x%02X \nActual data read: %d.\n", *pID, (char)*szBuffer, cbRead);

    LocalFree(szBuffer);
    return 0;
}

bool WritePipe(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pID, ULONG* pcbWritten)
{
	printf("\n\nAttempting to write to pipe %d.", *pID);
	if (hDeviceHandle==INVALID_HANDLE_VALUE || !pID || !pcbWritten)
    {
		printf("\n    Error while checking arguments.");
        return 1;
    }

    BOOL bResult = TRUE;

    UCHAR szBuffer[] = "Hello World, my name is fuz - nice to meet ya =^.^=!";
    ULONG cbSize = strlen((char*)szBuffer);
    ULONG cbSent = 0;

    bResult = WinUsb_WritePipe(hDeviceHandle, *pID, szBuffer, cbSize, &cbSent, 0);
    if(!bResult)
    {
        return 1;
    }

    printf("Wrote to pipe %d: %s \nActual data transferred: %d.\n", *pID, szBuffer, cbSent);
    *pcbWritten = cbSent;


done:
    return 0;
}

bool SearchGUID(GUID guidDeviceInterface, PHANDLE hDeviceHandle)
{
	// Variable Declarations
	PSP_DEVICE_INTERFACE_DETAIL_DATA pInterfaceDetailData = NULL;
	SP_DEVICE_INTERFACE_DATA deviceInterfaceData;
	SP_DEVINFO_DATA deviceInfoData;
	LPTSTR lpDevicePath = NULL;
	HDEVINFO deviceInfo;

	ULONG requiredLength=0;
	DWORD numDevices = 0;
	bool ef = 0;
	
	// Variable setup
	deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

	// Get info about installed devices using our GUID's Interface
	printf("GUID: {%02X-%02X-%02X-%02X}",
		guidDeviceInterface.Data1, guidDeviceInterface.Data2,
		guidDeviceInterface.Data3, guidDeviceInterface.Data4);
	printf("\n\nSearching installed interfaces...");
	deviceInfo = SetupDiGetClassDevs(
		&guidDeviceInterface, NULL, NULL,
		DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
	if(deviceInfo == INVALID_HANDLE_VALUE)
	{
		printf(" done.\n    Error(%d): INVALID_HANDLE_VALUE",deviceInfo);
		printf("\n    No devices have been installed with the FuzCor Driver.");
		ef = true;
	}
	else
		printf(" done.\n    GUID Matched. Device Info = 0x%02X", deviceInfo);

	// Enumerate the device interfaces
	printf("\n\nLocating the matched devices...");
	while( SetupDiEnumDeviceInfo(deviceInfo, numDevices, &deviceInfoData) )
	{
		if(lpDevicePath)
			LocalFree(lpDevicePath);
		if(pInterfaceDetailData)
			LocalFree(pInterfaceDetailData);

		deviceInterfaceData.cbSize = sizeof(SP_INTERFACE_DEVICE_DATA);

		SetupDiEnumDeviceInterfaces(
			deviceInfo,
			&deviceInfoData,
			&guidDeviceInterface,
			0,
			&deviceInterfaceData);

		if(GetLastError() == ERROR_NO_MORE_ITEMS)
		{
			printf(" done.");
			break;
		}

		SetupDiGetDeviceInterfaceDetail(
			deviceInfo,
			&deviceInterfaceData,
			NULL,
			0,
			&requiredLength,
			NULL);

		if( (GetLastError() == ERROR_INSUFFICIENT_BUFFER) && (requiredLength > 0) )
		{
			printf("\n    Device interface found.\n    Allocating buffer (size = %d)...",requiredLength);
			pInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)LocalAlloc(LPTR,requiredLength);
			if(!pInterfaceDetailData)
			{
				printf("\n    Buffer allocation error.\nHalting enumeration.");
				ef = true;
				break;
			}
			printf(" done.");
		} 
		else
		{
			printf("\nEnumeration error.\nHalting enumeration.");
			ef = true;
			break;
		}

		pInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
		printf("\n    Filling buffer...");
		SetupDiGetDeviceInterfaceDetail(
			deviceInfo,
			&deviceInterfaceData,
			pInterfaceDetailData,
			requiredLength,
			NULL,
			&deviceInfoData);
		printf(" done.");

		printf("\n    Copying device path...");
		size_t nLength = wcslen( pInterfaceDetailData->DevicePath ) + 1;
		lpDevicePath = (TCHAR*)LocalAlloc( LPTR, nLength * sizeof(TCHAR) );
		StringCchCopy(lpDevicePath, nLength, pInterfaceDetailData->DevicePath);
		lpDevicePath[nLength-1] = 0;
		printf(" done.");
		
		printf("\n    Device path: ");
		for(unsigned int idx=0; idx<nLength; idx++)
			printf("%c",(char*)lpDevicePath[idx]);
		
		numDevices++;
	}
	if(!numDevices)
	{
		printf(" error.\n    *No device interfaces avaliable.");
		printf("\n    *Make sure your device is connected and installed using the FuzCor driver.");
		printf("\n\n    Note that the FuzCor driver is what ");
		printf("\n    matches your device to the installed interface\n");
		ef = true;
	}
	else
		printf("\n    Total of %d devices located.", numDevices);
	printf("\nEnumeration complete.");

	// Open the device
	if(numDevices > 0)
	{
		printf("\n\nOpening device...");
		*hDeviceHandle = CreateFile(
			lpDevicePath,
			GENERIC_READ | GENERIC_WRITE,
			FILE_SHARE_READ | FILE_SHARE_WRITE,
			NULL,
			OPEN_EXISTING,
			FILE_FLAG_OVERLAPPED,
			NULL);
		if(hDeviceHandle == INVALID_HANDLE_VALUE)
		{
			printf(" done.\n    Error opening device. Aborting.");
			ef = true;
		}
		else
			printf(" done.");
	}

	// Clean up unneeded variables
	printf("\n\nCleaning up...");
	if(lpDevicePath)
		LocalFree(lpDevicePath);
	if(pInterfaceDetailData)
		LocalFree(pInterfaceDetailData);

	if( !(SetupDiDestroyDeviceInfoList(deviceInfo)) )
		printf(" done.\n    Error while deleting temp variables.");
	else
		printf(" done.");

	return ef;
}

// File:	"USB Data.cpp"
// Author:	Chris Yan
// Date:	April 15, 2012
// Desc:	Program-flow for reading/writing data to my mbed

// Project headers
#include "stdafx.h"
#include "USB_Functions.h"

// Linked libraries
#pragma comment (lib , "setupapi.lib" )
#pragma comment (lib , "winusb.lib" )

// Main entry-point
int _tmain(int argc, _TCHAR* argv[])
{
	// Variable declarations
	WINUSB_INTERFACE_HANDLE hWinUSBHandle = INVALID_HANDLE_VALUE;
	HANDLE hDeviceHandle = INVALID_HANDLE_VALUE;
	GUID deviceGUID = FC_DEVICE_INTERFACE;
	PIPE pipes;
	
	bool ef = 0;

	// Search for connected devices matching our GUID and exit if not successful
	ef = SearchGUID( FC_DEVICE_INTERFACE, &hDeviceHandle );
	if(ef)
		goto cleanup;

	// Initialize the WinUSB interface using the device found above
	ef = StartWinUSB( hDeviceHandle, &hWinUSBHandle );
	if(ef)
		goto cleanup;

	// Enumerate and evaluate the avaliable endpoints
	ef = FindEndpoints( hWinUSBHandle, &pipes );
	if(ef)
		goto cleanup;

	// Try and read and write something from the interrupt pipe 
	UCHAR x = 129;
	UCHAR y = 1;
	ULONG cbSize = 0;
	int idy = 0;
	while( idy < 10 )
	{
		printf("\n");
		system("PAUSE");
		ef = ReadPipe( hWinUSBHandle, &x, 8 );
		ef = WritePipe( hWinUSBHandle, &y, &cbSize);
		if(ef)
			goto cleanup;
		idy++;
	}

cleanup:
	if(hDeviceHandle != INVALID_HANDLE_VALUE)
		CloseHandle(hDeviceHandle);
	if(hWinUSBHandle != INVALID_HANDLE_VALUE)
		WinUsb_Free(hWinUSBHandle);
	return ExitProgram(ef);
}

#include "mbed.h"
#include "USBHID.h"

//We declare a USBHID device. By default input and output reports are 64 bytes long.
USBHID hid(8, 8, 0x1337, 0x1234, 0x0002, false);

Serial pc(USBTX, USBRX);

//This report will contain data to be sent
HID_REPORT send_report;
HID_REPORT recv_report;

DigitalOut l1(LED1);

int main(void) {

    bool firstRun = true;
    pc.printf("\nConnect USB to begin...");
    hid.connect();
    pc.printf(" Connected.\n");
    pc.printf("\nStarting application code...");

    
    send_report.length = 8;
    char datum = 0x00;
    
    while (1) 
    {
        if(firstRun)
            pc.printf(" Code Started.\nSending Report...");
        //Fill the report
        datum = rand() & 0xff;
        for (int i = 0; i < send_report.length; i++)
            send_report.data[i] = datum;

        //Send the report
        hid.send(&send_report);
        pc.printf("\n    0x%02X sent.\n", datum);
        if(firstRun)
            pc.printf("Report sent.\n Checking for message...");

        //try to read a msg
        if(hid.readNB(&recv_report)) 
        {
            if(firstRun)
                pc.printf(" Message found.\n");
            l1 = !l1;
            for(int i = 0; i < recv_report.length; i++) 
            {
                l1 = !l1;
                pc.printf("%c", (char)recv_report.data[i]);
            }
            pc.printf("\r\n");
            l1 = 0;
        }
        else
            if(firstRun)
                pc.printf(" No message found.\n");
        if(firstRun)
        {
            pc.printf("\nProgram will now loop silently.\n");
            l1 = 1;
            firstRun = false;
        }
    }
}