#include "usbdriver.h"

ULONG UsbGetCurrentFrameNumber(IN PDEVICE_OBJECT fdo);
ULONG UsbGetDeviceDescriptor(IN PDEVICE_OBJECT fdo,
							 PVOID pvOutputBuffer);
ULONG UsbGetStringDescriptor(IN PDEVICE_OBJECT fdo,
                             UCHAR             Index,
                             USHORT            LanguageId,
                             PVOID             pvOutputBuffer,
                             ULONG             ulLength);
ULONG UsbGetConfigDescriptor(IN PDEVICE_OBJECT fdo,
                             PVOID   pvOutputBuffer,
                             ULONG   ulLength);
NTSTATUS Bulk_Read_Write(IN  PDEVICE_OBJECT fdo,IN  PIRP Irp);
ULONG UsbVendorRequest(IN PDEVICE_OBJECT fdo, IN PVENDOR_REQUEST_IN pVendorRequest);
//
NTSTATUS TestCreate(IN PDEVICE_OBJECT fdo, IN PIRP Irp)
{
	NTSTATUS ntStatus=STATUS_SUCCESS;
    PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION )fdo->DeviceExtension;

    pdx->OpenHandles++;
							
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
    IoCompleteRequest (Irp, IO_NO_INCREMENT);
    return ntStatus;
}
//
NTSTATUS TestClose(IN PDEVICE_OBJECT fdo, IN PIRP Irp)
{
   NTSTATUS ntStatus=STATUS_SUCCESS;
   PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION )fdo->DeviceExtension;

   pdx->OpenHandles--;

   Irp->IoStatus.Status = STATUS_SUCCESS;
   Irp->IoStatus.Information = 0;
   IoCompleteRequest (Irp, IO_NO_INCREMENT);
   return ntStatus;
}
//
NTSTATUS TestIOCTL(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
	NTSTATUS ntStatus;
	PIO_STACK_LOCATION IrpStack;
    PDEVICE_EXTENSION pdx;
    ULONG IoControlCode;
    PVOID IoBuffer;
    ULONG InputBufferLength;
    ULONG OutputBufferLength;
    ULONG length;
    PUCHAR pch;

	pdx = (PDEVICE_EXTENSION )fdo->DeviceExtension;
    if (!LockDevice(fdo))
		return CompleteRequest(Irp, STATUS_DELETE_PENDING, 0);

   IrpStack = IoGetCurrentIrpStackLocation (Irp);
   Irp->IoStatus.Status = STATUS_SUCCESS;
   Irp->IoStatus.Information = 0;

   IoBuffer           = Irp->AssociatedIrp.SystemBuffer;
   InputBufferLength  = IrpStack->Parameters.DeviceIoControl.InputBufferLength;
   OutputBufferLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;
   IoControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;

   switch (IoControlCode) {
       case IOCTL_EZUSB_GET_CURRENT_FRAME_NUMBER:
		   {
			   ULONG frameNumber = 0;
               if (OutputBufferLength < sizeof(ULONG)) {
				   Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                   break;
			   }
               frameNumber = UsbGetCurrentFrameNumber (fdo);
               if (frameNumber) {
				   *((PULONG)IoBuffer) = frameNumber;
                   Irp->IoStatus.Information = sizeof(ULONG);
                   Irp->IoStatus.Status = STATUS_SUCCESS;
			   }
               else
				   Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
		   }
           break;

       case IOCTL_Ezusb_GET_DEVICE_DESCRIPTOR:
		  {
              length = UsbGetDeviceDescriptor (fdo, IoBuffer);
              Irp->IoStatus.Information = length;
              Irp->IoStatus.Status = STATUS_SUCCESS;
		  }
		  break;
      case IOCTL_Ezusb_GET_STRING_DESCRIPTOR:
		  {
			  PGET_STRING_DESCRIPTOR_IN Input = IoBuffer;

              if ((InputBufferLength = sizeof(GET_STRING_DESCRIPTOR_IN)) &&
                  (OutputBufferLength > 0)) {
				  length = UsbGetStringDescriptor (fdo,
                                                   Input->Index,
                                                   Input->LanguageId,
                                                   IoBuffer,
                                                   OutputBufferLength);
                  if (length) {
					  Irp->IoStatus.Information = length;
                      Irp->IoStatus.Status = STATUS_SUCCESS;
				  }
                  else
					  Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
			  }
              else            
               Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
		  }      
          break;

         case IOCTL_Ezusb_GET_CONFIGURATION_DESCRIPTOR:
			 {
                 length = UsbGetConfigDescriptor (fdo, IoBuffer, OutputBufferLength);
                 Irp->IoStatus.Information = length;
                 Irp->IoStatus.Status = STATUS_SUCCESS;
			 }
             break;
 
         case IOCTL_EZUSB_BULK_WRITE:
         case IOCTL_EZUSB_BULK_READ:
			 Irp->IoStatus.Status = Bulk_Read_Write(fdo,Irp);
			 break;
         
		 case IOCTL_Ezusb_VENDOR_REQUEST:
             length = UsbVendorRequest (fdo, (PVENDOR_REQUEST_IN) IoBuffer);
             if (length)
			 {
				 Irp->IoStatus.Information = length;
                 Irp->IoStatus.Status = STATUS_SUCCESS;
			 }
             else
			 {
				 Irp->IoStatus.Status = STATUS_SUCCESS;
			 }             
             break;

		 case IOCTL_Ezusb_ANCHOR_DOWNLOAD:
			 {
				 #define CHUNKLENGTH 512
                 PURB    urb = NULL;
                 int     chunkcount;
                 int     chunklength = 1024;
                 PVOID   IoBufferPtr = NULL;
                 int     i;

                 urb = ExAllocatePool(NonPagedPool, 
                             sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));
                 if (urb)
				 {
					 chunkcount = InputBufferLength / CHUNKLENGTH;
                     IoBufferPtr = IoBuffer;

                     for (i=0;i<chunkcount;i++)
					 {
						 RtlZeroMemory(urb,sizeof(struct  _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));

                         urb->UrbHeader.Length = sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST);
                         urb->UrbHeader.Function = URB_FUNCTION_VENDOR_DEVICE;
                         urb->UrbControlVendorClassRequest.TransferBufferLength = CHUNKLENGTH;
                         urb->UrbControlVendorClassRequest.TransferBuffer = IoBufferPtr;
                         urb->UrbControlVendorClassRequest.TransferBufferMDL = NULL;
                         urb->UrbControlVendorClassRequest.Request = 0xA0;
                         urb->UrbControlVendorClassRequest.Value = (i * CHUNKLENGTH);
                         urb->UrbControlVendorClassRequest.Index = 0;

                         ntStatus = UsbCallUSBDI(fdo, urb);
                         (char *) IoBufferPtr += CHUNKLENGTH;
					 }
                     ExFreePool(urb);
				 }
			 }
			 break;

         default:
			  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
     } 
    UnlockDevice(fdo);
    ntStatus = Irp->IoStatus.Status;
    IoCompleteRequest (Irp,IO_NO_INCREMENT);
    return ntStatus;
}
//
ULONG UsbGetCurrentFrameNumber(IN PDEVICE_OBJECT fdo)
{
	NTSTATUS  ntStatus = STATUS_SUCCESS;
	PURB urb = NULL;
    PDEVICE_EXTENSION   pdx;
    ULONG  frameNumber = 0;
    
    pdx = fdo->DeviceExtension;
    urb = ExAllocatePool(NonPagedPool,sizeof(struct _URB_GET_CURRENT_FRAME_NUMBER));
    if (urb == NULL)
		return 0;
    RtlZeroMemory(urb,sizeof(struct _URB_GET_CURRENT_FRAME_NUMBER));
  
	urb->UrbHeader.Length = sizeof(struct _URB_GET_CURRENT_FRAME_NUMBER);
    urb->UrbHeader.Function = URB_FUNCTION_GET_CURRENT_FRAME_NUMBER;
 
	ntStatus = UsbCallUSBDI(fdo, urb);
    if (NT_SUCCESS(ntStatus)) {
		frameNumber = urb->UrbGetCurrentFrameNumber.FrameNumber;
    }

    ExFreePool(urb);
    return frameNumber;
}
//
ULONG UsbGetDeviceDescriptor(IN PDEVICE_OBJECT fdo,
							 PVOID pvOutputBuffer)
{
	NTSTATUS ntStatus = STATUS_SUCCESS;
    PURB     urb = NULL;
    ULONG    length = 0;
    PDEVICE_EXTENSION   pdx = NULL;

    pdx = fdo->DeviceExtension;
    urb = ExAllocatePool(NonPagedPool, 
                         sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST));
    if (urb==NULL)
		return STATUS_NO_MEMORY;        

    if (pvOutputBuffer==NULL)