BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → / @ 18

  → / @ 19

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

No changes between revisions

Ignore whitespace Rev 18 → Rev 19

/wiener_pcivme/pcivme Package/pcivme Package.vcxproj.filters
0,0 → 1,9
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Driver Files">
<UniqueIdentifier>{8E41214B-6785-4CFE-B992-037D68949A14}</UniqueIdentifier>
<Extensions>inf;inv;inx;mof;mc;</Extensions>
</Filter>
</ItemGroup>
</Project>

/wiener_pcivme/pcivme Package/Win7Release/pcivme Package.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme Package/Win7Release/pcivmePackage.Build.CppClean.log
0,0 → 1,10
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7release\pcivme package\pcivme.cat
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat-expand.1444.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat-expand.1444.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat-expand.960.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat-expand.960.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat-expand.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat-expand.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7release\inf2cat.write.1.tlog

/wiener_pcivme/pcivme Package/Win8.1Release/pcivme Package.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme Package/Win8.1Release/pcivmePackage.Build.CppClean.log
0,0 → 1,10
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1release\pcivme package\pcivme.cat
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat-expand.4252.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat-expand.4252.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat-expand.5104.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat-expand.5104.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat-expand.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat-expand.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1release\inf2cat.write.1.tlog

/wiener_pcivme/pcivme Package/Win8Release/pcivme Package.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.02

/wiener_pcivme/pcivme Package/Win8Release/pcivmePackage.Build.CppClean.log
0,0 → 1,10
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8release\pcivme package\pcivme.cat
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat-expand.2972.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat-expand.2972.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat-expand.548.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat-expand.548.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat-expand.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat-expand.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8release\inf2cat.write.1.tlog

/wiener_pcivme/pcivme Package/pcivme Package.vcxproj.user
0,0 → 1,4
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>

/wiener_pcivme/pcivme Package/pcivme Package.vcxproj
0,0 → 1,334
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Win8.1 Debug|Win32">
<Configuration>Win8.1 Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8.1 Release|Win32">
<Configuration>Win8.1 Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8 Debug|Win32">
<Configuration>Win8 Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8 Release|Win32">
<Configuration>Win8 Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win7 Debug|Win32">
<Configuration>Win7 Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win7 Release|Win32">
<Configuration>Win7 Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8.1 Debug|x64">
<Configuration>Win8.1 Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8.1 Release|x64">
<Configuration>Win8.1 Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8 Debug|x64">
<Configuration>Win8 Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8 Release|x64">
<Configuration>Win8 Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win7 Debug|x64">
<Configuration>Win7 Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win7 Release|x64">
<Configuration>Win7 Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{48C072A6-A36E-4090-B208-F0084AC06272}</ProjectGuid>
<TemplateGuid>{4605da2c-74a5-4865-98e1-152ef136825f}</TemplateGuid>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
<Configuration>Win8.1 Debug</Configuration>
<Platform Condition="'$(Platform)' == ''">Win32</Platform>
<RootNamespace>pcivme_Package</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|Win32'" Label="Configuration">
<TargetVersion>WindowsV6.3</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|Win32'" Label="Configuration">
<TargetVersion>WindowsV6.3</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'" Label="Configuration">
<TargetVersion>Windows8</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'" Label="Configuration">
<TargetVersion>Windows8</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'" Label="Configuration">
<TargetVersion>Windows7</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'" Label="Configuration">
<TargetVersion>Windows7</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|x64'" Label="Configuration">
<TargetVersion>WindowsV6.3</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|x64'" Label="Configuration">
<TargetVersion>WindowsV6.3</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'" Label="Configuration">
<TargetVersion>Windows8</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'" Label="Configuration">
<TargetVersion>Windows8</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'" Label="Configuration">
<TargetVersion>Windows7</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'" Label="Configuration">
<TargetVersion>Windows7</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Utility</ConfigurationType>
<DriverType>Package</DriverType>
<DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<EnableDeployment>False</EnableDeployment>
<RemoveDriver>True</RemoveDriver>
<HardwareIdString />
<CommandLine />
<DeployFiles />
<EnableVerifier>False</EnableVerifier>
<AllDrivers>False</AllDrivers>
<VerifyProjectOutput>True</VerifyProjectOutput>
<VerifyDrivers />
<VerifyFlags>133563</VerifyFlags>
</PropertyGroup>
<ItemGroup>
<FilesToPackage Include="@(Inf->'%(CopyOutput)')" Condition="'@(Inf)'!=''" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\pcivme\pcivme.vcxproj">
<Project>{2ac3560d-0575-4214-a7aa-04f7a8de84be}</Project>
</ProjectReference>
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

/wiener_pcivme/pcivme Package/Win7Debug/pcivme Package.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.02

/wiener_pcivme/pcivme Package/Win7Debug/pcivmePackage.Build.CppClean.log
0,0 → 1,14
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7debug\pcivme package\pcivme.cat
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7debug\pcivmepackage.cer
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat-expand.3180.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat-expand.3180.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat-expand.6020.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat-expand.6020.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat-expand.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat-expand.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\inf2cat.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\signtool.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\signtool.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win7debug\signtool.write.1.tlog

/wiener_pcivme/pcivme Package/Win8.1Debug/pcivme Package.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme Package/Win8.1Debug/pcivmePackage.Build.CppClean.log
0,0 → 1,14
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1debug\pcivme package\pcivme.cat
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1debug\pcivmepackage.cer
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat-expand.3084.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat-expand.3084.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat-expand.5916.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat-expand.5916.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat-expand.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat-expand.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\inf2cat.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\signtool.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\signtool.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8.1debug\signtool.write.1.tlog

/wiener_pcivme/pcivme Package/Win8Debug/pcivme Package.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme Package/Win8Debug/pcivmePackage.Build.CppClean.log
0,0 → 1,14
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8debug\pcivme package\pcivme.cat
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8debug\pcivmepackage.cer
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat-expand.1500.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat-expand.1500.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat-expand.5664.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat-expand.5664.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat-expand.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat-expand.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\inf2cat.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\signtool.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\signtool.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme package\win8debug\signtool.write.1.tlog

