dispatch.c

本压缩包为作者截取的PCI9054的WDM官方驱动源码。欢迎下载。

            pIoBuffer->ReturnCode =
                PlxPciPhysicalMemoryUnmap(
                    pdx,
                    &(pIoBuffer->u.MiscData.u.PciMemory),
                    pStack->FileObject
                    );
            break;

        case PLX_IOCTL_COMMON_BUFFER_PROPERTIES:
            DebugPrintf_NoInfo(("PLX_IOCTL_COMMON_BUFFER_PROPERTIES\n"));

            // Return buffer information
            if (pGbl_CommonBuffer == NULL)
            {
                pIoBuffer->u.MiscData.u.PciMemory.PhysicalAddr = 0;
                pIoBuffer->u.MiscData.u.PciMemory.CpuPhysical  = 0;
                pIoBuffer->u.MiscData.u.PciMemory.Size         = 0;
            }
            else
            {
                pIoBuffer->u.MiscData.u.PciMemory.PhysicalAddr =
                                      pGbl_CommonBuffer->BusPhysical;
                pIoBuffer->u.MiscData.u.PciMemory.CpuPhysical =
                                      pGbl_CommonBuffer->CpuPhysical;
                pIoBuffer->u.MiscData.u.PciMemory.Size =
                                      pGbl_CommonBuffer->Size;
            }
            break;


        /*******************************************
         * PCI Register Access Functions
         ******************************************/
        case PLX_IOCTL_PCI_REGISTER_READ:
            DebugPrintf_NoInfo(("PLX_IOCTL_PCI_REGISTER_READ\n"));

            pIoBuffer->u.MgmtData.value =
                PlxPciRegisterRead(
                    pdx,
                    pIoBuffer->u.MgmtData.u.Device.BusNumber,
                    pIoBuffer->u.MgmtData.u.Device.SlotNumber,
                    pIoBuffer->u.MgmtData.offset,
                    &(pIoBuffer->ReturnCode)
                    );

            DebugPrintf((
                "PCI Reg %03X = %08X\n",
                pIoBuffer->u.MgmtData.offset,
                (U32)pIoBuffer->u.MgmtData.value
                ));
            break;

        case PLX_IOCTL_PCI_REGISTER_WRITE:
            DebugPrintf_NoInfo(("PLX_IOCTL_PCI_REGISTER_WRITE\n"));

            pIoBuffer->ReturnCode =
                PlxPciRegisterWrite(
                    pdx,
                    pIoBuffer->u.MgmtData.u.Device.BusNumber,
                    pIoBuffer->u.MgmtData.u.Device.SlotNumber,
                    pIoBuffer->u.MgmtData.offset,
                    (U32)pIoBuffer->u.MgmtData.value
                    );

            DebugPrintf((
                "Wrote %08X to PCI Reg %03X\n",
                (U32)pIoBuffer->u.MgmtData.value,
                pIoBuffer->u.MgmtData.offset
                ));
            break;

        case PLX_IOCTL_PCI_REG_READ_UNSUPPORTED:
            DebugPrintf_NoInfo(("PLX_IOCTL_PCI_REG_READ_UNSUPPORTED\n"));

            pIoBuffer->u.MgmtData.value =
                PlxPciRegisterRead_Unsupported(
                    pdx,
                    pIoBuffer->u.MgmtData.u.Device.BusNumber,
                    pIoBuffer->u.MgmtData.u.Device.SlotNumber,
                    pIoBuffer->u.MgmtData.offset,
                    &(pIoBuffer->ReturnCode)
                    );
            break;

        case PLX_IOCTL_PCI_REG_WRITE_UNSUPPORTED:
            DebugPrintf_NoInfo(("PLX_IOCTL_PCI_REG_WRITE_UNSUPPORTED\n"));

            pIoBuffer->ReturnCode =
                PlxPciRegisterWrite_Unsupported(
                    pdx,
                    pIoBuffer->u.MgmtData.u.Device.BusNumber,
                    pIoBuffer->u.MgmtData.u.Device.SlotNumber,
                    pIoBuffer->u.MgmtData.offset,
                    (U32)pIoBuffer->u.MgmtData.value
                    );
            break;


        /***********************************
         * Local Register Access Functions
         **********************************/
        case PLX_IOCTL_REGISTER_READ:
            DebugPrintf_NoInfo(("PLX_IOCTL_REGISTER_READ\n"));

            if (pdx->PowerState > MIN_WORKING_POWER_STATE)
            {
                pIoBuffer->ReturnCode       = ApiPowerDown;
                pIoBuffer->u.MgmtData.value = (U32)-1;
            }
            else
            {
                pIoBuffer->ReturnCode =
                    PlxRegisterRead(
                        pdx,
                        pIoBuffer->u.MgmtData.offset,
                        (U32*)&(pIoBuffer->u.MgmtData.value)
                        );
            }
            break;

        case PLX_IOCTL_REGISTER_WRITE:
            DebugPrintf_NoInfo(("PLX_IOCTL_REGISTER_WRITE\n"));

            if (pdx->PowerState > MIN_WORKING_POWER_STATE)
            {
                pIoBuffer->ReturnCode = ApiPowerDown;
            }
            else
            {
                pIoBuffer->ReturnCode =
                    PlxRegisterWrite(
                        pdx,
                        pIoBuffer->u.MgmtData.offset,
                        (U32)pIoBuffer->u.MgmtData.value
                        );
            }
            break;


        /********************************
         * Interrupt Support Functions
         *******************************/
        case PLX_IOCTL_INTR_ENABLE:
            DebugPrintf_NoInfo(("PLX_IOCTL_INTR_ENABLE\n"));

            if (pdx->PowerState > MIN_WORKING_POWER_STATE)
            {
                pIoBuffer->ReturnCode = ApiPowerDown;
            }
            else
            {
                pIoBuffer->ReturnCode =
                    PlxPciIntrEnable(
                        pdx,
                        &(pIoBuffer->u.MiscData.u.IntrInfo)
                        );
            }
            break;

        case PLX_IOCTL_INTR_DISABLE:
            DebugPrintf_NoInfo(("PLX_IOCTL_INTR_DISABLE\n"));

            if (pdx->PowerState > MIN_WORKING_POWER_STATE)
            {
                pIoBuffer->ReturnCode = ApiPowerDown;
            }
            else
            {
                pIoBuffer->ReturnCode =
                    PlxPciIntrDisable(
                        pdx,
                        &(pIoBuffer->u.MiscData.u.IntrInfo)
                        );
            }
            break;

        case PLX_IOCTL_INTR_STATUS_GET:
            DebugPrintf_NoInfo(("PLX_IOCTL_INTR_STATUS_GET\n"));

            pIoBuffer->ReturnCode =
                PlxPciIntrStatusGet(
                    pdx,
                    &(pIoBuffer->u.MiscData.u.IntrInfo)
                    );
            break;

        case PLX_IOCTL_NOTIFICATION_REGISTER_FOR:
            DebugPrintf_NoInfo(("PLX_IOCTL_NOTIFICATION_REGISTER_FOR\n"));

            pIoBuffer->ReturnCode =
                PlxNotificationRegisterFor(
                    pdx,
                    (PLX_INTR*)(pIoBuffer->u.MiscData.data[0]),
                    (PLX_NOTIFY_OBJECT*)(pIoBuffer->u.MiscData.data[1]),
                    pStack->FileObject
                    );
            break;

        case PLX_IOCTL_NOTIFICATION_WAIT:
            DebugPrintf_NoInfo(("PLX_IOCTL_NOTIFICATION_WAIT\n"));

            pIoBuffer->ReturnCode =
                PlxNotificationWait(
                    pdx,
                    (PLX_NOTIFY_OBJECT*)(pIoBuffer->u.MiscData.data[0]),
                    (U32)pIoBuffer->u.MiscData.data[1]
                    );
            break;

        case PLX_IOCTL_NOTIFICATION_CANCEL:
            DebugPrintf_NoInfo(("PLX_IOCTL_NOTIFICATION_CANCEL\n"));

            pIoBuffer->ReturnCode =
                PlxNotificationCancel(
                    pdx,
                    (PLX_NOTIFY_OBJECT*)(pIoBuffer->u.MiscData.data[0]),
                    pStack->FileObject
                    );
            break;


        /*********************************
         * Bus Memory and I/O Functions
         ********************************/
        case PLX_IOCTL_BUS_IOP_READ:
            DebugPrintf_NoInfo(("PLX_IOCTL_BUS_IOP_READ\n"));

            if (pdx->PowerState > MIN_WORKING_POWER_STATE)
            {
                pIoBuffer->ReturnCode = ApiPowerDown;
            }
            else
            {
                pIoBuffer->ReturnCode =
                    PlxPciBusMemTransfer(
                        pdx,
                        pIoBuffer->u.BusIopData.IopSpace,
                        (U32)pIoBuffer->u.BusIopData.Address,
                        pIoBuffer->u.BusIopData.bRemap,
                        PLX_INT_TO_PTR(pIoBuffer->u.BusIopData.Buffer),
                        pIoBuffer->u.BusIopData.TransferSize,
                        pIoBuffer->u.BusIopData.AccessType,
                        TRUE           // Specify read operation
                        );
            }
            break;

        case PLX_IOCTL_BUS_IOP_WRITE:
            DebugPrintf_NoInfo(("PLX_IOCTL_BUS_IOP_WRITE\n"));

            if (pdx->PowerState > MIN_WORKING_POWER_STATE)
            {
                pIoBuffer->ReturnCode = ApiPowerDown;
            }
            else
            {
                pIoBuffer->ReturnCode =
                    PlxPciBusMemTransfer(
                        pdx,
                        pIoBuffer->u.BusIopData.IopSpace,
                        (U32)pIoBuffer->u.BusIopData.Address,
                        pIoBuffer->u.BusIopData.bRemap,
                        PLX_INT_TO_PTR(pIoBuffer->u.BusIopData.Buffer),
                        pIoBuffer->u.BusIopData.TransferSize,
                        pIoBuffer->u.BusIopData.AccessType,
                        FALSE          // Specify write operation
                        );
            }
            break;

        case PLX_IOCTL_IO_PORT_READ:
            DebugPrintf_NoInfo(("PLX_IOCTL_IO_PORT_READ\n"));

            if (pdx->PowerState > MIN_WORKING_POWER_STATE)
            {
                pIoBuffer->ReturnCode = ApiPowerDown;
            }
            else
            {
                pIoBuffer->ReturnCode =
                    PlxPciIoPortTransfer(
                        pIoBuffer->u.BusIopData.Address,
                        pIoBuffer->u.BusIopData.AccessType,
                        (VOID*)&(pIoBuffer->u.BusIopData.Buffer),
                        TRUE           // Specify read operation
                        );
            }
            break;

        case PLX_IOCTL_IO_PORT_WRITE:
            DebugPrintf_NoInfo(("PLX_IOCTL_IO_PORT_WRITE\n"));

            if (pdx->PowerState > MIN_WORKING_POWER_STATE)
            {
                pIoBuffer->ReturnCode = ApiPowerDown;
            }
            else
            {
                pIoBuffer->ReturnCode =
                    PlxPciIoPortTransfer(
                        pIoBuffer->u.BusIopData.Address,
                        pIoBuffer->u.BusIopData.AccessType,
                        (VOID*)&(pIoBuffer->u.BusIopData.Buffer),
                        FALSE          // Specify write operation
                        );
            }
            break;


        /*******************************
         * Power Management Functions
         ******************************/
        case PLX_IOCTL_POWER_LEVEL_SET:
            DebugPrintf_NoInfo(("PLX_IOCTL_POWER_LEVEL_SET\n"));

            pIoBuffer->ReturnCode =
                PlxPciPowerLevelSet(
                    pdx,
                    (PLX_POWER_LEVEL)(pIoBuffer->u.MgmtData.value)
                    );

            if (pIoBuffer->ReturnCode == ApiSuccess)
                pdx->PowerState = (PLX_POWER_LEVEL)(pIoBuffer->u.MgmtData.value);

            break;

        case PLX_IOCTL_POWER_LEVEL_GET:
            DebugPrintf_NoInfo(("PLX_IOCTL_POWER_LEVEL_GET\n"));

            pIoBuffer->ReturnCode =
                PlxPciPowerLevelGet(
                    pdx,
                    (PLX_POWER_LEVEL*)&(pIoBuffer->u.MgmtData.value)
                    );
            break;

        case PLX_IOCTL_PM_NCP_READ:
            DebugPrintf_NoInfo(("PLX_IOCTL_PM_NCP_READ\n"));

            pIoBuffer->ReturnCode =
                PlxPciPmNcpRead(
                    pdx,
                    (U8*)&(pIoBuffer->u.MgmtData.value)
                    );
            break;


        /***********************************
         *     Hot Swap Functions
         **********************************/
        case PLX_IOCTL_HS_NCP_READ:
            DebugPrintf_NoInfo(("PLX_IOCTL_HS_NCP_READ\n"));

            pIoBuffer->ReturnCode =
                PlxPciHotSwapNcpRead(
                    pdx,
                    (U8*)&(pIoBuffer->u.MgmtData.value)
                    );
            break;

        case PLX_IOCTL_HS_STATUS:
            DebugPrintf_NoInfo(("PLX_IOCTL_HS_STATUS\n"));

            pIoBuffer->ReturnCode =
                PlxPciHotSwapStatus(
                    pdx,
                    (U8*)&(pIoBuffer->u.MgmtData.value)
                    );
            break;


        /***********************************
         *         VPD Functions
         **********************************/
        case PLX_IOCTL_VPD_NCP_READ:
            DebugPrintf_NoInfo(("PLX_IOCTL_VPD_NCP_READ\n"));

            pIoBuffer->ReturnCode =
                PlxPciVpdNcpRead(
                    pdx,
                    (U8*)&(pIoBuffer->u.MgmtData.value)
                    );
            break;

        case PLX_IOCTL_VPD_READ:
            DebugPrintf_NoInfo(("PLX_IOCTL_VPD_READ\n"));

            pIoBuffer->ReturnCode =
                PlxPciVpdRead(
                    pdx,
                    pIoBuffer->u.MgmtData.offset,
                    (U32*)&(pIoBuffer->u.MgmtData.value)
                    );
            break;

        case PLX_IOCTL_VPD_WRITE: