530 lines
13 KiB
C#
530 lines
13 KiB
C#
//----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) Intel Corporation, 2003 - 2012 All Rights Reserved.
|
|
//
|
|
// File: AMT_PCIDevice.cs
|
|
//
|
|
// Contents: Capabilities and management of a PCI device controller on an adapter card.
|
|
// This file was automatically generated from AMT_PCIDevice.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>
|
|
///Capabilities and management of a PCI device controller on an adapter card.
|
|
/// </summary>
|
|
[System.SerializableAttribute()]
|
|
[System.Xml.Serialization.XmlTypeAttribute(Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_PCIDevice")]
|
|
[System.Xml.Serialization.XmlRootAttribute("AMT_PCIDevice", Namespace="http://intel.com/wbem/wscim/1/amt-schema/1/AMT_PCIDevice", IsNullable=false)]
|
|
public class AMT_PCIDevice : CIM_PCIController
|
|
{
|
|
/// <summary>
|
|
/// Default constructor.
|
|
/// </summary>
|
|
public AMT_PCIDevice() :base()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Constructor that recieves an xml string for deserialization.
|
|
/// </summary>
|
|
/// <param name="xml">xml string to deserialize</param>
|
|
public AMT_PCIDevice(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 AMT_PCIDevice(IWSManClient client): base(client)
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// Remove BaseAddress field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveBaseAddress()
|
|
{
|
|
RemoveField("BaseAddress");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field BaseAddress exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool BaseAddressExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("BaseAddress");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Array of doubleword base-memory addresses.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual uint[] BaseAddress
|
|
{
|
|
get
|
|
{
|
|
return CimTypesUtils.StringArrayToArray<uint>(this["BaseAddress"]);
|
|
}
|
|
set
|
|
{
|
|
string[] arr = CimTypesUtils.ArrayToStringArray<uint>(value);
|
|
this.SetOrAddField("BaseAddress", arr);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove ClassCode field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public override void RemoveClassCode()
|
|
{
|
|
RemoveField("ClassCode");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field ClassCode exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public override bool ClassCodeExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("ClassCode");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, The PCI class code read from the device's PCI configuration space.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public override byte ClassCode
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["ClassCode"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("ClassCode",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Required, An address or other identifying information to uniquely name the PCI device.
|
|
/// </summary>
|
|
[CimField(true, true)]
|
|
public override string DeviceID
|
|
{
|
|
get
|
|
{
|
|
return this.GetField("DeviceID")[0];
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("DeviceID",value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove DeviceLocation field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveDeviceLocation()
|
|
{
|
|
RemoveField("DeviceLocation");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field DeviceLocation exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool DeviceLocationExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("DeviceLocation");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, The bus, device, and function number of the device.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort DeviceLocation
|
|
{
|
|
get
|
|
{
|
|
return ushort.Parse(this["DeviceLocation"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("DeviceLocation",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove MaxLatency field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveMaxLatency()
|
|
{
|
|
RemoveField("MaxLatency");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field MaxLatency exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool MaxLatencyExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("MaxLatency");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Register that specifies how often the device needs access to the PCI bus in 250ns. A 0 value indicates no requirement.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual byte MaxLatency
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["MaxLatency"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("MaxLatency",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove MinGrantTime field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveMinGrantTime()
|
|
{
|
|
RemoveField("MinGrantTime");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field MinGrantTime exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool MinGrantTimeExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("MinGrantTime");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Register that indicates how long the master would like to retain PCI bus ownership whenever it initiates a transaction. A 0 value indicates no requirement.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual byte MinGrantTime
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["MinGrantTime"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("MinGrantTime",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove ProgIf field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveProgIf()
|
|
{
|
|
RemoveField("ProgIf");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field ProgIf exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool ProgIfExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("ProgIf");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, The programmatic interface code read from the device's PCI configuration space.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual byte ProgIf
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["ProgIf"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("ProgIf",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove RevisionID field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveRevisionID()
|
|
{
|
|
RemoveField("RevisionID");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field RevisionID exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool RevisionIDExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("RevisionID");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, The revision ID read from the device's PCI configuration space.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual byte RevisionID
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["RevisionID"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("RevisionID",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove Subclass field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveSubclass()
|
|
{
|
|
RemoveField("Subclass");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field Subclass exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool SubclassExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("Subclass");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, The PCI subclass code read from the device's PCI configuration space.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual byte Subclass
|
|
{
|
|
get
|
|
{
|
|
return byte.Parse(this["Subclass"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("Subclass",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove SubsystemID field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveSubsystemID()
|
|
{
|
|
RemoveField("SubsystemID");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field SubsystemID exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool SubsystemIDExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("SubsystemID");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, The subsystem ID read from the device's PCI configuration space.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort SubsystemID
|
|
{
|
|
get
|
|
{
|
|
return ushort.Parse(this["SubsystemID"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("SubsystemID",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove SubsystemVendorID field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveSubsystemVendorID()
|
|
{
|
|
RemoveField("SubsystemVendorID");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field SubsystemVendorID exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool SubsystemVendorIDExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("SubsystemVendorID");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, Subsystem vendor ID. ID information is reported from a PCIDevice through protocol-specific requests. The correct place in the CIM Schema for this information is in CIM_Physical Element (the Manufacturer property) for hardware, and CIM_Product (the Vendor property) if the information is related to Product acquisition. This data is also reported here, because it is part of the standard output from the Device and is an optimization.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort SubsystemVendorID
|
|
{
|
|
get
|
|
{
|
|
return ushort.Parse(this["SubsystemVendorID"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("SubsystemVendorID",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Remove VendorID field.
|
|
/// Note: This method will succeed only if this field is optional in the concrete object.
|
|
/// </summary>
|
|
public virtual void RemoveVendorID()
|
|
{
|
|
RemoveField("VendorID");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is true if the field VendorID exists in the current object,
|
|
/// otherwise is false.
|
|
/// </summary>
|
|
public virtual bool VendorIDExist
|
|
{
|
|
get
|
|
{
|
|
return ContainsField("VendorID");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optional, The vendor ID read from the device's PCI configuration space.
|
|
/// </summary>
|
|
[CimField(false, false)]
|
|
public virtual ushort VendorID
|
|
{
|
|
get
|
|
{
|
|
return ushort.Parse(this["VendorID"][0], CultureInfo.InvariantCulture);
|
|
}
|
|
set
|
|
{
|
|
this.SetOrAddField("VendorID",value.ToString(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of AMT_PCIDevice class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <param name="cimKeys">Keys for selecting the instances</param>
|
|
/// <returns>Collection of AMT_PCIDevice objects</returns>
|
|
public static new Collection<AMT_PCIDevice> Enumerate(IWSManClient client, CimBase.CimKeys cimKeys)
|
|
{
|
|
List<AMT_PCIDevice> ret = CimBase.Enumerate<AMT_PCIDevice>(client, cimKeys);
|
|
return new Collection<AMT_PCIDevice>(ret);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Enumerate instances of AMT_PCIDevice class at an endpoint.
|
|
/// </summary>
|
|
/// <param name="client">WS-Management client</param>
|
|
/// <returns>Collection of AMT_PCIDevice objects</returns>
|
|
public static new Collection<AMT_PCIDevice> Enumerate(IWSManClient client)
|
|
{
|
|
List<AMT_PCIDevice> ret = CimBase.Enumerate<AMT_PCIDevice>(client);
|
|
return new Collection<AMT_PCIDevice>(ret);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Delete the instance of AMT_PCIDevice 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<AMT_PCIDevice>(client);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Represents the keys of the AMT_PCIDevice class.
|
|
/// </summary>
|
|
|
|
public new class CimKeys : CIM_PCIController.CimKeys
|
|
{
|
|
/// <summary>
|
|
/// Required, An address or other identifying information to uniquely name the PCI device.
|
|
/// </summary>
|
|
|
|
public virtual string DeviceID
|
|
{
|
|
get
|
|
{
|
|
return GetKey("DeviceID");
|
|
}
|
|
set
|
|
{
|
|
SetOrAddKey("DeviceID", value);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|