//   Input: PIRP     pIrp - IRP
//  Output: NTSTATUS      - Operation status
// Written: by Anton V. Krivenko 4/10/2002
//****************************************************************************
NTSTATUS CFuncDevice::PreStartDevice(PIRP pIrp)
{
    // ...
    // You can implement here any specific code, which should be executed on
    // device starting prior to starting PDO. It can be useful to make some
    // corrections to IRP (e.g. to resource list) BEFORE passing IRP to PDO.
    // ...

    return STATUS_SUCCESS;
}

//****************************************************************************
//                  --- CFuncDevice::PostStartDevice ---
//
// Purpose: Post start device processing
//   Input: PIRP     pIrp     - IRP
//          NTSTATUS ntStatus - Status of StartDevice
//  Output: none
// Written: by Anton V. Krivenko 4/10/2002
//****************************************************************************
void CFuncDevice::PostStartDevice(PIRP pIrp, NTSTATUS ntStatus)
{
    // ...
    // You can implement here any specific code, which should be executed
    // immediately after device starting. It can be useful to make some
    // manipulations depend on status of starting.
    // ...
}

//****************************************************************************
//                   --- CFuncDevice::QueryInterface ---
//
// Purpose: Query interfaces for PCMCIA device
//   Input: none
//  Output: BOOLEAN  - Operation status
// Written: by Anton V. Krivenko 4/11/2002
//****************************************************************************
BOOLEAN CFuncDevice::QueryInterface(void)
{
    NTSTATUS ntStatus;                      // Query status

//-------------------- Query PCMCIA standard interface -----------------------

    ntStatus = PnpQueryInterface( m_pNextStackDevice,
                                 &GUID_PCMCIA_INTERFACE_STANDARD,
                                 &m_PcmciaIface,
                                  sizeof(m_PcmciaIface),
                                  1);
    ASSERTS_PNPDRV(NT_SUCCESS(ntStatus));

    if (NT_SUCCESS(ntStatus))
    {

//------------------ Query PCMCIA bus standard interface ---------------------

        ntStatus = PnpQueryInterface( m_pNextStackDevice,
                                     &GUID_PCMCIA_BUS_INTERFACE_STANDARD,
                                     &m_BusIface,
                                      sizeof(m_BusIface),
                                      1);
        ASSERTS_PNPDRV(NT_SUCCESS(ntStatus));
    }                                       // if (NT_SUCCESS(ntStatus))

    return NT_SUCCESS(ntStatus) ? TRUE : FALSE;
}

//****************************************************************************
//                    --- CFuncDevice::StartDevice ---
//
// Purpose: Start device
//   Input: PCM_PARTIAL_RESOURCE_LIST pList - Resource list
//  Output: NTSTATUS                        - Operation status
// Written: by Anton V. Krivenko 4/10/2002
//****************************************************************************
NTSTATUS CFuncDevice::StartDevice(PCM_PARTIAL_RESOURCE_LIST pList)
{
    NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;// Assumes, failed

    // Since we requested only 1 memory window, we can retrieve here resources,
    // which assign for us PnP manager.

    ASSERTS_PNPDRV(pList != NULL);

    if (pList != NULL)
    {
        PCM_PARTIAL_RESOURCE_DESCRIPTOR ppd = &pList->PartialDescriptors[0];

        m_uStart                            = ppd->u.Memory.Start.u.LowPart;
        m_uLength                           = ppd->u.Memory.Length;
		m_phyMemAddr                        = ppd->u.Memory.Start;

        if (QueryInterface())
        {
            // Here you can analyse CIS, using m_BusIface.ReadCfgSpace method.
            // In a like manner you can write some values to CIS (if card
            // require it), using m_BusIface.WriteCfgSpace.
			m_dwMask = 1;
            ntStatus = STATUS_SUCCESS;
        }                                   // if (QueryInterface())
    }                                       // if (pList != NULL)

    return ntStatus;
}

//****************************************************************************
//                  --- CFuncDevice::ReadWriteRequest ---
//
// Purpose: Read / write request
//   Input: BOOLEAN fRead   - Read or write
//          PVOID   pData   - Data buffer
//          ULONG   uOffset - Offset on card to read / write
//          ULONG   uLength - Size of data to read / write
//  Output: BOOLEAN         - Operation status
// Written: by Anton V. Krivenko 4/11/2002
//****************************************************************************
BOOLEAN CFuncDevice::ReadWriteRequest(BOOLEAN fRead, PVOID pData, ULONG uOffset, ULONG uLength)
{
    // You can implement here any card specific reading / writing. It can be
    // simply memory copying for memory cards (SRAM/FLASH). You can use
    // m_PcmciaIface.MapMemoryWindow call to map any part of your memory card
    // in you memory window, which you initializes in StartDevice:
    //
     if(m_PcmciaIface.MapMemoryWindow(m_uStart,
                                   uOffset,
                                   m_uLength,
                                   2,
                                   PCMCIA_MEMORY_16BIT_ACCESS))
	return TRUE;
    
    // Or it can be ATA/ATAPI specific code for ATA/ATAPI based cards.

    return FALSE;
}

