device.h

pci 底层驱动

//
//  File:   device.h
//  Description: The definition of class Device
//
//  Created:  Wed. Jan 15, 2003
//
//
// 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 MERCHANTABILITY AND/OR FITNESS FOR A
//   PARTICULAR PURPOSE.
//
//   IN NO EVENT SHALL CONEXANT BE LIABLE TO ANY PARTY FOR DIRECT,
//   INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
//   INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE
//   AND ITS DOCUMENTATION, EVEN IF CONEXANT HAS BEEN ADVISED OF THE
//   POSSIBILITY OF SUCH DAMAGE.
//
//   Copyright (c) 2000-2001 Conexant Systems, Inc.
//
//   All Rights Reserved.
//   ---------------------------------------------------------------
//
// Module Revision Id:
//
//

#ifndef _DEVICE_H_
#define _DEVICE_H_

#include "hid.h"        //HidProcessing
#include "registers.h"  //RegisterIo
#include "ircontrol.h"  //IR_Control

/////////////////////////////////////////////////////////////////////////////////////////
//Class Device is the main class for this driver and represents the device object.
// This class handles device IRP processing include IRP_MJ_PNP, IRP_MJ_POWER, and 
// IRP_MJ_INTERNAL_DEVICE_CONTROL.  
//
// The static DDK entry points are:
//     static_add - AddDevice handler.  Allocates the Device object.
//     static_pnp - Handler for IRP_MJ_PNP
//     static_power - Handler for IRP_MJ_POWER
//     static_internalDeviceControl - Handler for IRP_MJ_INTERNAL_DEVICE_CONTROL
// 
// Device keeps track of the hardware resources, the interrupt object and the memory
// range, allocated when IRP_MN_START_DEVICE is received.
//
// All HID processing is done by class HidProcessing.
//

typedef enum
{
    DEVICE_STATE_NONE,
    DEVICE_STATE_NOT_STARTED,
    DEVICE_STATE_STARTING,
    DEVICE_STATE_RUNNING,
    DEVICE_STATE_STOPPING,
    DEVICE_STATE_STOPPED,
    DEVICE_STATE_REMOVING
}DEVICE_STATE;


class Device
{
public:
    //Construction
    Device(PDEVICE_OBJECT p_device_object);
    ~Device();

    //////////////////////////
    //static DDK entry points
    
    //AddDevice
    static NTSTATUS static_add(
        PDRIVER_OBJECT p_driver_object,
        PDEVICE_OBJECT p_device_object);

    //IRP_MJ_PNP
    static NTSTATUS static_pnp(
          PDEVICE_OBJECT p_device_object,
          PIRP           p_irp);

    //IRP_MJ_POWER
    static NTSTATUS static_power(
          PDEVICE_OBJECT p_device_object,
          PIRP           p_irp);

    //IRP_MJ_INTERNAL_DEVICE_CONTROL
    static NTSTATUS static_internalDeviceControl(
        PDEVICE_OBJECT p_device_object,
        PIRP           p_irp);

    //ISR
    static BOOLEAN static_interruptRoutine(
        PKINTERRUPT interrupt,
        PVOID p_context);

protected:
    //Pass the IRP to the lower device
    NTSTATUS passIrpDown(PIRP p_irp);
    NTSTATUS passIrpDownSync(PIRP p_irp);

    //IRP processing
    NTSTATUS start(PIRP p_irp);
    NTSTATUS stop(PIRP p_irp);
    NTSTATUS internalDeviceControl(PIRP p_irp);

    //Power management processing
    VOID powerDown();
    VOID powerUp();

    //Registry access
    HANDLE openDriverKey(ACCESS_MASK desired_access);
    NTSTATUS getRegistryValue(
        HANDLE handle,
        const PUNICODE_STRING key_name,
        PCHAR data, 
        ULONG data_length);
    VOID Device::readRegistryDword(PCHAR name, PDWORD p_value);

private:
    //Internal helper functions
    
    //init and getResources are helpers for start()
    NTSTATUS init(PIRP p_irp);
    VOID getResources(             
        PIRP p_irp,
        PCM_PARTIAL_RESOURCE_DESCRIPTOR* p_memory,
        PCM_PARTIAL_RESOURCE_DESCRIPTOR* p_interrupt);

    VOID releaseResources();

    //Completion routine used in passIrpDownSync()
    static NTSTATUS static_syncIrpCompletion(
        PDEVICE_OBJECT p_device_object,
        IN PIRP        p_irp,
        IN PVOID       p_context);

    //Allows passing the IRP down when the device is not created
    static NTSTATUS static_passIrpDown(
        PDEVICE_OBJECT p_lower_device, 
        PIRP p_irp);

    //Completion routine for power up IRPs
    static NTSTATUS static_powerUpCompletion(
        PDEVICE_OBJECT p_device_object,
        IN PIRP        p_irp,
        IN PVOID       p_context);

private:
    /////////////////////////////////////
    //Member variables

    //device's PnP state.  (Started, Stopping, etc.) 
    DEVICE_STATE        _device_state;
    
    //Lower device object used for passing down IRPs
    PDEVICE_OBJECT      _p_device_object;

    HidProcessing       _hid;
    RegisterIo*         _p_registers;
    IR_Control*         _p_ir_control;

    PKINTERRUPT         _p_interrupt;   

    DEVICE_POWER_STATE  _power_state;
};


inline NTSTATUS Device::passIrpDown(PIRP p_irp)
{
    IoSkipCurrentIrpStackLocation(p_irp);
    return IoCallDriver(GET_NEXT_DEVICE_OBJECT(_p_device_object), p_irp);   
}


inline VOID Device::releaseResources()
{
    IoDisconnectInterrupt(_p_interrupt);
    
    delete _p_ir_control;
    delete _p_registers;
    
    _p_ir_control = NULL;
    _p_registers = NULL;
}


#endif