/wiener_pcivme/pcivme.v12.suo
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/wiener_pcivme/pcivme/SOURCE/pcivme_drv.c
0,0 → 1,1147
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// the main body of the driver
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_drv.c,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
//
// what who when
// started AR 15.06.1999
// first release 1.0 AR 17.10.1999
// fixed error in PLX9050Bug AR 28.02.2000
// PLX9050Bugfix bug fixed AR 03.03.2000
// PCICC32 CAMAC Interface conflict solved AR 03.03.2000
// Version 1.1 released AR 03.03.2000
// register all used resources, the idle too AR 25.11.2001
// changed resource allocation caused by WIN2000 AR 08.06.2002
//
//-------------------------------------------------------------------------
// INCLUDES
//
#include <ntddk.h>
#include <devioctl.h>
#include <pcivme_drv.h>
#include <pcivme_v.h>
#include <pcivme_io.h>
#include <pcivme_i.h>
#include <pcivme.h>
#include <pciif.h>
#include <pcivme_fifo.h>
//------------------------------------------------------------------------
// DEFINES
//
#ifndef DWORD
#define DWORD ULONG
#endif
#ifndef WORD
#define WORD USHORT
#endif
#define CTL_INDEX(x) ((x >> 2) & 0x7FF) // get user control code as index
#define IRQ_LIST_LENGTH 128 // max count of irqs in FIFO for each file_obj
#define RESOURCE_ENTRY_COUNT 6 // WIN2000 forces to claim all entries
#define DOS_DEVICE_NAME L"\\DosDevices\\PCIVME:"
//------------------------------------------------------------------------
// GLOBALS
//
//------------------------------------------------------------------------
// FUNCTIONS
//
//------------------------------------------------------------------------
// exchange the pointer to Bus Error
//
PBOOLEAN ExchangePointer(PBOOLEAN *current, PBOOLEAN next)
{
PBOOLEAN pb;
pb = *current;
*current = next;
return pb;
}
//------------------------------------------------------------------------
// get the vmemm number out of the filename
//
NTSTATUS InterpreteFileName(PCHAR name, int *nVmemm)
{
char *ptr = name;
char *n = "vmemm";
int h = -1; // high part
int l = -1; // low part
if (*ptr == '\\') ptr++; // jump over leading ...
while (*n) // compare the basename
if (*n == tolower(*ptr))
{
n++;
ptr++;
}
else
return STATUS_NO_SUCH_FILE;
h = *ptr - '0'; // get the number
ptr++;
l = *ptr - '0';
if (*ptr == 0) // still over the end ??
{
l = h;
h = 0;
}
else
ptr++;
if ((h < 0) || (l < 0) || (*ptr != 0)) // anything wrong ??
return STATUS_NO_SUCH_FILE;
*nVmemm = (h * 10) + l; // calculate number
if (*nVmemm >= PCIVME_MAX_VMEMM) // out of range ??
return STATUS_NO_SUCH_FILE;
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// the ultimate driver unload
VOID PCIVMEUnload(PDRIVER_OBJECT driverObj)
{
int i;
UNICODE_STRING symbol_name;
DEVICE_EXT *ext = (DEVICE_EXT*)(driverObj->DeviceObject->DeviceExtension);
int nPCIADAs = ext->nPCIADAs;
PCIADA *pciada;
KdPrint(("PCIVMEUnload()\n"));
switch (ext->nInitState)
{
case 8:
case 7:
// stop interrupts and shut off
PCIVMEDeInitPCIADAs(driverObj->DeviceObject);
PCIVMEDisConnectInterrupt(driverObj->DeviceObject);
// remove interrupt lists
for (i = 0; i < nPCIADAs; i++)
{
pciada = &ext->pciada[i];
// removeQueueFromList(...)
while (IsListEmpty(&pciada->IrqListList) == FALSE)
{
PLIST_ENTRY pList;
FIFO_LIST *next;
KdPrint(("RemoveHeadList(0x%08x)\n", &pciada->IrqListList));
pList = RemoveHeadList(&pciada->IrqListList);
next = CONTAINING_RECORD(pList, FIFO_LIST, entry);
ExFreePool((PVOID)next);
}
}
case 6:
// InitializeIRPQueue has no counterpart
case 5:
// KeInitializeDpc has no counterpart
case 4:
// release io spaces
for (i = 0; i < nPCIADAs; i++)
{
pciada = &ext->pciada[i];
if (pciada->pvVirtLcr != NULL)
MmUnmapIoSpace(pciada->pvVirtLcr, LCR_SPACE);
if (pciada->pvVirtIfr != NULL)
MmUnmapIoSpace(pciada->pvVirtIfr, IFR_SPACE);
}
case 3:
// HalGetInterruptVector has no counterpart
case 2:
// HalTranslateBusAddress has no counterpart
case 1:
PCIVMEFreeResources(driverObj->DeviceObject);
default:
case 0:
RtlInitUnicodeString(&symbol_name, DOS_DEVICE_NAME);
// delete the symbolicLink in the registry
IoDeleteSymbolicLink( &symbol_name);
// delete the deviceObject
IoDeleteDevice(driverObj->DeviceObject);
}
KdPrint(("PCIVMEUnload() OK.\n"));
}
//------------------------------------------------------------------------
// called at CreateFile()
NTSTATUS PCIVMEOpen(PDEVICE_OBJECT deviceObj, PIRP Irp)
{
NTSTATUS result = STATUS_SUCCESS;
ANSI_STRING name;
int nVmemm;
int i;
DEVICE_EXT *pDevExt = (DEVICE_EXT *)(deviceObj->DeviceExtension);
PCIADA *pciada;
FILE_OBJ *file_obj = (FILE_OBJ *)NULL;
name.Buffer = NULL;
name.MaximumLength = 80;
result = RtlUnicodeStringToAnsiString(&name, &(Irp->Tail.Overlay.OriginalFileObject->FileName), TRUE);
if (result != STATUS_SUCCESS) goto fin;
result = InterpreteFileName(name.Buffer, &nVmemm);
if (result != STATUS_SUCCESS) goto fin;
KdPrint(("PCIVMEOpen(%d)\n", nVmemm));
RtlFreeAnsiString(&name);
file_obj = (FILE_OBJ *)ExAllocatePoolWithTag(NonPagedPool, sizeof(FILE_OBJ),'nepo');
if (file_obj == (FILE_OBJ *)NULL)
{
result = STATUS_NO_MEMORY;
goto fin;
}
file_obj->uwAssociatedVMEMM = (USHORT) nVmemm;
file_obj->bAddressModifier = 0x39;
file_obj->bAccessType = BYTE_ACCESS;
file_obj->bIncrement = BYTE_ACCESS; // increments each byte
file_obj->dwAccessBase = 0; // normal setting for all but extended
file_obj->bQueueIrq = FALSE;
result = InitializeFIFO(IRQ_LIST_LENGTH, &file_obj->pIrqListHandle);
if (result != STATUS_SUCCESS) goto fin;
Irp->Tail.Overlay.OriginalFileObject->FsContext = (PVOID)file_obj;
result = PCIVMEScanVMEMM(deviceObj);
if (result != STATUS_SUCCESS) goto fin;
for (i = 0; i < pDevExt->nPCIADAs; i++)
{
pciada = &pDevExt->pciada[i];
if (pciada->wModuleNumber == nVmemm)
{
pDevExt->vmemm[nVmemm] = pciada; // create association
pciada->dwLinkCount++;
break;
}
}
if (i >= pDevExt->nPCIADAs)
{
result = STATUS_NO_SUCH_FILE;
goto fin;
}
fin:
Irp->IoStatus.Status = result;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
// be careful when releasing allocated memory !
if (result != STATUS_SUCCESS)
if (file_obj != (FILE_OBJ *)NULL)
if (file_obj->pIrqListHandle != (PVOID)NULL)
DestroyFIFO(file_obj->pIrqListHandle);
return result;
}
//------------------------------------------------------------------------
// called at close()
NTSTATUS PCIVMEClose(PDEVICE_OBJECT deviceObj, PIRP Irp)
{
DEVICE_EXT *pDevExt = (DEVICE_EXT *)(deviceObj->DeviceExtension);
FILE_OBJ *file_obj = (FILE_OBJ *)NULL;
PCIADA *pciada;
file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
KdPrint(("PCIVMEClose(%d)\n", file_obj->uwAssociatedVMEMM));
if (file_obj != (FILE_OBJ *)NULL)
{
pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
pciada->dwLinkCount--;
// remove the ListEntry(s) associated with this path
removeQueueFromList(file_obj, pciada);
// empty and remove the interrupt queue (if there is anything stored)
DestroyFIFO(file_obj->pIrqListHandle);
ExFreePool(file_obj);
Irp->Tail.Overlay.OriginalFileObject->FsContext = (FILE_OBJ *)NULL;
}
KdPrint(("PCIVMEClose OK\n"));
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// called at
NTSTATUS PCIVMEShutdown(PDEVICE_OBJECT deviceObj, PIRP irp )
{
UNREFERENCED_PARAMETER(irp);
KdPrint(("PCIVMEShutdown()\n"));
// deinit interfaces and interrupts
PCIVMEDeInitPCIADAs(deviceObj);
KdPrint(("PCIVMEShutdown() OK\n"));
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// called at ioctl()
NTSTATUS PCIVMEDeviceControl(PDEVICE_OBJECT deviceObj, PIRP Irp)
{
PIO_STACK_LOCATION IrpStack;
int nIndex;
IrpStack = IoGetCurrentIrpStackLocation(Irp);
nIndex = CTL_INDEX(IrpStack->Parameters.DeviceIoControl.IoControlCode);
KdPrint(("PCIVMEDeviceControl(%d / 0x%08x)\n", nIndex, Irp->Tail.Overlay.OriginalFileObject));
if (nIndex > CTL_INDEX(PCIVME_LAST_CTL_CODE))
{
Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
KdPrint(("PCIVMEDeviceControl() FAIL.\n"));
return STATUS_UNSUCCESSFUL;
}
return ioctl[nIndex](deviceObj, Irp, IrpStack);
}
//------------------------------------------------------------------------
// called at read()
NTSTATUS PCIVMERead(PDEVICE_OBJECT device_Obj, PIRP Irp)
{
NTSTATUS Status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
PVOID pOutputBuffer = ((void *)(MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority)));
LARGE_INTEGER *fileOffset = (LARGE_INTEGER *)&Irp->Tail.Overlay.OriginalFileObject->CurrentByteOffset;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
DEVICE_EXT *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
PCIADA *pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
register ULONG Address = IrpStack->Parameters.Read.ByteOffset.LowPart + file_obj->dwAccessBase;
ULONG storeLength = 0;
PBOOLEAN pbPrevBusError;
KdPrint(("PCIVMERead(%d)\n", file_obj->uwAssociatedVMEMM));
// do here in between what has to be done -----------------
if (Address & file_obj->dwAddressMask) // don't do unaligned transfers
Status = STATUS_DATATYPE_MISALIGNMENT;
else
{
register ULONG Length = IrpStack->Parameters.Read.Length;
register ULONG blockLength;
register ULONG pageAddress;
register ULONG toNextPage;
KIRQL oldIrql;
Length &= ~file_obj->dwAddressMask; // align to integer increments
storeLength = Length;
// lock other users out
KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);
// check for modifier
if (pciada->bModifier != file_obj->bAddressModifier)
{
WRITE_REGISTER_UCHAR(pciada->pbModifier, file_obj->bAddressModifier);
pciada->bModifier = file_obj->bAddressModifier;
}
// do the read ---
file_obj->bBusError = FALSE;
pbPrevBusError = ExchangePointer(&pciada->pbBusError, &file_obj->bBusError);
while (Length)
{
pageAddress = Address & ~VME_ADR_MASK;
if (pageAddress != pciada->dwVMEPage)
{
WRITE_REGISTER_ULONG(pciada->pdwVMEAdr, pageAddress);
pciada->dwVMEPage = pageAddress;
}
toNextPage = (pageAddress + VME_ADR_MASK + 1) - Address;
blockLength = (toNextPage < Length) ? toNextPage : Length;
KdPrint(("Address 0x%08x, blockLength %d, Length %d\n",
Address, blockLength, Length));
file_obj->fRead(pOutputBuffer , blockLength, (PVOID)((PUCHAR)pciada->pvVME + (Address & VME_ADR_MASK)));
Length -= blockLength;
Address += blockLength;
pOutputBuffer = (PVOID)((PUCHAR)pOutputBuffer + blockLength);
}
// release the lock
KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
ExchangePointer(&pciada->pbBusError, pbPrevBusError);
if (file_obj->bBusError) Status = STATUS_ACCESS_VIOLATION;
if (file_obj->bIncrement) // only when increment to next is on
*fileOffset =
RtlLargeIntegerAdd(*fileOffset, RtlConvertUlongToLargeInteger(storeLength));
}
// do here in between what has to be done end -------------
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = storeLength;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
KdPrint(("PCIVMERead(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// called at write()
NTSTATUS PCIVMEWrite(PDEVICE_OBJECT device_Obj, PIRP Irp)
{
NTSTATUS Status = STATUS_SUCCESS;
PIO_STACK_LOCATION IrpStack = IoGetCurrentIrpStackLocation(Irp);
PVOID pInputBuffer = ((void *)(MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority)));
LARGE_INTEGER *fileOffset = (LARGE_INTEGER *)&Irp->Tail.Overlay.OriginalFileObject->CurrentByteOffset;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
DEVICE_EXT *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
PCIADA *pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
register ULONG Address = IrpStack->Parameters.Write.ByteOffset.LowPart + file_obj->dwAccessBase;
ULONG storeLength = 0;
PBOOLEAN pbPrevBusError;
KdPrint(("PCIVMEWrite(%d)\n", file_obj->uwAssociatedVMEMM));
// do here in between what has to be done -----------------
if (Address & file_obj->dwAddressMask) // don't do unaligned transfers
Status = STATUS_DATATYPE_MISALIGNMENT;
else
{
register ULONG Length = IrpStack->Parameters.Write.Length;
register ULONG blockLength;
register ULONG pageAddress;
register ULONG toNextPage;
KIRQL oldIrql;
Length &= ~file_obj->dwAddressMask; // align to integer increments
storeLength = Length;
// check for modifier
// lock other users out
KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);
if (pciada->bModifier != file_obj->bAddressModifier)
{
WRITE_REGISTER_UCHAR(pciada->pbModifier, file_obj->bAddressModifier);
pciada->bModifier = file_obj->bAddressModifier;
}
// do the read ---
file_obj->bBusError = FALSE;
pbPrevBusError = ExchangePointer(&pciada->pbBusError, &file_obj->bBusError);
while (Length)
{
pageAddress = Address & ~VME_ADR_MASK;
if (pageAddress != pciada->dwVMEPage)
{
WRITE_REGISTER_ULONG(pciada->pdwVMEAdr, pageAddress);
pciada->dwVMEPage = pageAddress;
}
toNextPage = (pageAddress + VME_ADR_MASK + 1) - Address;
blockLength = (toNextPage < Length) ? toNextPage : Length;
KdPrint(("Address 0x%08x, blockLength %d, Length %d\n",
Address, blockLength, Length));
file_obj->fWrite((PVOID)((PUCHAR)pciada->pvVME + (Address & VME_ADR_MASK)) , blockLength, pInputBuffer);
Length -= blockLength;
Address += blockLength;
pInputBuffer = (PVOID)((PUCHAR)pInputBuffer + blockLength);
}
// release the lock
KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
ExchangePointer(&pciada->pbBusError, pbPrevBusError);
if (file_obj->bBusError) Status = STATUS_ACCESS_VIOLATION;
if (file_obj->bIncrement) // only when increment to next is on
*fileOffset = RtlLargeIntegerAdd(*fileOffset, RtlConvertUlongToLargeInteger(storeLength));
}
// do here in between what has to be done end -------------
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = storeLength;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
KdPrint(("PCIVMEWrite(), Status = 0x%08x\n", Status));
return Status;
}
#ifdef DO_CLEANUP
//------------------------------------------------------------------------
// called at cancel of a path
NTSTATUS PCIVMECancel(PDEVICE_OBJECT device_Obj, PIRP Irp)
{
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
PIRP pIrpCancel;
KdPrint(("PCIVMECancel()\n"));
// remove all queued IRPs of this file_obj
do
{
pIrpCancel = RemoveIRPfromQueue(device_Obj, file_obj);
if (pIrpCancel == (PIRP)NULL)
{
IoReleaseCancelSpinLock(pIrpCancel->CancelIrql);
break;
}
else
{
IoAcquireCancelSpinLock(pIrpCancel->CancelIrql);
// mark irp as not pending
IoSetCancelRoutine(pIrpCancel, NULL);
IoReleaseCancelSpinLock(pIrpCancel->CancelIrql);
pIrpCancel->IoStatus.Status = STATUS_CANCELLED;
pIrpCancel->IoStatus.Information = 0;
}
} while (pIrpCancel != (PIRP)NULL);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
KdPrint(("PCIVMECancel(OK)\n"));
return STATUS_SUCCESS;
}
#endif
//------------------------------------------------------------------------
// search for pciada's
//
NTSTATUS SearchDevices(PDEVICE_OBJECT device_Obj)
{
PCI_SLOT_NUMBER SlotNumber;
PCI_COMMON_CONFIG pci_config;
PCIADA *pciada;
ULONG length;
int *found;
int i,j,k;
KdPrint(("SearchDevices()\n"));
// prepare structures ----------------------------------------
found = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->nPCIADAs;
*found = 0;
for (i = 0; i < PCIVME_MAX_PCIADA; i++)
{
pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
pciada->Bus = -1;
pciada->Slot.u.AsULONG = 0xFFFFFFFF;
}
// search for pciada's ---------------------------------------
SlotNumber.u.bits.Reserved = 0;
for (j = 0; j < PCI_MAX_BUSES; j++)
{
for (i = 0; i < PCI_MAX_DEVICES; i++)
{
SlotNumber.u.bits.DeviceNumber = i;
for (k = 0; k < PCI_MAX_FUNCTION; k++)
{
SlotNumber.u.bits.FunctionNumber = k;
length = HalGetBusData( PCIConfiguration, // Bustype
j, // PCI-Busnumber
SlotNumber.u.AsULONG, // Slotnumber
(PVOID) &(pci_config), // Pointer for the PCI-Information
sizeof(PCI_COMMON_CONFIG) );
if ((pci_config.VendorID == PCIVME_VENDOR_ID) &&
(pci_config.DeviceID == PCIVME_DEVICE_ID) &&
(pci_config.u.type0.SubSystemID == PCIVME_SUBSYS_ID) &&
(pci_config.u.type0.SubVendorID == PCIVME_SUBVEN_ID) &&
(pci_config.u.type0.BaseAddresses[2]))
{
pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[*found];
memcpy(&pciada->PCIDevice, &pci_config, sizeof(pci_config));
pciada->Slot = SlotNumber;
pciada->Bus = j;
KdPrint(("PCIADA found @ Bus/Slot %d/%d.\n", pciada->Bus, pciada->Slot.u.AsULONG));
(*found)++;
if (*found >= PCIVME_MAX_PCIADA) return STATUS_SUCCESS;
}
}
}
}
return STATUS_SUCCESS;
}
//---------------------------------------------------------------
// function to call for bug fix of PLX9050 build in bug
//
NTSTATUS PLX9050BugFix(PDEVICE_OBJECT device_Obj)
{
DEVICE_EXT *DeviceExtension = (DEVICE_EXT*)device_Obj->DeviceExtension;
int i;
ULONG dwData;
PCIADA *pciada;
KdPrint(("PLX9050BugFix()\n"));
for (i = 0; i < DeviceExtension->nPCIADAs; i++)
{
pciada = &DeviceExtension->pciada[i];
if ((dwData = pciada->PCIDevice.u.type0.BaseAddresses[0]) & 0x80)
{
KdPrint(("Changing address 0:0x%p with 4:0x%p\n",
pciada->PCIDevice.u.type0.BaseAddresses[0],
pciada->PCIDevice.u.type0.BaseAddresses[4]));
pciada->PCIDevice.u.type0.BaseAddresses[0] = // exchange
pciada->PCIDevice.u.type0.BaseAddresses[4];
pciada->PCIDevice.u.type0.BaseAddresses[4] = dwData;
if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
pciada->Slot.u.AsULONG,
(PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[0],
0x10, 4) != 4)
return STATUS_UNSUCCESSFUL;
if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
pciada->Slot.u.AsULONG,
(PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[4],
0x20, 4) != 4)
return STATUS_UNSUCCESSFUL;
}
if ((dwData = pciada->PCIDevice.u.type0.BaseAddresses[1]) & 0x80)
{
KdPrint(("Changing address 1:0x%p with 5:0x%p\n",
pciada->PCIDevice.u.type0.BaseAddresses[1],
pciada->PCIDevice.u.type0.BaseAddresses[5]));
pciada->PCIDevice.u.type0.BaseAddresses[1] = // exchange
pciada->PCIDevice.u.type0.BaseAddresses[5];
pciada->PCIDevice.u.type0.BaseAddresses[5] = dwData;
if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
pciada->Slot.u.AsULONG,
(PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[1],
0x14, 4) != 4)
return STATUS_UNSUCCESSFUL;
if (HalSetBusDataByOffset(PCIConfiguration, pciada->Bus,
pciada->Slot.u.AsULONG,
(PVOID)&pciada->PCIDevice.u.type0.BaseAddresses[5],
0x24, 4) != 4)
return STATUS_UNSUCCESSFUL;
}
}
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// reserve resources for PCIADAs
//
NTSTATUS PCIVMEExtractResources(PCIADA *pciada, PCM_RESOURCE_LIST pList)
{
PCM_RESOURCE_LIST pResourceList;
PCM_FULL_RESOURCE_DESCRIPTOR pFullDescriptor;
PCM_PARTIAL_RESOURCE_LIST pPartialList;
PCM_PARTIAL_RESOURCE_DESCRIPTOR pPartialDescriptor;
int i;
int bug = 0;
KdPrint(("PCIVMEExtractResources()\n"));
pResourceList = pList;
pFullDescriptor = pResourceList->List;
pPartialList = &pFullDescriptor->PartialResourceList;
for (i=0; i<(int)pPartialList->Count; i++)
{
pPartialDescriptor = &pPartialList->PartialDescriptors[i];
switch (pPartialDescriptor->Type)
{
case CmResourceTypeInterrupt:
pciada->Irql = (KIRQL)pPartialDescriptor->u.Interrupt.Level;
pciada->Vector = pPartialDescriptor->u.Interrupt.Vector;
pciada->Affinity = pPartialDescriptor->u.Interrupt.Affinity;
KdPrint(("Irq : Irql: %d, Vector: %d, Affinity: %d\n",
pciada->Irql, pciada->Vector, pciada->Affinity));
break;
case CmResourceTypeDma:
KdPrint(("Dma : \n"));
break;
case CmResourceTypePort:
KdPrint(("Port : 0x%p\n", pPartialDescriptor->u.Port.Start));
break;
case CmResourceTypeMemory:
// special handling of PLXBUG here because of WIN2000
// WIN2000 doesn't recognize late address changes
if (!bug)
{
if (i == 0)
{
pciada->pvPhysLcr = pPartialDescriptor->u.Memory.Start;
if (pciada->pvPhysLcr.LowPart & 0x80)
bug = 1;
}
}
else
{
if (i == 3)
pciada->pvPhysLcr = pPartialDescriptor->u.Memory.Start;
}
if (i == 2)
pciada->pvPhysIfr = pPartialDescriptor->u.Memory.Start;
KdPrint(("Memory : 0x%p\n", (PUCHAR)pPartialDescriptor->u.Memory.Start.LowPart));
break;
}
}
if (pciada->Irql == 0)
return STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT;
KdPrint(("PCIVMEExtractResources() OK.\n"));
return STATUS_SUCCESS;
}
NTSTATUS PCIVMEReserveResources(PDEVICE_OBJECT device_Obj)
{
PCM_RESOURCE_LIST pList = NULL;
NTSTATUS result = STATUS_SUCCESS;
int i;
DEVICE_EXT *pDevExt = (DEVICE_EXT*)(device_Obj->DeviceExtension);
int nPCIADAs = pDevExt->nPCIADAs;
PCIADA *pciada;
UNICODE_STRING DriverClassName;
KdPrint(("PCIVMEReserveResources()\n"));
// prepare resource claiming
RtlInitUnicodeString(&DriverClassName, L"PCICC32");
// cycle through all busses and slots assigned to PCIADAs
for (i = 0; i < nPCIADAs; i++)
{
pciada = &pDevExt->pciada[i];
result = HalAssignSlotResources(NULL, &DriverClassName, device_Obj->DriverObject, device_Obj,
PCIBus, pciada->Bus, pciada->Slot.u.AsULONG, &pList);
if (result != STATUS_SUCCESS)
break;
result = PCIVMEExtractResources(pciada, pList);
if (result != STATUS_SUCCESS)
break;
}
// its my part to free allocated resources
if (pList != NULL) ExFreePoolWithTag(pList,'nepo');
KdPrint(("PCIVMEReserveResources(0x%08x)\n", result));
return result;
};
//------------------------------------------------------------------------
// free resources from PCIADAs
//
NTSTATUS PCIVMEFreeResources(PDEVICE_OBJECT device_Obj)
{
CM_RESOURCE_LIST ResList;
BOOLEAN bConflict;
UNICODE_STRING DriverClassName;
KdPrint(("PCIVMEFreeResources()\n"));
RtlInitUnicodeString(&DriverClassName, L"PCIVME");
ResList.Count = 0;
IoReportResourceUsage(&DriverClassName, device_Obj->DriverObject,
&ResList, sizeof(ResList), device_Obj,
NULL, 0, FALSE, &bConflict);
return STATUS_SUCCESS;
};
//------------------------------------------------------------------------
// translate memory resources to neutral for PCIADAs
//
NTSTATUS PCIVMETranslateBusAddresses(PDEVICE_OBJECT device_Obj)
{
int i;
NTSTATUS result = STATUS_SUCCESS;
int nPCIADAs = ((DEVICE_EXT*)(device_Obj->DeviceExtension))->nPCIADAs;
ULONG memType0, memType2;
PCIADA *pciada;
KdPrint(("TranslateBusAddresseses()\n"));
for (i = 0; i < nPCIADAs; i++)
{
pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
memType0 = memType2 = 0;
if (!(HalTranslateBusAddress(PCIBus, pciada->Bus, pciada->pvPhysLcr, &memType0,
&pciada->pvPhysLcr)) ||
!(HalTranslateBusAddress(PCIBus, pciada->Bus, pciada->pvPhysIfr, &memType2,
&pciada->pvPhysIfr)))
{
result = STATUS_UNSUCCESSFUL;
break;
}
if ((memType0) || (memType2))
{
result = STATUS_UNSUCCESSFUL;
break;
}
}
return result;
}
//------------------------------------------------------------------------
// map address spaces to virtual addresses
//
NTSTATUS PCIVMEMapIOspace(PDEVICE_OBJECT device_Obj)
{
int i;
DEVICE_EXT *pDevExt = (DEVICE_EXT*)device_Obj->DeviceExtension;
int nPCIADAs = pDevExt->nPCIADAs;
PCIADA *pciada;
KdPrint(("PCIVMEMapIOspace()\n"));
for (i = 0; i < nPCIADAs; i++)
{
pciada = &pDevExt->pciada[i];
if ((pciada->pvVirtLcr = MmMapIoSpace(pciada->pvPhysLcr, LCR_SPACE, FALSE)) == NULL)
return STATUS_UNSUCCESSFUL;
if ((pciada->pvVirtIfr = MmMapIoSpace(pciada->pvPhysIfr, IFR_SPACE, FALSE)) == NULL)
return STATUS_UNSUCCESSFUL;
KdPrint(("PCIADA %d: LCR 0x%08x IFR 0x%08x\n",
i, pciada->pvVirtLcr, pciada->pvVirtIfr));
pciada->pwIntCSR = (PUSHORT)((PUCHAR)pciada->pvVirtLcr + 0x4C);
pciada->pwCntrl = (PUSHORT)((PUCHAR)pciada->pvVirtLcr + 0x50);
}
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// initializes and registers a DPC routine for each pciada
//
NTSTATUS InitializeCustomDPCObjects(PDEVICE_OBJECT device_object)
{
int i;
int nPCIADAs = ((DEVICE_EXT*)(device_object->DeviceExtension))->nPCIADAs;
PCIADA *pciada;
KdPrint(("InitializeCustomDPCObject()\n"));
for (i = 0; i < nPCIADAs; i++)
{
pciada = &((DEVICE_EXT*)(device_object->DeviceExtension))->pciada[i];
KeInitializeDpc(&pciada->kDPCobj, fMyDefferedRoutine, (PVOID)device_object);
}
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// initializes the queue for storing IRPs waiting for vectors
//
NTSTATUS InitializeIRPQueue(PDEVICE_OBJECT device_Obj)
{
DEVICE_EXT *pDevExt = ((DEVICE_EXT*)(device_Obj->DeviceExtension));
KdPrint(("InitializeIRPQueue()\n"));
KeInitializeSpinLock(&pDevExt->IRPLock);
InitializeListHead(&pDevExt->IRPList);
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// init structures a.s.o.
//
VOID PCIVMESoftInit(PDEVICE_OBJECT device_Obj)
{
int i;
PCIADA *pciada;
for (i = 0; i < PCIVME_MAX_PCIADA; i++)
{
pciada = &((DEVICE_EXT*)(device_Obj->DeviceExtension))->pciada[i];
pciada->pvPhysLcr.QuadPart = pciada->pvPhysIfr.QuadPart = 0;
pciada->pvVirtLcr = pciada->pvVirtIfr = NULL;
pciada->bConnected = FALSE; // connection still not verified
pciada->bWordMode = TRUE;
pciada->bSysControl = FALSE;
pciada->wModuleNumber = 0xFFFF;
pciada->wFPGAVersion = 0xFFFF;
pciada->wModuleType = 1; // always VMEMM
pciada->InterruptObject = NULL;
pciada->Irql = 0;
pciada->Vector = 0;
pciada->Affinity = 0;
pciada->dwLinkCount = 0;
KeInitializeSpinLock(&pciada->IrqListLock);
KeInitializeSpinLock(&pciada->AccessLock);
InitializeListHead(&pciada->IrqListList); // start of list of irq fifos
pciada->nInterruptHandlers = 0;
}
// no vmemm associated to any PCIADA
for (i = 0; i < PCIVME_MAX_VMEMM; i++)
((DEVICE_EXT*)(device_Obj->DeviceExtension))->vmemm[i] = NULL;
}
//------------------------------------------------------------------------
// the ultimate starting point of a driver
NTSTATUS DriverEntry(PDRIVER_OBJECT driverObj, PUNICODE_STRING regPath )
{
UNREFERENCED_PARAMETER(regPath);
PDEVICE_OBJECT device_object; // pointer to the device object
UNICODE_STRING device_name;
UNICODE_STRING symbol_name;
NTSTATUS result = STATUS_SUCCESS;
int nPCIADAs; // count of PCIADAs
DEVICE_EXT *DeviceExtension = NULL;
KdPrint(("DriverEntry() ---%d.%d---------------------------------\n", (DRIVER_VERSION >> 16) & 0xff, DRIVER_VERSION & 0xff));
driverObj->DriverUnload = PCIVMEUnload;
driverObj->MajorFunction[IRP_MJ_CREATE] = PCIVMEOpen;
driverObj->MajorFunction[IRP_MJ_CLOSE] = PCIVMEClose;
driverObj->MajorFunction[IRP_MJ_READ] = PCIVMERead;
driverObj->MajorFunction[IRP_MJ_WRITE] = PCIVMEWrite;
driverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PCIVMEDeviceControl;
#ifdef DO_CLEANUP
driverObj->MajorFunction[IRP_MJ_CLEANUP] = PCIVMECancel;
#endif
driverObj->MajorFunction[IRP_MJ_SHUTDOWN] = PCIVMEShutdown;
RtlInitUnicodeString(&device_name, L"\\Device\\PCIVME");
/* DeviceObject durch IO-Manager erzeugen */
result = IoCreateDevice( driverObj, // DriverObject received by the DriverEntry Call
sizeof(DEVICE_EXT), // required Memory for the DeviceExtension
&device_name, // Name of the device in the device-Directory
FILE_DEVICE_UNKNOWN, // Device-ID
0, // Device-Characteristics normal 0
FALSE, // TRUE : one Thread can open the driver
&device_object); // DeviceObject returned from the IO-Manager
// defines how the data are handled between user / kernel Adress-Space
device_object->Flags |= DO_DIRECT_IO;
#if 0
// register the shutdown notification entry
IoRegisterShutdownNotification(device_object);
#endif
// anounce driver as symbolic device ---------------------------------
if (result == STATUS_SUCCESS)
{
/* now the symbolic Link is created. If there is no S.L. a program cannot connect to the driver */
RtlInitUnicodeString(&symbol_name, DOS_DEVICE_NAME);
result = IoCreateSymbolicLink(&symbol_name,&device_name);
if (result != STATUS_SUCCESS)
{
IoDeleteDevice(device_object);
return result;
}
}
else
return result;
DeviceExtension = (DEVICE_EXT*)device_object->DeviceExtension;
DeviceExtension->actualIrp = NULL;
DeviceExtension->driverObj = driverObj;
DeviceExtension->nInitState = 0;
// init pciada structures ------------------------------------
PCIVMESoftInit(device_object);
// search for PCIADAs ----------------------------------------
result = SearchDevices(device_object);
nPCIADAs = DeviceExtension->nPCIADAs;
if ((result != STATUS_SUCCESS) || !(nPCIADAs))
{
PCIVMEUnload(driverObj);
return STATUS_DEVICE_DOES_NOT_EXIST;
}
// request exclusive ownership of .. ---------------------------------
if ((result = PCIVMEReserveResources(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return result;
}
else
DeviceExtension->nInitState++;
// fix PLX9050 Bug -------------------------------------------
if ((result = PLX9050BugFix(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return result;
}
// translate BUS relative addresses ----------------------------------
if ((result = PCIVMETranslateBusAddresses(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return STATUS_DEVICE_DOES_NOT_EXIST;
}
else
DeviceExtension->nInitState++;
// translate Interrupt Resources used --------------------------------
if ((result = PCIVMETranslateInterrupts(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return STATUS_DEVICE_DOES_NOT_EXIST;
}
else
DeviceExtension->nInitState++;
// map address spaces to virtual addresses ---------------------------
if ((result = PCIVMEMapIOspace(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return STATUS_DEVICE_DOES_NOT_EXIST;
}
else
DeviceExtension->nInitState++;
// initialze my custom DPC objects -----------------------------------
if ((result = InitializeCustomDPCObjects(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return result;
}
else
DeviceExtension->nInitState++;
// initialze the queue for IRPs waiting for vectors ------------------
if ((result = InitializeIRPQueue(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return result;
}
else
DeviceExtension->nInitState++;
// connect interrupts to service routines ----------------------------
if ((result = PCIVMEConnectInterrupt(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return STATUS_DEVICE_DOES_NOT_EXIST;
}
else
DeviceExtension->nInitState++;
// scan all connected VMEMM for info and later use -------------------
if ((result = PCIVMEScanVMEMM(device_object)) != STATUS_SUCCESS)
{
PCIVMEUnload(driverObj);
return STATUS_DEVICE_DOES_NOT_EXIST;
}
device_object->Flags &= ~DO_DEVICE_INITIALIZING;
KdPrint(("DriverEntry() OK.\n"));
return result;
}

/wiener_pcivme/pcivme/SOURCE/pciif.h
0,0 → 1,88
#ifndef __PCIIF_H__
//-----------------------------------------------------------------------
// Address definitions of PCI-VME interface designed by A.Rausch
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pciif.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:26 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// first parts AR 24.11.1997
// converted to new address layout AR 18.05.1998
// next address layout conversion AR 27.06.1998
// no pointer usage at definitions AR 20.02.1999
// first release AR 20.02.1999
// corrected global and local reset AR 18.04.1999
//
#include <vic.h>
/*-----------------------------------------------------------------------*/
/* all addresses relative to PCI-Window */
/*------------- addresses of vmemm local devices ------------------------*/
#define CSR (DWORD)0x0000 /* control status register */
#define VICRES (DWORD)0x0004 /* VIC reset register / interrupt status */
#define ADRHL (DWORD)0x0008 /* AdrH and AdrL as long */
#define VICBASE (DWORD)0x0400 /* base of VIC68A */
#define VECBASE (DWORD)0x0800 /* base of vector registers */
#define VMEBASE (DWORD)0x1000 /* base of 4k VME-BUS window */
/*---------- parts of addresses derived from above ----------------------*/
#define IVEC1 (DWORD)(VECBASE + 3) /* IACK 1 vector */
#define IVEC2 (DWORD)(VECBASE + 5) /* IACK 2 vector */
#define IVEC3 (DWORD)(VECBASE + 7) /* IACK 3 vector */
#define IVEC4 (DWORD)(VECBASE + 9) /* IACK 4 vector */
#define IVEC5 (DWORD)(VECBASE + b) /* IACK 5 vector */
#define IVEC6 (DWORD)(VECBASE + d) /* IACK 6 vector */
#define IVEC7 (DWORD)(VECBASE + f) /* IACK 7 vector */
#define ADRL (DWORD)ADRHL /* word access addr. VME-addr */
#define ADRH (DWORD)(ADRHL + 2)
/*--------- address mask ------------------------------------------------*/
#define VME_ADR_MASK (DWORD)0x00000FFF /* masks lower part of address */
/*--------- some masks in CSR -------------------------------------------*/
#define FLAG_RMC (WORD)0x0001 /* set = next cycle is RMC */
#define FLAG_BLT (WORD)0x0002 /* don't use it. must be 0 */
#define FLAG_WORD (WORD)0x0004 /* it is a word wide interface */
#define FLAG_SYSCTL (WORD)0x0008 /* the system contrl. is enabled */
#define MASK_MODNR (WORD)0x00F0 /* the mask to get the module No */
#define MASK_FPGA (WORD)0x0F00 /* the mask to get the FPGA rev. */
#define MASK_MODTYPE (WORD)0xF000 /* the mask to get type of module*/
/*---------- action commands in VICRES -----------------------------------*/
#define GLOBAL_RESET (WORD)0x000A /* write this to reset the intrfc */
#define LOCAL_RESET (WORD)0x0005 /* generate a local reset */
/*---------- release und inhibit into 0x50 of PLX ------------------------*/
#define RELEASE_VMEMM (WORD)0x4180 /* write this to release access ..*/
#define INHIBIT_VMEMM (WORD)0x4080 /* write this to inhibit access ..*/
#define ENABLE_PCIADA_IRQS (WORD)0x0049 /* enable PCIADA IRQs */
#define DISABLE_PCIADA_IRQS (WORD)0x0009 /* disable PCIADA IRQs */
#define __PCIIF_H__
#endif

/wiener_pcivme/pcivme/SOURCE/pcivme_i.h
0,0 → 1,70
#ifndef __PCIVME_I_H__
#define __PCIVME_I_H__
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// the header file to pcivme_i.c - all around interrupt handling
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_i.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:51 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 15.06.99
// changed resource allocation caused by WIN2000 AR 08.06.2002
//
//-------------------------------------------------------------------------
// INCLUDES
//
#include <ntddk.h>
#include <pcivme_drv.h>
//------------------------------------------------------------------------
// DEFINES
//
//------------------------------------------------------------------------
// PROTOTYPES
//
void globalInterruptEnable(PCIADA *pciada);
void globalInterruptDisable(PCIADA *pciada);
NTSTATUS PCIVMETranslateInterrupts(PDEVICE_OBJECT device_Obj);
NTSTATUS PCIVMEConnectInterrupt(PDEVICE_OBJECT device_Obj);
NTSTATUS PCIVMEDisConnectInterrupt(PDEVICE_OBJECT device_Obj);
/* release all this procedures after init of the driver */
#ifdef ALLOC_PRAGMA
#pragma alloc_text (init, PCIVMEConnectInterrupt)
#pragma alloc_text (init, PCIVMETranslateInterrupts)
#endif
/* put all this procedures in the paged memory-pool, all called at passiv Level */
#ifdef ALLOC_PRAGMA
#pragma alloc_text (page, PCIVMEDisConnectInterrupt)
#endif
#endif //__PCIVME_I_H__

/wiener_pcivme/pcivme/SOURCE/sources
0,0 → 1,12
TARGETNAME=pcivme
#VisualStudio 5
#TARGETPATH=d:\Programme\DevStudio\MyProjects\pcivme
#VisualStudio 6
TARGETPATH=d:\Programme\VisualStudio\MyProjects\pcivme
TARGETTYPE=DRIVER
TARGETLIBS=
INCLUDES=$(BASEDIR)\inc
SOURCES=pcivme_drv.c pcivme_v.c pcivme_io.c pcivme_i.c pcivme_fifo.c

/wiener_pcivme/pcivme/SOURCE/pcivme.ncb
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/wiener_pcivme/pcivme/SOURCE/pcivme.opt
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/wiener_pcivme/pcivme/SOURCE/pcivme_drv.h
0,0 → 1,220
#ifndef __PCIVME_DRV_H__
#define __PCIVME_DRV_H__
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// the main header file of the driver
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_drv.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:50 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.5 2002/10/27 18:41:21 klaus
// changed driver version to 2.0 (not 'inf' version)
//
// Revision 1.4 2002/10/27 17:02:30 klaus
// File addressing bug > 2 Gbtye circumvent
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 15.06.1999
// version 1.0 released AR 20.10.1ß99
// version 1.2 released AR 25.11.2001
// changed to VisualStudio 6.0 AR 30.09.2001
// compiled with DDK 1/2001 AR 20.11.2001
// removed alloc_text cause of WIN2000 problems AR 25.11.2001
// version 1.3 released AR 25.11.2001
// changed resource allocation caused by WIN2000 AR 08.06.2002
//
//-------------------------------------------------------------------------
#define DRIVER_VERSION ((2 << 16) | 0) // the only place for version info
#define DRIVER_VARIANT 0 // mark customisation here
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// precautions for debug compile
#define PCIVME_DEBUG
#ifndef PCIVME_DEBUG
#ifdef KdPrint()
#undef KdPrint()
#define KdPrint(x)
#endif
#endif
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// INCLUDES
//
#define PCI_MAX_BUSES 4 // buses to search for pciada
#define PCIVME_MAX_PCIADA 4 // maximum of PCIADA to search for
#define PCIVME_MAX_VMEMM 16 // maximum number of VMEMMs
//-------------------------------------------------------------------------
// DEFINES
//
#define PCIVME_VENDOR_ID 0x10B5
#define PCIVME_DEVICE_ID 0x9050
#define PCIVME_SUBSYS_ID 0x1167
#define PCIVME_SUBVEN_ID 0x9050
#define LCR_SPACE 256 // space in bytes of LCR
#define IFR_SPACE 8192 // space in bytes of IFR
//-------------------------------------------------------------------------
// TYPEDEFS
//
typedef struct _FILE_OBJ
{
USHORT uwAssociatedVMEMM; // which VMEMM it belongs
UCHAR bAddressModifier; // this is the current modifier
UCHAR bAccessType; // this is the current access type (1,2,4)
UCHAR bIncrement; // set 0 if no increment of address
ULONG dwAddressMask; // mask for aligned transfers
ULONG dwAccessBase;
void (*fRead)(void *to, ULONG length, void *from); // resulting read
void (*fWrite)(void *to, ULONG length, void *from); // resulting write
BOOLEAN bQueueIrq; // queue interrupt vectors belonging to this
PVOID pIrqListHandle; // pointer to the irq FIFO
BOOLEAN bBusError; // marks current access as responsible
} FILE_OBJ, *PFILE_OBJ;
typedef struct
{
int Bus; // bus number of pciada
PCI_SLOT_NUMBER Slot; // slot + function number encoded
PCI_COMMON_CONFIG PCIDevice; // content of pcr
PHYSICAL_ADDRESS pvPhysLcr; // local config register
PHYSICAL_ADDRESS pvPhysIfr; // interface registers
PVOID pvVirtLcr; // virtual LCR space
PVOID pvVirtIfr; // virtual IFR space
KIRQL Irql; // virtual Irq level
ULONG Vector; // mapped system vector
KAFFINITY Affinity; // which processor uses this irq
PKINTERRUPT InterruptObject; // points to the associated irq obj
PUSHORT pwCntrl; // LCR Cntrl Offset @ LCR + 0x50
PUSHORT pwIntCSR; // LCR IntCSR Offset @ LCR + 0x4C
ULONG dwLinkCount; // how often this interface is requested
BOOLEAN bConnected; // VMEMM is connected and powered
BOOLEAN bWordMode; // WordMode Jumper set
BOOLEAN bSysControl; // SystemController enabled
USHORT wModuleNumber; // Number (Jumper) of VMEMM
USHORT wFPGAVersion; // Revision of (VMEMM) FPGA
USHORT wModuleType; // Type of (VMEMM) module
PUSHORT pwCSR; // pointer to csr register
PUSHORT pwIRQStat; // pointer to irq status
PUCHAR pbVector; // pointer to vector read register
PULONG pdwVMEAdr; // pointer to VME adress register
PUCHAR pbModifier; // pointer to address modifier register
PVOID pvVME; // pointer into VME window
ULONG dwVMEPage; // current page to VME
UCHAR bModifier; // current Modifier
KSPIN_LOCK AccessLock; // a lock for Access to VMEMM registers
KSPIN_LOCK IrqListLock; // a lock to guard access to List
LIST_ENTRY IrqListList; // start of list of IRQ FIFOs
KDPC kDPCobj; // custom DPC object for irq tunneling
PBOOLEAN pbBusError; // points to the responsible party
int nInterruptHandlers; // counts the controlling interrupt handlers
} PCIADA;
typedef struct _DEVICE_EXT
{
PDEVICE_OBJECT DeviceObject; // points to myself
PDRIVER_OBJECT driverObj; // points to my driver */
PIRP actualIrp; // points to ..
KSPIN_LOCK IRPLock; // a lock to guard access to List
LIST_ENTRY IRPList; // List of queued IRPs
int nPCIADAs; // how many PCIADAs are found
PCIADA pciada[PCIVME_MAX_PCIADA]; // for each PCIADA a descriptor
PCIADA *vmemm[PCIVME_MAX_VMEMM]; // points to PCIADA to which it belongs
int nInitState; // tracks the state of initialisation
} DEVICE_EXT;
typedef struct
{
LIST_ENTRY entry; // doubly linked list
PFILE_OBJ pFile_obj; // the owner
PVOID pIrqListHandle; // the irq FIFO of this owner
} FIFO_LIST;
// Prototypes to support following pragmas
NTSTATUS DriverEntry(PDRIVER_OBJECT driverObj, PUNICODE_STRING regPath);
NTSTATUS PCIVMEOpen(PDEVICE_OBJECT deviceObj, PIRP irp);
NTSTATUS PCIVMEClose(PDEVICE_OBJECT deviceObj, PIRP irp);
VOID PCIVMEUnload(PDRIVER_OBJECT driverObj);
NTSTATUS SearchDevices(PDEVICE_OBJECT device_Obj);
NTSTATUS PLX9050BugFix(PDEVICE_OBJECT device_Obj);
NTSTATUS PCIVMEExtractResources(PCIADA *pciada, PCM_RESOURCE_LIST pList);
NTSTATUS PCIVMEReserveResources(PDEVICE_OBJECT device_Obj);
NTSTATUS PCIVMEFreeResources(PDEVICE_OBJECT device_Obj);
NTSTATUS PCIVMETranslateBusAddresses(PDEVICE_OBJECT device_Obj);
NTSTATUS PCIVMETranslateInterrupt(PDEVICE_OBJECT device_Obj);
NTSTATUS PCIVMEMapIOspace(PDEVICE_OBJECT device_object);
VOID PCIVMESoftInit(PDEVICE_OBJECT device_Obj);
PBOOLEAN ExchangePointer(PBOOLEAN *current, PBOOLEAN next);
/* release all this procedures after init of the driver */
#if 0 // WIN2000 change versus WINNT?
#ifdef ALLOC_PRAGMA
#pragma alloc_text (init, DriverEntry)
#pragma alloc_text (init, SearchDevices)
#pragma alloc_text (init, PLX9050BugFix)
#pragma alloc_text (init, PCIVMEExtractResources)
#pragma alloc_text (init, PCIVMEReserveResources)
#pragma alloc_text (init, PCIVMETranslateBusAddresses)
#pragma alloc_text (init, PCIVMETranslateInterrupt)
#pragma alloc_text (init, PCIVMEMapIOspace)
#pragma alloc_text (init, PCIVMESoftInit)
#endif
/* put all this procedures in the paged memory-pool, all called at passiv Level */
#ifdef ALLOC_PRAGMA
#pragma alloc_text (page, PCIVMEOpen)
#pragma alloc_text (page, PCIVMEClose)
#pragma alloc_text (page, PCIVMEUnload)
#pragma alloc_text (page, PCIVMEFreeResources)
#endif
#endif // WIN2000 change versus WINNT?
#endif // __PCIVME_DRV_H__

/wiener_pcivme/pcivme/SOURCE/pcivme_v.c
0,0 → 1,203
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// all around recognition and basic services of VMEMM
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_v.c,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:51 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 02.07.1999
// first release 1.0 AR 17.10.1999
// changed resource allocation caused by WIN2000 AR 08.06.2002
//
//-------------------------------------------------------------------------
// INCLUDES
//
#include <ntddk.h>
#include <pcivme_drv.h>
#include <pcivme_v.h>
#include <pciif.h> // all around the pci interface
#ifndef WORD // don't touch include files of WIN95 driver
#define WORD USHORT
#endif
#ifndef DWORD
#define DWORD ULONG
#endif
//------------------------------------------------------------------------
// PROTOTYPES
//
//------------------------------------------------------------------------
// GLOBALS
//
//------------------------------------------------------------------------
// FUNCTIONS
//
//------------------------------------------------------------------------
// test connection to VMEMM devices without disturbing anything
//
NTSTATUS TestConnection(PCIADA *pciada)
{
USHORT *pwADRH = (USHORT *)((ULONG)(pciada->pvVirtIfr) + (ULONG)ADRH);
USHORT *pwADRL = (USHORT *)((ULONG)(pciada->pvVirtIfr) + (ULONG)ADRL);
int i;
USHORT wRet;
USHORT wADRHContent;
USHORT wADRLContent;
KdPrint(("TestConnection()\n"));
wADRHContent = READ_REGISTER_USHORT(pwADRH); // save previous content
wADRLContent = READ_REGISTER_USHORT(pwADRL);
for (i = 0; i < 10000; i++)
{
WRITE_REGISTER_USHORT(pwADRH, 0x5555);
WRITE_REGISTER_USHORT(pwADRL, 0xAAAA);
wRet = READ_REGISTER_USHORT(pwADRH);
if (wRet != 0x5555) return STATUS_UNSUCCESSFUL;
WRITE_REGISTER_USHORT(pwADRH, 0xAAAA);
WRITE_REGISTER_USHORT(pwADRL, 0x5555);
wRet = READ_REGISTER_USHORT(pwADRH);
if (wRet != 0xAAAA) return STATUS_UNSUCCESSFUL;
WRITE_REGISTER_USHORT(pwADRH, 0x0000);
WRITE_REGISTER_USHORT(pwADRL, 0xFFFF);
wRet = READ_REGISTER_USHORT(pwADRH);
if (wRet != 0x0000) return STATUS_UNSUCCESSFUL;
WRITE_REGISTER_USHORT(pwADRH, 0xFFFF);
WRITE_REGISTER_USHORT(pwADRL, 0x0000);
wRet = READ_REGISTER_USHORT(pwADRH);
if (wRet != 0xFFFF) return STATUS_UNSUCCESSFUL;
}
WRITE_REGISTER_USHORT(pwADRH, wADRHContent); // restore previous content
WRITE_REGISTER_USHORT(pwADRL, wADRLContent);
KdPrint(("TestConnection() OK.\n"));
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// scan VMEMM devices without disturbing anything
//
NTSTATUS PCIVMEScanVMEMM(PDEVICE_OBJECT deviceObj)
{
int i;
int nPCIADAs = ((DEVICE_EXT*)(deviceObj->DeviceExtension))->nPCIADAs;
PCIADA *pciada;
USHORT wCntrl;
USHORT wIntCSR;
USHORT wVMEMMStatus;
KdPrint(("PCIVMEScanVMEMM()\n"));
for (i = 0; i < nPCIADAs; i++)
{
pciada = &((DEVICE_EXT*)(deviceObj->DeviceExtension))->pciada[i];
wCntrl = READ_REGISTER_USHORT(pciada->pwCntrl); // save it for later use
wIntCSR = READ_REGISTER_USHORT(pciada->pwIntCSR);
WRITE_REGISTER_USHORT(pciada->pwIntCSR, DISABLE_PCIADA_IRQS);
WRITE_REGISTER_USHORT(pciada->pwCntrl, RELEASE_VMEMM); // open it for test
if (wCntrl & 0x0800)
{
if (TestConnection(pciada) == STATUS_SUCCESS)
{
wVMEMMStatus = READ_REGISTER_USHORT(pciada->pvVirtIfr);
pciada->bConnected = TRUE;
// interpret the content
pciada->bWordMode = (wVMEMMStatus & FLAG_WORD) ? TRUE : FALSE;
pciada->bSysControl = (wVMEMMStatus & FLAG_SYSCTL) ? TRUE : FALSE;
pciada->wModuleNumber = (wVMEMMStatus & MASK_MODNR) >> 4;
pciada->wFPGAVersion = (wVMEMMStatus & MASK_FPGA) >> 8;
pciada->wModuleType = (wVMEMMStatus & MASK_MODTYPE) >> 12;
// calculate some heavy used addresses
pciada->pwCSR = (PUSHORT)((ULONG)(pciada->pvVirtIfr) + CSR);
pciada->pbModifier = (PUCHAR) ((ULONG)(pciada->pvVirtIfr) + VICBASE + AMSR);
pciada->pdwVMEAdr = (PULONG) ((ULONG)(pciada->pvVirtIfr) + ADRHL);
pciada->pwIRQStat = (PUSHORT)((ULONG)(pciada->pvVirtIfr) + VICRES);
pciada->pbVector = (PUCHAR) ((ULONG)(pciada->pvVirtIfr) + VECBASE);
pciada->pvVME = (PVOID) ((ULONG)(pciada->pvVirtIfr) + VMEBASE);
KdPrint(("PCIADA %d <-> VMEMM %d\n", i, pciada->wModuleNumber));
}
else
pciada->wModuleNumber = 0xFFFF; // not recognized, take it out
}
else
pciada->wModuleNumber = 0xFFFF; // not recognized, take it out
if (pciada->wModuleNumber != 0xFFFF)
WRITE_REGISTER_USHORT(pciada->pwCntrl, wCntrl); // restore state
else
WRITE_REGISTER_USHORT(pciada->pwCntrl, INHIBIT_VMEMM);
WRITE_REGISTER_USHORT(pciada->pwIntCSR, wIntCSR); // restore interrupt masks
}
return STATUS_SUCCESS;
}
//------------------------------------------------------------------------
// deinit all PCIADAs in a passive state
//
NTSTATUS PCIVMEDeInitPCIADAs(PDEVICE_OBJECT deviceObj)
{
int i;
DEVICE_EXT *pDevExt = (DEVICE_EXT*)deviceObj->DeviceExtension;
int nPCIADAs = pDevExt->nPCIADAs;
PCIADA *pciada;
KdPrint(("PCIVMEDeInitPCIADAs()\n"));
// dis connect the interrupts to service routines
for (i = 0; i < nPCIADAs; i++)
{
pciada = &pDevExt->pciada[i];
WRITE_REGISTER_USHORT(pciada->pwIntCSR, DISABLE_PCIADA_IRQS);
WRITE_REGISTER_USHORT(pciada->pwCntrl, INHIBIT_VMEMM);
}
return STATUS_SUCCESS;
}

/wiener_pcivme/pcivme/SOURCE/pcivme_io.c
0,0 → 1,1461
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// the ioctl functions
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_io.c,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:51 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.6 2002/10/27 18:30:57 klaus
// simpel typing correction
//
// Revision 1.5 2002/10/27 18:29:56 klaus
// honor backward compatibilty with non-extended modifier addressing
//
// Revision 1.4 2002/10/27 17:02:30 klaus
// File addressing bug > 2 Gbtye circumvent
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 03.07.1999
// first release 1.0 AR 17.10.1999
// changed resource allocation caused by WIN2000 AR 08.06.2002
//
//-------------------------------------------------------------------------
// INCLUDES
//
#include <ntddk.h>
#include <devioctl.h>
#include <pcivme_drv.h>
#include <pcivme.h>
#include <pcivme_v.h>
#include <pcivme_io.h>
#include <pciif.h>
#include <pcivme_i.h>
#include <pcivme_fifo.h>
//------------------------------------------------------------------------
// DEFINES
//
// buffers usage must match the corresponding ioctl code!
#define SET_BUFFERS_METHOD_OUT_DIRECT \
{\
InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
pInputBuffer = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
pOutputBuffer = ((void *)(MmGetSystemAddressForMdl(Irp->MdlAddress)));\
}
#define SET_BUFFERS_METHOD_IN_DIRECT \
{\
InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
pInputBuffer = ((void *)(MmGetSystemAddressForMdl(Irp->MdlAddress)));\
pOutputBuffer = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
}
#define SET_BUFFERS_METHOD_BUFFERED \
{\
InputLength = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
OutputLength = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
pInputBuffer = pOutputBuffer = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
}
#define COMPLETE_REQUEST \
{\
if (Status != STATUS_PENDING)\
{\
Irp->IoStatus.Status = Status; \
Irp->IoStatus.Information = irp_info; \
IoCompleteRequest(Irp,IO_NO_INCREMENT); \
}\
}
// compatibilty issues to WIN95 driver calls
#ifndef WORD
#define WORD USHORT
#endif
#ifndef DWORD
#define DWORD ULONG
#endif
#ifndef BYTE
#define BYTE UCHAR
#endif
#ifndef BOOL
#define BOOL BOOLEAN
#endif
#define MODIFIER_MASK 0x3F // mask for address modifier
//-------------------------------------------------------------------------
// GLOBALS
//
const PCIVME_INIT_ELEMENT init_element[] =
{{LCR, WORD_ACCESS, 0x4c, DISABLE_PCIADA_IRQS}, // disable interrupts
{LCR, WORD_ACCESS, 0x50, RELEASE_VMEMM}, // enable interface
{VIC, BYTE_ACCESS, (WORD)0x03, 0xf8+1}, // VIICR
{VIC, BYTE_ACCESS, (WORD)0x07, 0x78+1}, // VICR1
{VIC, BYTE_ACCESS, (WORD)0x0b, 0x78+2},
{VIC, BYTE_ACCESS, (WORD)0x0f, 0x78+3},
{VIC, BYTE_ACCESS, (WORD)0x13, 0x78+4},
{VIC, BYTE_ACCESS, (WORD)0x17, 0x78+5},
{VIC, BYTE_ACCESS, (WORD)0x1b, 0x78+6},
{VIC, BYTE_ACCESS, (WORD)0x1f, 0x78+7}, // VICR7
{VIC, BYTE_ACCESS, (WORD)0x23, 0xf8+0}, // DSICR
{VIC, BYTE_ACCESS, (WORD)0x27, 0xf8+1}, // LICR1
{VIC, BYTE_ACCESS, (WORD)0x2b, 0xf8+2},
{VIC, BYTE_ACCESS, (WORD)0x2f, 0xf8+3},
{VIC, BYTE_ACCESS, (WORD)0x33, 0xf8+4},
{VIC, BYTE_ACCESS, (WORD)0x37, 0xf8+5},
{VIC, BYTE_ACCESS, (WORD)0x3b, 0x38+6},
{VIC, BYTE_ACCESS, (WORD)0x3f, 0x38+7}, // LICR7
{VIC, BYTE_ACCESS, (WORD)0x43, 0xf8+2}, // ICGS
{VIC, BYTE_ACCESS, (WORD)0x47, 0xf8+3}, // ICMS
{VIC, BYTE_ACCESS, (WORD)0x4b, 0xf8+6}, // EGICR
{VIC, BYTE_ACCESS, (WORD)0x4f, 0x08}, // ICGS-IVBR (!)
{VIC, BYTE_ACCESS, (WORD)0x53, 0x0c}, // ICMS-IVBR (!)
{VIC, BYTE_ACCESS, (WORD)0x57, 0x00}, // LIVBR (!)
{VIC, BYTE_ACCESS, (WORD)0x5b, 0x10}, // EGIVBR (!)
{VIC, BYTE_ACCESS, (WORD)0x5f, 0x00}, // ICSR
{VIC, BYTE_ACCESS, (WORD)0x63, 0x00}, // ICR0
{VIC, BYTE_ACCESS, (WORD)0x67, 0x00},
{VIC, BYTE_ACCESS, (WORD)0x6b, 0x00},
{VIC, BYTE_ACCESS, (WORD)0x6f, 0x00},
{VIC, BYTE_ACCESS, (WORD)0x73, 0x00}, // ICR4
{VIC, BYTE_ACCESS, (WORD)0x83, 0xfe}, // VIRSR
{VIC, BYTE_ACCESS, (WORD)0x87, 0x0f}, // VIVR1
{VIC, BYTE_ACCESS, (WORD)0x8b, 0x0f},
{VIC, BYTE_ACCESS, (WORD)0x8f, 0x0f},
{VIC, BYTE_ACCESS, (WORD)0x93, 0x0f},
{VIC, BYTE_ACCESS, (WORD)0x97, 0x0f},
{VIC, BYTE_ACCESS, (WORD)0x9b, 0x0f},
{VIC, BYTE_ACCESS, (WORD)0x9f, 0x0f}, // VIVR7
{VIC, BYTE_ACCESS, (WORD)0xa3, 0x3c}, // TTR
{VIC, BYTE_ACCESS, (WORD)0xb3, 0x40}, // ARCR
{VIC, BYTE_ACCESS, (WORD)0xb7, 0x29}, // AMSR
{VIC, BYTE_ACCESS, (WORD)0xd3, 0x00}, // RCR
{IFR, LONG_ACCESS, (WORD)ADRHL, 0xF0F0F0F0}, // ADR-H, ADR-L
{IFR, WORD_ACCESS, (WORD)CSR , 0x0000}, // Contr-Reg
{VIC, BYTE_ACCESS, (WORD)0x7f, 0x80}, // ICR7
{LCR, WORD_ACCESS, 0x4c, DISABLE_PCIADA_IRQS},// disable interrupts
{STOP, WORD_ACCESS, 0, 0}};
const PCIVME_INIT_ELEMENT deinit_element_pre[] =
{{VIC, BYTE_ACCESS, (WORD)0x7f, 0x00}, // ICR7 - sysfail
{LCR, WORD_ACCESS, 0x4c, DISABLE_PCIADA_IRQS},// disable interrupts
{STOP, WORD_ACCESS, 0, 0}};
const PCIVME_INIT_ELEMENT deinit_element_post[] =
{{LCR, WORD_ACCESS, 0x50, INHIBIT_VMEMM}, // disable interface
{STOP, WORD_ACCESS, 0, 0}};
//--------------------------------------------------------------------------
// LOCAL FUNCTIONS
//
//--------------------------------------------------------------------------
// fast read or write functions - portable -
static void readByte(void *to, ULONG dwLength, void *from)
{
READ_REGISTER_BUFFER_UCHAR((PUCHAR)from, (PUCHAR)to, dwLength);
}
static void readWord(void *to, ULONG dwLength, void *from)
{
dwLength >>= 1;
READ_REGISTER_BUFFER_USHORT((PUSHORT)from, (PUSHORT)to, dwLength);
}
static void readLong(void *to, ULONG dwLength, void *from)
{
dwLength >>= 2;
READ_REGISTER_BUFFER_ULONG((PULONG)from, (PULONG)to, dwLength);
}
static void writeByte(void *to, ULONG dwLength, void *from)
{
WRITE_REGISTER_BUFFER_UCHAR((PUCHAR)to, (PUCHAR)from, dwLength);
}
static void writeWord(void *to, ULONG dwLength, void *from)
{
dwLength >>= 1;
WRITE_REGISTER_BUFFER_USHORT((PUSHORT)to, (PUSHORT)from, dwLength);
}
static void writeLong(void *to, ULONG dwLength, void *from)
{
dwLength >>= 2;
WRITE_REGISTER_BUFFER_ULONG((PULONG)to, (PULONG)from, dwLength);
}
//------------------------------------------------------------------------
// insert the irq queue into the linked list of queues
static NTSTATUS insertQueueInList(PFILE_OBJ pFile_obj, PCIADA *pciada)
{
NTSTATUS Status = STATUS_SUCCESS;
FIFO_LIST *next;
KIRQL OldIrql;
KdPrint(("insertQueueInList()\n"));
if (pFile_obj->bQueueIrq) // still enabled and in list
return Status;
// allocate memory to hold the list and its container
next = (FIFO_LIST *)ExAllocatePool(NonPagedPool, sizeof(FIFO_LIST));
if(next == (FIFO_LIST *)NULL)
return STATUS_INSUFFICIENT_RESOURCES;
else
{
// fill contents in entry
next->pFile_obj = pFile_obj;
next->pIrqListHandle = pFile_obj->pIrqListHandle;
// insert the entry in the list
KeAcquireSpinLock(&pciada->IrqListLock, &OldIrql);
KdPrint(("InsertHeadList(0x%08x, 0x%08x)\n", &pciada->IrqListList, &next->entry));
InsertHeadList(&pciada->IrqListList, &next->entry);
KeReleaseSpinLock(&pciada->IrqListLock, OldIrql);
// show and mark it
pFile_obj->bQueueIrq = TRUE;
}
return Status;
}
//------------------------------------------------------------------------
// remove the irq queue from the linked list of queues
NTSTATUS removeQueueFromList(PFILE_OBJ pFile_obj, PCIADA *pciada)
{
NTSTATUS Status = STATUS_SUCCESS;
FIFO_LIST *next;
PLIST_ENTRY pList;
KIRQL OldIrql;
KdPrint(("removeQueueFromList(0x%08x, 0x%08x)\n", pFile_obj, pciada));
pList = &pciada->IrqListList;
if ((pFile_obj == (FILE_OBJ *)NULL) || (pciada == (PCIADA *)NULL)) return Status;
// search for coincidence of pFile_obj in the list
KeAcquireSpinLock(&pciada->IrqListLock, &OldIrql);
while (pList->Flink != &pciada->IrqListList)
{
pList = pList->Flink;
next = CONTAINING_RECORD(pList, FIFO_LIST, entry);
if (next->pFile_obj == pFile_obj) // found
{
KdPrint(("RemoveEntryList(0%08x)\n", pList));
RemoveEntryList(pList);
ExFreePool((PVOID)next);
break;
}
}
KeReleaseSpinLock(&pciada->IrqListLock, OldIrql);
// in every case switch it off (again)
pFile_obj->bQueueIrq = FALSE;
KdPrint(("removeQueueFromList OK\n"));
return Status;
}
//--------------------------------------------------------------------------
// parsing of user supplied input for validy
static BOOLEAN check_command(const PCIVME_INIT_ELEMENT *psInitElement)
{
USHORT range;
USHORT access_size;
switch (psInitElement->range)
{
case LCR: range = 0x54; break;
case IFR: range = 0x0c; break;
case VIC: range = 0xe4;
if ((psInitElement->offset & 3) != 3)
return FALSE;
break;
default: range = 0; break;
}
switch (psInitElement->type)
{
case LONG_ACCESS: if (psInitElement->offset & 3)
return FALSE;
access_size = sizeof(ULONG);
break;
case WORD_ACCESS: if (psInitElement->offset & 1)
return FALSE;
access_size = sizeof( USHORT);
break;
case BYTE_ACCESS: access_size = sizeof( UCHAR); break;
default : access_size = 0xFFFF; break;
}
if ((psInitElement->offset + access_size) > range)
return FALSE; // ignore it
return TRUE;
}
//------------------------------------------------------------------------
// iterate through all commands
static VOID CmdMachine(const PCIVME_INIT_ELEMENT *psInitElement,
PVOID pvLcr, PVOID pvIfr)
{
PVOID adr;
// standard initialisierungen
while (psInitElement->range != STOP)
{
/*
KdPrint(("CmdMachine: %d %d 0x%02x 0x%02x\n",
psInitElement->range, psInitElement->type,
psInitElement->offset, psInitElement->value));
*/
if (check_command(psInitElement))
{
switch (psInitElement->range)
{
case LCR: adr = pvLcr; break;
case VIC: adr = (PVOID)((ULONG)pvIfr + (USHORT)VICBASE); break;
case IFR:
default: adr = pvIfr; break;
}
switch (psInitElement->type)
{
case LONG_ACCESS:
WRITE_REGISTER_ULONG((ULONG *)((UCHAR *)adr + psInitElement->offset),
psInitElement->value);
break;
case WORD_ACCESS:
WRITE_REGISTER_USHORT((USHORT *)((UCHAR *)adr + psInitElement->offset),
(USHORT)psInitElement->value);
break;
case BYTE_ACCESS:
default:
WRITE_REGISTER_UCHAR((UCHAR *)((UCHAR *)adr + psInitElement->offset),
(UCHAR)psInitElement->value);
break;
}
}
psInitElement++;
}
}
//------------------------------------------------------------------------
// init the interface with build in and user supplied constants
static BOOLEAN InitInterface(const PCIVME_INIT_COMMAND *psInitCmd,
PVOID pvLcr, PVOID pvIfr)
{
PCIVME_INIT_ELEMENT *psVie;
if ((psInitCmd == (PCIVME_INIT_COMMAND *)BOGUSADDRESS) ||
(psInitCmd == (PCIVME_INIT_COMMAND *)NULL) ||
(pvLcr == (PVOID)BOGUSADDRESS) ||
(pvLcr == (PVOID)NULL) ||
(pvIfr == (PVOID)BOGUSADDRESS) ||
(pvIfr == (PVOID)NULL))
return FALSE;
psVie = (PCIVME_INIT_ELEMENT *)psInitCmd->sVie;
CmdMachine(init_element , pvLcr, pvIfr); // standard initialisierungen
CmdMachine(psVie, pvLcr, pvIfr); // benutzer initialisierungen
return TRUE;
}
// deinit the interface with user supplied and build in constants
static BOOLEAN DeInitInterface(const PCIVME_INIT_COMMAND *psDeInitCmd,
PVOID pvLcr, PVOID pvIfr)
{
PCIVME_INIT_ELEMENT *psVie;
if ((psDeInitCmd == (PCIVME_INIT_COMMAND *)BOGUSADDRESS) ||
(psDeInitCmd == (PCIVME_INIT_COMMAND *)NULL) ||
(pvLcr == (PVOID)BOGUSADDRESS) ||
(pvLcr == (PVOID)NULL) ||
(pvIfr == (PVOID)BOGUSADDRESS) ||
(pvIfr == (PVOID)NULL))
return FALSE;
psVie = (PCIVME_INIT_ELEMENT *)psDeInitCmd->sVie;
CmdMachine(deinit_element_pre, pvLcr, pvIfr); // standard de-initialisierungen
CmdMachine(psVie, pvLcr, pvIfr); // benutzer de-initialisierungen
CmdMachine(deinit_element_post , pvLcr, pvIfr); // disable interface
return TRUE;
}
//------------------------------------------------------------------------
// a inserter into a user managed queue of IRPs
//
void InsertIRPtoQueue(PDEVICE_OBJECT device_Obj, PIRP Irp)
{
DEVICE_EXT *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
KIRQL oldIrql;
KdPrint(("InsertIRPtoQueue(0x%08x)\n", Irp));
KeAcquireSpinLock(&pDevExt->IRPLock, &oldIrql);
InsertHeadList(&pDevExt->IRPList, &Irp->Tail.Overlay.ListEntry);
KeReleaseSpinLock(&pDevExt->IRPLock, oldIrql);
}
//------------------------------------------------------------------------
// a remover out of a user managed queue of IRPs
//
PIRP RemoveIRPfromQueue(PDEVICE_OBJECT device_Obj, FILE_OBJ *pFile_obj)
{
DEVICE_EXT *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
KIRQL oldIrql;
register PLIST_ENTRY pList = &pDevExt->IRPList;
PIRP Irp;
PIRP pIrp = (PIRP)NULL;
FILE_OBJ *file_obj;
KdPrint(("RemoveIRPfromQueue()\n"));
KeAcquireSpinLock(&pDevExt->IRPLock, &oldIrql);
while (pList->Flink != &pDevExt->IRPList) // until the end is reached
{
pList = pList->Flink;
Irp = CONTAINING_RECORD(pList, IRP, Tail.Overlay.ListEntry);
file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
KdPrint(("pList 0x%08x, pList->Flink 0x%08x, Irp 0x%08x, file_obj 0x%08x\n", pList, pList->Flink, Irp, file_obj));
if ((file_obj == pFile_obj) && (pFile_obj != (FILE_OBJ *)NULL))
{
RemoveEntryList(pList);
pIrp = Irp;
break;
}
}
KeReleaseSpinLock(&pDevExt->IRPLock, oldIrql);
KdPrint(("return RemoveIRPfromQueue(0x%08x)\n", pIrp));
return pIrp;
}
//------------------------------------------------------------------------
// a remover out of a user managed queue of IRPs
//
PIRP RemoveIRPfromQueueByIrp(PDEVICE_OBJECT device_Obj, PIRP pIrpIn)
{
DEVICE_EXT *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
KIRQL oldIrql;
register PLIST_ENTRY pList = &pDevExt->IRPList;
PIRP Irp;
PIRP pIrp = (PIRP)NULL;
KdPrint(("RemoveIRPfromQueueByIrp()\n"));
KeAcquireSpinLock(&pDevExt->IRPLock, &oldIrql);
while (pList->Flink != &pDevExt->IRPList) // until the end is reached
{
pList = pList->Flink;
Irp = CONTAINING_RECORD(pList, IRP, Tail.Overlay.ListEntry);
KdPrint(("pList 0x%08x, pList->Flink 0x%08x, Irp 0x%08x\n", pList, pList->Flink, Irp));
if (pIrpIn == Irp)
{
RemoveEntryList(pList);
pIrp = Irp;
break;
}
}
KeReleaseSpinLock(&pDevExt->IRPLock, oldIrql);
KdPrint(("return RemoveIRPfromQueueByIrp(0x%08x)\n", pIrp));
return pIrp;
}
//------------------------------------------------------------------------
// the default cancel routine for an queued Irp
//
void CancelRequest(PDEVICE_OBJECT device_Obj, PIRP Irp)
{
PIRP pIrpCancel = RemoveIRPfromQueueByIrp(device_Obj, Irp);
if (pIrpCancel == (PIRP)NULL)
{
IoReleaseCancelSpinLock(Irp->CancelIrql);
KdPrint(("Nothing to do: CancelRequest(0x%08x)\n", Irp));
return;
}
else
{
IoReleaseCancelSpinLock(Irp->CancelIrql);
KdPrint(("Done: CancelRequest(0x%08x)\n", Irp));
Irp->IoStatus.Status = STATUS_CANCELLED;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
}
//------------------------------------------------------------------------
// the custom deffered routine to finish blocking io on read_vector
void fMyDefferedRoutine(PKDPC Dpc, PVOID pvDevice_object,
PVOID pvPciada, PVOID pvVector)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = sizeof(PCIVME_VECTOR_RESPONSE);
PIRP Irp = (PIRP)NULL;
PDEVICE_OBJECT device_Obj = (PDEVICE_OBJECT)pvDevice_object;
PCIADA *pciada = (PCIADA *)pvPciada;
FIFO_LIST *next;
KIRQL oldIrqlCancel;
KIRQL oldIrqlList;
register PLIST_ENTRY pList = &pciada->IrqListList;
UNREFERENCED_PARAMETER(pvVector);
UNREFERENCED_PARAMETER(Dpc);
KdPrint(("fMyDefferedRoutine()\n"));
// beware off damage due to intercept with cancel of thread
IoAcquireCancelSpinLock(&oldIrqlCancel);
KeAcquireSpinLock(&pciada->IrqListLock, &oldIrqlList);
while (pList->Flink != &pciada->IrqListList) // until the end is reached
{
pList = pList->Flink;
KeReleaseSpinLock(&pciada->IrqListLock, oldIrqlList); // shorten block
next = CONTAINING_RECORD(pList, FIFO_LIST, entry);
// get my associated packet
Irp = RemoveIRPfromQueue(device_Obj, next->pFile_obj);
if (Irp != (PIRP)NULL)
{
PCIVME_VECTOR_REQUEST *pVectorRequest = (PCIVME_VECTOR_REQUEST *)(Irp->AssociatedIrp.SystemBuffer);
PCIVME_VECTOR_RESPONSE *pVectorResponse = (PCIVME_VECTOR_RESPONSE *)pVectorRequest;
USHORT wRequestCount = pVectorRequest->wRequestCount;
UCHAR *pbVector = &pVectorResponse->bStatusID;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
UCHAR bNumberOfElements = (UCHAR) NumberOfElements(file_obj->pIrqListHandle);
// pull the vectors off the fifo
pVectorResponse->wCount = 0;
while ((bNumberOfElements) && (wRequestCount--))
{
bNumberOfElements = (UCHAR) PullElement(file_obj->pIrqListHandle,
(void *)pbVector);
pbVector++;
pVectorResponse->wCount++;
}
pVectorResponse->wPendingCount = bNumberOfElements;
pVectorResponse->bOverflow = CheckAndClearOverflow(file_obj->pIrqListHandle);
irp_info = sizeof(PCIVME_VECTOR_RESPONSE) +
sizeof(UCHAR) * (pVectorResponse->wCount - 1);
// release the cancel routine from this Irp
IoSetCancelRoutine(Irp, NULL);
COMPLETE_REQUEST;
}
KeAcquireSpinLock(&pciada->IrqListLock, &oldIrqlList);
}
// release the spin locks
KeReleaseSpinLock(&pciada->IrqListLock, oldIrqlList);
IoReleaseCancelSpinLock(oldIrqlCancel);
}
//------------------------------------------------------------------------
// all functions called from ioctl jump table
//
//------------------------------------------------------------------------
// initialize all hardware associated to a given wModuleNumber
static NTSTATUS ioctl_init_hardware(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = 0;
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
DEVICE_EXT *pDevExt;
PCIVME_INIT_COMMAND *pInitCommand;
PCIADA *pciada;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
SET_BUFFERS_METHOD_BUFFERED;
// do what must be here in between --- start ---
pInitCommand = (PCIVME_INIT_COMMAND *)pInputBuffer;
KdPrint(("ioctl_init_hardware(%d)\n", file_obj->uwAssociatedVMEMM));
pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
if (pciada != NULL)
{
KIRQL oldIrql;
if (pciada->dwLinkCount == 1)
{
// lock other users out
KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);
if (InitInterface(pInitCommand, pciada->pvVirtLcr, pciada->pvVirtIfr))
{
// fill cache for page and modifier
pciada->dwVMEPage = READ_REGISTER_ULONG(pciada->pdwVMEAdr) & ~VME_ADR_MASK;
pciada->bModifier = READ_REGISTER_UCHAR(pciada->pbModifier) & MODIFIER_MASK;
}
else
Status = STATUS_UNSUCCESSFUL;
// release the lock
KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
}
else
Status = STATUS_UNSUCCESSFUL;
}
else
Status = STATUS_UNSUCCESSFUL;
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_init_hardware(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// De-initialise all hardware associated to a given wModuleNumber
static NTSTATUS ioctl_deinit_hardware(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = 0;
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
DEVICE_EXT *pDevExt;
PCIVME_INIT_COMMAND *pInitCommand;
PCIADA *pciada;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
KdPrint(("ioctl_deinit_hardware()\n"));
pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
SET_BUFFERS_METHOD_BUFFERED;
// do what must be hier in between --- start ---
pInitCommand = (PCIVME_INIT_COMMAND *)pInputBuffer;
KdPrint(("ioctl_deinit_hardware(%d)\n", file_obj->uwAssociatedVMEMM));
pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
if (pciada != NULL)
{
KIRQL oldIrql;
if (pciada->dwLinkCount == 1)
{
// lock other users out
KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);
if (DeInitInterface(pInitCommand, pciada->pvVirtLcr, pciada->pvVirtIfr))
globalInterruptDisable(pciada);
else
Status = STATUS_UNSUCCESSFUL;
// everyone likes to have PCIVME
KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
}
else
Status = STATUS_UNSUCCESSFUL;
}
else
Status = STATUS_UNSUCCESSFUL;
// do what must be hier in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_deinit_hardware(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// a dummy entry because of compatibiltiy (near) WIN95 driver
static NTSTATUS ioctl_dummy(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = 0;
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
PCIVME_INIT_COMMAND *pInitCommand;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
SET_BUFFERS_METHOD_BUFFERED;
UNREFERENCED_PARAMETER(device_Obj);
#ifndef _DEBUG
UNREFERENCED_PARAMETER(file_obj);
#endif
pInitCommand = (PCIVME_INIT_COMMAND *)pInputBuffer;
KdPrint(("ioctl_dummy(%d)\n", file_obj->uwAssociatedVMEMM));
// do what must be here in between -----------
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_dummy(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// requests fixed unchangeable information - not compatible to WIN95 driver
static NTSTATUS ioctl_get_static_status(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = sizeof(PCIVME_STATIC_STATUS);
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
PCIADA *pciada;
DEVICE_EXT *pDevExt;
PCIVME_STATIC_STATUS *pStaticStatus;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_get_static_status(%d)\n", file_obj->uwAssociatedVMEMM));
// do what must be here in between -----------
if (OutputLength >= sizeof(PCIVME_STATIC_STATUS))
{
pStaticStatus = (PCIVME_STATIC_STATUS *)pOutputBuffer;
pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
pStaticStatus->dwInterface = file_obj->uwAssociatedVMEMM;
pStaticStatus->wNumMemWindows = 3;
pStaticStatus->wNumIOPorts = 2;
pStaticStatus->wNumIRQs = 1;
pStaticStatus->wNumDMAs = 0;
pStaticStatus->dwLinkCount = pciada->dwLinkCount;
pStaticStatus->wModuleType = pciada->wModuleType;
pStaticStatus->wFPGAVersion = pciada->wFPGAVersion;
pStaticStatus->wModuleNumber = pciada->wModuleNumber;
pStaticStatus->wWordMode = pciada->bWordMode;
pStaticStatus->wSysControl = pciada->bSysControl;
pStaticStatus->wConnected = pciada->bConnected;
pStaticStatus->pvLcr = pciada->pvPhysLcr;
pStaticStatus->pvIfr = pciada->pvPhysIfr;
pStaticStatus->dwDriverVersion = DRIVER_VERSION;
pStaticStatus->dwDriverVariant = DRIVER_VARIANT;
}
else
Status = STATUS_BUFFER_TOO_SMALL;
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_get_static_status(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// requests changeable status
static NTSTATUS ioctl_get_dynamic_status(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = sizeof(PCIVME_DYNAMIC_STATUS);
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
PCIADA *pciada;
DEVICE_EXT *pDevExt;
PCIVME_DYNAMIC_STATUS *pDynamicStatus;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_get_dynamic_status(%d)\n", file_obj->uwAssociatedVMEMM));
// do what must be here in between -----------
pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_get_static_status(%d)\n", file_obj->uwAssociatedVMEMM));
// do what must be here in between -----------
if (OutputLength >= sizeof(PCIVME_DYNAMIC_STATUS))
{
USHORT temp;
pDynamicStatus = (PCIVME_DYNAMIC_STATUS *)pOutputBuffer;
pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
pDynamicStatus->dwInterface = file_obj->uwAssociatedVMEMM;
temp = READ_REGISTER_USHORT(pciada->pwCntrl);
pDynamicStatus->wVMEMM_enable = ((temp & 0x0180) == 0x0180) ? 1 : 0;
pDynamicStatus->wVMEMM_connected = ((temp & 0x0c00) == 0x0800) ? 1 : 0;
temp = READ_REGISTER_USHORT(pciada->pwIntCSR);
pDynamicStatus->wPCIADAIrq = (temp & 0x0004) ? 1 : 0;
pDynamicStatus->wVMEMMIrq = (temp & 0x0020) ? 1 : 0;
}
else
Status = STATUS_BUFFER_TOO_SMALL;
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_get_dynamic_status(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// get the next vector out of the vector queue
static NTSTATUS ioctl_read_vector(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = sizeof(PCIVME_VECTOR_RESPONSE);
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
PCIVME_VECTOR_RESPONSE *pVectorResponse;
PCIVME_VECTOR_REQUEST *pVectorRequest;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
KIRQL oldIrql;
BOOLEAN bPoll;
USHORT wRequestCount;
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_read_vector(%d)\n", file_obj->uwAssociatedVMEMM));
pVectorRequest = (PCIVME_VECTOR_REQUEST *)pInputBuffer;
pVectorResponse = (PCIVME_VECTOR_RESPONSE *)pOutputBuffer;
// check the available room for vectors and correct if too less
if (OutputLength <
(sizeof(PCIVME_VECTOR_RESPONSE) +
(pVectorRequest->wRequestCount - 1) * sizeof(UCHAR)))
pVectorRequest->wRequestCount =
(USHORT)OutputLength - sizeof(PCIVME_VECTOR_RESPONSE) + sizeof(UCHAR);
// empty the inputbuffer as early as possible
wRequestCount = pVectorRequest->wRequestCount;
bPoll = pVectorRequest->bPoll;
// do what must be here in between -----------
if (OutputLength >= sizeof(PCIVME_VECTOR_RESPONSE)) // at least room for one
{
UCHAR bNumberOfElements;
UCHAR *pbVector = &pVectorResponse->bStatusID;
pVectorResponse->dwInterface = file_obj->uwAssociatedVMEMM;
bNumberOfElements = (UCHAR) NumberOfElements(file_obj->pIrqListHandle);
if ((bNumberOfElements) || (bPoll))
{
KdPrint(("Direct return (%d)\n", bNumberOfElements));
pVectorResponse->wCount = 0;
while ((bNumberOfElements) && (wRequestCount--))
{
bNumberOfElements = (UCHAR) PullElement(file_obj->pIrqListHandle,
(void *)pbVector);
pbVector++;
pVectorResponse->wCount++;
}
pVectorResponse->wPendingCount = bNumberOfElements;
pVectorResponse->bOverflow = CheckAndClearOverflow(file_obj->pIrqListHandle);
irp_info = sizeof(PCIVME_VECTOR_RESPONSE) +
sizeof(UCHAR) * (pVectorResponse->wCount - 1);
}
else // go in wait queue for an irq
{
IoAcquireCancelSpinLock(&oldIrql);
if (Irp->Cancel) // cancel while doing
{
KdPrint(("Canceld return (%d)\n", bNumberOfElements));
Status = STATUS_CANCELLED;
}
else
{
KdPrint(("Blocking return (%d)\n", bNumberOfElements));
InsertIRPtoQueue(device_Obj, Irp);
Status = STATUS_PENDING;
// mark irp as pending and return
IoMarkIrpPending(Irp);
IoSetCancelRoutine(Irp, CancelRequest);
} // if (Irp->Cancel) ...
IoReleaseCancelSpinLock(oldIrql);
}
}
else
Status = STATUS_BUFFER_TOO_SMALL;
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_read_vector(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// control or read the VIC68A on the VMEMM
static NTSTATUS ioctl_access_VIC68A(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = sizeof(PCIVME_VIC68A_ACTION);
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
PCIADA *pciada;
DEVICE_EXT *pDevExt;
PCIVME_VIC68A_ACTION *pVIC68A_action_in;
PCIVME_VIC68A_ACTION *pVIC68A_action_out;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_access_VIC68A(%d)\n", file_obj->uwAssociatedVMEMM));
// do what must be here in between -----------
pVIC68A_action_in = (PCIVME_VIC68A_ACTION *)pInputBuffer;
pVIC68A_action_out = (PCIVME_VIC68A_ACTION *)pOutputBuffer;
if ((pVIC68A_action_in->wRegisterAddress <= (USHORT)SRR) &&
((pVIC68A_action_in->wRegisterAddress & 0x03) == 3) &&
(OutputLength >= sizeof(PCIVME_VIC68A_ACTION)))
{
PUCHAR pbAddress;
UCHAR bByte=0;
KIRQL oldIrql;
pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
pVIC68A_action_out = pVIC68A_action_in; // copy it
pbAddress = (PUCHAR)((ULONG)(pciada->pvVirtIfr) + VICBASE + pVIC68A_action_in->wRegisterAddress);
// lock other users out
KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);
switch(pVIC68A_action_in->wAccessMode)
{
case VIC68A_WRITE: WRITE_REGISTER_UCHAR(pbAddress, pVIC68A_action_in->bContent);
bByte = READ_REGISTER_UCHAR(pbAddress);
break;
case VIC68A_WRITE_ONLY:
WRITE_REGISTER_UCHAR(pbAddress, pVIC68A_action_in->bContent);
break;
case VIC68A_OR: bByte = READ_REGISTER_UCHAR(pbAddress);
bByte |= pVIC68A_action_in->bContent;
WRITE_REGISTER_UCHAR(pbAddress, bByte);
bByte = READ_REGISTER_UCHAR(pbAddress);
break;
case VIC68A_AND: bByte = READ_REGISTER_UCHAR(pbAddress);
bByte &= pVIC68A_action_in->bContent;
WRITE_REGISTER_UCHAR(pbAddress, bByte);
bByte = READ_REGISTER_UCHAR(pbAddress);
break;
default: Status = STATUS_ILLEGAL_INSTRUCTION;
case VIC68A_READ: bByte = READ_REGISTER_UCHAR(pbAddress);
break;
}
// free lock
KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
pVIC68A_action_out->bContent = bByte;
}
else
Status = STATUS_ILLEGAL_INSTRUCTION;
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_access_VIC68A(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// if the interrupt is disabled for a blocking path, cancel the block
static void ReleaseBlockingIrp(PDEVICE_OBJECT device_Obj, PCIADA *pciada, PFILE_OBJ pFile_obj)
{
NTSTATUS Status = STATUS_CANCELLED;
PIRP Irp;
KIRQL oldIrqlCancel;
KIRQL oldIrqlList;
// beware off damage due to intercept with cancel of thread
IoAcquireCancelSpinLock(&oldIrqlCancel);
KeAcquireSpinLock(&pciada->IrqListLock, &oldIrqlList);
// get my associated packet
Irp = RemoveIRPfromQueue(device_Obj, pFile_obj);
if (Irp != (PIRP)NULL)
{
PCIVME_VECTOR_REQUEST *pVectorRequest = (PCIVME_VECTOR_REQUEST *)(Irp->AssociatedIrp.SystemBuffer);
PCIVME_VECTOR_RESPONSE *pVectorResponse = (PCIVME_VECTOR_RESPONSE *)pVectorRequest;
ULONG irp_info = sizeof(PCIVME_VECTOR_RESPONSE);
// pull the vectors off the fifo
pVectorResponse->wCount = 0;
pVectorResponse->wPendingCount = 0;
pVectorResponse->bOverflow = FALSE;
irp_info = sizeof(PCIVME_VECTOR_RESPONSE);
// release the cancel routine from this Irp
IoSetCancelRoutine(Irp, NULL);
COMPLETE_REQUEST;
}
// release the spin locks
KeReleaseSpinLock(&pciada->IrqListLock, oldIrqlList);
IoReleaseCancelSpinLock(oldIrqlCancel);
}
//------------------------------------------------------------------------
// switch the filling of the interrupt vector queue on or off, check the queue
static NTSTATUS ioctl_control_interrupts(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = sizeof(PCIVME_IRQ_CONTROL);
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
PCIADA *pciada;
DEVICE_EXT *pDevExt;
PCIVME_IRQ_CONTROL *pIrqControlIn;
PCIVME_IRQ_CONTROL *pIrqControlOut;
PFILE_OBJ pFile_obj = (PFILE_OBJ)Irp->Tail.Overlay.OriginalFileObject->FsContext;
pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_control_interrupts(%d)\n", pFile_obj->uwAssociatedVMEMM));
pIrqControlIn = (PCIVME_IRQ_CONTROL *)pInputBuffer;
pIrqControlOut = (PCIVME_IRQ_CONTROL *)pOutputBuffer;
pciada = pDevExt->vmemm[pFile_obj->uwAssociatedVMEMM];
// do what must be here in between -----------
if (pIrqControlIn->wEnable)
{
Status = insertQueueInList(pFile_obj, pciada);
if (!pciada->nInterruptHandlers)
{
KdPrint(("Interrupts enabled.\n"));
globalInterruptEnable(pciada);
pciada->nInterruptHandlers++;
}
}
else
{
if (pciada->nInterruptHandlers <= 1)
{
KdPrint(("Interrupts disabled.\n"));
globalInterruptDisable(pciada);
pciada->nInterruptHandlers = 0;
}
Status = removeQueueFromList(pFile_obj, pciada);
ReleaseBlockingIrp(device_Obj, pciada, pFile_obj);
}
// give back if the user grants space
if (OutputLength >= sizeof(PCIVME_IRQ_CONTROL))
{
pIrqControlOut->dwInterface = pFile_obj->uwAssociatedVMEMM;
pIrqControlOut->wEnable = pFile_obj->bQueueIrq;
}
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_control_interrupts(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// generate a uninterruptible read-modify-write cycle
static NTSTATUS ioctl_TAS(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = sizeof(PCIVME_TAS_STRUCT);
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
PCIADA *pciada;
DEVICE_EXT *pDevExt;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
KIRQL oldIrql;
UCHAR tempContent;
PBOOLEAN pbPrevBusError;
PVOID pvPartialAdr;
pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_TAS(%d)\n", file_obj->uwAssociatedVMEMM));
// do what must be here in between -----------
if (OutputLength >= sizeof(PCIVME_TAS_STRUCT))
{
PCIVME_TAS_STRUCT *pTAS_struct_in;
PCIVME_TAS_STRUCT *pTAS_struct_out;
USHORT csr; // storage for old csr content
ULONG pageAddress; // intermediate for the page register content
UCHAR bAddressModifier;
pTAS_struct_in = (PCIVME_TAS_STRUCT *)pInputBuffer;
pTAS_struct_out = (PCIVME_TAS_STRUCT *)pOutputBuffer;
pTAS_struct_out = pTAS_struct_in;
pTAS_struct_out->dwInterface = file_obj->uwAssociatedVMEMM;
pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
// take the file_obj associated modifier if greater than ...
bAddressModifier = (pTAS_struct_in->wModifier > 63) ?
file_obj->bAddressModifier : (UCHAR)pTAS_struct_in->wModifier;
// lock other users out
KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);
// check for modifier (and set if needed)
if (pciada->bModifier != bAddressModifier)
{
WRITE_REGISTER_UCHAR(pciada->pbModifier, bAddressModifier);
pciada->bModifier = bAddressModifier;
}
// check for page address (and set if needed)
pageAddress = pTAS_struct_in->dwAddress & ~VME_ADR_MASK;
if (pageAddress != pciada->dwVMEPage)
{
WRITE_REGISTER_ULONG(pciada->pdwVMEAdr, pageAddress);
pciada->dwVMEPage = pageAddress;
}
// save VMEMM csr register and prepare for read modify write
csr = READ_REGISTER_USHORT(pciada->pwCSR);
WRITE_REGISTER_USHORT(pciada->pwCSR, (USHORT)(csr | FLAG_RMC));
// prepare the TAS
tempContent = pTAS_struct_in->bContent; // in and out point to same buffer
pvPartialAdr = (PVOID)((PUCHAR)pciada->pvVME + (pTAS_struct_in->dwAddress & VME_ADR_MASK));
// get prepared for bus errors
file_obj->bBusError = FALSE;
pbPrevBusError = ExchangePointer(&pciada->pbBusError, &file_obj->bBusError);
// do the TAS
readByte(&pTAS_struct_out->bContent , 1, pvPartialAdr);
writeByte(pvPartialAdr , 1, &tempContent);
readByte(&tempContent , 1, pvPartialAdr); // to overcome write on ..
// restore csr
WRITE_REGISTER_USHORT(pciada->pwCSR, csr);
// release the lock
KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
ExchangePointer(&pciada->pbBusError, pbPrevBusError);
if (file_obj->bBusError) Status = STATUS_ACCESS_VIOLATION;
}
else
Status = STATUS_BUFFER_TOO_SMALL;
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_TAS(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// make a VME reset
static NTSTATUS ioctl_reset(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = sizeof(PCIVME_RESET_RESULT);
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
DEVICE_EXT *pDevExt;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_reset(%d)\n", file_obj->uwAssociatedVMEMM));
// do what must be here in between -----------
if (OutputLength >= sizeof(PCIVME_RESET_RESULT))
{
PCIVME_RESET_RESULT *pResetResult = (PCIVME_RESET_RESULT *)pOutputBuffer;
PCIVME_RESET_COMMAND *pResetCommand = (PCIVME_RESET_COMMAND *)pInputBuffer;
PCIADA *pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
USHORT wIRQStatus;
USHORT wControl;
UCHAR *pbReset;
KIRQL oldIrql;
// set default result return size and contents
pResetResult->dwInterface = file_obj->uwAssociatedVMEMM;
if (pciada->dwLinkCount == 1)
{
// lock other users out
KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);
// am I connected and switched on??
if ((READ_REGISTER_USHORT(pciada->pwCntrl) & 0x0980) == 0x0980)
{
// do command
switch (pResetCommand->wCommand)
{
case POLL_RESET_CMD:
break;
case VME_RESET_CMD:
WRITE_REGISTER_UCHAR(pciada->pbModifier, 0);
pbReset = (UCHAR *)((UCHAR *)pciada->pvVirtIfr +
(ULONG)VICBASE + (ULONG)SRR);
WRITE_REGISTER_UCHAR(pbReset, 0xf0); // make VME reset
break;
case LOCAL_RESET_CMD:
WRITE_REGISTER_UCHAR(pciada->pbModifier, 0);
WRITE_REGISTER_USHORT(pciada->pwIRQStat, LOCAL_RESET);
break;
case GLOBAL_RESET_CMD:
WRITE_REGISTER_UCHAR(pciada->pbModifier, 0);
WRITE_REGISTER_USHORT(pciada->pwIRQStat, GLOBAL_RESET);
break;
default: Status = STATUS_ILLEGAL_INSTRUCTION;
}
// save IRQ status of PCIADA and switch off PCIADA interrupts
wIRQStatus = READ_REGISTER_USHORT(pciada->pwIntCSR);
WRITE_REGISTER_USHORT(pciada->pwIntCSR, (USHORT)(wIRQStatus & ~0x0040));
// always poll reset status - access will sometimes generate PCIADA #2 interrupt
pResetResult->wResult = READ_REGISTER_UCHAR(pciada->pbModifier);
// reset any pending PCIADA interrupt #2
wControl = READ_REGISTER_USHORT(pciada->pwCntrl);
WRITE_REGISTER_USHORT(pciada->pwCntrl, (USHORT)(wControl & ~0x0100));
WRITE_REGISTER_USHORT(pciada->pwCntrl, wControl);
// restore IRQStatus
WRITE_REGISTER_USHORT(pciada->pwIntCSR, wIRQStatus);
}
else
Status = STATUS_ALREADY_DISCONNECTED;
// get other users free entry
KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
}
else
Status = STATUS_UNSUCCESSFUL;
}
else
Status = STATUS_BUFFER_TOO_SMALL;
// do what must be here in between --- end ---
COMPLETE_REQUEST;
KdPrint(("ioctl_reset(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// set parameter for this path for future access to VME
static NTSTATUS ioctl_access_para(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG irp_info = 0;
PVOID pInputBuffer,pOutputBuffer;
ULONG InputLength, OutputLength;
PCIVME_ACCESS_COMMAND *pAccessPara;
FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
DEVICE_EXT *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
PCIADA *pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
SET_BUFFERS_METHOD_BUFFERED;
KdPrint(("ioctl_access_para(%d)\n", file_obj->uwAssociatedVMEMM));
pAccessPara = (PCIVME_ACCESS_COMMAND *)pInputBuffer;
// do here in between what has to be done -----------------
file_obj->bAddressModifier = pAccessPara->bAddressModifier & MODIFIER_MASK;
file_obj->bAccessType = pAccessPara->bAccessType;
file_obj->bIncrement = pAccessPara->bIncrement;
file_obj->dwAddressMask = pAccessPara->bAccessType - 1;
// honor backward compatibility
if (file_obj->bAddressModifier & 0x30)
file_obj->dwAccessBase = 0;
else
file_obj->dwAccessBase = pAccessPara->dwAccessBase;
// access_type increment
// 1 0,1,2,3,4
// 2 0,2,4
// 4 0,4
if (pAccessPara->bIncrement % pAccessPara->bAccessType)
Status = STATUS_DATATYPE_MISALIGNMENT;
switch (pAccessPara->bAccessType)
{
case BYTE_ACCESS: file_obj->fRead = readByte;
file_obj->fWrite = writeByte;
break;
case WORD_ACCESS: file_obj->fRead = readWord;
file_obj->fWrite = writeWord;
break;
case LONG_ACCESS: if (pciada->bWordMode)
{
file_obj->fRead = readWord;
file_obj->fWrite = writeWord;
}
else
{
file_obj->fRead = readLong;
file_obj->fWrite = writeLong;
}
break;
default: Status = STATUS_UNSUCCESSFUL; break;
}
// do here in between what has to be done end -------------
COMPLETE_REQUEST;
KdPrint(("ioctl_access_para(), Status = 0x%08x\n", Status));
return Status;
}
//------------------------------------------------------------------------
// the ultimate jumptable for ioctl
//
NTSTATUS (*ioctl[])(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack) =
{
ioctl_init_hardware, // 0
ioctl_deinit_hardware, // 1
ioctl_dummy, // 2
ioctl_dummy, // 3
ioctl_get_static_status, // 4
ioctl_get_dynamic_status, // 5
ioctl_read_vector, // 6
ioctl_access_VIC68A, // 7
ioctl_dummy, // 8
ioctl_control_interrupts, // 9
ioctl_TAS, // 10
ioctl_dummy, // 11
ioctl_reset, // 12
ioctl_access_para // 13
};

/wiener_pcivme/pcivme/SOURCE/pcivme_v.h
0,0 → 1,48
#ifndef __PCIVME_V_H__
#define __PCIVME_V_H__
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// header file belonging to pcivme_v.c
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_v.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:51 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:03 klaus
// Added CVS log into header
//
// what who when
// started AR 02.07.99
// changed resource allocation caused by WIN2000 AR 08.06.2002
//
//-------------------------------------------------------------------------
// DEFINES
//
//-------------------------------------------------------------------------
// PROTOTYPES
//
NTSTATUS PCIVMEScanVMEMM(PDEVICE_OBJECT deviceObj);
NTSTATUS PCIVMEDeInitPCIADAs(PDEVICE_OBJECT deviceObj);
#endif // __PCIVME_V_H__

/wiener_pcivme/pcivme/SOURCE/pcivme_io.h
0,0 → 1,53
#ifndef __PCIVME_IO_H__
#define __PCIVME_IO_H__
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// the ioctl functions header file
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
// ntddk.h must included first!
//
// $Log: pcivme_io.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:51 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 03.07.99
// changed resource allocation caused by WIN2000 AR 08.06.2002
//
//------------------------------------------------------------------------
// FUNCTIONS + EXTERNALS
//
NTSTATUS (*ioctl[])(PDEVICE_OBJECT device_Obj, PIRP irp, PIO_STACK_LOCATION IrpStack);
void fMyDefferedRoutine(PKDPC Dpc, PVOID pvDevice_object, PVOID pvPciada, PVOID Nothing);
void CancelRequest(PDEVICE_OBJECT device_Obj, PIRP Irp);
NTSTATUS removeQueueFromList(PFILE_OBJ pFile_obj, PCIADA *pciada);
void InsertIRPtoQueue(PDEVICE_OBJECT device_Obj, PIRP Irp);
PIRP RemoveIRPfromQueue(PDEVICE_OBJECT device_Obj, FILE_OBJ *pFile_obj);
PIRP RemoveIRPfromQueueByIrp(PDEVICE_OBJECT device_Obj, PIRP pIrpIn);
#endif // __PCIVME_IO_H__

/wiener_pcivme/pcivme/SOURCE/pcivme.plg
0,0 → 1,52
<html>
<body>
<pre>
<h1>Erstellungsprotokoll</h1>
<h3>
--------------------Konfiguration: pcivme - Win32 Release--------------------
</h3>
<h3>Befehlszeilen</h3>
Erstellen der temporären Datei "E:\DOKUME~1\klaus\LOKALE~1\Temp\RSP73.tmp" mit Inhalten
[
/nologo /Gz /ML /W3 /Gi /O2 /I "D:\DDK\inc" /I "." /D "NDEBUG" /D DBG=0 /D "_X86_" /D _WIN32_WINNT=0x500 /FR"Release/" /Fp"Release/pcivme.pch" /YX /Fo"Release/" /Fd"Release/" /FD /Gs -GF /c
"E:\Work\projects\pcivme\pcivme_drv.c"
"E:\Work\projects\pcivme\pcivme_fifo.c"
"E:\Work\projects\pcivme\pcivme_i.c"
"E:\Work\projects\pcivme\pcivme_io.c"
"E:\Work\projects\pcivme\pcivme_v.c"
]
Creating command line "cl.exe @E:\DOKUME~1\klaus\LOKALE~1\Temp\RSP73.tmp"
Erstellen der temporären Datei "E:\DOKUME~1\klaus\LOKALE~1\Temp\RSP74.tmp" mit Inhalten
[
int64.lib ntoskrnl.lib hal.lib /nologo /base:"0x10000" /entry:"DriverEntry" /incremental:no /pdb:"Release/pcivme.pdb" /machine:I386 /nodefaultlib /out:"Release\pcivme.SYS" /libpath:"D:\DDK\lib\i386\free" -driver -subsystem:NATIVE,4.00
.\Release\pcivme_drv.obj
.\Release\pcivme_fifo.obj
.\Release\pcivme_i.obj
.\Release\pcivme_io.obj
.\Release\pcivme_v.obj
]
Erstellen der Befehlzeile "link.exe @E:\DOKUME~1\klaus\LOKALE~1\Temp\RSP74.tmp"
Erstellen der temporären Datei "E:\DOKUME~1\klaus\LOKALE~1\Temp\RSP75.bat" mit Inhalten
[
@echo off
copy .\Release\pcivme.SYS E:\WINNT\System32\Drivers\*.*
]
Erstellen der Befehlzeile "E:\DOKUME~1\klaus\LOKALE~1\Temp\RSP75.bat"
Kompilierung läuft...
pcivme_drv.c
pcivme_fifo.c
pcivme_i.c
pcivme_io.c
pcivme_v.c
Linker-Vorgang läuft...
<h3>Ausgabefenster</h3>
Copying Driver to System32\Drivers
1 Datei(en) kopiert.
<h3>Ergebnisse</h3>
pcivme.SYS - 0 Fehler, 0 Warnung(en)
</pre>
</body>
</html>

/wiener_pcivme/pcivme/SOURCE/Vic.h
0,0 → 1,116
#ifndef __VIC_H__
#define __VIC_H__
//------------------------------------------------------------------------------------------
// vic.h - some constants about the VIC68A chip from cypress semiconductor
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
//
// $Log: Vic.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:51 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:03 klaus
// Added CVS log into header
//
// what who when
// finished first release to use with the PCIVME interface of ARW AR 24.11.1997
// SRR corrected from SSR AR 18.04.1999
//
/* all address offsets relative to vic base */
#define VICR1 (WORD)0x07 /* VMEbus Interrupt Control Register #.. */
#define VICR2 (WORD)0x0b
#define VICR3 (WORD)0x0f
#define VICR4 (WORD)0x13
#define VICR5 (WORD)0x17
#define VICR6 (WORD)0x1b
#define VICR7 (WORD)0x1f
#define LICR1 (WORD)0x27 /* Local interrupt control register .. */
#define LICR2 (WORD)0x2b
#define LICR3 (WORD)0x2f
#define LICR4 (WORD)0x33
#define LICR5 (WORD)0x37
#define LICR6 (WORD)0x3b
#define LICR7 (WORD)0x3f
#define LIVBR (WORD)0x57 /* Local interrupt vector base register */
#define ICGSICR (WORD)0x43 /* ICGS interrupt control register */
#define ICGSVBR (WORD)0x4f /* ICGS vector base register */
#define ICMSICR (WORD)0x47 /* ICMS interrupt control register */
#define ICMSVBR (WORD)0x53 /* ICMS vector base register */
#define EGICR (WORD)0x4b /* Error group interrupt control register */
#define EGIVBR (WORD)0x5b /* Error group interrupt vector base rg */
#define ICSR (WORD)0x5f /* Interprozessor communication switch rg */
#define ICR0 (WORD)0x63
#define ICR1 (WORD)0x67
#define ICR2 (WORD)0x6b
#define ICR3 (WORD)0x6f
#define ICR4 (WORD)0x73
#define ICR5 (WORD)0x77
#define ICR6 (WORD)0x7b
#define ICR7 (WORD)0x7f
#define VIICR (WORD)0x03 /* VMEbus Interrupter Interrupt Control */
#define VIRSR (WORD)0x83 /* VMEbus interrupt request status reg */
#define VIVR1 (WORD)0x87 /* VMEbus interrupt vector register .. */
#define VIVR2 (WORD)0x8b
#define VIVR3 (WORD)0x8f
#define VIVR4 (WORD)0x93
#define VIVR5 (WORD)0x97
#define VIVR6 (WORD)0x9b
#define VIVR7 (WORD)0x9f
#define TTR (WORD)0xa3 /* transfer timeout register */
#define LTR (WORD)0xa7 /* local timing register */
#define ICR (WORD)0xaf /* interface configuration register */
#define ARCR (WORD)0xb3 /* arbiter/requester configuration register*/
#define AMSR (WORD)0xb7 /* address modifier source register */
#define BESR (WORD)0xbb /* bus error source register */
#define DSICR (WORD)0x23 /* DMA status interrupt control register */
#define DSR (WORD)0xbf /* DMA status register */
#define SSCR00 (WORD)0xc3 /* slave select 0 control register 0 */
#define SSCR01 (WORD)0xc7 /* slave select 0 control register 1 */
#define SSCR10 (WORD)0xcb /* slave select 1 control register 0 */
#define SSCR11 (WORD)0xcf /* slave select 1 control register 1 */
#define RCR (WORD)0xd3 /* release control register */
#define BTDR (WORD)0xab /* block transfer definition register */
#define BTCR (WORD)0xd7 /* block transfer control register */
#define BTLR0 (WORD)0xdb /* block transfer length register 0 */
#define BTLR1 (WORD)0xdf /* block transfer length register 1 */
#define SRR (WORD)0xe3 /* system reset register */
#endif
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------

/wiener_pcivme/pcivme/SOURCE/pcivme_fifo.c
0,0 → 1,188
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// functions for a fast fifo (first in first out) implementation
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_fifo.c,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:50 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 06.10.1999
// first release 1.0 AR 17.10.1999
//
//-------------------------------------------------------------------------
// INCLUDES
//
#include <ntddk.h>
#include <pcivme_fifo.h>
//------------------------------------------------------------------------
// DEFINES
//
//------------------------------------------------------------------------
// TYPEDEFS
//
typedef struct
{
USHORT wLevel; // actual Number of Elements
UCHAR *pbBegin; // points to begin of the buffer
UCHAR *pbEnd; // points to the (end of the buffer + 1)
UCHAR *pbWrite; // next write here
UCHAR *pbRead; // next read (if any) here
KSPIN_LOCK Lock; // to guard access to the fifo
BOOLEAN bOverflow; // indicates a overflow to that FIFO
} FIFO_MANAGER;
//------------------------------------------------------------------------
// FUNCTIONS
//
// the global functions to manage the fifo
// first: init the fifo and allocate nonpaged memory
NTSTATUS InitializeFIFO(USHORT CountOfElements, PVOID *pHandle)
{
ULONG allocSize;
register FIFO_MANAGER *fifo_manager;
*pHandle = NULL;
allocSize = sizeof(FIFO_MANAGER) + sizeof(UCHAR) * CountOfElements + 16; // cause alignment
*pHandle = ExAllocatePool(NonPagedPool, allocSize);
if(*pHandle == NULL) return STATUS_NO_MEMORY;
RtlZeroMemory(*pHandle, allocSize);
fifo_manager = (FIFO_MANAGER *)*pHandle;
// init the fifo_manager
KeInitializeSpinLock(&fifo_manager->Lock);
fifo_manager->wLevel = 0;
fifo_manager->bOverflow = FALSE;
fifo_manager->pbBegin = (UCHAR *)(((ULONG)(fifo_manager + 1) + 8) & ~7); //align
fifo_manager->pbEnd = (UCHAR *)((ULONG)fifo_manager->pbBegin + sizeof(UCHAR) * CountOfElements);
fifo_manager->pbWrite =
fifo_manager->pbRead = fifo_manager->pbBegin;
// KdPrint(("fifo_manager: 0x%08x, begin: 0x%08x, end: 0x%08x\n",
// fifo_manager, fifo_manager->pbBegin, fifo_manager->pbEnd));
return STATUS_SUCCESS;
}
// second: push elements to the FIFO
int PushElement(PVOID Handle, UCHAR bElement)
{
register FIFO_MANAGER *fifo_manager = (FIFO_MANAGER *)Handle;
KIRQL oldIrql;
KeAcquireSpinLock(&fifo_manager->Lock, &oldIrql);
if ((fifo_manager->wLevel) && (fifo_manager->pbWrite == fifo_manager->pbRead))
{
KeReleaseSpinLock(&fifo_manager->Lock, oldIrql);
return fifo_manager->wLevel;
}
*(fifo_manager->pbWrite)++ = bElement;
// wrap around
if (fifo_manager->pbWrite >= fifo_manager->pbEnd)
fifo_manager->pbWrite = fifo_manager->pbBegin;
// check for overflow - indicate - and reset pointer to same before
if (fifo_manager->pbWrite == fifo_manager->pbRead)
{
fifo_manager->bOverflow = TRUE;
fifo_manager->pbWrite--;
if (fifo_manager->pbWrite < fifo_manager->pbBegin)
fifo_manager->pbWrite = fifo_manager->pbEnd - 1;
}
else
(fifo_manager->wLevel)++;
KeReleaseSpinLock(&fifo_manager->Lock, oldIrql);
return fifo_manager->wLevel;
}
// third: pull elements from the FIFO
int PullElement(PVOID Handle, UCHAR *pbElement)
{
register FIFO_MANAGER *fifo_manager = (FIFO_MANAGER *)Handle;
KIRQL oldIrql;
if (!(fifo_manager->wLevel)) return 0;
KeAcquireSpinLock(&fifo_manager->Lock, &oldIrql);
if (fifo_manager->wLevel)
{
*pbElement = *(fifo_manager->pbRead)++;
(fifo_manager->wLevel)--;
}
else
*pbElement = 0; // the caller tries to get more than available?
// wrap around
if (fifo_manager->pbRead >= fifo_manager->pbEnd)
fifo_manager->pbRead = fifo_manager->pbBegin;
KeReleaseSpinLock(&fifo_manager->Lock, oldIrql);
return fifo_manager->wLevel;
}
// test how many elements are in the FIFO
int NumberOfElements(PVOID Handle)
{
register FIFO_MANAGER *fifo_manager = (FIFO_MANAGER *)Handle;
return fifo_manager->wLevel;
}
// check and clear the overflow flag
BOOLEAN CheckAndClearOverflow(PVOID Handle)
{
register FIFO_MANAGER *fifo_manager = (FIFO_MANAGER *)Handle;
KIRQL oldIrql;
BOOLEAN helper;
KeAcquireSpinLock(&fifo_manager->Lock, &oldIrql);
helper = fifo_manager->bOverflow;
fifo_manager->bOverflow = FALSE;
KeReleaseSpinLock(&fifo_manager->Lock, oldIrql);
return helper;
}
// close the FIFO and free the allocated memory
void DestroyFIFO(PVOID Handle)
{
if (Handle != NULL) ExFreePool(Handle);
}

/wiener_pcivme/pcivme/SOURCE/pcivme.h
0,0 → 1,289
#ifndef __PCIVME_H__
#define __PCIVME_H__
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// IO definitions and common data structures between application and driver
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:50 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.4 2002/10/27 17:02:30 klaus
// File addressing bug > 2 Gbtye circumvent
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 15.06.99
//
//-------------------------------------------------------------------------
// INCLUDES
//
// #include <devioctl.h> must be declared before inclusion when used for driver
// #include <winioctl.h> must be declared before inclusion when used for applications
//-------------------------------------------------------------------------
// DEFINES
//
// to get a compatible view to WIN95 driver
#define USER_CONTROL_CODE(x) (0x800 + x)
// initialise a dedicated VMEMM hardware
#define PCIVME_INIT_HARDWARE CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(0),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// de-initialise a dedicated VMEMM hardware
#define PCIVME_DEINIT_HARDWARE CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(1),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// get a static status info from a dedicted VMEMM+PCIADA hardware
#define PCIVME_GET_STATIC_STATUS CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(4),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// get dynamically changing status from PCIADA+VMEMM
#define PCIVME_GET_DYNAMIC_STATUS CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(5),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// read a vector in case of interrupt from VMEMM or PCIADA
#define PCIVME_READ_VECTOR CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(6),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// access VIC68A registers direct
#define PCIVME_ACCESS_VIC68A CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(7),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// enable or disable interrupts from user space
#define PCIVME_CONTROL_INTERRUPTS CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(9),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// generate a (undivisible) test-and-set instruction
#define PCIVME_TAS CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(10),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// generate a reset on VME BUS for a dedicated VMEMM interface
#define PCIVME_RESET CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(12),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// set the access parameter for this file (vmemm)
#define PCIVME_SET_ACCESS_PARA CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(13),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// my last usefull control code - change each time you add a ctl_code
#define PCIVME_LAST_CTL_CODE PCIVME_SET_ACCESS_PARA
// to make standard entries for not compatible WIN95 call codes
#define PCIVME_INCOMPATIBLE CTL_CODE(\
FILE_DEVICE_UNKNOWN,\
USER_CONTROL_CODE(255),\
METHOD_BUFFERED,\
FILE_ANY_ACCESS)
// to get a compatible view to WIN95 driver
#define VPCIVMED_INIT_HARDWARE PCIVME_INIT_HARDWARE
#define VPCIVMED_DEINIT_HARDWARE PCIVME_DEINIT_HARDWARE
#define VPCIVMED_ATTACH_WINDOW PCIVME_INCOMPATIBLE // no compatibility!
#define VPCIVMED_DETACH_WINDOW PCIVME_INCOMPATIBLE // no compatibility!
#define VPCIVMED_GET_STATIC_STATUS PCIVME_GET_STATIC_STATUS
#define VPCIVMED_GET_DYNAMIC_STATUS PCIVME_GET_DYNAMIC_STATUS
#define VPCIVMED_READ_VECTOR PCIVME_READ_VECTOR
#define VPCIVMED_ACCESS_VIC68A PCIVME_ACCESS_VIC68A
#define VPCIVMED_CONTROL_INTERRUPTS PCIVME_CONTROL_INTERRUPTS
#define VPCIVMED_TAS PCIVME_TAS
#define VPCIVMED_GET_PCIADA_STATUS PCIVME_GET_PCIADA_STATUS
#define VPCIVMED_RESET PCIVME_RESET
// switches for PCIVME_(DE)INIT_HARDWARE ------------------------
#define LCR (UCHAR)0 // destination is LCR register
#define IFR (UCHAR)1 // destination is VME-Interface register
#define VIC (UCHAR)2 // destination is VIC68A register
#define STOP (UCHAR)255 // this command stops the init machine
#define BYTE_ACCESS (UCHAR)1 // write byte wise
#define WORD_ACCESS (UCHAR)2 // word
#define LONG_ACCESS (UCHAR)4 // long
// switches for PCIVME_ACCESS_VIC68A --------------------------
#define VIC68A_READ 0 // read only access
#define VIC68A_WRITE 1 // write and read back access
#define VIC68A_OR 2 // read, bitwise 'or' content and read back access
#define VIC68A_AND 3 // read, bitwise 'and' content and read back access
#define VIC68A_WRITE_ONLY 4 // do not read back after write
// switches for the PCIVME_RESET ------------------------------
#define VME_RESET_CMD 0 // raise a VME reset only
#define LOCAL_RESET_CMD 1 // raise a local reset only
#define GLOBAL_RESET_CMD 2 // raise a global reset
#define POLL_RESET_CMD 3 // ask if reset is finished
#define BOGUSADDRESS 0xFFFFFFFF // compatibilty to WIN95
#ifndef PHYSICAL_ADDRESS
#define PHYSICAL_ADDRESS LARGE_INTEGER
#endif
//-------------------------------------------------------------------------
// TYPEDEFS
//
typedef struct // one command element to initialize interface or deinitialize
{
UCHAR range; // 0 = lcr, 1 = vme-interface, -1 = stop, default = vme-if
UCHAR type; // 1 = byte access, 2 = word access, 4 = dword access, default byte
USHORT offset; // offset into interface address range for initialisation
ULONG value; // value to initialize
} PCIVME_INIT_ELEMENT;
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95
PCIVME_INIT_ELEMENT sVie[8]; // at least one zero element must be the last
} PCIVME_INIT_COMMAND;
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95
UCHAR bAddressModifier; // set the current modifier
UCHAR bAccessType; // set the current access type (1,2,4)
UCHAR bIncrement; // set the current byte increment count
ULONG dwAccessBase; // base address of seek operation (extended modifiers only, else must = 0)
} PCIVME_ACCESS_COMMAND;
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95
USHORT wRegisterAddress; // address offset of vic68a register
USHORT wAccessMode; // read, write, or, and
UCHAR bContent; // content to write, and, or
} PCIVME_VIC68A_ACTION;
// includes static information about driver parameters ------
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95
ULONG dwLinkCount; // how often this interface is requested
USHORT wNumMemWindows; // aus der aktuellen konfiguration
USHORT wNumIOPorts;
USHORT wNumIRQs;
USHORT wNumDMAs;
USHORT wModuleType; // von der angeschlossenen hardware gelesen
USHORT wFPGAVersion;
USHORT wModuleNumber;
USHORT wWordMode;
USHORT wSysControl; // if the associated VMEMM has slot 1 function
USHORT wConnected; // is the VMEMM connected (obsolete sometimes)
PHYSICAL_ADDRESS pvLcr; // physikalische adresse des lcr
PHYSICAL_ADDRESS pvIfr; // physikalische adresse des interfaces ohne vme
ULONG dwDriverVersion; // highWord.lowWord
ULONG dwDriverVariant; // show customized variants here
} PCIVME_STATIC_STATUS;
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95
USHORT wVMEMM_connected; // status: VMEMM is connected and powered
USHORT wVMEMM_enable; // status: VMEMM access is enabled
USHORT wPCIADAIrq; // status: PCIADA timeout IRQ pending
USHORT wVMEMMIrq; // status: VMEMM IRQ pending
} PCIVME_DYNAMIC_STATUS;
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95
ULONG dwAddress; // tas to address
USHORT wModifier; // VME address modifier for this window
UCHAR bContent; // byte content to store and get back
} PCIVME_TAS_STRUCT;
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95
USHORT wCommand; // the appropriate reset command
} PCIVME_RESET_COMMAND;
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95
USHORT wResult;
} PCIVME_RESET_RESULT; // polling result: in progress if (wResult != 0)
typedef struct
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95..
USHORT wEnable; // a 1 enables the queue filling, a 0 disables
} PCIVME_IRQ_CONTROL;
typedef struct // to request vectors from a interface
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95..
USHORT wRequestCount; // maximum number of vectors to requests
BOOLEAN bPoll; // no blocking allowed - poll always
} PCIVME_VECTOR_REQUEST;
typedef struct // the response to the above request
{
ULONG dwInterface; // here dummy 'cause of compatibility to WIN95..
USHORT wPendingCount; // represents the number of vectors pending
USHORT wCount; // actual delivered count of vectors
BOOLEAN bOverflow; // there was a irq overflow @ this channel
UCHAR bStatusID; // base of following vector array
} PCIVME_VECTOR_RESPONSE;
#endif // __PCIVME_H__

/wiener_pcivme/pcivme/SOURCE/pcivme_i.c
0,0 → 1,299
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// all around irq handling
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_i.c,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:50 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 01.08.1999
// first release 1.0 AR 17.10.1999
// IoConnectInterrupt, share vector now true AR 04.03.2000
// changed resource allocation caused by WIN2000 AR 08.06.2002
//
//-------------------------------------------------------------------------
// COMMENTS
//
// Each path (file_obj) maintains its own FIFO to hold incoming vector from
// hardware acknowledged interrupts. These FIFOs are always accessible for read
// while the path is open. In case a path enables its interrupts the link to
// its FIFO is included in a list of "interrupt enabled" FIFOs. The opposite
// happens when a path disables its interrupts.
// There are up to MAX_PCIADA lists of "interrupt enabled" FIFOs, each list is
// associated to a PCIADA (pciada).
// Each time a pciada receives a interrupt request the software first checks
// for a bus error interrupt. This kind of requests are directly associated with
// a user initiated access and put forward to the accessor. (Excluding spurious
// interrupts). If the request is no bus error request the vector is pushed
// into all FIFOs queued for this PCIADA.
// After this a DPC call is fired to wake up queued IRPs waiting for a vector.
// The DPC call iterates through the list of FIFOs and looks if a queued IRP
// exists for this path. If so the vector is pulled off the FIFO and the IRP
// is released.
// If a IRP arrives to request a vector the driver checks if there is a vector
// stored in the path associated FIFO. If so the IRP returns immediately with
// the pulled vector from the FIFO. If not the IRP is queued in a PCIADA
// associated queue of pending IRPs.
// When the interrupts for a path are disabled all pending vectors in the FIFO
// associated with this path are still available. But if the FIFO is empty
// request to get the next vector will block.
//-------------------------------------------------------------------------
// INCLUDES
//
#include <ntddk.h>
#include <pcivme_drv.h>
#include <pcivme_i.h>
#include <pcivme.h>
#include <pciif.h>
#include <pcivme_fifo.h>
//------------------------------------------------------------------------
// DEFINES
//
#ifndef DWORD
#define DWORD ULONG
#endif
#ifndef WORD
#define WORD USHORT
#endif
//------------------------------------------------------------------------
// GLOBALS
//
//------------------------------------------------------------------------
// FUNCTIONS
//
//------------------------------------------------------------------------
// determine which interrupt and evaluates vector
//
static UCHAR evaluate_vector(PCIADA *pciada)
{
USHORT wIntCSR = READ_REGISTER_USHORT(pciada->pwIntCSR);
USHORT offset;
USHORT wCntrl = READ_REGISTER_USHORT(pciada->pwCntrl);
if (wCntrl & 0x100) // pciada switched on ?
{
if ((wIntCSR & 0x68) == 0x68)
{
// it's the pci interrupt # 2
// get current Cntrl - and clear interrupt
wCntrl &= ~0x0100; // disable
WRITE_REGISTER_USHORT(pciada->pwCntrl, wCntrl);
wCntrl |= 0x0100; // enable again
WRITE_REGISTER_USHORT(pciada->pwCntrl, wCntrl);
return 1;
}
if ((wIntCSR & 0x45) == 0x45)
{
// it's the interrupt # 1
offset = READ_REGISTER_USHORT(pciada->pwIRQStat);
if (offset & 1)
return 0xff & READ_REGISTER_UCHAR((PUCHAR)pciada->pbVector + offset);
}
}
return 0;
}
//------------------------------------------------------------------------
// enable and disable of interrupts
//
void globalInterruptEnable(PCIADA *pciada)
{
WRITE_REGISTER_USHORT(pciada->pwIntCSR, ENABLE_PCIADA_IRQS);
}
void globalInterruptDisable(PCIADA *pciada)
{
WRITE_REGISTER_USHORT(pciada->pwIntCSR, DISABLE_PCIADA_IRQS);
}
//------------------------------------------------------------------------
// insert the vector in a queue of interrupts (and rescue waiting IRPs)
//
static void InsertInIrqQueues(PCIADA *pciada, UCHAR vector)
{
FIFO_LIST *next;
KIRQL oldIrqlList;
register PLIST_ENTRY pList = &pciada->IrqListList;
KdPrint(("InsertInIrqQueues\n"));
// iterate all fifos and insert the vector in each fifo
KeAcquireSpinLock(&pciada->IrqListLock, &oldIrqlList);
while (pList->Flink != &pciada->IrqListList)
{
pList = pList->Flink;
next = CONTAINING_RECORD(pList, FIFO_LIST, entry);
KdPrint(("Vector %d pushed\n", vector));
// push the vector into the fifo
PushElement(next->pIrqListHandle, vector);
}
KeReleaseSpinLock(&pciada->IrqListLock, oldIrqlList);
// more handling in the deffered procedure call
KeInsertQueueDpc(&pciada->kDPCobj, (PVOID)pciada, (PVOID)&vector);
}
//------------------------------------------------------------------------
// main interrupt handler function
//
BOOLEAN irq_service(PKINTERRUPT Interrupt, PVOID ServiceContext)
{
PCIADA *pciada = (PCIADA *)ServiceContext;
UCHAR vector;
UNREFERENCED_PARAMETER(Interrupt);
vector = evaluate_vector(pciada);
if (!(vector)) return FALSE;
KdPrint(("irq_service: %d\n", vector & 0xff));
if ((pciada->pbBusError) && ((vector == 7) || (vector == 1)))
*pciada->pbBusError = TRUE;
else
InsertInIrqQueues(pciada, vector); // insert at top of the queues
return TRUE;
}
//------------------------------------------------------------------------
// translate interrupt resources for PCIADAs to neutral ones
//
NTSTATUS PCIVMETranslateInterrupts(PDEVICE_OBJECT device_Obj)
{
int i;
NTSTATUS result = STATUS_SUCCESS;
DEVICE_EXT *pDevExt = (DEVICE_EXT*)device_Obj->DeviceExtension;
int nPCIADAs = pDevExt->nPCIADAs;
PCIADA *pciada = (PCIADA *) NULL;
KdPrint(("TranslateInterrupt()\n"));
for (i = 0; i < nPCIADAs; i++)
{
pciada = &pDevExt->pciada[i];
KdPrint(("In - Bus:%d, IrqLine:%d\n", pciada->Bus, pciada->Irql));
if (pciada->Irql)
{
pciada->Vector = HalGetInterruptVector(PCIBus, pciada->Bus,
pciada->Irql,
pciada->Vector,
&pciada->Irql, &pciada->Affinity);
}
else
result = STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT;
}
KdPrint(("Out - Irql:%d, Vector: %d, Affinity:%d\n", pciada->Irql, pciada->Vector, pciada->Affinity));
return result;
}
//------------------------------------------------------------------------
// connect service routines to all PCIADA interrupts
//
NTSTATUS PCIVMEConnectInterrupt(PDEVICE_OBJECT device_Obj)
{
int i;
NTSTATUS result = STATUS_SUCCESS;
DEVICE_EXT *pDevExt = (DEVICE_EXT*)device_Obj->DeviceExtension;
int nPCIADAs = pDevExt->nPCIADAs;
PCIADA *pciada;
KdPrint(("ConnectInterrupt()\n"));
// connect the interrupts to service routines
for (i = 0; i < nPCIADAs; i++)
{
pciada = &pDevExt->pciada[i];
pciada->InterruptObject = NULL;
if (pciada->Vector)
result = IoConnectInterrupt(&pciada->InterruptObject,
irq_service,
(PVOID)pciada,
NULL,
pciada->Vector,
pciada->Irql,
pciada->Irql,
LevelSensitive,
TRUE,
pciada->Affinity,
FALSE);
KdPrint(("pIrqObj:0x%08x, VirtVect:%d, Irql:%d, hIrql:%d, Aff:0x%08x, Status:0x%08x\n",
pciada->InterruptObject,
pciada->Vector, pciada->Irql, pciada->Irql, pciada->Affinity, result));
if (result != STATUS_SUCCESS) break;
}
return result;
}
//------------------------------------------------------------------------
// dis-connect service routines to all PCIADA interrupts
//
NTSTATUS PCIVMEDisConnectInterrupt(PDEVICE_OBJECT device_Obj)
{
int i;
DEVICE_EXT *pDevExt = (DEVICE_EXT*)device_Obj->DeviceExtension;
int nPCIADAs = pDevExt->nPCIADAs;
PCIADA *pciada;
KdPrint(("DisConnectInterrupt()\n"));
// dis connect the interrupts to service routines
for (i = 0; i < nPCIADAs; i++)
{
pciada = &pDevExt->pciada[i];
KdPrint(("IrqObj:0x%08x\n", pciada->InterruptObject));
if (pciada->InterruptObject)
IoDisconnectInterrupt(pciada->InterruptObject);
}
return STATUS_SUCCESS;
}

/wiener_pcivme/pcivme/SOURCE/pcivme_fifo.h
0,0 → 1,46
#ifndef __PCIVME_FIFO_H__
#define __PCIVME_FIFO_H__
//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// header for functions for a fast fifo (first in first out) implementation
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
// $Log: pcivme_fifo.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:50 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:02 klaus
// Added CVS log into header
//
// what who when
// started AR 06.10.99
//
NTSTATUS InitializeFIFO(USHORT CountOfElements, PVOID *pHandle);
int PushElement(PVOID Handle, UCHAR bElement);
int PullElement(PVOID Handle, UCHAR *pbElement);
int NumberOfElements(PVOID Handle);
BOOLEAN CheckAndClearOverflow(PVOID Handle);
void DestroyFIFO(PVOID Handle);
#endif // __PCIVME_FIFO_H__

/wiener_pcivme/pcivme/SOURCE/Vme.h
0,0 → 1,57
#ifndef __VME_H__
#define __VME_H__
//------------------------------------------------------------------------------------------
// vme.h - some constants about VME address modifiers in a more readable kind
//
// (c) 1999-2004 ARW Elektronik
//
// this source code is published under GPL (Open Source). You can use, redistrubute and
// modify it unless this header is not modified or deleted. No warranty is given that
// this software will work like expected.
// This product is not authorized for use as critical component in life support systems
// wihout the express written approval of ARW Elektronik Germany.
//
// Please announce changes and hints to ARW Elektronik
//
//
// $Log: Vme.h,v $
// Revision 1.3 2004/07/24 07:07:26 klaus
// Update copyright to 2004
//
// Revision 1.2 2003/11/15 19:12:51 klaus
// Update copyright to 2003
//
// Revision 1.1.1.1 2003/11/14 23:16:33 klaus
// First put into repository
//
// Revision 1.3 2002/10/27 16:17:48 klaus
// Typing bug fixed caused at log addition
//
// Revision 1.2 2002/10/27 16:11:03 klaus
// Added CVS log into header
//
// what who when
// finished first release to use with the PCIVME interface of ARW AR 22.03.1999
//
typedef WORD ADDRESS_MODIFIER;
#define Std_Sup_Data (ADDRESS_MODIFIER)0x3d
#define Std_Sup_Prog (ADDRESS_MODIFIER)0x3e
#define Std_NoPriv_Data (ADDRESS_MODIFIER)0x39
#define Std_NoPriv_Prog (ADDRESS_MODIFIER)0x3a
#define Short_Sup (ADDRESS_MODIFIER)0x2d
#define Short_NoPriv (ADDRESS_MODIFIER)0x29
#define Ext_Sup_Data (ADDRESS_MODIFIER)0x0d
#define Ext_Sup_Prog (ADDRESS_MODIFIER)0x0e
#define Ext_NoPriv_Data (ADDRESS_MODIFIER)0x09
#define Ext_NoPriv_Prog (ADDRESS_MODIFIER)0x0a
#endif
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------

/wiener_pcivme/pcivme/SOURCE/guid.h
0,0 → 1,6
INTERFACENAME = { /* c4ad1dfa-3e35-4659-bf2b-c83cda6833e1 */
0xc4ad1dfa,
0x3e35,
0x4659,
{0xbf, 0x2b, 0xc8, 0x3c, 0xda, 0x68, 0x33, 0xe1}
};

/wiener_pcivme/pcivme/pcivme.vcxproj.filters
0,0 → 1,26
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="Driver Files">
<UniqueIdentifier>{8E41214B-6785-4CFE-B992-037D68949A14}</UniqueIdentifier>
<Extensions>inf;inv;inx;mof;mc;</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<Inf Include="pcivme.inf">
<Filter>Driver Files</Filter>
</Inf>
</ItemGroup>
</Project>

/wiener_pcivme/pcivme/Win7Release/pcivme.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme/Win7Release/pcivme.Build.CppClean.log
0,0 → 1,19
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\vc120.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme_v.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme_io.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme_i.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme_fifo.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme_drv.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7release\pcivme.sys
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7release\pcivme.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7release\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\stampinf.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\stampinf.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\stampinf.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme.tlog\cl.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme.tlog\cl.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme.tlog\cl.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme.tlog\link.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme.tlog\link.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7release\pcivme.tlog\link.write.1.tlog

/wiener_pcivme/pcivme/Win8.1Release/pcivme.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.22

/wiener_pcivme/pcivme/Win8.1Release/pcivme.Build.CppClean.log
0,0 → 1,19
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\vc120.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme_v.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme_io.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme_i.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme_fifo.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme_drv.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1release\pcivme.sys
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1release\pcivme.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1release\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\stampinf.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\stampinf.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\stampinf.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme.tlog\cl.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme.tlog\cl.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme.tlog\cl.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme.tlog\link.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme.tlog\link.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1release\pcivme.tlog\link.write.1.tlog

/wiener_pcivme/pcivme/Win8Release/pcivme.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme/Win8Release/pcivme.Build.CppClean.log
0,0 → 1,19
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\vc120.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme_v.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme_io.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme_i.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme_fifo.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme_drv.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8release\pcivme.sys
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8release\pcivme.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8release\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\stampinf.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\stampinf.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\stampinf.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme.tlog\cl.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme.tlog\cl.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme.tlog\cl.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme.tlog\link.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme.tlog\link.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8release\pcivme.tlog\link.write.1.tlog

/wiener_pcivme/pcivme/pcivme.vcxproj.user
0,0 → 1,4
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup />
</Project>

/wiener_pcivme/pcivme/Win7Debug/pcivme.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme/Win7Debug/pcivme.Build.CppClean.log
0,0 → 1,23
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7debug\pcivme.sys
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\vc120.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme_v.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme_io.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme_i.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme_fifo.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme_drv.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7debug\pcivme.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7debug\pcivme.cer
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win7debug\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\signtool.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\signtool.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\signtool.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\stampinf.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\stampinf.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\stampinf.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme.tlog\cl.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme.tlog\cl.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme.tlog\cl.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme.tlog\link.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme.tlog\link.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win7debug\pcivme.tlog\link.write.1.tlog

/wiener_pcivme/pcivme/Win8.1Debug/pcivme.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme/Win8.1Debug/pcivme.Build.CppClean.log
0,0 → 1,23
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1debug\pcivme.sys
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\vc120.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme_v.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme_io.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme_i.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme_fifo.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme_drv.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1debug\pcivme.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1debug\pcivme.cer
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8.1debug\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\signtool.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\signtool.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\signtool.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\stampinf.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\stampinf.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\stampinf.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme.tlog\cl.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme.tlog\cl.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme.tlog\cl.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme.tlog\link.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme.tlog\link.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8.1debug\pcivme.tlog\link.write.1.tlog

/wiener_pcivme/pcivme/Win8Debug/pcivme.log
0,0 → 1,5
Build started 10.2.2014 10:02:12.
Build succeeded.
Time Elapsed 00:00:00.01

/wiener_pcivme/pcivme/Win8Debug/pcivme.Build.CppClean.log
0,0 → 1,23
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8debug\pcivme.sys
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\vc120.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme_v.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme_io.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme_i.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme_fifo.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme_drv.obj
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8debug\pcivme.pdb
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8debug\pcivme.cer
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\win8debug\pcivme.inf
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\signtool.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\signtool.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\signtool.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\stampinf.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\stampinf.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\stampinf.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme.tlog\cl.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme.tlog\cl.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme.tlog\cl.write.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme.tlog\link.command.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme.tlog\link.read.1.tlog
c:\users\f9daq\rok\wienerpciada\pcivme\win2000-xp\driver\pcivme\pcivme\win8debug\pcivme.tlog\link.write.1.tlog

/wiener_pcivme/pcivme/pcivme.vcxproj
0,0 → 1,310
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Win8.1 Debug|Win32">
<Configuration>Win8.1 Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8.1 Release|Win32">
<Configuration>Win8.1 Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8 Debug|Win32">
<Configuration>Win8 Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8 Release|Win32">
<Configuration>Win8 Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win7 Debug|Win32">
<Configuration>Win7 Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win7 Release|Win32">
<Configuration>Win7 Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8.1 Debug|x64">
<Configuration>Win8.1 Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8.1 Release|x64">
<Configuration>Win8.1 Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8 Debug|x64">
<Configuration>Win8 Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win8 Release|x64">
<Configuration>Win8 Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win7 Debug|x64">
<Configuration>Win7 Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Win7 Release|x64">
<Configuration>Win7 Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}</ProjectGuid>
<TemplateGuid>{1bc93793-694f-48fe-9372-81e2b05556fd}</TemplateGuid>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<MinimumVisualStudioVersion>11.0</MinimumVisualStudioVersion>
<Configuration>Win8.1 Debug</Configuration>
<Platform Condition="'$(Platform)' == ''">Win32</Platform>
<RootNamespace>pcivme</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|Win32'" Label="Configuration">
<TargetVersion>WindowsV6.3</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|Win32'" Label="Configuration">
<TargetVersion>WindowsV6.3</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'" Label="Configuration">
<TargetVersion>Windows8</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'" Label="Configuration">
<TargetVersion>Windows8</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'" Label="Configuration">
<TargetVersion>Windows7</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'" Label="Configuration">
<TargetVersion>Windows7</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|x64'" Label="Configuration">
<TargetVersion>WindowsV6.3</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|x64'" Label="Configuration">
<TargetVersion>WindowsV6.3</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'" Label="Configuration">
<TargetVersion>Windows8</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'" Label="Configuration">
<TargetVersion>Windows8</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'" Label="Configuration">
<TargetVersion>Windows7</TargetVersion>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'" Label="Configuration">
<TargetVersion>Windows7</TargetVersion>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>WindowsKernelModeDriver8.1</PlatformToolset>
<ConfigurationType>Driver</ConfigurationType>
<DriverType>KMDF</DriverType>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<IncludePath>$(ProjectDir);$(IncludePath);$(ProjectDir)\SOURCE</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<IncludePath>$(ProjectDir);$(IncludePath);$(ProjectDir)\SOURCE</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<IncludePath>$(ProjectDir);$(IncludePath);$(ProjectDir)\SOURCE</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<IncludePath>$(ProjectDir);$(IncludePath);$(ProjectDir)\SOURCE</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<IncludePath>$(ProjectDir);$(IncludePath);$(ProjectDir)\SOURCE</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
<IncludePath>$(ProjectDir);$(IncludePath);$(ProjectDir)\SOURCE</IncludePath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'">
<DebuggerFlavor>DbgengKernelDebugger</DebuggerFlavor>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|Win32'">
<ClCompile>
<WppEnabled>false</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|Win32'">
<ClCompile>
<WppEnabled>false</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|Win32'">
<ClCompile>
<WppEnabled>false</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|Win32'">
<ClCompile>
<WppEnabled>false</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|Win32'">
<ClCompile>
<WppEnabled>false</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|Win32'">
<ClCompile>
<WppEnabled>false</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Debug|x64'">
<ClCompile>
<WppEnabled>true</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win8.1 Release|x64'">
<ClCompile>
<WppEnabled>true</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Debug|x64'">
<ClCompile>
<WppEnabled>true</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win8 Release|x64'">
<ClCompile>
<WppEnabled>true</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Debug|x64'">
<ClCompile>
<WppEnabled>true</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Win7 Release|x64'">
<ClCompile>
<WppEnabled>true</WppEnabled>
<WppScanConfigurationData Condition="'%(ClCompile. ScanConfigurationData)' == ''">trace.h</WppScanConfigurationData>
<WppKernelMode>true</WppKernelMode>
</ClCompile>
</ItemDefinitionGroup>
<ItemGroup>
<Inf Include="pcivme.inf" />
</ItemGroup>
<ItemGroup>
<FilesToPackage Include="$(TargetPath)" />
<FilesToPackage Include="@(Inf->'%(CopyOutput)')" Condition="'@(Inf)'!=''" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="SOURCE\guid.h" />
<ClInclude Include="SOURCE\pciif.h" />
<ClInclude Include="SOURCE\pcivme.h" />
<ClInclude Include="SOURCE\pcivme_drv.h" />
<ClInclude Include="SOURCE\pcivme_fifo.h" />
<ClInclude Include="SOURCE\pcivme_i.h" />
<ClInclude Include="SOURCE\pcivme_io.h" />
<ClInclude Include="SOURCE\pcivme_v.h" />
<ClInclude Include="SOURCE\Vic.h" />
<ClInclude Include="SOURCE\Vme.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="SOURCE\pcivme_drv.c" />
<ClCompile Include="SOURCE\pcivme_fifo.c" />
<ClCompile Include="SOURCE\pcivme_i.c" />
<ClCompile Include="SOURCE\pcivme_io.c" />
<ClCompile Include="SOURCE\pcivme_v.c" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

/wiener_pcivme/pcivme/pcivme.inf
0,0 → 1,97
;
; pcivme.inf
;
[Version]
Signature="$WINDOWS NT$"
Provider = %ManufacturerName%
Class = %PCIVME_class_name%
ClassGUID = {c4ad1dfa-3e35-4659-bf2b-c83cda6833e1}
DriverVer = 02/10/2014, 4.0.0.0
CatalogFile=pcivme.cat
;DriverVer= ; TODO: set DriverVer in stampinf property pages
[DestinationDirs]
DefaultDestDir = 12
; ================= Class section =====================
[ClassInstall32]
Addreg=SampleClassReg
[SampleClassReg]
HKR,,,0,%ClassName%
HKR,,Icon,,-5
[SourceDisksNames]
1 = %DiskName%,,,""
[SourceDisksFiles]
pcivme.sys = 1,,
;*****************************************
; Install Section
;*****************************************
[Manufacturer]
%ManufacturerName%=Standard,NT$ARCH$
[Standard.NT$ARCH$]
;%pcivme.DeviceDesc%=pcivme_Device, Root\pcivme ; TODO: edit hw-id
%pcivme.DeviceDesc%=pcivme_Device, PCI\VEN_10B5&DEV_9050
%pcivme.DeviceDesc%=pcivme_Device, PCI\VEN_10B5&DEV_9050&SUBSYS_11679050
%pcivme.DeviceDesc%=pcivme_Device, PCI\VEN_10B5&DEV_9050&SUBSYS_11679050&REV_01
%pcivme.DeviceDesc%=pcivme_Device, PCI\VEN_10B5&DEV_9050&SUBSYS_11679050&REV_02
[pcivme_Device.NT]
CopyFiles=Drivers_Dir
[Drivers_Dir]
pcivme.sys
;-------------- Service installation
[pcivme_Device.NT.Services]
AddService = pcivme,%SPSVCINST_ASSOCSERVICE%, pcivme_Service_Inst
; -------------- pcivme driver install sections
[pcivme_Service_Inst]
DisplayName = %pcivme.SVCDESC%
ServiceType = 1 ; SERVICE_KERNEL_DRIVER
StartType = 3 ; SERVICE_DEMAND_START
ErrorControl = 0 ; SERVICE_ERROR_IGNORE
ServiceBinary = %12%\pcivme.sys
LoadOrderGroup = Extended Base
;
;--- pcivme_Device Coinstaller installation ------
;
[DestinationDirs]
pcivme_Device_CoInstaller_CopyFiles = 11
[pcivme_Device.NT.CoInstallers]
AddReg=pcivme_Device_CoInstaller_AddReg
CopyFiles=pcivme_Device_CoInstaller_CopyFiles
[pcivme_Device_CoInstaller_AddReg]
HKR,,CoInstallers32,0x00010000, "WdfCoInstaller$KMDFCOINSTALLERVERSION$.dll,WdfCoInstaller"
[pcivme_Device_CoInstaller_CopyFiles]
WdfCoInstaller$KMDFCOINSTALLERVERSION$.dll
[SourceDisksFiles]
WdfCoInstaller$KMDFCOINSTALLERVERSION$.dll=1 ; make sure the number matches with SourceDisksNames
[pcivme_Device.NT.Wdf]
KmdfService = pcivme, pcivme_wdfsect
[pcivme_wdfsect]
KmdfLibraryVersion = $KMDFVERSION$
[Strings]
SPSVCINST_ASSOCSERVICE= 0x00000002
ManufacturerName="ARW Elektronik, Germany" ; TODO: add ManufacturerName
ClassName="ARW BUS Interfaces" ; TODO: edit ClassName
DiskName = "pcivme Installation Disk"
pcivme.DeviceDesc = "pcivme Device"
pcivme.SVCDESC = "pcivme Service"

/wiener_pcivme/pcivme.sdf
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/wiener_pcivme/pcivme.sln
0,0 → 1,105

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.30110.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pcivme", "pcivme\pcivme.vcxproj", "{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "pcivme Package", "pcivme Package\pcivme Package.vcxproj", "{48C072A6-A36E-4090-B208-F0084AC06272}"
ProjectSection(ProjectDependencies) = postProject
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE} = {2AC3560D-0575-4214-A7AA-04F7A8DE84BE}
EndProjectSection
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Win7 Debug|Win32 = Win7 Debug|Win32
Win7 Debug|x64 = Win7 Debug|x64
Win7 Release|Win32 = Win7 Release|Win32
Win7 Release|x64 = Win7 Release|x64
Win8 Debug|Win32 = Win8 Debug|Win32
Win8 Debug|x64 = Win8 Debug|x64
Win8 Release|Win32 = Win8 Release|Win32
Win8 Release|x64 = Win8 Release|x64
Win8.1 Debug|Win32 = Win8.1 Debug|Win32
Win8.1 Debug|x64 = Win8.1 Debug|x64
Win8.1 Release|Win32 = Win8.1 Release|Win32
Win8.1 Release|x64 = Win8.1 Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Debug|Win32.ActiveCfg = Win7 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Debug|Win32.Build.0 = Win7 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Debug|Win32.Deploy.0 = Win7 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Debug|x64.ActiveCfg = Win7 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Debug|x64.Build.0 = Win7 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Debug|x64.Deploy.0 = Win7 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Release|Win32.ActiveCfg = Win7 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Release|Win32.Build.0 = Win7 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Release|Win32.Deploy.0 = Win7 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Release|x64.ActiveCfg = Win7 Release|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Release|x64.Build.0 = Win7 Release|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win7 Release|x64.Deploy.0 = Win7 Release|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Debug|Win32.ActiveCfg = Win8 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Debug|Win32.Build.0 = Win8 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Debug|Win32.Deploy.0 = Win8 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Debug|x64.ActiveCfg = Win8 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Debug|x64.Build.0 = Win8 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Debug|x64.Deploy.0 = Win8 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Release|Win32.ActiveCfg = Win8 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Release|Win32.Build.0 = Win8 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Release|Win32.Deploy.0 = Win8 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Release|x64.ActiveCfg = Win8 Release|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Release|x64.Build.0 = Win8 Release|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8 Release|x64.Deploy.0 = Win8 Release|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Debug|Win32.ActiveCfg = Win8.1 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Debug|Win32.Build.0 = Win8.1 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Debug|Win32.Deploy.0 = Win8.1 Debug|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Debug|x64.ActiveCfg = Win8.1 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Debug|x64.Build.0 = Win8.1 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Debug|x64.Deploy.0 = Win8.1 Debug|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Release|Win32.ActiveCfg = Win8.1 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Release|Win32.Build.0 = Win8.1 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Release|Win32.Deploy.0 = Win8.1 Release|Win32
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Release|x64.ActiveCfg = Win8.1 Release|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Release|x64.Build.0 = Win8.1 Release|x64
{2AC3560D-0575-4214-A7AA-04F7A8DE84BE}.Win8.1 Release|x64.Deploy.0 = Win8.1 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Debug|Win32.ActiveCfg = Win7 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Debug|Win32.Build.0 = Win7 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Debug|Win32.Deploy.0 = Win7 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Debug|x64.ActiveCfg = Win7 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Debug|x64.Build.0 = Win7 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Debug|x64.Deploy.0 = Win7 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Release|Win32.ActiveCfg = Win7 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Release|Win32.Build.0 = Win7 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Release|Win32.Deploy.0 = Win7 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Release|x64.ActiveCfg = Win7 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Release|x64.Build.0 = Win7 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win7 Release|x64.Deploy.0 = Win7 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Debug|Win32.ActiveCfg = Win8 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Debug|Win32.Build.0 = Win8 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Debug|Win32.Deploy.0 = Win8 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Debug|x64.ActiveCfg = Win8 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Debug|x64.Build.0 = Win8 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Debug|x64.Deploy.0 = Win8 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Release|Win32.ActiveCfg = Win8 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Release|Win32.Build.0 = Win8 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Release|Win32.Deploy.0 = Win8 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Release|x64.ActiveCfg = Win8 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Release|x64.Build.0 = Win8 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8 Release|x64.Deploy.0 = Win8 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Debug|Win32.ActiveCfg = Win8.1 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Debug|Win32.Build.0 = Win8.1 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Debug|Win32.Deploy.0 = Win8.1 Debug|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Debug|x64.ActiveCfg = Win8.1 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Debug|x64.Build.0 = Win8.1 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Debug|x64.Deploy.0 = Win8.1 Debug|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Release|Win32.ActiveCfg = Win8.1 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Release|Win32.Build.0 = Win8.1 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Release|Win32.Deploy.0 = Win8.1 Release|Win32
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Release|x64.ActiveCfg = Win8.1 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Release|x64.Build.0 = Win8.1 Release|x64
{48C072A6-A36E-4090-B208-F0084AC06272}.Win8.1 Release|x64.Deploy.0 = Win8.1 Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal