ioctl.c

usb to rs232 虚拟RS232串口驱动程序

	    //  5) has a stop device pending
	    if ( !USB2COM_CanAcceptIoRequests( DeviceObject ) ) {
	        ntStatus = STATUS_DELETE_PENDING;
	        Irp->IoStatus.Status = ntStatus;
	        Irp->IoStatus.Information = 0;
	
	        IoCompleteRequest( Irp, IO_NO_INCREMENT );
	
	        return ntStatus;
	    }
	    USB2COM_IncrementIoCount(DeviceObject);
    }

    //
    // Handle Ioctls from User mode
    //

    switch (ioControlCode) {

    case IOCTL_USB2COM_RESET_PIPE:
        {
            PUSBD_PIPE_INFORMATION pipe;
                PFILE_OBJECT fileObject;

                    // get our context and see if it is a pipe
                fileObject = irpStack->FileObject;
		if(fileObject)
                    pipe = (PUSBD_PIPE_INFORMATION) fileObject->FsContext;    

                    if(pipe == NULL) {
                            // error, this is not a pipe
                    ntStatus =
                            Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                    } else {            
                USB2COM_ResetPipe(DeviceObject, pipe );
            
                ntStatus = Irp->IoStatus.Status = STATUS_SUCCESS;
            }
        }
        USB2COM_DecrementIoCount(DeviceObject);                       
        break;

     case IOCTL_USB2COM_GET_CONFIG_DESCRIPTOR:

        //
        // This api returns a copy of the configuration descriptor
        // and all endpoint/interface descriptors.
        //

        //
        // inputs  - none
        // outputs - configuration descriptor plus interface
        //          and endpoint descriptors
        //

        pch = (PUCHAR) ioBuffer;

        configurationDescriptor =
            deviceExtension->UsbConfigurationDescriptor;

        if (configurationDescriptor) {
            
            length = configurationDescriptor->wTotalLength;

            if (outputBufferLength >= length) {

                RtlCopyMemory(pch,
                              (PUCHAR) configurationDescriptor,
                              length);
                
                Irp->IoStatus.Information = length;
                
                ntStatus = Irp->IoStatus.Status = STATUS_SUCCESS;
            }
            else {
        
                Irp->IoStatus.Information = 0;
    
                ntStatus = Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
            }    
        }
        else {

            Irp->IoStatus.Information = 0;

            ntStatus = Irp->IoStatus.Status = STATUS_DEVICE_DATA_ERROR;
        }
    	USB2COM_DecrementIoCount(DeviceObject);                       
        break;
     case IOCTL_USB2COM_RESET_DEVICE:
        
        ntStatus = USB2COM_ResetDevice( DeviceObject );
    	USB2COM_DecrementIoCount(DeviceObject);                       
        break;               
	{
		case IOCTL_SERIAL_GET_PROPERTIES:
		{
			if (outputBufferLength < sizeof(SERIAL_COMMPROP))
			{
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			}
			else if (ioBuffer == NULL)
			{
				ntStatus = STATUS_INVALID_PARAMETER;
			}
			else
			{
				ntStatus= SerialGetCommProp((PSERIAL_COMMPROP)ioBuffer, deviceExtension);
				length = sizeof(SERIAL_COMMPROP);
			}
			break;
		}
		case IOCTL_SERIAL_CLEAR_STATS:
		{
			SerialClearPerfStats(deviceExtension);
			ntStatus = STATUS_SUCCESS;
			break;
		}
		case IOCTL_SERIAL_GET_STATS:
		{
			if (outputBufferLength < sizeof(SERIALPERF_STATS))
			{
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			}
			else if (ioBuffer == NULL)
			{
				ntStatus = STATUS_INVALID_PARAMETER;
			}
			else
			{
				SerialGetPerfStats(Irp);
				ntStatus = STATUS_SUCCESS;
				length = sizeof(SERIALPERF_STATS);
			}
			break;
		}
		case IOCTL_SERIAL_GET_BAUD_RATE:
		{
			if (outputBufferLength < sizeof(SERIAL_BAUD_RATE))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else
			{
				((PSERIAL_BAUD_RATE)ioBuffer)->BaudRate = deviceExtension->BaudRate;
				length = sizeof(SERIAL_BAUD_RATE);
				ntStatus = STATUS_SUCCESS;
			}
			break;
		}
		case IOCTL_SERIAL_SET_BAUD_RATE:
		{
			PULONG pNewBaudRate;
			if (inputBufferLength != sizeof(ULONG) || ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else
			{
				pNewBaudRate = (PULONG)ioBuffer;
				ntStatus = SerialSetBaudRateAndLineControl(
							deviceExtension,
							*pNewBaudRate,
							NULL);
			}
			break;
		}
		case IOCTL_SERIAL_GET_LINE_CONTROL:
		{
			if (outputBufferLength < sizeof(SERIAL_LINE_CONTROL))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else
			{
				*((PSERIAL_LINE_CONTROL)ioBuffer) = deviceExtension->SerialLineControl;
				length = sizeof(SERIAL_LINE_CONTROL);
				ntStatus = STATUS_SUCCESS;
			}
			break;
		}
		case IOCTL_SERIAL_SET_LINE_CONTROL:
		{
			if (inputBufferLength < sizeof(SERIAL_LINE_CONTROL))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else
				ntStatus = SerialSetBaudRateAndLineControl(
							deviceExtension,
							0,
							(PSERIAL_LINE_CONTROL)ioBuffer);
			break;
		}
		case IOCTL_SERIAL_GET_COMMSTATUS:
		{
			if (outputBufferLength  < sizeof(SERIAL_STATUS))
			{
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			}
			else if (ioBuffer == NULL)
			{
				ntStatus = STATUS_INVALID_PARAMETER;
			}
			else
			{
				ntStatus = SerialGetCommStatus((PSERIAL_STATUS)ioBuffer, deviceExtension);
				length = sizeof(SERIAL_STATUS);
			}
			break;
		}
		case IOCTL_SERIAL_SET_QUEUE_SIZE:
		{
			if (inputBufferLength < sizeof(SERIAL_QUEUE_SIZE ))
				return STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				return STATUS_INVALID_PARAMETER;
			else
			{
				KIRQL Irql;
				PSERIAL_QUEUE_SIZE NewQueueSize = (PSERIAL_QUEUE_SIZE)ioBuffer;
				ntStatus = STATUS_SUCCESS;
				if (NewQueueSize->InSize > deviceExtension->InputBuffer.Length)
				{
					KeAcquireSpinLock(&deviceExtension->InputBufferLock, &Irql);
					ntStatus = IncreaseCircularBufferSize(&deviceExtension->InputBuffer, NewQueueSize->InSize);
					KeReleaseSpinLock(&deviceExtension->InputBufferLock, Irql);
				}
				if (NT_SUCCESS(ntStatus) && NewQueueSize->OutSize > deviceExtension->OutputBuffer.Length)
				{
					KeAcquireSpinLock(&deviceExtension->OutputBufferLock, &Irql);
					ntStatus = IncreaseCircularBufferSize(&deviceExtension->OutputBuffer, NewQueueSize->OutSize);
					KeReleaseSpinLock(&deviceExtension->OutputBufferLock, Irql);
				}
			}
			break;
		}
		case IOCTL_SERIAL_GET_CHARS:
		{
            		if (outputBufferLength < sizeof(SERIAL_CHARS)) 
            		{
                		ntStatus = STATUS_BUFFER_TOO_SMALL;
            		}
            		else if (ioBuffer == NULL)
            		{
				ntStatus = STATUS_INVALID_PARAMETER;
			}
            		else{
            			*((PSERIAL_CHARS)ioBuffer) = deviceExtension->SpecialChars;
            			length = sizeof(SERIAL_CHARS);
            			ntStatus = STATUS_SUCCESS;
            		}
			break;
		}
		case IOCTL_SERIAL_SET_CHARS:
		{
			if (inputBufferLength < sizeof(SERIAL_CHARS))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else{
				deviceExtension->SpecialChars = *((PSERIAL_CHARS)ioBuffer);
				ntStatus = STATUS_SUCCESS;
			}
			break;
		}
		case IOCTL_SERIAL_GET_HANDFLOW:
		{
			if (outputBufferLength < sizeof(SERIAL_HANDFLOW)) 
            		{
                		ntStatus = STATUS_BUFFER_TOO_SMALL;
            		}
            		else if (ioBuffer == NULL)
            		{
				ntStatus = STATUS_INVALID_PARAMETER;
			}
            		else{
            			*((PSERIAL_HANDFLOW)ioBuffer) = deviceExtension->HandFlow;
            			length = sizeof(SERIAL_HANDFLOW);
            			ntStatus = STATUS_SUCCESS;
            		}
			break;
		}
		case IOCTL_SERIAL_SET_HANDFLOW:
		{	
			if (inputBufferLength < sizeof(SERIAL_HANDFLOW))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else{
				deviceExtension->HandFlow = *((PSERIAL_HANDFLOW)ioBuffer);
				ntStatus = STATUS_SUCCESS;
			}
			break;
		}
		case IOCTL_SERIAL_GET_TIMEOUTS:
		{
			if (outputBufferLength < sizeof(SERIAL_TIMEOUTS))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else
			{
				*((PSERIAL_TIMEOUTS)ioBuffer) = deviceExtension->SerialTimeOuts;
				length = sizeof(SERIAL_TIMEOUTS);
				ntStatus = STATUS_SUCCESS;
			}
			break;
		}
		case IOCTL_SERIAL_SET_TIMEOUTS:
		{
			if (inputBufferLength < sizeof(SERIAL_TIMEOUTS))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else{
				deviceExtension->SerialTimeOuts = *((PSERIAL_TIMEOUTS)ioBuffer);
				DbgPrint("ReadIntervalTimeout = %d\n"
					 "ReadTotalTimeoutMultiplier = %d\n"
					 "ReadTotalTimeoutConstant = %d\n"
					 "WriteTotalTimeoutMultiplier = %d\n"
					 "WriteTotalTimeoutConstant = %d\n",
					 deviceExtension->SerialTimeOuts.ReadIntervalTimeout,
					 deviceExtension->SerialTimeOuts.ReadTotalTimeoutMultiplier,
					 deviceExtension->SerialTimeOuts.ReadTotalTimeoutConstant,
					 deviceExtension->SerialTimeOuts.WriteTotalTimeoutMultiplier,
					 deviceExtension->SerialTimeOuts.WriteTotalTimeoutConstant
					 );
				ntStatus = STATUS_SUCCESS;
			}
			break;
		}
		case IOCTL_SERIAL_GET_WAIT_MASK:
		{
			if (outputBufferLength < sizeof(ULONG))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else
			{
				*((ULONG *)ioBuffer) = deviceExtension->WaitMask;
				length = sizeof(ULONG);
				ntStatus = STATUS_SUCCESS;
			}
			break;
		}
		case IOCTL_SERIAL_SET_WAIT_MASK:
		{
			if (inputBufferLength < sizeof(ULONG))
				ntStatus = STATUS_BUFFER_TOO_SMALL;
			else if (ioBuffer == NULL)
				ntStatus = STATUS_INVALID_PARAMETER;
			else
			{
				deviceExtension->WaitMask = *((ULONG *)ioBuffer);
				DbgPrint("WaitMask = %x\n",deviceExtension->WaitMask);
				length = 0;
				ntStatus = SerialSetWaitMask(Irp);
			}
			break;
		}
		case IOCTL_SERIAL_WAIT_ON_MASK:
		{
			return SerialWaitOnMask(Irp);
		}
		case IOCTL_SERIAL_PURGE:
		{