501 lines
15 KiB
C#
501 lines
15 KiB
C#
//----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) Intel Corporation, 2003 - 2012 All Rights Reserved.
|
|
//
|
|
// File: CIM_PCIController.cs
|
|
//
|
|
// Contents: PCIController is a superclass for the PCIBridge and PCIDevice classes. These classes model adapters and bridges on a PCI bus. The properties in PCIController and its subclasses are defined in the various PCI Specifications that are published by the PCI SIG.
|
|
// This file was automatically generated from CIM_PCIController.mof
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Text;
|
|
using System.Globalization;
|
|
using System.Xml.Serialization;
|
|
using System.IO;
|
|
using Intel.Manageability.WSManagement;
|
|
using Intel.Manageability.Cim.Untyped;
|
|
|
|
|
|
namespace Intel.Manageability.Cim.Typed
|
|
{
|
|
/// <summary>
|
|
///PCIController is a superclass for the PCIBridge and PCIDevice classes. These classes model adapters and bridges on a PCI bus. The properties in PCIController and its subclasses are defined in the various PCI Specifications that are published by the PCI SIG.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PCIController")]
|
|
[System.Xml.Serialization.XmlRootAttribute("CIM_PCIController", Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PCIController", IsNullable=false)]
|
|
public class CIM_PCIController : CIM_Controller
|
|
{
|
|
/// <summary>
|
|
/// Default constructor.
|
|
/// </summary>
|
|
public CIM_PCIController() :base()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Constructor that recieves an xml string for deserialization.
|
|
/// </summary>
|
|
/// <param name="xml">xml string to deserialize</param>
|
|
public CIM_PCIController(string xml): base((IWSManClient)null)
|
|
{
|
|
this.Deserialize(xml);
|
|
}
|
|
/// <summary>
|
|
/// Constructor which recieves a Ws-Management client object.
|
|
/// </summary>
|
|
/// <param name="client">Ws-Management client</param>
|
|
public CIM_PCIController(IWSManClient client): base(client)
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Remove CacheLineSize field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveCacheLineSize()
|
|
{
|
|
RemoveField("CacheLineSize");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field CacheLineSize exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool CacheLineSizeExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("CacheLineSize");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Specifies the system cache line size in doubleword increments (for example, a 486-based system would store the value 04h, indicating a cache line size of four doublewords.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual byte CacheLineSize
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["CacheLineSize"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("CacheLineSize",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove Capabilities field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveCapabilities()
|
|
{
|
|
RemoveField("Capabilities");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field Capabilities exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool CapabilitiesExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("Capabilities");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, An array of integers that indicates controller capabilities. Information such as "Supports 66MHz" (value=2) is specified in this property. The data in the Capabilities array is gathered from the PCI Status Register and the PCI Capabilities List as defined in the PCI Specification.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort[] Capabilities
|
|
{
|
|
get
|
|
{
|
|
return CimTypesUtils.StringArrayToArray<ushort>(this["Capabilities"]);
|
|
}
|
|
set
|
|
{
|
|
string[] arr = CimTypesUtils.ArrayToStringArray<ushort>(value);
|
|
this.SetOrAddField("Capabilities", arr);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove CapabilityDescriptions field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveCapabilityDescriptions()
|
|
{
|
|
RemoveField("CapabilityDescriptions");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field CapabilityDescriptions exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool CapabilityDescriptionsExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("CapabilityDescriptions");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, An array of free-form strings that provides more detailed explanations for any of the PCIController features that are indicated in the Capabilities array. Note, each entry of this array is related to the entry in the Capabilities array that is located at the same index.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual string[] CapabilityDescriptions
|
|
{
|
|
get
|
|
{
|
|
return CimTypesUtils.StringArrayToArray<string>(this["CapabilityDescriptions"]);
|
|
}
|
|
set
|
|
{
|
|
string[] arr = CimTypesUtils.ArrayToStringArray<string>(value);
|
|
this.SetOrAddField("CapabilityDescriptions", arr);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove ClassCode field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveClassCode()
|
|
{
|
|
RemoveField("ClassCode");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field ClassCode exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool ClassCodeExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("ClassCode");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Register of 8 bits that identifies the basic function of the PCI device. This property is only the upper byte (offset 0Bh) of the 3-byte ClassCode field. Note that the ValueMap array of the property specifies the decimal representation of this information.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual byte ClassCode
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["ClassCode"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("ClassCode",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove CommandRegister field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveCommandRegister()
|
|
{
|
|
RemoveField("CommandRegister");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field CommandRegister exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool CommandRegisterExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("CommandRegister");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Current contents of the register that provides basic control over the ability of the device to respond to or perform PCI accesses.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort CommandRegister
|
|
{
|
|
get
|
|
{
|
|
return ushort.Parse(this["CommandRegister"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("CommandRegister",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove DeviceSelectTiming field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveDeviceSelectTiming()
|
|
{
|
|
RemoveField("DeviceSelectTiming");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field DeviceSelectTiming exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool DeviceSelectTimingExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("DeviceSelectTiming");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, The slowest device-select timing for a target device.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort DeviceSelectTiming
|
|
{
|
|
get
|
|
{
|
|
return ushort.Parse(this["DeviceSelectTiming"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("DeviceSelectTiming",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove ExpansionROMBaseAddress field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveExpansionROMBaseAddress()
|
|
{
|
|
RemoveField("ExpansionROMBaseAddress");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field ExpansionROMBaseAddress exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool ExpansionROMBaseAddressExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("ExpansionROMBaseAddress");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Doubleword Expansion ROM-base memory address.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual uint ExpansionROMBaseAddress
|
|
{
|
|
get
|
|
{
|
|
return uint.Parse(this["ExpansionROMBaseAddress"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("ExpansionROMBaseAddress",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove InterruptPin field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveInterruptPin()
|
|
{
|
|
RemoveField("InterruptPin");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field InterruptPin exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool InterruptPinExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("InterruptPin");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Defines the PCI interrupt request pin (INTA# to INTD#) to which a PCI functional device is connected.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort InterruptPin
|
|
{
|
|
get
|
|
{
|
|
return ushort.Parse(this["InterruptPin"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("InterruptPin",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove LatencyTimer field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveLatencyTimer()
|
|
{
|
|
RemoveField("LatencyTimer");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field LatencyTimer exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool LatencyTimerExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("LatencyTimer");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Defines the minimum amount of time, in PCI clock cycles, that the bus master can retain ownership of the bus.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual byte LatencyTimer
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["LatencyTimer"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("LatencyTimer",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove SelfTestEnabled field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveSelfTestEnabled()
|
|
{
|
|
RemoveField("SelfTestEnabled");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field SelfTestEnabled exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool SelfTestEnabledExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("SelfTestEnabled");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Reports if the PCI device can perform the self-test function. Returns bit 7 of the BIST register as a Boolean.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual bool SelfTestEnabled
|
|
{
|
|
get
|
|
{
|
|
return bool.Parse(this["SelfTestEnabled"][0]);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("SelfTestEnabled",value.ToString().ToLower(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
///Method to invoke PCI device self-test. This method sets bit 6 of the BIST register. The return result is the lower 4 bits of the BIST register where 0 indicates success and non-zero is a device-dependent failure. Support for this method is optional in the PCI Specification.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PCIController", IsNullable=false)]
|
|
private class BISTExecution_INPUT : CimParams
|
|
{
|
|
public BISTExecution_INPUT(string ns) : base(ns)
|
|
{
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
///Method to invoke PCI device self-test. This method sets bit 6 of the BIST register. The return result is the lower 4 bits of the BIST register where 0 indicates success and non-zero is a device-dependent failure. Support for this method is optional in the PCI Specification.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(AnonymousType=true)]
|
|
[System.Xml.Serialization.XmlRootAttribute(Namespace="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_PCIController", IsNullable=false)]
|
|
private class BISTExecution_OUTPUT : CimParams
|
|
{
|
|
public BISTExecution_OUTPUT() : base("")
|
|
{
|
|
}
|
|
|
|
}
|
|
/// <summary>
|
|
///Method to invoke PCI device self-test. This method sets bit 6 of the BIST register. The return result is the lower 4 bits of the BIST register where 0 indicates success and non-zero is a device-dependent failure. Support for this method is optional in the PCI Specification.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// </returns>
|
|
public virtual uint BISTExecution()
|
|
{
|
|
BISTExecution_INPUT input = new BISTExecution_INPUT(this.XmlNamespace);
|
|
BISTExecution_OUTPUT output = new BISTExecution_OUTPUT();
|
|
uint returnValue = base.Invoke("BISTExecution",input,out output);
|
|
return returnValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of CIM_PCIController class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <param name="cimKeys">Keys for selecting the instances</param>
|
|
/// <returns>Collection of CIM_PCIController objects</returns>
|
|
public static new Collection<CIM_PCIController> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
|
|
{
|
|
List<CIM_PCIController> ret = CimBase.Enumerate<CIM_PCIController>(client, cimKeys);
|
|
return new Collection<CIM_PCIController>(ret);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of CIM_PCIController class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <returns>Collection of CIM_PCIController objects</returns>
|
|
public static new Collection<CIM_PCIController> Enumerate(IWSManClient client)
|
|
{
|
|
List<CIM_PCIController> ret = CimBase.Enumerate<CIM_PCIController>(client);
|
|
return new Collection<CIM_PCIController>(ret);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Delete the instance of CIM_PCIController if it is singular.
|
|
/// Note: This method will succeed only if a single instance of the class exists.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
public static new void Delete(IWSManClient client)
|
|
{
|
|
CimBase.Delete<CIM_PCIController>(client);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Represents the keys of the CIM_PCIController class.
|
|
/// </summary>
|
|
|
|
public new class CimKeys : CIM_Controller.CimKeys
|
|
{
|
|
}
|
|
|
|
}
|
|
}
|
|
|