//****************************************************************************
//                     --- CFuncDevice::OnIrpRead ---
//
// Purpose: IRP_MJ_READ handler
//   Input: PIRP         pIrp     - IRP
//          NTSTATUS   & ntStatus - Operation status
//  Output: BOOLEAN               - FALSE to complete request outside
// Written: by Anton V. Krivenko 4/11/2002
//****************************************************************************
BOOLEAN CFuncDevice::OnIrpRead(PIRP pIrp, NTSTATUS & ntStatus)
{
    STRACE_PNPDRV(">> CFuncDevice::OnIrpRead()\n");

    PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
    PVOID              pData  = MmGetSystemAddressForMdlSafe(pIrp->MdlAddress, HighPagePriority);
    PUCHAR             MemBaseAddr;
    PVOID              pOut   = pIrp->UserBuffer;
    ntStatus                  = STATUS_UNSUCCESSFUL;

//    READ_REGISTER_BUFFER_UCHAR((PUCHAR)(MemBaseAddr),(PUCHAR)pOut,pStack->Parameters.Read.Length);

    ASSERTS_PNPDRV(pData != NULL);

    if (pData != NULL)
    {
        STRACE_PNPDRV("   Buffer: %08lXh\n"
                      "   Offset: %08lXh\n"
                      "   Length: %08lXh\n",
                      pData,
                      pStack->Parameters.Read.ByteOffset.LowPart,
                      pStack->Parameters.Read.Length);

        if (ReadWriteRequest(TRUE, pData,
                             pStack->Parameters.Read.ByteOffset.LowPart,
                             pStack->Parameters.Read.Length))
        {
            pIrp->IoStatus.Information = pStack->Parameters.Read.Length;
	  MemBaseAddr = (PUCHAR)MmMapIoSpace(m_phyMemAddr,pStack->Parameters.Read.Length,MmNonCached);
	  READ_REGISTER_BUFFER_UCHAR(MemBaseAddr,(PUCHAR)pOut,pStack->Parameters.Read.Length);
	  MmUnmapIoSpace(MemBaseAddr,pStack->Parameters.Read.Length);
            ntStatus                   = STATUS_SUCCESS;
        }                                   
    }                                       

    STRACE_PNPDRV("<< CFuncDevice::OnIrpRead()- ntStatus=%08lX\n", ntStatus);
    return FALSE;
}

//****************************************************************************
//                     --- CFuncDevice::OnIrpWrite ---
//
// Purpose: IRP_MJ_WRITE handler
//   Input: PIRP         pIrp     - IRP
//          NTSTATUS   & ntStatus - Operation status
//  Output: BOOLEAN               - FALSE to complete request outside
// Written: by Anton V. Krivenko 4/11/2002
//****************************************************************************
BOOLEAN CFuncDevice::OnIrpWrite(PIRP pIrp, NTSTATUS & ntStatus)
{
    STRACE_PNPDRV(">> CFuncDevice::OnIrpWrite()\n");

    PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp);
    PVOID              pData  = MmGetSystemAddressForMdlSafe(pIrp->MdlAddress, HighPagePriority);

    ntStatus                  = STATUS_UNSUCCESSFUL;

    ASSERTS_PNPDRV(pData != NULL);

    if (pData != NULL)
    {

//------------------------ Check write protection ----------------------------

        if (m_PcmciaIface.IsWriteProtect())
            ntStatus = STATUS_MEDIA_WRITE_PROTECTED;
        else
        {
            STRACE_PNPDRV("   Buffer: %08lXh\n"
                          "   Offset: %08lXh\n"
                          "   Length: %08lXh\n",
                          pData,
                          pStack->Parameters.Write.ByteOffset.LowPart,
                          pStack->Parameters.Write.Length);

            if (ReadWriteRequest(FALSE, pData,
                                 pStack->Parameters.Write.ByteOffset.LowPart,
                                 pStack->Parameters.Write.Length))
            {
                pIrp->IoStatus.Information = pStack->Parameters.Write.Length;
                ntStatus                   = STATUS_SUCCESS;
            }
        }                                   // if (m_pPart->ReadRequest(...
    }                                       // if (pData != NULL)

    STRACE_PNPDRV("<< CFuncDevice::OnIrpWrite()- ntStatus=%08lX\n", ntStatus);
    return FALSE;
}