Logo Search packages:      
Sourcecode: wireshark version File versions  Download package

packet-ipmi.c

/* packet-ipmi.c
 * Routines for IPMI-over-LAN packet dissection
 *
 * Duncan Laurie <duncan@sun.com>
 *
 * $Id: packet-ipmi.c 18412 2006-06-09 22:55:25Z sahlberg $
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * Copied from packet-rmcp.c
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 *
 *
 * See the IPMI spec at
 *
 *    http://www.intel.com/design/servers/ipmi/
 *
 * IPMI LAN Message Request
 *  ipmi.session.authtype
 *  ipmi.session.sequence
 *  ipmi.session.id
 * [ipmi.session.authcode]
 *  ipmi.msg.len
 *  ipmi.msg.rsaddr
 *  ipmi.msg.netfn << 2 | ipmi.msg.rslun
 *  ipmi.msg.csum1
 *  ipmi.msg.rqaddr
 *  ipmi.msg.seq << 2 | ipmi.msg.rqlun
 *  ipmi.msg.cmd
 *  ipmi.msg.DATA
 *  ipmi.msg.csum2
 *
 * IPMI LAN Message Response
 *  ipmi.session.authtype
 *  ipmi.session.sequence
 *  ipmi.session.id
 * [ipmi.session.authcode]
 *  ipmi.msg.len
 *  ipmi.msg.rqaddr
 *  ipmi.msg.netfn << 2 | ipmi.msg.rqlun
 *  ipmi.msg.csum1
 *  ipmi.msg.rsaddr
 *  ipmi.msg.seq << 2 | ipmi.msg.rslun
 *  ipmi.msg.cmd
 *  ipmi.msg.ccode
 *  ipmi.msg.DATA
 *  ipmi.msg.csum2
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <glib.h>
#include <epan/packet.h>

#define RMCP_CLASS_IPMI 0x07

static dissector_handle_t data_handle;
static int proto_ipmi = -1;

static gint ett_ipmi = -1;
static gint ett_ipmi_session = -1;
static gint ett_ipmi_msg_nlfield = -1;
static gint ett_ipmi_msg_slfield = -1;

/********* Sensor/Event, NetFN = 0x04 *********/

/* Platform Event Message, added by lane */
static gint ett_cmd_PEM_EventDirAndEventType = -1;
static gint ett_cmd_PEM_EventData1_threshold = -1;
static gint ett_cmd_PEM_EventData1_discrete = -1;
static gint ett_cmd_PEM_EventData2_discrete = -1;
static gint ett_cmd_PEM_EventData1_OEM = -1;
static gint ett_cmd_PEM_EventData2_OEM = -1;
/* Get Device SDR Info, added by lane */
static gint ett_cmd_GetDeviceSDRInfo_Flag = -1; /* add subtree for Flag */
/* Get Sensor Reading, added by lane */
static gint ett_cmd_GetSensorReading_ResponseDataByte2 = -1;
static gint ett_cmd_GetSensorReading_ResponseDataByte3 = -1;
static gint ett_cmd_GetSensorReading_ResponseDataByte3_threshold = -1;
static gint ett_cmd_GetSensorReading_ResponseDataByte4 = -1;
/* Set Sensor Thresholds, added by lane */
static gint ett_cmd_SetSensorThresholds_ControlByte = -1;
/* Get Sensor Thresholds, added by lane */
static gint ett_cmd_GetSensorThresholds_ControlByte = -1;

/********* APP, NetFN = 0x06 *********/

/* Get Device ID, added by lane */
static gint ett_cmd_GetDeviceID_data_dr = -1;    /* add subtree for Device Revision field  */
static gint ett_cmd_GetDeviceID_data_fr = -1;     /* add subtree for firmware Revision field  */
static gint ett_cmd_GetDeviceID_data_ads = -1;  /* add subtree for Additional Device Support */


/********* Storage, NetFN = 0x0a *********/

/* Get FRU Inventory Area Info, added by lane */
static gint ett_cmd_GetFRUInventoryAreaInfo_data_ResponseDataByte4 = -1;    /* add subtree for ResponseDataByte4 */
/* Get SEL Info, added by lane */
static gint ett_cmd_GetSELInfo_data_OperationSupport = -1;    /* add subtree for Operation Support */
/* Clear SEL, added by lane */
static gint ett_cmd_ClearSEL_data_ErasureProgress = -1;    /* add subtree for Erasure Progress */

/********* PICMG, NetFN = 0x2c *********/

/* Get FRU Led Properties, added by lane */
static gint  ett_cmd_GetFRULedProperties_data_LedProperties = -1; /* add subtree for Get FRU Led Properties */
/* Get Led Color Capabilities, added by lane */
static gint ett_cmd_GetLedColorCapabilities_data_LEDColorCapabilities = -1; /* add subtree for LED Color Capabilities */
static gint ett_cmd_GetLedColorCapabilities_data_DefaultLEDColorLocalControl = -1; /* add subtree for Default LED Color in Local Control State */
static gint ett_cmd_GetLedColorCapabilities_data_DefaultLEDColorOverride = -1; /* add subtree for Get Default LED Color  in Override State */
/* Set FRU Led State, added by lane */
static gint ett_cmd_SetFRULedState_data_Color = -1; /* add subtree for Color when illuminated */
/* Get FRU Led State, added by lane */
static gint ett_cmd_GetFRULedState_data_LEDState = -1;   /* add subtree for LED State*/
static gint ett_cmd_GetFRULedState_data_LocalControlColor = -1;  /* add subtree for Local Control Color*/
static gint ett_cmd_GetFRULedState_data_OverrideStateColor = -1;  /* add subtree for Override State Color*/
/* Set FRU Activation Policy, added by lane */
static gint ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicyMaskBit = -1; 
static gint ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicySetBit = -1; 
/* Get FRU Activation Policy, added by lane */
static gint ett_cmd_GetFRUActivationPolicy_data_FRUActivationPolicy = -1; 
/* Get Power Level, added by lane */
static gint ett_cmd_GetPowerLevel_data_Properties = -1; /* add subtree for Properties */


/***************************************************************************************************/


/* IPMI session header */
static int hf_ipmi_session_id = -1;
static int hf_ipmi_session_authtype = -1;
static int hf_ipmi_session_sequence = -1;
static int hf_ipmi_session_authcode = -1;

/* IPMI message header */
static int hf_ipmi_msg_len = -1;
static int hf_ipmi_msg_rsaddr = -1;
static int hf_ipmi_msg_nlfield = -1;
static int hf_ipmi_msg_netfn = -1;
static int hf_ipmi_msg_rqlun = -1;
static int hf_ipmi_msg_csum1 = -1;
static int hf_ipmi_msg_rqaddr = -1;
static int hf_ipmi_msg_slfield = -1;
static int hf_ipmi_msg_seq = -1;
static int hf_ipmi_msg_rslun = -1;
static int hf_ipmi_msg_cmd = -1;
static int hf_ipmi_msg_ccode = -1;
static int hf_ipmi_msg_csum2 = -1;

/********* Sensor/Event, NetFN = 0x04 **********/

/* Platform Event Message, added by lane */
static int hf_PEM_datafield_EvMRev = -1; 
static int hf_PEM_datafield_SensorType = -1; 
static int hf_PEM_datafield_SensorNumber = -1; 
static int hf_PEM_datafield_EventDirAndEventType_EventDir = -1; 
static int hf_PEM_datafield_EventDirAndEventType_EventType = -1; 

static int hf_PEM_datafield_EventData1_threshold_76 = -1; 
static int hf_PEM_datafield_EventData1_threshold_54 = -1; 
static int hf_PEM_datafield_EventData1_threshold_30 = -1; 
static int hf_PEM_datafield_EventData2_threshold = -1; 
static int hf_PEM_datafield_EventData3_threshold = -1; 

static int hf_PEM_datafield_EventData1_discrete_76 = -1; 
static int hf_PEM_datafield_EventData1_discrete_54 = -1; 
static int hf_PEM_datafield_EventData1_discrete_30 = -1; 
static int hf_PEM_datafield_EventData2_discrete_74 = -1; 
static int hf_PEM_datafield_EventData2_discrete_30 = -1; 
static int hf_PEM_datafield_EventData3_discrete = -1; 

static int hf_PEM_datafield_EventData1_OEM_76 = -1; 
static int hf_PEM_datafield_EventData1_OEM_54 = -1; 
static int hf_PEM_datafield_EventData1_OEM_30 = -1; 
static int hf_PEM_datafield_EventData2_OEM_74 = -1; 
static int hf_PEM_datafield_EventData2_OEM_30 = -1; 
static int hf_PEM_datafield_EventData3_OEM = -1; 

static int hf_PEM_datafield_HotSwapEvent_CurrentState = -1; 
static int hf_PEM_datafield_HotSwapEvent_StateChangeCause = -1;
static int hf_PEM_datafield_HotSwapEvent_PreviousState = -1;
static int hf_PEM_datafield_HotSwapEvent_FRUDeviceID = -1;

/* Get Device SDR Info, added by lane */
static int hf_GetDeviceSDRInfo_datafield_SensorNumber = -1;
static int hf_GetDeviceSDRInfo_datafield_Flag = -1;
static int hf_GetDeviceSDRInfo_datafield_Flag_Dynamicpopulation = -1;
static int hf_GetDeviceSDRInfo_datafield_Flag_Reserved = -1;
static int hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs3 = -1;
static int hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs2 = -1;
static int hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs1 = -1;
static int hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs0 = -1;
static int hf_GetDeviceSDRInfo_datafield_SensorPopulationChangeIndicator = -1;
/* Get Device SDR, added by lane */
static int hf_GetDeviceSDR_datafield_NextRecordID = -1;
static int hf_GetDeviceSDR_datafield_ReservationID = -1;
static int hf_GetDeviceSDR_datafield_RecordID = -1;
static int hf_GetDeviceSDR_datafield_OffsetIntoRecord = -1; 
static int hf_GetDeviceSDR_datafield_BytesToRead = -1;
/* Reserve Device SDR Repository, added by lane */
static int hf_ReserveDeviceSDRRepository_datafield_ReservationID = -1;
/* Set Sensor Hysteresis, added by lane */
static int hf_SetSensorHysteresis_datafield_SensorNumber = -1;
static int hf_SetSensorHysteresis_datafield_ReservedForHysteresisMask = -1;
static int hf_SetSensorHysteresis_datafield_PositivegoingThresholdHysteresisValue = -1;
static int hf_SetSensorHysteresis_datafield_NegativegoingThresholdHysteresisValue = -1;
/* Get Sensor Hysteresis, added by lane */
static int hf_GetSensorHysteresis_datafield_SensorNumber = -1;
static int hf_GetSensorHysteresis_datafield_ReservedForHysteresisMask = -1;
static int hf_GetSensorHysteresis_datafield_PositivegoingThresholdHysteresisValue = -1;
static int hf_GetSensorHysteresis_datafield_NegativegoingThresholdHysteresisValue = -1;
/* Set Sensor Thresholds, added by lane */
static int hf_SetSensorThresholds_datafield_SensorNumber = -1;
static int hf_SetSensorThresholds_datafield_ControlByte_Bit76 = -1;
static int hf_SetSensorThresholds_datafield_ControlByte_Bit5 = -1;
static int hf_SetSensorThresholds_datafield_ControlByte_Bit4 = -1;
static int hf_SetSensorThresholds_datafield_ControlByte_Bit3 = -1;
static int hf_SetSensorThresholds_datafield_ControlByte_Bit2 = -1;
static int hf_SetSensorThresholds_datafield_ControlByte_Bit1 = -1;
static int hf_SetSensorThresholds_datafield_ControlByte_Bit0 = -1;
static int hf_SetSensorThresholds_datafield_LowerNonCriticalThreshold = -1;
static int hf_SetSensorThresholds_datafield_LowerCriticalThreshold = -1;
static int hf_SetSensorThresholds_datafield_LowerNonRecoverableThreshold = -1;
static int hf_SetSensorThresholds_datafield_UpperNonCriticalThreshold = -1;
static int hf_SetSensorThresholds_datafield_UpperCriticalThreshold = -1;
static int hf_SetSensorThresholds_datafield_UpperNonRecoverableThreshold = -1;
/* Get Sensor Thresholds, added by lane */
static int hf_GetSensorThresholds_datafield_SensorNumber = -1;
static int hf_GetSensorThresholds_datafield_ControlByte_Bit76 = -1;
static int hf_GetSensorThresholds_datafield_ControlByte_Bit5 = -1;
static int hf_GetSensorThresholds_datafield_ControlByte_Bit4 = -1;
static int hf_GetSensorThresholds_datafield_ControlByte_Bit3 = -1;
static int hf_GetSensorThresholds_datafield_ControlByte_Bit2 = -1;
static int hf_GetSensorThresholds_datafield_ControlByte_Bit1 = -1;
static int hf_GetSensorThresholds_datafield_ControlByte_Bit0 = -1;
static int hf_GetSensorThresholds_datafield_LowerNonCriticalThreshold = -1;
static int hf_GetSensorThresholds_datafield_LowerCriticalThreshold = -1;
static int hf_GetSensorThresholds_datafield_LowerNonRecoverableThreshold = -1;
static int hf_GetSensorThresholds_datafield_UpperNonCriticalThreshold = -1;
static int hf_GetSensorThresholds_datafield_UpperCriticalThreshold = -1;
static int hf_GetSensorThresholds_datafield_UpperNonRecoverableThreshold = -1;
/* Get Sensor Reading, added by lane */
static int hf_GetSensorReading_datafield_SensorNumber = -1;
static int hf_GetSensorReading_datafield_Sensorreading = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte2_Bit7 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte2_Bit6 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte2_Bit5 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte2_Bit40 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit7 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit6 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit5 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit4 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit3 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit2 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit1 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit0 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte4_Bit7 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte4_Bit6 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte4_Bit5 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte4_Bit4 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte4_Bit3 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte4_Bit2 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte4_Bit1 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte4_Bit0 = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit76_threshold = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit5_threshold = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit4_threshold = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit3_threshold = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit2_threshold = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit1_threshold = -1;
static int hf_GetSensorReading_datafield_ResponseDataByte3_Bit0_threshold = -1;

/********* App, NetFN = 0x06 *********/

/* Get Device ID, added by lane */
static int hf_GetDeviceID_datafield_DeviceID = -1;
static int hf_GetDeviceID_datafield_DeviceSDR = -1;
static int hf_GetDeviceID_datafield_DeviceRevision = -1;
static int hf_GetDeviceID_datafield_DeviceAvailable = -1;
static int hf_GetDeviceID_datafield_MajorFirmwareRevision = -1;
static int hf_GetDeviceID_datafield_MinorFirmwareRevision = -1;
static int hf_GetDeviceID_datafield_IPMIRevision = -1;
static int hf_GetDeviceID_datafield_ADS_Chasis = -1;
static int hf_GetDeviceID_datafield_ADS_Bridge = -1;
static int hf_GetDeviceID_datafield_ADS_IPMBEventGenerator = -1;
static int hf_GetDeviceID_datafield_ADS_IPMBEventReceiver = -1;
static int hf_GetDeviceID_datafield_ADS_FRUInventoryDevice = -1;
static int hf_GetDeviceID_datafield_ADS_SELDevice = -1;
static int hf_GetDeviceID_datafield_ADS_SDRRepositoryDevice = -1;
static int hf_GetDeviceID_datafield_ADS_SensorDevice = -1;
static int hf_GetDeviceID_datafield_ManufactureID = -1;
static int hf_GetDeviceID_datafield_ProductID = -1;
static int hf_GetDeviceID_datafield_AFRI = -1;

/********* Storage, NetFN = 0x0a *********/

/* Get FRU Inventory Area Info, added by lane */
static int hf_GetFRUInventoryAreaInfo_datafield_FRUDeviceID = -1;
static int hf_GetFRUInventoryAreaInfo_datafield_FRUInventoryAreaSize = -1;
static int hf_GetFRUInventoryAreaInfo_datafield_ResponseDataByte4_Bit71 = -1;
static int hf_GetFRUInventoryAreaInfo_datafield_ResponseDataByte4_Bit0 = -1;
/* Get SEL Info, added by lane */
static int hf_GetSELInfo_datafield_SELVersion = -1;
static int hf_GetSELInfo_datafield_Entries = -1;
static int hf_GetSELInfo_datafield_FreeSpace = -1;
static int hf_GetSELInfo_datafield_AdditionTimestamp = -1;
static int hf_GetSELInfo_datafield_EraseTimestamp = -1;
static int hf_GetSELInfo_datafield_OperationSupport_Bit7 = -1;
static int hf_GetSELInfo_datafield_OperationSupport_Reserved = -1;
static int hf_GetSELInfo_datafield_OperationSupport_Bit3 = -1;
static int hf_GetSELInfo_datafield_OperationSupport_Bit2 = -1;
static int hf_GetSELInfo_datafield_OperationSupport_Bit1 = -1;
static int hf_GetSELInfo_datafield_OperationSupport_Bit0 = -1;
/* Reserve SEL, added by lane */
static int hf_ReserveSEL_datafield_ReservationID  = -1;
/* Get SEL Entry, added by lane */
static int hf_GetSELEntry_datafield_ReservationID = -1;
static int hf_GetSELEntry_datafield_SELRecordID = -1;
static int hf_GetSELEntry_datafield_OffsetIntoRecord = -1;
static int hf_GetSELEntry_datafield_BytesToRead = -1;
static int hf_GetSELEntry_datafield_NextSELRecordID = -1;
/* Clear SEL, added by lane */
static int hf_ClearSEL_datafield_ReservationID = -1;
static int hf_ClearSEL_datafield_Byte3 = -1;
static int hf_ClearSEL_datafield_Byte4 = -1;
static int hf_ClearSEL_datafield_Byte5 = -1;
static int hf_ClearSEL_datafield_Byte6 = -1;
static int hf_ClearSEL_datafield_ErasureProgress_Reserved = -1;
static int hf_ClearSEL_datafield_ErasureProgress_EraProg = -1;


/********* PICMG, NetFN = 0X2c *********/

/* Get PICMG Properties, added by lane */
static int hf_GetPICMGProperties_datafield_PICMGIdentifier = -1;
static int hf_GetPICMGProperties_datafield_PICMGExtensionVersion = -1;
static int hf_GetPICMGProperties_datafield_MaxFRUDeviceID = -1;
static int hf_GetPICMGProperties_datafield_FRUDeviceIDforIPMController = -1;
/* FRU Control, added by lane */
static int hf_FRUControl_datafield_PICMGIdentifier = -1;
static int hf_FRUControl_datafield_FRUDeviceID = -1;
static int hf_FRUControl_datafield_FRUControlOption = -1;
/* Get FRU Led Properties, added by lane */
static int hf_GetFRULedProperties_datafield_PICMGIdentifier = -1;
static int hf_GetFRULedProperties_datafield_FRUDeviceID = -1;
static int hf_GetFRULedProperties_datafield_LedProperties_Reserved = -1;
static int hf_GetFRULedProperties_datafield_LedProperties_LED3 = -1;
static int hf_GetFRULedProperties_datafield_LedProperties_LED2 = -1;
static int hf_GetFRULedProperties_datafield_LedProperties_LED1 = -1;
static int hf_GetFRULedProperties_datafield_LedProperties_BlueLED = -1;
static int hf_GetFRULedProperties_datafield_ApplicationSpecificLEDCount = -1;
/* Get Led Color Capabilities, added by lane */
static int hf_GetLedColorCapabilities_datafield_PICMGIdentifier = -1;
static int hf_GetLedColorCapabilities_datafield_FRUDeviceID = -1;
static int hf_GetLedColorCapabilities_datafield_LEDID = -1;
static int hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_Reserved_7 = -1;
static int hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_WHITE = -1;
static int hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_ORANGE = -1;
static int hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_AMBER = -1;
static int hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_GREEN = -1;
static int hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_RED = -1;
static int hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_BLUE = -1;
static int hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_Reserved_0 = -1;
static int hf_GetLedColorCapabilities_datafield_DefaultLEDColorLocalControl_Reserved_74 = -1;
static int hf_GetLedColorCapabilities_datafield_DefaultLEDColorLocalControl_Color = -1;
static int hf_GetLedColorCapabilities_datafield_DefaultLEDColorOverride_Reserved_74 = -1;
static int hf_GetLedColorCapabilities_datafield_DefaultLEDColorOverride_Color = -1;
/* Set FRU Led State, added by lane */
static int hf_SetFRULedState_datafield_PICMGIdentifier = -1;
static int hf_SetFRULedState_datafield_FRUDeviceID = -1;
static int hf_SetFRULedState_datafield_LEDID = -1;
static int hf_SetFRULedState_datafield_LEDFunction = -1;
static int hf_SetFRULedState_datafield_Offduration = -1;
static int hf_SetFRULedState_datafield_Onduration = -1;
static int hf_SetFRULedState_datafield_Color_Reserved = -1;
static int hf_SetFRULedState_datafield_Color_ColorVal = -1;
/* Get FRU Led State, added by lane */
static int hf_GetFRULedState_datafield_PICMGIdentifier = -1;
static int hf_GetFRULedState_datafield_FRUDeviceID = -1;
static int hf_GetFRULedState_datafield_LEDID = -1;
static int hf_GetFRULedState_datafield_LEDState_Reserved = -1;
static int hf_GetFRULedState_datafield_LEDState_Bit2 = -1;
static int hf_GetFRULedState_datafield_LEDState_Bit1 = -1;
static int hf_GetFRULedState_datafield_LEDState_Bit0 = -1;
static int hf_GetFRULedState_datafield_LocalControlLEDFunction = -1;
static int hf_GetFRULedState_datafield_LocalControlOffduration = -1;
static int hf_GetFRULedState_datafield_LocalControlOnduration = -1;
static int hf_GetFRULedState_datafield_LocalControlColor_Reserved = -1;
static int hf_GetFRULedState_datafield_LocalControlColor_ColorVal = -1;
static int hf_GetFRULedState_datafield_OverrideStateLEDFunction = -1;
static int hf_GetFRULedState_datafield_OverrideStateOffduration = -1;
static int hf_GetFRULedState_datafield_OverrideStateOnduration = -1;
static int hf_GetFRULedState_datafield_OverrideStateColor_Reserved = -1;
static int hf_GetFRULedState_datafield_OverrideStateColor_ColorVal = -1;
static int hf_GetFRULedState_datafield_LampTestDuration = -1;
/* Set FRU Activation Policy, added by lane */
static int hf_SetFRUActivationPolicy_datafield_PICMGIdentifier = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUDeviceID = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit72 = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit1 = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit0 = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit72 = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit1 = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit0 = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit1_ignored  = -1;
static int hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit0_ignored  = -1;
/* Get FRU Activation Policy, added by lane */
static int hf_GetFRUActivationPolicy_datafield_PICMGIdentifier = -1;
static int hf_GetFRUActivationPolicy_datafield_FRUDeviceID = -1;
static int hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit72 = -1;
static int hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit1 = -1;
static int hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit0 = -1;
/* Set FRU Activation, added by lane */
static int hf_SetFRUActivation_datafield_PICMGIdentifier = -1;
static int hf_SetFRUActivation_datafield_FRUDeviceID = -1;
static int hf_SetFRUActivation_datafield_FRUActivationDeactivation = -1;
/* Get Device Locator Record ID, added by lane */
static int hf_GetDeviceLocatorRecordID_datafield_PICMGIdentifier = -1;
static int hf_GetDeviceLocatorRecordID_datafield_FRUDeviceID = -1;
static int hf_GetDeviceLocatorRecordID_datafield_RecordID = -1;
/* Set Power Level, added by lane */
static int hf_SetPowerLevel_datafield_PICMGIdentifier = -1;
static int hf_SetPowerLevel_datafield_FRUDeviceID = -1;
static int hf_SetPowerLevel_datafield_PowerLevel = -1;
static int hf_SetPowerLevel_datafield_SetPresentLevelsToDesiredLevels = -1;
/* Get Power Level, added by lane */
static int hf_GetPowerLevel_datafield_PICMGIdentifier = -1;
static int hf_GetPowerLevel_datafield_FRUDeviceID = -1;
static int hf_GetPowerLevel_datafield_PowerType = -1;
static int hf_GetPowerLevel_datafield_Properties = -1;
static int hf_GetPowerLevel_datafield_Properties_DynamicPowerCon = -1;
static int hf_GetPowerLevel_datafield_Properties_Reserved = -1;
static int hf_GetPowerLevel_datafield_Properties_PowerLevel = -1;
static int hf_GetPowerLevel_datafield_DelayToStablePower = -1;
static int hf_GetPowerLevel_datafield_PowerMultiplier = -1;
static int hf_GetPowerLevel_datafield_PowerDraw = -1;
/* Set Fan Level, added by lane */
static int hf_SetFanLevel_datafield_PICMGIdentifier = -1;
static int hf_SetFanLevel_datafield_FRUDeviceID = -1;
static int hf_SetFanLevel_datafield_FanLevel = -1;
/* Get Fan Level, added by lane */
static int hf_GetFanLevel_datafield_PICMGIdentifier = -1;
static int hf_GetFanLevel_datafield_FRUDeviceID = -1;
static int hf_GetFanLevel_datafield_OverrideFanLevel = -1;
static int hf_GetFanLevel_datafield_LocalControlFanLevel = -1;



/***********************************************************************/

static const value_string ipmi_netfn_vals[] = {
      { 0x00,     "Chassis Request" },
      { 0x01,     "Chassis Response" },
      { 0x02,     "Bridge Request" },
      { 0x03,     "Bridge Response" },
      { 0x04,     "Sensor/Event Request" },
      { 0x05,     "Sensor/Event Response" },
      { 0x06,     "Application Request" },
      { 0x07,     "Application Response" },
      { 0x08,     "Firmware Request" },
      { 0x09,     "Frimware Response" },
      { 0x0a,     "Storage Request" },
      { 0x0b,     "Storage Response" },
      { 0x0c,     "Transport Request" },
      { 0x0d,     "Transport Response" },
      { 0x2c,     "PICMG Request" },       /* lane */
      { 0x2d,     "PICMG Response" },    /* lane */
      { 0x30,     "OEM Request" },
      { 0x31,     "OEM Response" },
      { 0x00,     NULL },
};

static const value_string ipmi_authtype_vals[] = {
      { 0x00,     "NONE" },
      { 0x01,     "MD2" },
      { 0x02,     "MD5" },
      { 0x04,     "PASSWORD" },
      { 0x05,     "OEM" },
      { 0x00,     NULL }
};

static const value_string ipmi_ccode_vals[] = {
      { 0x00, "Command completed normally" },
      /* added by lane */
      { 0x81, "cannot execute command, SEL erase in progress" },
      /***************/
      { 0xc0, "Node busy" },
      { 0xc1, "Unrecognized or unsupported command" },
      { 0xc2, "Command invalid for given LUN" },
      { 0xc3, "Timeout while processing command" },
      { 0xc4, "Out of space" },
      { 0xc5, "Reservation cancelled or invalid reservation ID" },
      { 0xc6, "Request data truncated" },
      { 0xc7, "Request data length invalid" },
      { 0xc8, "Request data field length limit exceeded" },
      { 0xc9, "Parameter out of range" },
      { 0xca, "Cannot return number of requested data bytes" },
      { 0xcb, "Requested sensor, data, or record not present" },
      { 0xcc, "Invalid data field in request" },
      { 0xcd, "Command illegal for specified sensor or record type" },
      { 0xce, "Command response could not be provided" },
      { 0xcf, "Cannot execute duplicated request" },
      { 0xd0, "SDR repository in update mode" },
      { 0xd1, "Device in firmware update mode" },
      { 0xd2, "BMC initialization or initialization agent running" },
      { 0xd3, "Destination unavailable" },
      { 0xd4, "Insufficient privilege level" },
      { 0xd5, "Command or param not supported in present state" },
      { 0xff, "Unspecified error" },
      { 0x00, NULL },
};

static const value_string ipmi_addr_vals[] = {
      { 0x20, "BMC Slave Address" },
      { 0x81,     "Remote Console Software 1" },
      { 0x83,     "Remote Console Software 2" },
      { 0x85,     "Remote Console Software 3" },
      { 0x87,     "Remote Console Software 4" },
      { 0x89,     "Remote Console Software 5" },
      { 0x8b,     "Remote Console Software 6" },
      { 0x8d,     "Remote Console Software 7" },
      { 0x00,     NULL },
};

static const value_string ipmi_chassis_cmd_vals[] = {
      /* Chassis Device Commands */
      { 0x00,     "Get Chassis Capabilities" },
      { 0x01,     "Get Chassis Status" },
      { 0x02,     "Chassis Control" },
      { 0x03,     "Chassis Reset" },
      { 0x04,     "Chassis Identify" },
      { 0x05,     "Set Chassis Capabilities" },
      { 0x06,     "Set Power Restore Policy" },
      { 0x07,     "Get System Restart Cause" },
      { 0x08,     "Set System Boot Options" },
      { 0x09,     "Get System Boot Options" },
      { 0x0f,     "Get POH Counter" },
      { 0x00,     NULL },
};

static const value_string ipmi_bridge_cmd_vals[] = {
      /* ICMB Bridge Management Commands */
      { 0x00,     "Get Bridge State" },
      { 0x01,     "Set Bridge State" },
      { 0x02,     "Get ICMB Address" },
      { 0x03,     "Set ICMB Address" },
      { 0x04,     "Set Bridge ProxyAddress" },
      { 0x05,     "Get Bridge Statistics" },
      { 0x06,     "Get ICMB Capabilities" },
      { 0x08,     "Clear Bridge Statistics" },
      { 0x09,     "Get Bridge Proxy Address" },
      { 0x0a,     "Get ICMB Connector Info" },
      { 0x0b,     "Get ICMB Connection ID" },
      { 0x0c,     "Send ICMB Connection ID" },
      /* ICMB Discovery Commands */
      { 0x10,     "Prepare For Discovery" },
      { 0x11,     "Get Addresses" },
      { 0x12,     "Set Discovered" },
      { 0x13,     "Get Chassis Device ID" },
      { 0x14,     "Set Chassis Device ID" },
      /* ICMB Bridging Commands */
      { 0x20,     "Bridge Request" },
      { 0x21,     "Bridge Message" },
      /* ICMB Event Commands */
      { 0x30,     "Get Event Count" },
      { 0x31,     "Set Event Destination" },
      { 0x32,     "Set Event Reception State" },
      { 0x33,     "Send ICMB Event Message" },
      { 0x34,     "Get Event Destination" },
      { 0x35,     "Get Event Reception State" },
      { 0x00,     NULL },
};

static const value_string ipmi_se_cmd_vals[] = {
      /* Event Commands */
      { 0x00,     "Set Event Receiver" },
      { 0x01,     "Get Event Receiver" },
      { 0x02,     "Platform Event Message" },
      /* PEF and Alerting Commands */
      { 0x10,     "Get PEF Capabilities" },
      { 0x11,     "Arm PEF Postpone Timer" },
      { 0x12,     "Set PEF Config Params" },
      { 0x13,     "Get PEF Config Params" },
      { 0x14,     "Set Last Processed Event ID" },
      { 0x15,     "Get Last Processed Event ID" },
      { 0x16,     "Alert Immediate" },
      { 0x17,     "PET Acknowledge" },
      /* Sensor Device Commands */
      { 0x20,     "Get Device SDR Info" },
      { 0x21,     "Get Device SDR" },
      { 0x22,     "Reserve Device SDR Repository" },
      { 0x23,     "Get Sensor Reading Factors" },
      { 0x24,     "Set Sensor Hysteresis" },
      { 0x25,     "Get Sensor Hysteresis" },
      { 0x26,     "Set Sensor Threshold" },
      { 0x27,     "Get Sensor Threshold" },
      { 0x28,     "Set Sensor Event Enable" },
      { 0x29,     "Get Sensor Event Enable" },
      { 0x2a,     "Re-arm Sensor Events" },
      { 0x2b,     "Get Sensor Event Status" },
      { 0x2d,     "Get Sensor Reading" },
      { 0x2e,     "Set Sensor Type" },
      { 0x2f,     "Get Sensor Type" },
      { 0x00,     NULL },
};

static const value_string ipmi_storage_cmd_vals[] = {
      /* FRU Device Commands */
      { 0x10,     "Get FRU Inventory Area Info" },
      { 0x11,     "Read FRU Data" },
      { 0x12,     "Write FRU Data" },
      /* SDR Device Commands */
      { 0x20,     "Get SDR Repository Info" },
      { 0x21,     "Get SDR Repository Allocation Info" },
      { 0x22,     "Reserve SDR Repository" },
      { 0x23,     "Get SDR" },
      { 0x24,     "Add SDR" },
      { 0x25,     "Partial Add SDR" },
      { 0x26,     "Delete SDR" },
      { 0x27,     "Clear SDR Repository" },
      { 0x28,     "Get SDR Repository Time" },
      { 0x29,     "Set SDR Repository Time" },
      { 0x2a,     "Enter SDR Repository Update Mode" },
      { 0x2b,     "Exit SDR Repository Update Mode" },
      { 0x2c,     "Run Initialization Agent" },
      /* SEL Device Commands */
      { 0x40,     "Get SEL Info" },
      { 0x41,     "Get SEL Allocation Info" },
      { 0x42,     "Reserve SEL" },
      { 0x43,     "Get SEL Entry" },
      { 0x44,     "Add SEL Entry" },
      { 0x45,     "Partial Add SEL Entry" },
      { 0x46,     "Delete SEL Entry" },
      { 0x47,     "Clear SEL" },
      { 0x48,     "Get SEL Time" },
      { 0x49,     "Set SEL Time" },
      { 0x5a,     "Get Auxillary Log Status" },
      { 0x5b,     "Set Auxillary Log Status" },
      { 0x00,     NULL },
};

static const value_string ipmi_transport_cmd_vals[] = {
      /* LAN Device Commands */
      { 0x01,     "Set LAN Config Param" },
      { 0x02,     "Get LAN Config Param" },
      { 0x03,     "Suspend BMC ARPs" },
      { 0x04,     "Get IP/UDP/RMCP Statistics" },
      /* Serial/Modem Device Commands */
      { 0x10,     "Set Serial/Modem Config" },
      { 0x11,     "Get Serial/Modem Config" },
      { 0x12,     "Get Serial/Modem Mux" },
      { 0x13,     "Get TAP Response Codes" },
      { 0x14,     "Set PPP UDP Proxy Transmit Data" },
      { 0x15,     "Get PPP UDP Proxy Transmit Data" },
      { 0x16,     "Send PPP UDP Proxy Packet" },
      { 0x17,     "Get PPP UDP Proxy Data" },
      { 0x18,     "Serial/Modem Connection Active" },
      { 0x19,     "Callback" },
      { 0x1a,     "Set User Callback Options" },
      { 0x1b,     "Get User Callback Options" },
      { 0x00,     NULL },
};

static const value_string ipmi_app_cmd_vals[] = {
      /* Device "Global" Commands */
      { 0x01,     "Get Device ID" },
      { 0x02,     "Cold Reset" },
      { 0x03,     "Warm Reset" },
      { 0x04,     "Get Self Test Results" },
      { 0x05,     "Manufacturing Test On" },
      { 0x06,     "Set ACPI Power State" },
      { 0x07,     "Get ACPI Power State" },
      { 0x08,     "Get Device GUID" },
      /* BMC Watchdog Timer Commands */
      { 0x22,     "Reset Watchdog Timer" },
      { 0x24,     "Set Watchdog Timer" },
      { 0x25,     "Get Watchdog Timer" },
      /* BMC Device and Messaging Commands */
      { 0x2e,     "Set BMC Global Enables" },
      { 0x2f,     "Get BMC Global Enables" },
      { 0x30,     "Clear Message Flags" },
      { 0x31,     "Get Message Flags" },
      { 0x32,     "Enable Message Channel Receive" },
      { 0x33,     "Get Message" },
      { 0x34,     "Send Message" },
      { 0x35,     "Read Event Message Buffer" },
      { 0x36,     "Get BT Interface Capabilities" },
      { 0x37,     "Get System GUID" },
      { 0x38,     "Get Channel Auth Capabilities" },
      { 0x39,     "Get Session Challenge" },
      { 0x3a,     "Activate Session" },
      { 0x3b,     "Set Session Privilege Level" },
      { 0x3c,     "Close Session" },
      { 0x3d,     "Get Session Info" },
      { 0x3e,     "unassigned" },
      { 0x3f,     "Get AuthCode" },
      { 0x40,     "Set Channel Access" },
      { 0x41,     "Get Channel Access" },
      { 0x42,     "Get Channel Info" },
      { 0x43,     "Set User Access" },
      { 0x44,     "Get User Access" },
      { 0x45,     "Set User Name" },
      { 0x46,     "Get User Name" },
      { 0x47,     "Set User Password" },
      { 0x52,     "Master Write-Read" },
      { 0x00,     NULL },
};

/* ipmi_picmg_cmd_vals[] array added by lane  */
static const value_string ipmi_picmg_cmd_vals[] = {   
      { 0x00,     "Get PICMG Properties" },
      { 0x01,     "Get Address Info" },
      { 0x02,     "Get Shelf Address Info" },
      { 0x03,     "Set Shelf Address Info" },
      { 0x04,     "FRU Control" },
      { 0x05,     "Get FRU LED Properties" },
      { 0x06,     "Get LED Color Capabilities" },
      { 0x07,     "Set FRU LED State" },
      { 0x08,     "Get FRU LED State" },
      { 0x09,     "Set IPMB State" },
      { 0x0a,     "Set FRU Activation Policy" },
      { 0x0b,     "Get FRU Activation Policy" },
      { 0x0c,     "Set FRU Activation" },
      { 0x0d,     "Get Device Locator Record Id" },
      { 0x0e,     "Set Port State" },
      { 0x0f,     "Get Port State" },
      { 0x10,     "Compute Power Properties" },
      { 0x11,     "Set Power Level" },
      { 0x12,     "Get Power Level" },
      { 0x13,     "Renegotiate Power" },
      { 0x14,     "Get Fan Speed Properties" },
      { 0x15,     "Set Fan Level" },
      { 0x16,     "Get Fan Level" },
      { 0x17,     "Bused Resource" },
      { 0x18,     "Get IPMB Link Info" }, 
      { 0x00,     NULL },
};

/***********************************************************************/

/********* Sensor/Event, NetFN = 0x04 *********/

/* Platform Event Message, added by lane */
static const value_string cmd_PEM_EvMRev_vals[] = {
      { 0x03,     "IPMI V1.0" },
      { 0x04,     "IPMI V1.5" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_SensorType_vals[] = {
      { 0x00,     "Reserved" },
      { 0x01,     "Temperature" },
      { 0x02,     "Voltage" },
      { 0x03,     "Current" },
      { 0x04,     "Fan" },
      { 0x05,     "Physical Security (Chassis Intrusion)" },
      { 0x06,     "Platform Security Violation Attempt" },
      { 0x07,     "Processor" },
      { 0x08,     "Power Supply" },
      { 0x09,     "Power Unit" },
      { 0x0a,     "Cooling Device" },
      { 0x0b,     "Other Units-based Sensor (per units given in SDR)" },
      { 0x0c,     "Memory" },
      { 0x0d,     "Drive Slot (Bay)" },
      { 0x0e,     "POST Memory Resize" },
      { 0x0f,     "System Firmware Progress (formerly POST Error)" },
      { 0x10,     "Event Logging Disabled" },
      { 0x11,     "Watchdog 1" },
      { 0x12,     "System Event" },
      { 0x13,     "Critical Interrupt" },
      { 0x14,     "Button" },
      { 0x15,     "Module / Board" },
      { 0x16,     "Microcontroller / Coprocessor" },
      { 0x17,     "Add-in Card" },
      { 0x18,     "Chassis" },
      { 0x19,     "Chip Set" },
      { 0x1a,     "Other FRU" },
      { 0x1b,     "Cable / Interconnect" },
      { 0x1c,     "Terminator" },
      { 0x1d,     "System Boot Initiated" },
      { 0x1e,     "Boot Error" },
      { 0x1f,     "OS Boot" },
      { 0x20,     "OS Critical Stop" },
      { 0x21,     "Slot /Connector" },
      { 0x22,     "System ACPI Power State" },
      { 0x23,     "Watchdog 2" },
      { 0x24,     "Platform Alert" },
      { 0x25,     "Entity Presence" },
      { 0x26,     "Monitor ASIC / IC" },
      { 0x27,     "LAN" },
      { 0x28,     "Management Subsystem Health" },
      { 0x29,     "Battery" },
      { 0xf0,     "Hot Swap Event" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_EventDir_vals[] = {
      { 0x00,     "Assertion Event" },
      { 0x01,     "Deassertion Event" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_EventData1_threshold_76_vals[] = {
      { 0x00,     "unspecified byte 2" },
      { 0x01,     "trigger reading in byte 2" },
      { 0x02,     "OEM code in byte 2" },
      { 0x03,     "sensor-specific event extension code in byte 2" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_EventData1_threshold_54_vals[] = {
      { 0x00,     "unspecified byte 3" },
      { 0x01,     "trigger reading in byte 3" },
      { 0x02,     "OEM code in byte 3" },
      { 0x03,     "sensor-specific event extension code in byte 3" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_EventData1_discrete_76_vals[] = {
      { 0x00,     "unspecified byte 2" },
      { 0x01,     "previous state and/or severity in byte 2" },
      { 0x02,     "OEM code in byte 2" },
      { 0x03,     "sensor-specific event extension code in byte 3" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_EventData1_discrete_54_vals[] = {
      { 0x00,     "unspecified byte 3" },
      { 0x01,     "reserved" },
      { 0x02,     "OEM code in byte 3" },
      { 0x03,     "sensor-specific event extension code in byte 3" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_EventData1_OEM_76_vals[] = {
      { 0x00,     "unspecified byte 2" },
      { 0x01,     "previous state and/or severity in byte 2" },
      { 0x02,     "OEM code in byte 2" },
      { 0x03,     "sensor-specific event extension code in byte 3" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_EventData1_OEM_54_vals[] = {
      { 0x00,     "unspecified byte 3" },
      { 0x01,     "reserved" },
      { 0x02,     "OEM code in byte 3" },
      { 0x03,     "sensor-specific event extension code in byte 3" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_HotSwapEvent_StateChangeCause_vals[] = {
      { 0x00,     "Normal State Change" },
      { 0x01,     "Change Commanded by Shelf Manager with Set FRU Activation" },
      { 0x02,     "State Change due to operator Changing a Handle Switch" },
      { 0x03,     "State Change due to FRU programmatic action" },
      { 0x04,     "Communication Lost or Regained" },
      { 0x05,     "Communication Lost or Regained-locally detected" },
      { 0x06,     "Suprise State Change due to extraction" },
      { 0x07,     "State Change due to provided information" },
      { 0x08,     "Invalid Hardware Address Detected" },
      { 0x09,     "UnexpectedDeactivation" },
      { 0x0a,     "Reserved" },
      { 0x0b,     "Reserved" },
      { 0x0c,     "Reserved" },
      { 0x0d,     "Reserved" },
      { 0x0e,     "Reserved" },
      { 0x0f,     "State Change, Cause Unknow" },
      { 0x00,     NULL },
};

static const value_string cmd_PEM_HotSwapEvent_state_vals[] = {
      { 0x00,     "M0 - FRU Not Installed" },
      { 0x01,     "M1 - FRU Inactive" },
      { 0x02,     "M2 - FRU Activation Request" },
      { 0x03,     "M3 - FRU Activation In Progress" },
      { 0x04,     "M4 - FRU Active" },
      { 0x05,     "M5 - FRU Deactivation Request" },
      { 0x06,     "M6 - FRU Deactivation In Progress" },
      { 0x07,     "M7 - FRU Communication Lost" },
      { 0x08,     "Reserved" },
      { 0x09,     "Reserved" },
      { 0x0a,     "Reserved" },
      { 0x0b,     "Reserved" },
      { 0x0c,     "Reserved" },
      { 0x0d,     "Reserved" },
      { 0x0e,     "Reserved" },
      { 0x0f,     "Reserved" },
      { 0x00,     NULL },
};

/* Get Device SDR Info, added by lane */
static const value_string cmd_GetDeviceSDRInfo_data_Flag_Dynamicpopulation_vals[] = {
      { 0x00,     "static sensor population" },
      { 0x01,     "dynamic sensor population" },
      { 0x00,     NULL },
};

static const value_string cmd_GetDeviceSDRInfo_data_Flag_DeviceLUNs_vals[] = {
      { 0x00,     "has no sensors" },
      { 0x01,     "has sensors" },
      { 0x00,     NULL },
};

/* Get Device SDR, added by lane */
static const value_string cmd_GetDeviceSDR_data_BytesToRead_vals[] = {
      { 0xff,     "Read entire record" },
      { 0x00,     NULL },
};

/* Set Sensor Thresholds, added by lane */
static const value_string cmd_SetSensorThresholds_data_ControlByte_Bit_vals[] = {
      { 0x00,     "Ignored" },
      { 0x01,     "Set" },
      { 0x00,     NULL },
};

/* Get Sensor Thresholds, added by lane */
static const value_string cmd_GetSensorThresholds_data_ControlByte_Bit_vals[] = {
      { 0x00,     "Ignored" },
      { 0x01,     "Readable" },
      { 0x00,     NULL },
};

/* Get Sensor Reading, added by lane */
static const value_string cmd_GetSensorReading_data_ResponseDataByte2_Bit7_vals[] = {
      { 0x00,     "All Event Messages disabled from this sensor" },
      { 0x01,     "All Event Messages enabled from this sensor" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte2_Bit6_vals[] = {
      { 0x00,     "sensor scanning disabled" },
      { 0x01,     "sensor scanning enabled" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte2_Bit5_vals[] = {
      { 0x00,     "update sensor status completed" },
      { 0x01,     "initial update in progress" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit7_vals[] = {
      { 0x00,     "state 7 has not been asserted" },
      { 0x01,     "state 7 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit6_vals[] = {
      { 0x00,     "state 6 has not been asserted" },
      { 0x01,     "state 6 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit5_vals[] = {
      { 0x00,     "state 5 has not been asserted" },
      { 0x01,     "state 5 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit4_vals[] = {
      { 0x00,     "state 4 has not been asserted" },
      { 0x01,     "state 4 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit3_vals[] = {
      { 0x00,     "state 3 has not been asserted" },
      { 0x01,     "state 3 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit2_vals[] = {
      { 0x00,     "state 2 has not been asserted" },
      { 0x01,     "state 2 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit1_vals[] = {
      { 0x00,     "state 1 has not been asserted" },
      { 0x01,     "state 1 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit0_vals[] = {
      { 0x00,     "state 0 has not been asserted" },
      { 0x01,     "state 0 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte4_Bit7_vals[] = {
      { 0x00,     "Reserved, Shall returned as 1b" },
      { 0x01,     "Reserved, Returned as 1b" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte4_Bit6_vals[] = {
      { 0x00,     "state 14 has not been asserted" },
      { 0x01,     "state 14 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte4_Bit5_vals[] = {
      { 0x00,     "state 13 has not been asserted" },
      { 0x01,     "state 13 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte4_Bit4_vals[] = {
      { 0x00,     "state 12 has not been asserted" },
      { 0x01,     "state 12 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte4_Bit3_vals[] = {
      { 0x00,     "state 11 has not been asserted" },
      { 0x01,     "state 11 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte4_Bit2_vals[] = {
      { 0x00,     "state 10 has not been asserted" },
      { 0x01,     "state 10 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte4_Bit1_vals[] = {
      { 0x00,     "state 9 has not been asserted" },
      { 0x01,     "state 9 asserted" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte4_Bit0_vals[] = {
      { 0x00,     "state 8 has not been asserted" },
      { 0x01,     "state 8 asserted" },
      { 0x00,     NULL },
};


static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit5_threshold_vals[] = {
      { 0x00,     "unknown" },
      { 0x01,     "at or above upper non-recoverable threshold" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit4_threshold_vals[] = {
      { 0x00,     "unknown" },
      { 0x01,     "at or above upper critical threshold" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit3_threshold_vals[] = {
      { 0x00,     "unknown" },
      { 0x01,     "at or above upper non-critical threshold" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit2_threshold_vals[] = {
      { 0x00,     "unknown" },
      { 0x01,     "at or below lower non-recoverable threshold" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit1_threshold_vals[] = {
      { 0x00,     "unknown" },
      { 0x01,     "at or below lower critical threshold" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSensorReading_data_ResponseDataByte3_Bit0_threshold_vals[] = {
      { 0x00,     "unknown" },
      { 0x01,     "at or below lower non-critical threshold" },
      { 0x00,     NULL },
};


/********* APP, NetFN = 0x06 *********/

/* Get Device ID data, added by lane*/
static const value_string cmd_GetDeviceID_data_DeviceSDR_vals[] = {
      { 0x00,     "Device provides device SDR" },
      { 0x01,     "Device does not provide device SDR" },
      { 0x00,     NULL },
};

static const value_string cmd_GetDeviceID_Data_DeviceRevision_vals[] = {
      { 0x00,     "0" },
      { 0x01,     "1" },
      { 0x02,     "2" },
      { 0x03,     "3" },
      { 0x04,     "4" },
      { 0x05,     "5" },
      { 0x06,     "6" },
      { 0x07,     "7" },
      { 0x08,     "8" },
      { 0x09,     "9" },
      { 0x0a,     "10" },
      { 0x0b,     "11" },
      { 0x0c,     "12" },
      { 0x0d,     "13" },
      { 0x0e,     "14" },      
      { 0x0f,     "15" },
      { 0x00,     NULL },
};

static const value_string cmd_GetDeviceID_data_DeviceAvailable_vals[] = {
      { 0x00,     "normal operation" },
      { 0x01,     "device firmware" },
      { 0x00,     NULL },
};

static const value_string cmd_GetDeviceID_Data_IPMIRevision_vals[] = {
      { 0x01,     "V1.0" },
      { 0x11,     "V1.1" },
      { 0x21,     "V1.2" },
      { 0x31,     "V1.3" },
      { 0x41,     "V1.4" },
      { 0x51,     "V1.5" },
      { 0x61,     "V1.6" },
      { 0x71,     "V1.7" },
      { 0x81,     "V1.8" },
      { 0x91,     "V1.9" },
      { 0x02,     "V2.0" },
      { 0x12,     "V2.1" },
      { 0x22,     "V2.2" },
      { 0x32,     "V2.3" },
      { 0x42,     "V2.4" },      
      { 0x52,     "V2.5" },
      { 0x62,     "V2.6" },
      { 0x72,     "V2.7" },
      { 0x82,     "V2.8" },
      { 0x92,     "V2.9" },
      { 0x00,     NULL },
};

static const value_string cmd_GetDeviceID_data_ADS_vals[] = {
      { 0x00,     "No" },
      { 0x01,     "Yes" },
      { 0x00,     NULL },
};


/********* Storage, NetFN = 0x0a *********/

/* Get FRU Inventory Area Info, added by lane */
static const value_string cmd_GetFRUInventoryAreaInfo_Data_ResponseDataByte4_Bit0_vals[] = {
      { 0x00,     "By bytes" },
      { 0x01,     "By words" },
      { 0x00,     NULL },
};

/* Get SEL Info, added by lane */
static const value_string cmd_GetSELInfo_Data_SELVersion_vals[] = {
      { 0x01,     "V1.0" },
      { 0x11,     "V1.1" },
      { 0x21,     "V1.2" },
      { 0x31,     "V1.3" },
      { 0x41,     "V1.4" },
      { 0x51,     "V1.5" },
      { 0x61,     "V1.6" },
      { 0x71,     "V1.7" },
      { 0x81,     "V1.8" },
      { 0x91,     "V1.9" },
      { 0x02,     "V2.0" },
      { 0x12,     "V2.1" },
      { 0x22,     "V2.2" },
      { 0x32,     "V2.3" },
      { 0x42,     "V2.4" },      
      { 0x52,     "V2.5" },
      { 0x62,     "V2.6" },
      { 0x72,     "V2.7" },
      { 0x82,     "V2.8" },
      { 0x92,     "V2.9" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSELInfo_Data_OperationSupport_Bit7_vals[] = {
      { 0x00,     "Ok" },
      { 0x01,     "Events have been dropped due to lack of space in the SEL" },
      { 0x00,     NULL },
};

static const value_string cmd_GetSELInfo_Data_OperationSupport_Bit3to0_vals[] = {
      { 0x00,     "Don't Support" },
      { 0x01,     "Support" },
      { 0x00,     NULL },
};

/* Clear SEL, added by lane */
static const value_string cmd_ClearSEL_Data_Byte6_vals[] = {
      { 0x00,     "get erasure status" },
      { 0xaa,     "initiate erase" },
      { 0x00,     NULL },
};

static const value_string cmd_ClearSEL_Data_ErasureProgress_EraProg_vals[] = {
      { 0x00,     "erasure in progress" },
      { 0x01,     "erase completed" },
      { 0x00,     NULL },
};



/********* PICMG, NetFN = 0X2c *********/

/* Get PICMG Properties data, added by lane */
static const value_string cmd_GetPICMGProperties_data_PICMGExtensionVersion_vals[] = {
      { 0x12,     "V2.1" },
      { 0x00,     NULL },
};

/* FRU Control, added by lane */
static const value_string cmd_FRUControl_data_FRUControlOption_vals[] = {
      { 0x00,     "Cold Reset" },
      { 0x01,     "Warm Reset" },
      { 0x02,     "Graceful Reboot" },
      { 0x03,     "Issue Diagnostic Interrupt" },
      { 0x04,     "Reserved" },
      { 0xff,     "Reserved" },
      { 0x00,     NULL },
};

/* Get FRU Led Properties, added by lane */
static const value_string cmd_GetFRULedProperties_data_LedProperties_LED3_vals[] = {
      { 0x00,     "FRU can't control LED3" },
      { 0x01,     "FRU can control LED3" },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRULedProperties_data_LedProperties_LED2_vals[] = {
      { 0x00,     "FRU can't control LED2" },
      { 0x01,     "FRU can control LED2" },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRULedProperties_data_LedProperties_LED1_vals[] = {
      { 0x00,     "FRU can't control LED1" },
      { 0x01,     "FRU can control LED1" },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRULedProperties_data_LedProperties_BLUELED_vals[] = {
      { 0x00,     "FRU can't control Blue LED" },
      { 0x01,     "FRU can control Blue LED" },
      { 0x00,     NULL },
};

/* Get Led Color Capabilities, added by lane */
static const value_string cmd_GetLedColorCapabilities_data_LEDColorCapabilities_vals[] = {
      { 0x00,     "Don't Support" },
      { 0x01,     "Support" },
      { 0x00,     NULL },
};

static const value_string cmd_GetLedColorCapabilities_data_DefaultLEDColor_vals[] = {
      { 0x00,     "Reserved" },
      { 0x01,     "BLUE" },
      { 0x02,     "RED" },
      { 0x03,     "GREEN" },
      { 0x04,     "AMBER" },
      { 0x05,     "ORANGE" },
      { 0x06,     "WHITE" },
      { 0x07,     "Reserved" },
      { 0x08,     "Reserved" },
      { 0x09,     "Reserved" },
      { 0x0a,     "Reserved" },
      { 0x0b,     "Reserved" },
      { 0x0c,     "Reserved" },
      { 0x0d,     "Reserved" },
      { 0x0e,     "Reserved" },
      { 0x0f,     "Reserved" },
      { 0x00,     NULL },
};

/* Set FRU Activation data, added by lane */
static const value_string cmd_SetFRUActivation_data_FRUActivationDeactivation_vals[] = {
      { 0x00,     "Deactivate FRU" },
      { 0x01,     "Activate FRU" },
      { 0x00,     NULL },
};

/* Set FRU Led State, added by lane */
static const value_string cmd_SetFRULedState_data_LEDID_vals[] = {
      { 0x00,     "BLUE LED (Bottom of Board)" },
      { 0x01,     "LED1 Topmost" },
      { 0x02,     "LED2 Second from top" },
      { 0x03,     "LED3 Third from top" },
      { 0xff,     "Lamp Test" },
      { 0x00,     NULL },
};

static const value_string cmd_SetFRULedState_data_LEDFunction_vals[] = {
      { 0x00,     "LED off override" },
      { 0x01,     "LED BLINKING override" },
      /* ... */
      { 0xfa,     "LED BLINKING override" },
      { 0xfb,     "LAMP TEST state" },
      { 0xfc,     "LED state restored to Local Control state" },
      { 0xfd,     "Reserved" },
      { 0xfe,     "Reserved" },
      { 0xff,     "LED on override" },
      { 0x00,     NULL },
};

static const value_string cmd_SetFRULedState_data_Color_ColorVal_vals[] = {
      { 0x00,     "Reserved" },
      { 0x01,     "Use BLUE" },
      { 0x02,     "Use RED" },
      { 0x03,     "Use GREEN" },
      { 0x04,     "Use AMBER" },
      { 0x05,     "Use ORANGE" },
      { 0x06,     "Use WHITE" },
      { 0x07,     "Reserved" },
      { 0x08,     "Reserved" },
      { 0x09,     "Reserved" },
      { 0x0a,     "Reserved" },
      { 0x0b,     "Reserved" },
      { 0x0c,     "Reserved" },
      { 0x0d,     "Reserved" },
      { 0x0e,     "Do not Change" },
      { 0x0f,     "Use default color" },
      { 0x00,     NULL },
};

/* Get FRU Led State, added by lane */
static const value_string cmd_GetFRULedState_data_LEDID_vals[] = {
      { 0x00,     "BLUE LED (Bottom of Board)" },
      { 0x01,     "LED1 Topmost" },
      { 0x02,     "LED2 Second from top" },
      { 0x03,     "LED3 Third from top" },
      { 0xff,     "Lamp Test" },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRULedState_data_LEDState_Bit21_vals[] = {
      { 0x00,     "Disabled" },
      { 0x01,     "Enabled" },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRULedState_data_LEDState_Bit0_vals[] = {
      { 0x00,     "No" },
      { 0x01,     "Yes" },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRULedState_data_LocalControlLEDFunction_vals[] = {
      { 0x00,     "LED is off" },
      { 0x01,     "LED is BLINKING" },
      /* ... */
      { 0xfa,     "LED is BLINKING" },
      { 0xfb,     "Reserved" },
      { 0xfc,     "Reserved" },
      { 0xfd,     "Reserved" },
      { 0xfe,     "Reserved" },
      { 0xff,     "LED is on " },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRULedState_data_ColorVal_vals[] = {
      { 0x00,     "Reserved" },
      { 0x01,     "Use BLUE" },
      { 0x02,     "Use RED" },
      { 0x03,     "Use GREEN" },
      { 0x04,     "Use AMBER" },
      { 0x05,     "Use ORANGE" },
      { 0x06,     "Use WHITE" },
      { 0x07,     "Reserved" },
      { 0x08,     "Reserved" },
      { 0x09,     "Reserved" },
      { 0x0a,     "Reserved" },
      { 0x0b,     "Reserved" },
      { 0x0c,     "Reserved" },
      { 0x0d,     "Reserved" },
      { 0x0e,     "Reserved" },
      { 0x0f,     "Reserved" },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRULedState_data_OverrideStateLEDFunction_vals[] = {
      { 0x00,     "LED Override State is off" },
      { 0x01,     "LED Override State is BLINKING" },
      /* ... */
      { 0xfa,     "LED Override State is BLINKING" },
      { 0xfb,     "Reserved" },
      { 0xfc,     "Reserved" },
      { 0xfd,     "Reserved" },
      { 0xfe,     "Reserved" },
      { 0xff,     "LED Override State is on " },
      { 0x00,     NULL },
};

/* Set FRU Activation Policy, added by lane */
static const value_string cmd_SetFRUActivationPolicy_data_PFRUActivationPolicyMaskBit_Bit1_vals[] = {
      { 0x00,     "Bit 1 in Byte 4 of command will be ignored" },
      { 0x01,     "Bit 1 in Byte 4 of command will affect the Deactivation-Locked bit" },
      { 0x00,     NULL },
};

static const value_string cmd_SetFRUActivationPolicy_data_PFRUActivationPolicyMaskBit_Bit0_vals[] = {
      { 0x00,     "Bit 0 in Byte 4 of command will be ignored" },
      { 0x01,     "Bit 0 in Byte 4 of command will affect the Locked bit" },
      { 0x00,     NULL },
};

static const value_string cmd_SetFRUActivationPolicy_data_PFRUActivationPolicySetBit_Bit1_vals[] = {
      { 0x00,     "FRU can transition from M4 to M5" },
      { 0x01,     "FRU can not transition from M4 to M5" },
      { 0x00,     NULL },
};

static const value_string cmd_SetFRUActivationPolicy_data_PFRUActivationPolicySetBit_Bit0_vals[] = {
      { 0x00,     "FRU can transition from M1 to M2" },
      { 0x01,     "FRU can not transition from M1 to M2" },
      { 0x00,     NULL },
};

static const value_string cmd_SetFRUActivationPolicy_data_PFRUActivationPolicySetBit_Bit1_ignored_vals[] = {
      { 0x00,     "ignored, because Bit 1 of Byte 3 = 0" },
      { 0x01,     "ignored, because Bit 1 of Byte 3 = 0" },
      { 0x00,     NULL },
};

static const value_string cmd_SetFRUActivationPolicy_data_PFRUActivationPolicySetBit_Bit0_ignored_vals[] = {
      { 0x00,     "ignored, because Bit 0 of Byte 3 = 0" },
      { 0x01,     "ignored, because Bit 0 of Byte 3 = 0" },
      { 0x00,     NULL },
};

/* Get FRU Activation Policy, added by lane */
static const value_string cmd_GetFRUActivationPolicy_data_FRUActivationPolicy_Bit1_vals[] = {
      { 0x00,     "FRU is not Deactivation-Locked" },
      { 0x01,     "FRU is Deactivation-Locked" },
      { 0x00,     NULL },
};

static const value_string cmd_GetFRUActivationPolicy_data_FRUActivationPolicy_Bit0_vals[] = {
      { 0x00,     "FRU is not Locked" },
      { 0x01,     "FRU is Locked" },
      { 0x00,     NULL },
};

/* Set Power Level data, added by lane */
static const value_string cmd_SetPowerLevel_data_PowerLevel_vals[] = {
      { 0x00,     "Power Off" },
      { 0x01,     "Select the power level" },
      { 0x02,     "Select the power level" },
      { 0x03,     "Select the power level" },
      { 0x04,     "Select the power level" },
      { 0x05,     "Select the power level" },
      { 0x06,     "Select the power level" },
      { 0x07,     "Select the power level" },
      { 0x08,     "Select the power level" },
      { 0x09,     "Select the power level" },
      { 0x0a,     "Select the power level" },
      { 0x0b,     "Select the power level" },
      { 0x0c,     "Select the power level" },
      { 0x0d,     "Select the power level" },
      { 0x0e,     "Select the power level" },
      { 0x0f,     "Select the power level" },
      { 0x10,     "Select the power level" },
      { 0x11,     "Select the power level" },
      { 0x12,     "Select the power level" },
      { 0x13,     "Select the power level" },
      { 0x14,     "Select the power level" },
      { 0xff,     "Do not change current power level" },
      { 0x00,     NULL },
};

static const value_string cmd_SetPowerLevel_data_SetPresentLevelsToDesiredLevels_vals[] = {
      { 0x00,     "Do not change present power level" },
      { 0x01,     "Copy Present Levels To Desired Levels" },
      { 0x00,     NULL },
};

/* Get Power Level data, added by lane */
static const value_string cmd_GetPowerLevel_data_PowerType_vals[] = {
      { 0x00,     "Steady state power draw levels" },
      { 0x01,     "Desired steady state draw levels" },
      { 0x02,     "Early power draw levels" },
      { 0x03,     "Desired early levels" },
      { 0x00,     NULL },
};

static const value_string cmd_GetPowerLevel_data_Properties_DynamicPowerCon_vals[] = {
      { 0x00,     "FRU doesn't support dynamic reconfiguration of power" },
      { 0x01,     "FRU support dynamic reconfiguration of power" },
      { 0x00,     NULL },
};

/* Set Fan Level, added by lane */
static const value_string cmd_SetFanLevel_data_FanLevel_vals[] = {
      { 0xfe,     "Emergency Shut Down" },
      { 0xff,     "Local Control" },
      { 0x00,     NULL },
};

/* Get Fan Level, added by lane */
static const value_string cmd_GetFanLevel_data_OverrideFanLevel_vals[] = {
      { 0xfe,     "Fan has been placed in ' Emergency Shut Down ' by the Shelf Manager" },
      { 0xff,     "Fan operating in Local Control mode" },
      { 0x00,     NULL },
};


/*****************************************************************************************/


/* ipmi command dissector struct , added by lane */

typedef struct _ipmi_cmd_dissect{
  guint8  netfn;
  guint8  cmd;
  void   (*dissectfunc)(proto_tree *, proto_tree *, packet_info *, tvbuff_t *, gint *, guint8, guint8, guint8);  
} ipmi_cmd_dissect;



/* Sensor/Event  NetFN (0x04) */

static void
dissect_cmd_PlatformEventMessage(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo, tvbuff_t *tvb,
                                                gint *poffset, guint8 len, guint8 response, guint8 authtype)
{

      tvbuff_t          *next_tvb;
      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            SensorType, EventDirAndEventType, EventType, EventData1, EventData2;

      if(response) {

            return;           
      }
      else {

            /* EvMRev */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_PEM_datafield_EvMRev,
                                                tvb, (*poffset)++, 1, TRUE);
                  len--;
            }

            /* Sensor Type */
            SensorType = tvb_get_guint8(tvb, authtype ? 33 : 17) ;
            
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_PEM_datafield_SensorType,
                                                tvb, (*poffset)++, 1, TRUE);
                  len--;
            }
            
            /* Sensor Number */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_PEM_datafield_SensorNumber,
                                                tvb, (*poffset)++, 1, TRUE);
                  len--;
            }
      
            /* Event Dir & Event Type*/
            EventDirAndEventType = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
            EventType = EventDirAndEventType&0x7f;
            
            if (tree) {
                  
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "EventDir&EventType: %s0x%02x", " ", EventDirAndEventType);
                        field_tree = proto_item_add_subtree(tf, ett_cmd_PEM_EventDirAndEventType);

                        proto_tree_add_item(field_tree, hf_PEM_datafield_EventDirAndEventType_EventDir,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_PEM_datafield_EventDirAndEventType_EventType,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                        len--;                        
                  }
            
            
            /* EventData 1~3 */
            switch(SensorType) {

                  case 0xf0:              /* Hot Swap Event */
                        /* unspecial */
                        if(0x00==EventType) {


                        }
                        
                        /* threshold  */
                        if(0x01==EventType) {
                              /* EventData 1*/
                              EventData1 = tvb_get_guint8(tvb, authtype ? 36 : 20) ;
                              if (tree) {
                                    tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                                "EventData 1: %s0x%02x", " ", EventData1);

                                    field_tree = proto_item_add_subtree(tf, ett_cmd_PEM_EventData1_threshold);

                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData1_threshold_76,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData1_threshold_54,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData1_threshold_30,
                                                      tvb, *poffset, 1, TRUE);
                        
                                    (*poffset)++;
                                    len--;
                              }
                              
                              /* EventData 2*/
                              if (tree&&(len!=0)) {
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData2_threshold,
                                                      tvb, (*poffset)++, 1, TRUE);
                                    len--;
                              }
                              
                              /* EventData 3*/
                              if (tree&&(len!=0)) {
                                    proto_tree_add_item(ipmi_tree, hf_PEM_datafield_EventData3_threshold,
                                                      tvb, (*poffset)++, 1, TRUE);
                              }

                        }

      
                        /* discrete */
                        if(((EventType>=0x02)&&(EventType<=0x0b))||(0x6f==EventType)) {
                              /* EventData 1*/
                              if (tree) {
                                    EventData1 = tvb_get_guint8(tvb, authtype ? 36 : 20) ;
                                    tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                                "EventData 1: %s0x%02x", " ", EventData1);

                                    field_tree = proto_item_add_subtree(tf, ett_cmd_PEM_EventData1_discrete);

                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData1_discrete_76,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData1_discrete_54,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_HotSwapEvent_CurrentState,
                                                      tvb, *poffset, 1, TRUE);
                        
                                    (*poffset)++;
                                    len--;
                              }
                              
                              /* EventData 2*/
                              if (tree&&(len!=0)) {
                                    EventData2 = tvb_get_guint8(tvb, authtype ? 37 : 21) ;
                                    tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                                "EventData 2: %s0x%02x", " ", EventData2);

                                    field_tree = proto_item_add_subtree(tf, ett_cmd_PEM_EventData2_discrete);

                                    proto_tree_add_item(field_tree, hf_PEM_datafield_HotSwapEvent_StateChangeCause,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_HotSwapEvent_PreviousState,
                                                      tvb, *poffset, 1, TRUE);
                        
                                    (*poffset)++;
                                    len--;
                              }
                              
                              /* EventData 3*/
                              if (tree&&(len!=0)) {
                                    proto_tree_add_item(ipmi_tree, hf_PEM_datafield_HotSwapEvent_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                              }

                        }
                        
                        /* OEM */
                        if((EventType>=0x70)&&(EventType<=0x7f)) {
                              /* EventData 1*/
                              if (tree) {
                                    EventData1 = tvb_get_guint8(tvb, authtype ? 36 : 20) ;
                                    tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                                "EventData 1: %s0x%02x", " ", EventData1);

                                    field_tree = proto_item_add_subtree(tf, ett_cmd_PEM_EventData1_OEM);

                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData1_OEM_76,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData1_OEM_54,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData1_OEM_30,
                                                      tvb, *poffset, 1, TRUE);
                        
                                    (*poffset)++;
                                    len--;
                              }
                              /* EventData 2*/
                              if (tree&&(len!=0)) {
                                    EventData2 = tvb_get_guint8(tvb, authtype ? 37 : 21) ;
                                    tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                                "EventData 2: %s0x%02x", " ", EventData2);

                                    field_tree = proto_item_add_subtree(tf, ett_cmd_PEM_EventData2_OEM);

                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData2_OEM_74,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_PEM_datafield_EventData2_OEM_30,
                                                      tvb, *poffset, 1, TRUE);
                        
                                    (*poffset)++;
                                    len--;
                              }
                              /* EventData 3*/
                              if (tree&&(len!=0)) {
                                    proto_tree_add_item(ipmi_tree, hf_PEM_datafield_EventData3_OEM,
                                                      tvb, (*poffset)++, 1, TRUE);
                              }

                        }
                        break;


                  default:
                        if (tree) {
                              next_tvb = tvb_new_subset(tvb, *poffset, len, len);
                              call_dissector(data_handle, next_tvb, pinfo, tree);
                              *poffset += len;
                        }
                        break;
            }
            
      }

}


static void
dissect_cmd_GetDeviceSDR(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo, tvbuff_t *tvb,
                                                gint *poffset, guint8 len, guint8 response, guint8 authtype _U_)
{
      tvbuff_t    *next_tvb;

      if(response) {

            /* Record ID for next record */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceSDR_datafield_NextRecordID,
                                                tvb, *poffset, 1, TRUE);
                  (*poffset)+=2;
                  len-=2;
            }
            /* Requested bytes from record */
            if (tree) {
                  next_tvb = tvb_new_subset(tvb, *poffset, len, len);
                  call_dissector(data_handle, next_tvb, pinfo, tree);
                  *poffset += len;
            }
            
      }
      else {

            /* Reservation ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceSDR_datafield_ReservationID,
                                                tvb, *poffset, 1, TRUE);
            (*poffset)+=2;
            }
            /* Record ID of record to Get */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceSDR_datafield_RecordID,
                                                tvb, *poffset, 1, TRUE);
            (*poffset)+=2;
            }
            /* Offset into record */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceSDR_datafield_OffsetIntoRecord,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            /* Bytes to read */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceSDR_datafield_BytesToRead,
                                                tvb, (*poffset)++, 1, TRUE);
            }

      }

}


static void
dissect_cmd_Get_Device_SDR_Info(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{

      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            flag;
      
      if(response) {

            flag = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
            
            /* Number of the Sensors in device*/
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceSDRInfo_datafield_SensorNumber,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            /* Flag */
            if (tree) {
                  
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Flag: %s0x%02x", " ", flag);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetDeviceSDRInfo_Flag);

                        proto_tree_add_item(field_tree, hf_GetDeviceSDRInfo_datafield_Flag_Dynamicpopulation,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetDeviceSDRInfo_datafield_Flag_Reserved,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs3,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs2,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs1,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs0,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                        
                  }
            /* Sensor Population Change Indicator */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceSDRInfo_datafield_SensorPopulationChangeIndicator,
                                                tvb, *poffset, 1, TRUE);
                  (*poffset)+=4;
            }
            
      }
      else
            return;

}

static void
dissect_cmd_Reserve_Device_SDR_Repository(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{

      if(response) {

            /* Reservation ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_ReserveDeviceSDRRepository_datafield_ReservationID ,
                                                tvb, *poffset, 1, TRUE);
                  (*poffset)+=2;
            }

      }
      else
            return;

}

static void
dissect_cmd_Set_Sensor_Hysteresis(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{

      if(response) {
            return;
      }
      else {
            /* sensor number */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_SetSensorHysteresis_datafield_SensorNumber,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            /* reserved for future 'hysteresis mask' definition. */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_SetSensorHysteresis_datafield_ReservedForHysteresisMask,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            /* Positive-going Threshold Hysteresis Value */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_SetSensorHysteresis_datafield_PositivegoingThresholdHysteresisValue,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            /* Negative-going Threshold Hysteresis Value */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_SetSensorHysteresis_datafield_NegativegoingThresholdHysteresisValue,
                                                tvb, (*poffset)++, 1, TRUE);
            }
      }

}

static void
dissect_cmd_Get_Sensor_Hysteresis(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{

      if(response) {
            /* Positive-going Threshold Hysteresis Value */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSensorHysteresis_datafield_PositivegoingThresholdHysteresisValue,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            /* Negative-going Threshold Hysteresis Value */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSensorHysteresis_datafield_NegativegoingThresholdHysteresisValue,
                                                tvb, (*poffset)++, 1, TRUE);
            }
      }
      else {
            /* sensor number */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSensorHysteresis_datafield_SensorNumber,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            /* reserved for future 'hysteresis mask' definition. */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSensorHysteresis_datafield_ReservedForHysteresisMask,
                                                tvb, (*poffset)++, 1, TRUE);
            }
      }

}

static void
dissect_cmd_Set_Sensor_Thresholds(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{

      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            ControlByte;

      if(response) {
            return;
      }
      else {
            /* sensor number */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_SetSensorThresholds_datafield_SensorNumber,
                                                tvb, (*poffset)++, 1, TRUE);
                  /* Control Byte */
                  ControlByte = tvb_get_guint8(tvb, authtype ? 33 : 17) ;
                  tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Control Byte: %s0x%02x", " ", ControlByte);
                  field_tree = proto_item_add_subtree(tf, ett_cmd_SetSensorThresholds_ControlByte);

                  proto_tree_add_item(field_tree, hf_SetSensorThresholds_datafield_ControlByte_Bit76,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_SetSensorThresholds_datafield_ControlByte_Bit5,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_SetSensorThresholds_datafield_ControlByte_Bit4,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_SetSensorThresholds_datafield_ControlByte_Bit3,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_SetSensorThresholds_datafield_ControlByte_Bit2,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_SetSensorThresholds_datafield_ControlByte_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_SetSensorThresholds_datafield_ControlByte_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                  (*poffset)++;

                  /* lower non-critical threshold */
                  if(ControlByte&0x01) 
                        proto_tree_add_item(ipmi_tree, hf_SetSensorThresholds_datafield_LowerNonCriticalThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* lower critical threshold */
                  if(ControlByte&0x02) 
                        proto_tree_add_item(ipmi_tree, hf_SetSensorThresholds_datafield_LowerCriticalThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* lower non-recoverable threshold */
                  if(ControlByte&0x04) 
                        proto_tree_add_item(ipmi_tree, hf_SetSensorThresholds_datafield_LowerNonRecoverableThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* upper non-critical threshold */
                  if(ControlByte&0x08) 
                        proto_tree_add_item(ipmi_tree, hf_SetSensorThresholds_datafield_UpperNonCriticalThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* upper critical threshold value */
                  if(ControlByte&0x10) 
                        proto_tree_add_item(ipmi_tree, hf_SetSensorThresholds_datafield_UpperCriticalThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* upper non-recoverable threshold value */
                  if(ControlByte&0x20) 
                        proto_tree_add_item(ipmi_tree, hf_SetSensorThresholds_datafield_UpperNonRecoverableThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);
            }

      }

}

static void
dissect_cmd_Get_Sensor_Thresholds(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{

      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            ControlByte;

      if(response) {
            /* Control Byte */
            if (tree) {
                  ControlByte = tvb_get_guint8(tvb, authtype ? 33 : 17) ;
                  tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Control Byte: %s0x%02x", " ", ControlByte);
                  field_tree = proto_item_add_subtree(tf, ett_cmd_GetSensorThresholds_ControlByte);

                  proto_tree_add_item(field_tree, hf_GetSensorThresholds_datafield_ControlByte_Bit76,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSensorThresholds_datafield_ControlByte_Bit5,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSensorThresholds_datafield_ControlByte_Bit4,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSensorThresholds_datafield_ControlByte_Bit3,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSensorThresholds_datafield_ControlByte_Bit2,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSensorThresholds_datafield_ControlByte_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSensorThresholds_datafield_ControlByte_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                  (*poffset)++;

                  /* lower non-critical threshold */
                  if(ControlByte&0x01) 
                        proto_tree_add_item(ipmi_tree, hf_GetSensorThresholds_datafield_LowerNonCriticalThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* lower critical threshold */
                  if(ControlByte&0x02) 
                        proto_tree_add_item(ipmi_tree, hf_GetSensorThresholds_datafield_LowerCriticalThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* lower non-recoverable threshold */
                  if(ControlByte&0x04) 
                        proto_tree_add_item(ipmi_tree, hf_GetSensorThresholds_datafield_LowerNonRecoverableThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* upper non-critical threshold */
                  if(ControlByte&0x08) 
                        proto_tree_add_item(ipmi_tree, hf_GetSensorThresholds_datafield_UpperNonCriticalThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* upper critical threshold value */
                  if(ControlByte&0x10) 
                        proto_tree_add_item(ipmi_tree, hf_GetSensorThresholds_datafield_UpperCriticalThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);

                  /* upper non-recoverable threshold value */
                  if(ControlByte&0x20) 
                        proto_tree_add_item(ipmi_tree, hf_GetSensorThresholds_datafield_UpperNonRecoverableThreshold,
                                                      tvb, (*poffset)++, 1, TRUE);
            }

      }
      else {
            /* sensor number */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSensorThresholds_datafield_SensorNumber,
                                                tvb, (*poffset)++, 1, TRUE);
            }
      }

}

static void
dissect_cmd_Get_Sensor_Reading(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len, guint8 response, guint8 authtype)
{

      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            Response_Data_Byte2, Response_Data_Byte3, Response_Data_Byte4;
      
      if(response) {

            /* Sensor reading*/
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSensorReading_datafield_Sensorreading,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            /* Response Data Byte2 */
            if (tree) {
                  
                        Response_Data_Byte2 = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
                        
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Response Data Byte 2: %s0x%02x", " ", Response_Data_Byte2);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetSensorReading_ResponseDataByte2);

                        proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte2_Bit7,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte2_Bit6,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte2_Bit5,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte2_Bit40,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                        
            }
            
            if(len==4) {
                        /* Response Data Byte3 (For discrete reading sensors) */
                        if (tree) {
                  
                              Response_Data_Byte3 = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
                        
                              tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Response Data Byte 3: %s0x%02x", " ", Response_Data_Byte3);

                              field_tree = proto_item_add_subtree(tf, ett_cmd_GetSensorReading_ResponseDataByte3);

                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit7,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit6,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit5,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit4,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit3,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit2,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                              (*poffset)++;
                        
                        }
                        /* Response Data Byte4 (For discrete reading sensors) */
                        if (tree) {
                  
                              Response_Data_Byte4 = tvb_get_guint8(tvb, authtype ? 36 : 20) ;
                        
                              tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Response Data Byte 4: %s0x%02x", " ", Response_Data_Byte4);

                              field_tree = proto_item_add_subtree(tf, ett_cmd_GetSensorReading_ResponseDataByte4);

                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte4_Bit7,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte4_Bit6,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte4_Bit5,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte4_Bit4,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte4_Bit3,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte4_Bit2,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte4_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte4_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                              (*poffset)++;
                        
                        }
            }
            else {
                        /* Response Data Byte3 (For threshold-based sensors) */
                        if (tree) {
                  
                              Response_Data_Byte3 = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
                        
                              tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Present threshold comparison status: %s0x%02x", " ", Response_Data_Byte3);

                              field_tree = proto_item_add_subtree(tf, ett_cmd_GetSensorReading_ResponseDataByte3_threshold);

                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit76_threshold,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit5_threshold,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit4_threshold,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit3_threshold,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit2_threshold,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit1_threshold,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_GetSensorReading_datafield_ResponseDataByte3_Bit0_threshold,
                                                      tvb, *poffset, 1, TRUE);
                              (*poffset)++;
                        
                        }
            }
            
      }
      else {
            /* Sensor Number */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSensorReading_datafield_SensorNumber,
                                                tvb, (*poffset)++, 1, TRUE);
            }
      }
      

}



/* App NetFN (0x06) */

static void
dissect_cmd_Get_Device_ID(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len, guint8 response, guint8 authtype)
{

      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            device_revision, firmware_revision1, additional_device_support;
      guint32           ManufactureID; 
      guint16           ProductID;              
      

      if(response) {

            device_revision = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
            firmware_revision1 = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
            additional_device_support = tvb_get_guint8(tvb, authtype ? 38 : 22) ;
            ManufactureID = tvb_get_ntoh24(tvb, authtype ? 39 : 23);
            ProductID = tvb_get_ntohs(tvb, authtype ? 42 : 26);
            

            /* Device ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceID_datafield_DeviceID,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            
            
            /* DeviceSDR/DeviceRevision */
            if (tree) {
                  
                  tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                               "Device SDR/Device Revision: %s (0x%02x)", val_to_str(device_revision>>7,
                               cmd_GetDeviceID_data_DeviceSDR_vals, "Unknown (0x%02x)"), device_revision>>7);

                  field_tree = proto_item_add_subtree(tf, ett_cmd_GetDeviceID_data_dr);

                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_DeviceSDR,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_DeviceRevision,
                            tvb, *poffset, 1, TRUE);
                  proto_item_append_text(tf, ", DeviceRevision (0x%02x)", device_revision&0x0f);
                  (*poffset)++;
            }

            /* Device available/Major Firmware Revision */
            if (tree) {
                  
                  tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                               "Device available/Major Firmware Revision: %s (0x%02x)", val_to_str(firmware_revision1>>7,
                               cmd_GetDeviceID_data_DeviceAvailable_vals, "Unknown (0x%02x)"), firmware_revision1>>7);

                  field_tree = proto_item_add_subtree(tf, ett_cmd_GetDeviceID_data_fr);

                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_DeviceAvailable,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_MajorFirmwareRevision,
                            tvb, *poffset, 1, TRUE);
                  proto_item_append_text(tf, ", MajorFirmwareRevision 0x%02x", device_revision&0x7f);
                  (*poffset)++;
            }

            /* Minor Firmware Revision */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceID_datafield_MinorFirmwareRevision,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            
            /* IPMI Revision */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceID_datafield_IPMIRevision,
                                                tvb, (*poffset)++, 1, TRUE);
            }

            /* Additional Device Support */
            if (tree) {
                  
                  tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                               "Additional Device Support: %s0x%02x", " ", additional_device_support);

                  field_tree = proto_item_add_subtree(tf, ett_cmd_GetDeviceID_data_ads);

                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_ADS_Chasis,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_ADS_Bridge,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_ADS_IPMBEventGenerator,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_ADS_IPMBEventReceiver,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_ADS_FRUInventoryDevice,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_ADS_SELDevice,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_ADS_SDRRepositoryDevice,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetDeviceID_datafield_ADS_SensorDevice,
                            tvb, *poffset, 1, TRUE);
                  
                  (*poffset)++;
            }

            /* Manufacture ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceID_datafield_ManufactureID,
                                                tvb, *poffset, 3, TRUE);
                  (*poffset)+=3;
            }

            /* Product ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceID_datafield_ProductID,
                                                tvb, *poffset, 2, TRUE);
                  (*poffset)+=2;
            }

            /* Auxiliary Firmware Revision Infomation */
            if ((15==len)&&tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetDeviceID_datafield_AFRI,
                                                tvb, *poffset, 4, TRUE);
                  (*poffset)+=4;
            }           

      }
      else
            return;

}



/* Storage NetFN (0x0a) */
static void
dissect_cmd_Get_FRU_Inventory_Area_Info(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{

      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            Response_Data_Byte4;
      
      if(response) {

            /* FRU Inventory area size in bytes */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetFRUInventoryAreaInfo_datafield_FRUInventoryAreaSize,
                                                tvb, (*poffset), 2, TRUE);
                  (*poffset)+=2;
            }
            /* Response Data Byte4 */
            if (tree) {
                  
                  Response_Data_Byte4 =  tvb_get_guint8(tvb, authtype ? 35 : 19) ;
                  
                  tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                               "Device is accessed by bytes or words: %s0x%02x", " ", Response_Data_Byte4);

                  field_tree = proto_item_add_subtree(tf, ett_cmd_GetFRUInventoryAreaInfo_data_ResponseDataByte4);

                  proto_tree_add_item(field_tree, hf_GetFRUInventoryAreaInfo_datafield_ResponseDataByte4_Bit71,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetFRUInventoryAreaInfo_datafield_ResponseDataByte4_Bit0,
                            tvb, *poffset, 1, TRUE);
                  (*poffset)++;
            }
            
      }
      else {
            
            /* FRU Device ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetFRUInventoryAreaInfo_datafield_FRUDeviceID,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            
      }
      
}

static void
dissect_cmd_Get_SEL_Info(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{

      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            Operation_Support;
      
      if(response) {

            /* SEL Version */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSELInfo_datafield_SELVersion,
                                                tvb, (*poffset)++, 1, TRUE);
            }
            
            
            /* number of log entries in SEL */
            if (tree) {
                  
                  proto_tree_add_item(ipmi_tree, hf_GetSELInfo_datafield_Entries,
                            tvb, *poffset, 2, TRUE);
                  (*poffset)+=2;
            }

            /* Free Space in bytes */
            if (tree) {
                  
                  proto_tree_add_item(ipmi_tree, hf_GetSELInfo_datafield_FreeSpace,
                            tvb, *poffset, 2, TRUE);
                  (*poffset)+=2;
            }


            /* Most recent addition timestamp */
            if (tree) {
                  
                  proto_tree_add_item(ipmi_tree, hf_GetSELInfo_datafield_AdditionTimestamp,
                            tvb, *poffset, 4, TRUE);
                  (*poffset)+=4;
            
            }

            /* Most recent addition timestamp */
            if (tree) {
                  
                  proto_tree_add_item(ipmi_tree, hf_GetSELInfo_datafield_EraseTimestamp,
                            tvb, *poffset, 4, TRUE);
                  (*poffset)+=4;
            
            }
            
            /* Operation Support */
            if (tree) {
                  
                  Operation_Support =  tvb_get_guint8(tvb, authtype ? 46 : 30) ;
                  
                  tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                               "Operation Support: %s0x%02x", " ", Operation_Support);

                  field_tree = proto_item_add_subtree(tf, ett_cmd_GetSELInfo_data_OperationSupport);

                  proto_tree_add_item(field_tree, hf_GetSELInfo_datafield_OperationSupport_Bit7,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSELInfo_datafield_OperationSupport_Reserved,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSELInfo_datafield_OperationSupport_Bit3,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSELInfo_datafield_OperationSupport_Bit2,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSELInfo_datafield_OperationSupport_Bit1,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_GetSELInfo_datafield_OperationSupport_Bit0,
                            tvb, *poffset, 1, TRUE);
                  (*poffset)++;
            }
            
      }
      else
            return;

}

static void
dissect_cmd_Reserve_SEL(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{
      
      if(response) {

            /* Reservation ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_ReserveSEL_datafield_ReservationID,
                            tvb, *poffset, 2, TRUE);
                  (*poffset)+=2;
            }

      }
      else
            return;

}

static void
dissect_cmd_Get_SEL_Entry(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo, tvbuff_t *tvb,
                                                gint *poffset, guint8 len, guint8 response, guint8 authtype _U_)
{

      tvbuff_t          *next_tvb;
      
      if(response) {

            /* Next SEL Record ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSELEntry_datafield_NextSELRecordID,
                                                tvb, (*poffset), 2, TRUE);
                  (*poffset)+=2;
                  len-=2;
            }
            /* Record Data */
            if (tree) {
                  next_tvb = tvb_new_subset(tvb, *poffset, len, len);
                  call_dissector(data_handle, next_tvb, pinfo, tree);
                  *poffset += len;
            }
            
      }
      else {
            
            /* Reservation ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSELEntry_datafield_ReservationID,
                            tvb, *poffset, 2, TRUE);
                  (*poffset)+=2;
            }
            /* SEL Record ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSELEntry_datafield_SELRecordID,
                            tvb, *poffset, 2, TRUE);
                  (*poffset)+=2;
            }
            /* Offset into record */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSELEntry_datafield_OffsetIntoRecord,
                            tvb, (*poffset)++, 1, TRUE);
            }
            /* Bytes to read */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_GetSELEntry_datafield_BytesToRead,
                            tvb, (*poffset)++, 1, TRUE);
            }

      }

}

static void
dissect_cmd_Clear_SEL(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{

      proto_tree  *field_tree = NULL;
      proto_item  *tf = NULL;
      guint8            erasure_progress;
      
      if(response) {

            /* Erasure progress */
            if (tree) {
                  
                  erasure_progress =  tvb_get_guint8(tvb, authtype ? 33 : 17) ;
                  
                  tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                               "Erasure progress: %s0x%02x", " ", erasure_progress);

                  field_tree = proto_item_add_subtree(tf, ett_cmd_ClearSEL_data_ErasureProgress);

                  proto_tree_add_item(field_tree, hf_ClearSEL_datafield_ErasureProgress_Reserved,
                            tvb, *poffset, 1, TRUE);
                  proto_tree_add_item(field_tree, hf_ClearSEL_datafield_ErasureProgress_EraProg,
                            tvb, *poffset, 1, TRUE);
                  (*poffset)++;
            }
            
      }
      else {
            
            /* Reservation ID */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_ClearSEL_datafield_ReservationID,
                            tvb, *poffset, 2, TRUE);
                  (*poffset)+=2;
            }
            /* 'C' (43h) */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_ClearSEL_datafield_Byte3,
                            tvb, (*poffset)++, 1, TRUE);
            }
            /* 'L' (4Ch) */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_ClearSEL_datafield_Byte4,
                            tvb, (*poffset)++, 1, TRUE);
            }
            /* 'R' (52h) */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_ClearSEL_datafield_Byte5,
                            tvb, (*poffset)++, 1, TRUE);
            }
            /* Data Byte 6 */
            if (tree) {
                  proto_tree_add_item(ipmi_tree, hf_ClearSEL_datafield_Byte6,
                            tvb, (*poffset)++, 1, TRUE);
            }

      }
}


/* Picmg NetFN (0x2c) */

static void
dissect_cmd_Get_PICMG_Properties(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{
            /*proto_tree      *field_tree = NULL;
            proto_item  *tf = NULL;
            guint8            picmg_identifier,  PICMGExtensionVersion, MaxFRUDeviceID, FRUDeviceIDforIPMController;*/
                  
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPICMGProperties_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* PICMG Extension Version */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPICMGProperties_datafield_PICMGExtensionVersion,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /*Max FRU Device ID*/
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPICMGProperties_datafield_MaxFRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }     
                  /*FRU Device ID for IPM Controller*/
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPICMGProperties_datafield_FRUDeviceIDforIPMController,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }     
            }
            else {
                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPICMGProperties_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
            }


}

static void
dissect_cmd_FRU_Control(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                          gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{

            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_FRUControl_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }

            }
            else {
                  
                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_FRUControl_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_FRUControl_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Control Option*/
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_FRUControl_datafield_FRUControlOption,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }

            }

}

static void
dissect_cmd_Get_FRU_Led_Properties(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                          gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{
            proto_tree  *field_tree = NULL;
            proto_item  *tf = NULL;
            guint8            LedProperties;
            
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedProperties_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* General Status LED Properties */
                  if (tree) {
                  
                        LedProperties = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
                        
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "General Status LED Properties: %s0x%02x", " ", LedProperties);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetFRULedProperties_data_LedProperties);

                        proto_tree_add_item(field_tree, hf_GetFRULedProperties_datafield_LedProperties_Reserved,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedProperties_datafield_LedProperties_LED3,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedProperties_datafield_LedProperties_LED2,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedProperties_datafield_LedProperties_LED1,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedProperties_datafield_LedProperties_BlueLED,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                        
                  }
                  /* Application Specific LED Count */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedProperties_datafield_ApplicationSpecificLEDCount,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }

            }
            else {
                  
                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedProperties_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedProperties_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }

}

static void 
dissect_cmd_Get_Led_Color_Capabilities(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                          gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{

            proto_tree  *field_tree = NULL;
            proto_item  *tf = NULL;
            guint8            LEDColorCapabilities, DefaultLEDColorLocalControl, DefaultLEDColorOverride;
            
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetLedColorCapabilities_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* LED Color Capabilities */
                  if (tree) {
                  
                        LEDColorCapabilities = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
                        
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "LED Color Capabilities: %s0x%02x", " ", LEDColorCapabilities);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetLedColorCapabilities_data_LEDColorCapabilities);

                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_Reserved_7,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_WHITE,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_ORANGE,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_AMBER,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_GREEN,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_RED,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_BLUE,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_Reserved_0,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                        
                  }
                  /* Default LED Color in Local Control State*/
                  if (tree) {
                        
                        DefaultLEDColorLocalControl = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
                        
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Default LED Color in Local Control State: %s0x%02x", " ", DefaultLEDColorLocalControl);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetLedColorCapabilities_data_DefaultLEDColorLocalControl);

                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_DefaultLEDColorLocalControl_Reserved_74,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_DefaultLEDColorLocalControl_Color,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                  }
                  /* Default LED Color in Override State */
                  if (tree) {
                        
                        DefaultLEDColorOverride = tvb_get_guint8(tvb, authtype ? 36 : 20) ;
                        
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Default LED Color in Override State: %s0x%02x", " ", DefaultLEDColorOverride);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetLedColorCapabilities_data_DefaultLEDColorOverride);

                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_DefaultLEDColorOverride_Reserved_74,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetLedColorCapabilities_datafield_DefaultLEDColorOverride_Color,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                  }

            }
            else {
                  
                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetLedColorCapabilities_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetLedColorCapabilities_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* LED ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetLedColorCapabilities_datafield_LEDID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
                  
            }

}

static void 
dissect_cmd_Set_FRU_Led_State(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{
            proto_tree  *field_tree = NULL;
            proto_item  *tf = NULL;
            guint8            Color;

            
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRULedState_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }
            else {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRULedState_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRULedState_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* LED ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRULedState_datafield_LEDID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* LED Function */
                  if (tree) {
                        guint8 LEDFunction = tvb_get_guint8(tvb, *poffset);
                        if ((LEDFunction < 0x01) || (LEDFunction > 0xfa)) {
                              proto_tree_add_item(ipmi_tree, hf_SetFRULedState_datafield_LEDFunction,
                                                      tvb, (*poffset)++, 1, TRUE);
                        } else {
                              proto_tree_add_uint_format(ipmi_tree, hf_SetFRULedState_datafield_Offduration,
                                                      tvb, (*poffset)++, 1, LEDFunction,
                                                      "Off-duration: %u ms (0x%02x)", LEDFunction * 10, LEDFunction);
                        }
                  }
                  /*On-duration */
                  if (tree) {
                        guint8 duration = tvb_get_guint8(tvb, *poffset);
                        proto_tree_add_uint_format(ipmi_tree, hf_SetFRULedState_datafield_Onduration, 
                                                      tvb, (*poffset)++, 1, duration,
                                                      "On-duration: %u ms (0x%02x)", duration * 10, duration);
                  }
                  /* Color when illuminated */
                  if (tree) {

                        Color = tvb_get_guint8(tvb, authtype ? 37 : 21) ;
                  
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Color when illuminated: %s0x%02x", " ", Color);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_SetFRULedState_data_Color);

                        proto_tree_add_item(field_tree, hf_SetFRULedState_datafield_Color_Reserved,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_SetFRULedState_datafield_Color_ColorVal,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                        
                  }
                  
            }

}

static void 
dissect_cmd_Get_FRU_Led_State(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{
            proto_tree  *field_tree = NULL;
            proto_item  *tf = NULL;
            guint8            led_state, Color;

            
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedState_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* LED state */
                  if (tree) {

                        led_state = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
                  
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "LED State: %s0x%02x", " ", led_state);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetFRULedState_data_LEDState);

                        proto_tree_add_item(field_tree, hf_GetFRULedState_datafield_LEDState_Reserved,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedState_datafield_LEDState_Bit2,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedState_datafield_LEDState_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedState_datafield_LEDState_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                  }
                  /* Local Control LED Function */
                  if (tree) {
                        guint8 LEDFunction = tvb_get_guint8(tvb, *poffset);
                        if ((LEDFunction < 0x01) || (LEDFunction > 0xfa)) {
                              proto_tree_add_item(ipmi_tree, hf_GetFRULedState_datafield_LocalControlLEDFunction,
                                                      tvb, (*poffset)++, 1, TRUE);
                        } else {
                              proto_tree_add_uint_format(ipmi_tree, hf_GetFRULedState_datafield_LocalControlOffduration,
                                                      tvb, (*poffset)++, 1, LEDFunction,
                                                      "Local Control Off-duration: %u ms (0x%02x)", LEDFunction * 10, LEDFunction);
                        }
                  }
                  /* Local Control On-duration */
                  if (tree) {
                        guint8 duration = tvb_get_guint8(tvb, *poffset);
                        proto_tree_add_uint_format(ipmi_tree, hf_GetFRULedState_datafield_LocalControlOnduration,
                                                      tvb, (*poffset)++, 1, duration,
                                                      "Local Control On-duration: %u ms (0x%02x)", duration * 10, duration);
                  }
                  /* Local Control Color */
                  if (tree) {

                        Color = tvb_get_guint8(tvb, authtype ? 37 : 21) ;
                  
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Local Control Color: %s0x%02x", " ", Color);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetFRULedState_data_LocalControlColor);

                        proto_tree_add_item(field_tree, hf_GetFRULedState_datafield_LocalControlColor_Reserved,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedState_datafield_LocalControlColor_ColorVal,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                        
                  }
                  /* Override State LED Function */
                  if (tree) {
                        guint8 LEDFunction = tvb_get_guint8(tvb, *poffset);
                        if ((LEDFunction < 0x01) || (LEDFunction > 0xfa)) {
                              proto_tree_add_item(ipmi_tree, hf_GetFRULedState_datafield_OverrideStateLEDFunction,
                                                      tvb, (*poffset)++, 1, TRUE);
                        } else {
                              proto_tree_add_uint_format(ipmi_tree, hf_GetFRULedState_datafield_OverrideStateOffduration,
                                                      tvb, (*poffset)++, 1, LEDFunction,
                                                      "Override State Off-duration: %u ms (0x%02x)", LEDFunction * 10, LEDFunction);
                        }
                  }
                  /* Override State On-duration */
                  if (tree) {
                        guint8 duration = tvb_get_guint8(tvb, *poffset);
                        proto_tree_add_uint_format(ipmi_tree, hf_GetFRULedState_datafield_OverrideStateOnduration,
                                                      tvb, (*poffset)++, 1, duration,
                                                      "Override State On-duration: %u ms (0x%02x)", duration * 10, duration);
                  }
                  /* Override State Color */
                  if (tree) {
                        
                        Color = tvb_get_guint8(tvb, authtype ? 40 : 24) ;
                  
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Override State Color: %s0x%02x", " ", Color);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetFRULedState_data_OverrideStateColor);

                        proto_tree_add_item(field_tree, hf_GetFRULedState_datafield_OverrideStateColor_Reserved,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRULedState_datafield_OverrideStateColor_ColorVal,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                  }
                  /* Lamp Test Duration */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedState_datafield_LampTestDuration,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }
            else {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedState_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedState_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* LED ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRULedState_datafield_LEDID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }

}

static void
dissect_cmd_Set_FRU_Activation_Policy(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{
            proto_tree  *field_tree = NULL;
            proto_item  *tf = NULL;
            guint8            FRUActivationPolicyMaskBit, MaskBit1, MaskBit0, FRUActivationPolicySetBit;
            
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRUActivationPolicy_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }
            else {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRUActivationPolicy_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRUActivationPolicy_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Activation Policy Mask Bit */
                  FRUActivationPolicyMaskBit = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
                  if (tree) {
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "FRU Activation Policy Mask Bit : %s0x%02x", " ", FRUActivationPolicyMaskBit);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicyMaskBit);

                        proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit72,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                  }
                  /* FRU Activation Policy Set Bit */
                  MaskBit1 = FRUActivationPolicyMaskBit & 0x02;
                  MaskBit0 = FRUActivationPolicyMaskBit & 0x01;
                  
                  if(MaskBit1&&MaskBit0) {

                        if (tree) {
                              FRUActivationPolicySetBit = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
                              tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "FRU Activation Policy Set Bit : %s0x%02x", " ", FRUActivationPolicySetBit);

                              field_tree = proto_item_add_subtree(tf, ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicySetBit);

                              proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit72,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                              proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                              (*poffset)++;
                        }
                        
                  }
                  else if(MaskBit1) {
                        
                              if (tree) {
                                    FRUActivationPolicySetBit = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
                                    tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "FRU Activation Policy Set Bit : %s0x%02x", " ", FRUActivationPolicySetBit);

                                    field_tree = proto_item_add_subtree(tf, ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicySetBit);

                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit72,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit0_ignored,
                                                      tvb, *poffset, 1, TRUE);
                                    (*poffset)++;
                              }
                              
                        }
                  else if(MaskBit0) {

                              if (tree) {
                                    FRUActivationPolicySetBit = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
                                    tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "FRU Activation Policy Set Bit : %s0x%02x", " ", FRUActivationPolicySetBit);

                                    field_tree = proto_item_add_subtree(tf, ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicySetBit);

                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit72,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit1_ignored,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                                    (*poffset)++;
                              }
                        }
                  else {
                        
                        if (tree) {
                                    FRUActivationPolicySetBit = tvb_get_guint8(tvb, authtype ? 35 : 19) ;
                                    tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "FRU Activation Policy Set Bit : %s0x%02x", " ", FRUActivationPolicySetBit);

                                    field_tree = proto_item_add_subtree(tf, ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicySetBit);

                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit72,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit1_ignored,
                                                      tvb, *poffset, 1, TRUE);
                                    proto_tree_add_item(field_tree, hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit0_ignored,
                                                      tvb, *poffset, 1, TRUE);
                                    (*poffset)++;
                              }
                        
                  }
                        
                  
            }

}

static void
dissect_cmd_Get_FRU_Activation_Policy(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype)
{

            proto_tree  *field_tree = NULL;
            proto_item  *tf = NULL;
            guint8            FRUActivationPolicy;
            
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRUActivationPolicy_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Activation Policy Mask Bit */
                  if (tree) {
                        FRUActivationPolicy = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "FRU Activation Policy : %s0x%02x", " ", FRUActivationPolicy);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetFRUActivationPolicy_data_FRUActivationPolicy);

                        proto_tree_add_item(field_tree, hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit72,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit1,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit0,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                  }
                  
            }
            else {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRUActivationPolicy_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFRUActivationPolicy_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }


}

static void
dissect_cmd_Set_FRU_Activation(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{

            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRUActivation_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }
            else {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRUActivation_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRUActivation_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /*FRU Activation/Deactivation*/
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFRUActivation_datafield_FRUActivationDeactivation,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }     
                  
            }

}

static void
dissect_cmd_Get_Device_Locator_Record_ID(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{
                        
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetDeviceLocatorRecordID_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* Record ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetDeviceLocatorRecordID_datafield_RecordID,
                                                      tvb, *poffset, 2, TRUE);
                        (*poffset)+=2;
                  }
                  
            }
            else {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetDeviceLocatorRecordID_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                   /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetDeviceLocatorRecordID_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
            
            }

}

static void
dissect_cmd_Set_Power_Level(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetPowerLevel_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }

            }
            else {
                  
                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetPowerLevel_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetPowerLevel_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* Power Level*/
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetPowerLevel_datafield_PowerLevel,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* Set Present Levels to Desired Levels */
                  if (tree) {
                              proto_tree_add_item(ipmi_tree, hf_SetPowerLevel_datafield_SetPresentLevelsToDesiredLevels,
                                                      tvb, (*poffset)++, 1, TRUE);
                        }     
                                    
            }

}

static void
dissect_cmd_Get_Power_Level(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len, guint8 response, guint8 authtype)
{
            proto_tree  *field_tree = NULL;
            proto_item  *tf = NULL;
            guint8            Properties, j;

            
            if(response) {

                  Properties = tvb_get_guint8(tvb, authtype ? 34 : 18) ;
                  
                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPowerLevel_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* Properties */
                  if (tree) {
                  
                        tf = proto_tree_add_text(ipmi_tree, tvb, *poffset, 1,
                                          "Properties: %s0x%02x", " ", Properties);

                        field_tree = proto_item_add_subtree(tf, ett_cmd_GetPowerLevel_data_Properties);

                        proto_tree_add_item(field_tree, hf_GetPowerLevel_datafield_Properties_DynamicPowerCon,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetPowerLevel_datafield_Properties_Reserved,
                                                      tvb, *poffset, 1, TRUE);
                        proto_tree_add_item(field_tree, hf_GetPowerLevel_datafield_Properties_PowerLevel,
                                                      tvb, *poffset, 1, TRUE);
                        (*poffset)++;
                        
                  }
                  /*Delay To Stable Power*/
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPowerLevel_datafield_DelayToStablePower,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /*Power Multiplier*/
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPowerLevel_datafield_PowerMultiplier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /*Power Draw*/
                  for(j=0; j<len-4; j++) {
                  
                        if (tree) {
                              proto_tree_add_item(ipmi_tree, hf_GetPowerLevel_datafield_PowerDraw,
                                                      tvb, (*poffset)++, 1, TRUE);
                        }     
                  }
                              
            }
            else {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPowerLevel_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPowerLevel_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* Power Type */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetPowerLevel_datafield_PowerType,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }

}

static void
dissect_cmd_Set_Fan_Level(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len _U_, guint8 response, guint8 authtype _U_)
{
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFanLevel_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }

            }
            else {
                  
                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFanLevel_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFanLevel_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* Fan Level */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_SetFanLevel_datafield_FanLevel,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                                    
            }

}

static void
dissect_cmd_Get_Fan_Level(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo _U_, tvbuff_t *tvb,
                                                gint *poffset, guint8 len, guint8 response, guint8 authtype _U_)
{
                        
            if(response) {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFanLevel_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                   
                  /* Override Fan Level */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFanLevel_datafield_OverrideFanLevel,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  if(3==len) {
                  /* Local Control Fan Level */
                        if (tree) {
                              proto_tree_add_item(ipmi_tree, hf_GetFanLevel_datafield_LocalControlFanLevel,
                                                      tvb, (*poffset)++, 1, TRUE);
                        }
                  }
                        
            }
            else {

                  /* PICMG Identifier */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFanLevel_datafield_PICMGIdentifier,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  /* FRU Device ID */
                  if (tree) {
                        proto_tree_add_item(ipmi_tree, hf_GetFanLevel_datafield_FRUDeviceID,
                                                      tvb, (*poffset)++, 1, TRUE);
                  }
                  
            }

}



/******************************************lane**********************************************/

static void dissect_ipmi_data(proto_tree *, proto_tree *, packet_info *, tvbuff_t *, gint *,
                                    guint8, guint8, guint8, guint8,guint8);


ipmi_cmd_dissect ipmi_cmd_array[] = {
      
      /* Chassis netfn (0x00) */
      { 0x00,     0x00, NULL},
      { 0x00,     0x01, NULL},
      { 0x00,     0x02, NULL},
      { 0x00,     0x03, NULL},
      { 0x00,     0x04, NULL},
      { 0x00,     0x05, NULL},
      { 0x00,     0x06, NULL},
      { 0x00,     0x07, NULL},
      { 0x00,     0x08, NULL},
      { 0x00,     0x09, NULL},
      { 0x00,     0x0f, NULL},
      /* Bridge netfn (0x02) */
      { 0x02,     0x00, NULL},
      { 0x02,     0x01, NULL},
      { 0x02,     0x02, NULL},
      { 0x02,     0x03, NULL},
      { 0x02,     0x04, NULL},
      { 0x02,     0x05, NULL},
      { 0x02,     0x06, NULL},
      { 0x02,     0x07, NULL},
      { 0x02,     0x08, NULL},
      { 0x02,     0x09, NULL},
      { 0x02,     0x0a, NULL},
      { 0x02,     0x0b, NULL},
      { 0x02,     0x0c, NULL},
      { 0x02,     0x10, NULL},
      { 0x02,     0x11, NULL},
      { 0x02,     0x12, NULL},
      { 0x02,     0x13, NULL},
      { 0x02,     0x14, NULL},
      { 0x02,     0x20, NULL},
      { 0x02,     0x21, NULL},
      { 0x02,     0x30, NULL},
      { 0x02,     0x31, NULL},
      { 0x02,     0x32, NULL},
      { 0x02,     0x33, NULL},
      { 0x02,     0x34, NULL},
      { 0x02,     0x35, NULL},
      { 0x02,     0xff, NULL},
      /* Sensor/Event netfn (0x04) */
      { 0x04,     0x00, NULL},
      { 0x04,     0x01, NULL},
      { 0x04,     0x02, dissect_cmd_PlatformEventMessage},
      { 0x04,     0x10, NULL},
      { 0x04,     0x11, NULL},
      { 0x04,     0x12, NULL},
      { 0x04,     0x13, NULL},
      { 0x04,     0x14, NULL},
      { 0x04,     0x15, NULL},
      { 0x04,     0x16, NULL},
      { 0x04,     0x17, NULL},
      { 0x04,     0x20, dissect_cmd_Get_Device_SDR_Info},
      { 0x04,     0x21, dissect_cmd_GetDeviceSDR},
      { 0x04,     0x22, dissect_cmd_Reserve_Device_SDR_Repository},
      { 0x04,     0x23, NULL},
      { 0x04,     0x24, dissect_cmd_Set_Sensor_Hysteresis},
      { 0x04,     0x25, dissect_cmd_Get_Sensor_Hysteresis},
      { 0x04,     0x26, dissect_cmd_Set_Sensor_Thresholds},
      { 0x04,     0x27, dissect_cmd_Get_Sensor_Thresholds},
      { 0x04,     0x28, NULL},
      { 0x04,     0x29, NULL},
      { 0x04,     0x2a, NULL},
      { 0x04,     0x2b, NULL},
      { 0x04,     0x2d, dissect_cmd_Get_Sensor_Reading},
      { 0x04,     0x2e, NULL},
      { 0x04,     0x2f, NULL},
      /* App netfn (0x06) */
      { 0x06,     0x01, dissect_cmd_Get_Device_ID},
      /* { 0x06,  0x01, NULL}, */
      { 0x06,     0x02, NULL},
      { 0x06,     0x03, NULL},
      { 0x06,     0x04, NULL},
      { 0x06,     0x05, NULL},
      { 0x06,     0x06, NULL},
      { 0x06,     0x07, NULL},
      { 0x06,     0x08, NULL},
      { 0x06,     0x22, NULL},
      { 0x06,     0x24, NULL},
      { 0x06,     0x25, NULL},
      { 0x06,     0x2e, NULL},
      { 0x06,     0x2f, NULL},
      { 0x06,     0x30, NULL},
      { 0x06,     0x31, NULL},
      { 0x06,     0x32, NULL},
      { 0x06,     0x33, NULL},
      { 0x06,     0x34, NULL},
      { 0x06,     0x35, NULL},
      { 0x06,     0x36, NULL},
      { 0x06,     0x37, NULL},
      { 0x06,     0x38, NULL},
      { 0x06,     0x39, NULL},
      { 0x06,     0x3a, NULL},
      { 0x06,     0x3b, NULL},
      { 0x06,     0x3c, NULL},
      { 0x06,     0x3d, NULL},
      { 0x06,     0x3f, NULL},
      { 0x06,     0x40, NULL},
      { 0x06,     0x41, NULL},
      { 0x06,     0x42, NULL},
      { 0x06,     0x43, NULL},
      { 0x06,     0x44, NULL},
      { 0x06,     0x45, NULL},
      { 0x06,     0x46, NULL},
      { 0x06,     0x47, NULL},
      { 0x06,     0x52, NULL},
      /*Storage netfn (0x0a)  */
      { 0x0a,     0x10, dissect_cmd_Get_FRU_Inventory_Area_Info},
      { 0x0a,     0x11, NULL},
      { 0x0a,     0x12, NULL},
      { 0x0a,     0x20, NULL},
      { 0x0a,     0x21, NULL},
      { 0x0a,     0x22, NULL},
      { 0x0a,     0x23, NULL},
      { 0x0a,     0x24, NULL},
      { 0x0a,     0x25, NULL},
      { 0x0a,     0x26, NULL},
      { 0x0a,     0x27, NULL},
      { 0x0a,     0x28, NULL},
      { 0x0a,     0x29, NULL},
      { 0x0a,     0x2a, NULL},
      { 0x0a,     0x2b, NULL},
      { 0x0a,     0x2d, NULL},
      { 0x0a,     0x2c, NULL},
      { 0x0a,     0x40, dissect_cmd_Get_SEL_Info},
      { 0x0a,     0x41, NULL},
      { 0x0a,     0x42, dissect_cmd_Reserve_SEL},
      { 0x0a,     0x43, dissect_cmd_Get_SEL_Entry},
      { 0x0a,     0x44, NULL},
      { 0x0a,     0x45, NULL},
      { 0x0a,     0x46, NULL},
      { 0x0a,     0x47, dissect_cmd_Clear_SEL},
      { 0x0a,     0x48, NULL},
      { 0x0a,     0x49, NULL},
      { 0x0a,     0x5a, NULL},
      { 0x0a,     0x5b, NULL},
      /* PICMG netfn (0x2c) */
      {0x2c,      0x00, dissect_cmd_Get_PICMG_Properties},
      {0x2c,      0x01, NULL},
      {0x2c,      0x02, NULL},
      {0x2c,      0x03, NULL},
      {0x2c,      0x04, dissect_cmd_FRU_Control},
      {0x2c,      0x05, dissect_cmd_Get_FRU_Led_Properties},
      {0x2c,      0x06, dissect_cmd_Get_Led_Color_Capabilities},
      {0x2c,      0x07, dissect_cmd_Set_FRU_Led_State},
      {0x2c,      0x08, dissect_cmd_Get_FRU_Led_State},
      {0x2c,      0x09, NULL},
      {0x2c,      0x0a, dissect_cmd_Set_FRU_Activation_Policy},
      {0x2c,      0x0b, dissect_cmd_Get_FRU_Activation_Policy},
      {0x2c,      0x0c, dissect_cmd_Set_FRU_Activation},
      {0x2c,      0x0d, dissect_cmd_Get_Device_Locator_Record_ID},
      {0x2c,      0x0e, NULL},
      {0x2c,      0x0f, NULL},
      {0x2c,      0x10, NULL},
      {0x2c,      0x11, dissect_cmd_Set_Power_Level},
      {0x2c,      0x12, dissect_cmd_Get_Power_Level},
      {0x2c,      0x13, NULL},
      {0x2c,      0x14, NULL},
      {0x2c,      0x15, dissect_cmd_Set_Fan_Level},
      {0x2c,      0x16, dissect_cmd_Get_Fan_Level},
      {0x2c,      0x17, NULL},
      {0x2c,      0x18, NULL},            
};

#define NUM_OF_CMD_ARRAY (sizeof(ipmi_cmd_array)/sizeof(ipmi_cmd_dissect))

/***************************************************/

static const char *
get_netfn_cmd_text(guint8 netfn, guint8 cmd)
{
      switch (netfn) {
      case 0x00:
      case 0x01:
            return val_to_str(cmd, ipmi_chassis_cmd_vals, "Unknown (0x%02x)");
      case 0x02:
      case 0x03:
            return val_to_str(cmd, ipmi_bridge_cmd_vals, "Unknown (0x%02x)");
      case 0x04:
      case 0x05:
            return val_to_str(cmd, ipmi_se_cmd_vals, "Unknown (0x%02x)");
      case 0x06:
      case 0x07:
            return val_to_str(cmd, ipmi_app_cmd_vals, "Unknown (0x%02x)");
      case 0x0a:
      case 0x0b:
            return val_to_str(cmd, ipmi_storage_cmd_vals, "Unknown (0x%02x)");
      case 0x0c:
      case 0x0d:
            return val_to_str(cmd, ipmi_transport_cmd_vals, "Unknown (0x%02x)");
      case 0x2c: /* added by lane */
      case 0x2d:
            return val_to_str(cmd, ipmi_picmg_cmd_vals, "Unknown (0x%02x)");
      default:
            return (netfn & 1) ? "Unknown Response" : "Unknown Request";
      }
}

static void
dissect_ipmi(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
      proto_tree  *ipmi_tree = NULL, *field_tree = NULL;
      proto_item  *ti = NULL, *tf;
      gint              offset = 0;
      /* tvbuff_t *next_tvb; */  /* modified by lane */
      guint32           session_id;
      guint8            authtype, netfn, cmd, ccode, len, response;

      /* session authtype, 0=no authcode present */
      authtype = tvb_get_guint8(tvb, 0);

      /* session ID */
      session_id = tvb_get_letohl(tvb, 5);

      /* network function code */
      netfn = tvb_get_guint8(tvb, authtype ? 27 : 11) >> 2;

      /* bit 0 of netfn: even=request odd=response */
      response =  netfn & 1;

      /* command */
      cmd = tvb_get_guint8(tvb, authtype ? 31 : 15);

      /* completion code */
      ccode = response ? tvb_get_guint8(tvb, authtype ? 32 : 16) : 0;

      if (check_col(pinfo->cinfo, COL_PROTOCOL))
            col_set_str(pinfo->cinfo, COL_PROTOCOL, "IPMI");
      if (check_col(pinfo->cinfo, COL_INFO))
            col_clear(pinfo->cinfo, COL_INFO);
      if (check_col(pinfo->cinfo, COL_INFO)) {
            if (ccode)
                  col_add_fstr(pinfo->cinfo, COL_INFO, "%s, %s: %s",
                       get_netfn_cmd_text(netfn, cmd),
                       val_to_str(netfn, ipmi_netfn_vals,   "Unknown (0x%02x)"),
                       val_to_str(ccode, ipmi_ccode_vals,   "Unknown (0x%02x)"));
            else
                  col_add_fstr(pinfo->cinfo, COL_INFO, "%s, %s",
                       get_netfn_cmd_text(netfn, cmd),
                       val_to_str(netfn, ipmi_netfn_vals,   "Unknown (0x%02x)"));
      }

      if (tree) {
            ti = proto_tree_add_protocol_format(tree, proto_ipmi,
                      tvb, offset, authtype ? 32 : 16,
                      "Intelligent Platform Management Interface, "
                      "NetFn: %s (0x%02x), Cmd: %s (0x%02x)",
                      val_to_str(netfn, ipmi_netfn_vals, "Unknown (0x%02x)"),
                      netfn, get_netfn_cmd_text(netfn, cmd), cmd);
            ipmi_tree = proto_item_add_subtree(ti, ett_ipmi);
      }
      
      /* ipmi session field */
      if (tree) {
            tf = proto_tree_add_text(ipmi_tree, tvb, offset,
                         authtype ? 25 : 9,
                         "Session: ID 0x%08x (%d bytes)",
                         session_id, authtype ? 25 : 9);
            field_tree = proto_item_add_subtree(tf, ett_ipmi_session);
            proto_tree_add_item(field_tree, hf_ipmi_session_authtype,
                      tvb, offset++, 1, TRUE);
            proto_tree_add_item(field_tree, hf_ipmi_session_sequence,
                      tvb, offset, 4, TRUE);
            offset += 4;
            proto_tree_add_item(field_tree, hf_ipmi_session_id,
                      tvb, offset, 4, TRUE);
            offset += 4;
            if (authtype) {
                  proto_tree_add_item(field_tree, hf_ipmi_session_authcode,
                            tvb, offset, 16, TRUE);
                  offset += 16;
            }
      }

      /* message length */
      if (tree) {
            proto_tree_add_item(ipmi_tree, hf_ipmi_msg_len,
                      tvb, offset++, 1, TRUE);
      }

      /* r[sq]addr */
      if (tree) {
            proto_tree_add_item(ipmi_tree,
                      response ? hf_ipmi_msg_rqaddr : hf_ipmi_msg_rsaddr,
                      tvb, offset++, 1, TRUE);
      }

      /* netfn/lun */
      if (tree) {
            guint8 lun;

            tf = proto_tree_add_text(ipmi_tree, tvb, offset, 1,
                   "NetFn/LUN: %s (0x%02x)", val_to_str(netfn,
                   ipmi_netfn_vals, "Unknown (0x%02x)"),
                   netfn);

            field_tree = proto_item_add_subtree(tf, ett_ipmi_msg_nlfield);

            proto_tree_add_item(field_tree, hf_ipmi_msg_netfn,
                            tvb, offset, 1, TRUE);
            proto_tree_add_item(field_tree,
                            response ? hf_ipmi_msg_rqlun : hf_ipmi_msg_rslun,
                            tvb, offset, 1, TRUE);
            lun = tvb_get_guint8(tvb, offset) & 3;
            proto_item_append_text(tf, ", LUN 0x%02x", lun);
            offset += 1;
      }

      /* checksum */
      if (tree) {
            proto_tree_add_item(ipmi_tree, hf_ipmi_msg_csum1,
                            tvb, offset++, 1, TRUE);
      }

      /* r[sq]addr */
      if (tree) {
            proto_tree_add_item(ipmi_tree,
                            response ? hf_ipmi_msg_rsaddr : hf_ipmi_msg_rqaddr,
                            tvb, offset++, 1, TRUE);
      }

      /* seq/lun */
      if (tree) {
            guint8 lun;

            tf = proto_tree_add_item(ipmi_tree, hf_ipmi_msg_slfield,
                               tvb, offset, 1, TRUE);
            field_tree = proto_item_add_subtree(tf, ett_ipmi_msg_slfield);

            proto_tree_add_item(field_tree, hf_ipmi_msg_seq,
                            tvb, offset, 1, TRUE);
            proto_tree_add_item(field_tree,
                            response ? hf_ipmi_msg_rslun : hf_ipmi_msg_rqlun,
                            tvb, offset, 1, TRUE);
            lun = tvb_get_guint8(tvb, offset) & 3;
            proto_item_append_text(tf, ", LUN 0x%02x", lun);
            offset += 1;
      }
      

      /* command */
      if (tree) {
            proto_tree_add_text(ipmi_tree, tvb, offset++, 1,
                            "Command: %s (0x%02x)",
                            get_netfn_cmd_text(netfn, cmd), cmd);
      }
      

      /* completion code */
      if (tree && response) {
            proto_tree_add_item(ipmi_tree, hf_ipmi_msg_ccode,
                            tvb, offset++, 1, TRUE);
      }
      

      /* If ccode is non zero and there is only one more byte remaining in
       * the packet this probably means that the response has been truncated
       * and the single remaining byte is just the checksum field.
       */
      if(ccode && response && tvb_reported_length_remaining(tvb, offset)==1){
            proto_tree_add_text(ipmi_tree, tvb, offset, 0, "[Truncated response]");

            /* checksum */
            proto_tree_add_item(ipmi_tree, hf_ipmi_msg_csum2,
                            tvb, offset++, 1, TRUE);
            return;
      }

      /* determine data length */
      len = tvb_get_guint8(tvb, authtype ? 25 : 9) - 6 - (response ? 1 : 0) -1;

      /* rem by lane */
      /*
      next_tvb = tvb_new_subset(tvb, offset, len, len);
      call_dissector(data_handle, next_tvb, pinfo, tree);
      offset += len;
      */

      /* dissect the data block, added by lane */
      dissect_ipmi_data(tree, ipmi_tree, pinfo, tvb, &offset, len, netfn, cmd, response, authtype);
      

      /* checksum 2 */
      if (tree) {
            proto_tree_add_item(ipmi_tree, hf_ipmi_msg_csum2,
                            tvb, offset++, 1, TRUE);
      }
}

void
proto_register_ipmi(void)
{
      static hf_register_info hf_session[] = {
            { &hf_ipmi_session_authtype, {
                  "Authentication Type", "ipmi.session.authtype",
                  FT_UINT8, BASE_HEX, VALS(ipmi_authtype_vals), 0,
                  "IPMI Authentication Type", HFILL }},
            { &hf_ipmi_session_sequence, {
                  "Session Sequence Number", "ipmi.session.sequence",
                  FT_UINT32, BASE_HEX, NULL, 0,
                  "IPMI Session Sequence Number", HFILL }},
            { &hf_ipmi_session_id, {
                  "Session ID", "ipmi.session.id",
                  FT_UINT32, BASE_HEX, NULL, 0,
                  "IPMI Session ID", HFILL }},
            { &hf_ipmi_session_authcode, {
                  "Authentication Code", "ipmi.session.authcode",
                  FT_BYTES, BASE_HEX, NULL, 0,
                  "IPMI Message Authentication Code", HFILL }},
      };
      static hf_register_info hf_msg[] = {
            { &hf_ipmi_msg_len, {
                  "Message Length", "ipmi.msg.len",
                  FT_UINT8, BASE_DEC, NULL, 0,
                  "IPMI Message Length", HFILL }},
            { &hf_ipmi_msg_rsaddr, {
                  "Response Address", "ipmi.msg.rsaddr",
                  FT_UINT8, BASE_HEX, VALS(ipmi_addr_vals), 0,
                  "Responder's Slave Address", HFILL }},
            { &hf_ipmi_msg_csum1, {
                  "Checksum 1", "ipmi.msg.csum1",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "2s Complement Checksum", HFILL }},
            { &hf_ipmi_msg_rqaddr, {
                  "Request Address", "ipmi.msg.rqaddr",
                  FT_UINT8, BASE_HEX, VALS(ipmi_addr_vals), 0,
                  "Requester's Address (SA or SWID)", HFILL }},
            { &hf_ipmi_msg_cmd, {
                  "Command", "ipmi.msg.cmd",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "IPMI Command Byte", HFILL }},
            { &hf_ipmi_msg_ccode, {
                  "Completion Code", "ipmi.msg.ccode",
                  FT_UINT8, BASE_HEX, VALS(ipmi_ccode_vals), 0,
                  "Completion Code for Request", HFILL }},
            { &hf_ipmi_msg_csum2, {
                  "Checksum 2", "ipmi.msg.csum2",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "2s Complement Checksum", HFILL }},
      };
      static hf_register_info hf_msg_field[] = {
            { &hf_ipmi_msg_nlfield, {
                  "NetFn/LUN", "ipmi.msg.nlfield",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Network Function and LUN field", HFILL }},
            { &hf_ipmi_msg_netfn, {
                  "NetFn", "ipmi.msg.nlfield.netfn",
                  FT_UINT8, BASE_HEX, VALS(ipmi_netfn_vals), 0xfc,
                  "Network Function Code", HFILL }},
            { &hf_ipmi_msg_rqlun, {
                  "Request LUN", "ipmi.msg.nlfield.rqlun",
                  FT_UINT8, BASE_HEX, NULL, 0x03,
                  "Requester's Logical Unit Number", HFILL }},
            { &hf_ipmi_msg_slfield, {
                  "Seq/LUN", "ipmi.msg.slfield",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Sequence and LUN field", HFILL }},
            { &hf_ipmi_msg_seq, {
                  "Sequence", "ipmi.msg.slfield.seq",
                  FT_UINT8, BASE_HEX, NULL, 0xfc,
                  "Sequence Number (requester)", HFILL }},
            { &hf_ipmi_msg_rslun, {
                  "Response LUN", "ipmi.msg.slfield.rslun",
                  FT_UINT8, BASE_HEX, NULL, 0x03,
                  "Responder's Logical Unit Number", HFILL }},
      };

/********* Sensor/Event, NetFN = 0x04 **********/

      /*  Data field of Platform Event Message command, added by lane */
      static hf_register_info hf_PEM_datafield[] = {
            { &hf_PEM_datafield_EvMRev, {
                  "Event Message Revision", "PEM.datafield.EvMRev",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_EvMRev_vals), 0,
                  "Event Message Revision", HFILL }},
            { &hf_PEM_datafield_SensorType, {
                  "Sensor Type", "PEM.datafield.SensorType",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_SensorType_vals), 0,
                  "Sensor Type", HFILL }},
            { &hf_PEM_datafield_SensorNumber, {
                  "Sensor #", "PEM.datafield.SensorNumber",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Sensor Number", HFILL }},
            { &hf_PEM_datafield_EventDirAndEventType_EventDir, {
                  "Event Direction", "PEM.datafield.EventDirAndEventType.EventDir",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_EventDir_vals), 0x80,
                  "Event Direction", HFILL }},
            { &hf_PEM_datafield_EventDirAndEventType_EventType, {
                  "Event Type", "PEM.datafield.EventType",
                  FT_UINT8, BASE_HEX, NULL, 0x7f,
                  "Event Type", HFILL }},
            /* threshold */
            { &hf_PEM_datafield_EventData1_threshold_76, {
                  "[7,6] ", "PEM.datafield.EventData1_threshold_76",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_EventData1_threshold_76_vals), 0xc0,
                  "byte 2 in the event data", HFILL }},
            { &hf_PEM_datafield_EventData1_threshold_54, {
                  "[5,4] ", "PEM.datafield.EventData1_threshold_54",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_EventData1_threshold_54_vals), 0x30,
                  "byte 3 in the event data", HFILL }},
            { &hf_PEM_datafield_EventData1_threshold_30, {
                  "Offset from Event/Reading Code for threshold event", "PEM.datafield.EventData1_threshold_30",
                  FT_UINT8, BASE_HEX, NULL, 0x0f,
                  "Offset from Event/Reading Code for threshold event", HFILL }},
            { &hf_PEM_datafield_EventData2_threshold, {
                  "reading that triggered event", "PEM.datafield.EventData2_threshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "reading that triggered event", HFILL }},
            { &hf_PEM_datafield_EventData3_threshold, {
                  "threshold value that triggered event", "PEM.datafield.EventData3_threshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "threshold value that triggered event", HFILL }},     
            /* discrete */
            { &hf_PEM_datafield_EventData1_discrete_76, {
                  "[7,6] ", "PEM.datafield.EventData1_discrete_76",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_EventData1_discrete_76_vals), 0xc0,
                  "byte 2 in the event data", HFILL }},
            { &hf_PEM_datafield_EventData1_discrete_54, {
                  "[5,4] ", "PEM.datafield.EventData1_discrete_54",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_EventData1_discrete_54_vals), 0x30,
                  "byte 3 in the event data", HFILL }},
            { &hf_PEM_datafield_EventData1_discrete_30, {
                  "Offset from Event/Reading Code for threshold event", "PEM.datafield.EventData1_discrete_30",
                  FT_UINT8, BASE_HEX, NULL, 0x0f,
                  "Offset from Event/Reading Code for threshold event", HFILL }},
            { &hf_PEM_datafield_EventData2_discrete_74, {
                  "Optional offset from 'Severity' Event/Reading Code(0x0f if unspecified)", "PEM.datafield.EventData2_discrete_74",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Optional offset from 'Severity' Event/Reading Code(0x0f if unspecified)", HFILL }},
            { &hf_PEM_datafield_EventData2_discrete_30, {
                  "Optional offset from Event/Reading Type Code for previous discrete event state (0x0f if unspecified)", "PEM.datafield.EventData2_discrete_30",
                  FT_UINT8, BASE_HEX, NULL, 0x0f,
                  "Optional offset from Event/Reading Type Code for previous discrete event state (0x0f if unspecified)", HFILL }},
            { &hf_PEM_datafield_EventData3_discrete, {
                  "Optional OEM code", "PEM.datafield.EventData3_discrete",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Optional OEM code", HFILL }},
            /* OEM */
            { &hf_PEM_datafield_EventData1_OEM_76, {
                  "[7,6] ", "PEM.datafield.EventData1_OEM_76",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_EventData1_OEM_76_vals), 0xc0,
                  "byte 2 in the event data", HFILL }},
            { &hf_PEM_datafield_EventData1_OEM_54, {
                  "[5,4] ", "PEM.datafield.EventData1_OEM_54",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_EventData1_OEM_54_vals), 0x30,
                  "byte 3 in the event data", HFILL }},
            { &hf_PEM_datafield_EventData1_OEM_30, {
                  "Offset from Event/Reading Type Code", "PEM.datafield.EventData1_OEM_30",
                  FT_UINT8, BASE_HEX, NULL, 0x0f,
                  "Offset from Event/Reading Type Code", HFILL }},
            { &hf_PEM_datafield_EventData2_OEM_74, {
                  "Optional OEM code bits or offset from 'Severity' Event/Reading Type Code(0x0f if unspecified)", "PEM.datafield.EventData2_OEM_74",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Optional OEM code bits or offset from 'Severity' Event/Reading Type Code(0x0f if unspecified)", HFILL }},
            { &hf_PEM_datafield_EventData2_OEM_30, {
                  "Optional OEM code or offset from Event/Reading Type Code for previous event state(0x0f if unspecified)", "PEM.datafield.EventData2_OEM_30",
                  FT_UINT8, BASE_HEX, NULL, 0x0f,
                  "Optional OEM code or offset from Event/Reading Type Code for previous event state(0x0f if unspecified)", HFILL }},
            { &hf_PEM_datafield_EventData3_OEM, {
                  "Optional OEM code", "PEM.datafield.EventData3_discrete",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Optional OEM code", HFILL }},
            /* Hot Swap Event  dedicated */
            { &hf_PEM_datafield_HotSwapEvent_CurrentState, {
                  "Current State", "PEM.datafield.HotSwapEvent_CurrentState",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_HotSwapEvent_state_vals), 0x0f,
                  "Current State", HFILL }},
            { &hf_PEM_datafield_HotSwapEvent_StateChangeCause, {
                  "Cause of State Change", "PEM.datafield.HotSwapEvent_EventData2_74",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_HotSwapEvent_StateChangeCause_vals), 0xf0,
                  "Cause of State Change", HFILL }},
            { &hf_PEM_datafield_HotSwapEvent_PreviousState, {
                  "Previous State", "PEM.datafield.HotSwapEvent_HotSwapEvent_PreviousState",
                  FT_UINT8, BASE_HEX, VALS(cmd_PEM_HotSwapEvent_state_vals), 0x0f,
                  "Previous State", HFILL }},
            { &hf_PEM_datafield_HotSwapEvent_FRUDeviceID, {
                  "FRU Device ID", "PEM.datafield.HotSwapEvent_FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
      };

      /* Data field of Get Device SDR Info command, added by lane */
      static hf_register_info hf_GetDeviceSDRInfo_datafield[] = {
            { &hf_GetDeviceSDRInfo_datafield_SensorNumber, {
                  "Number of the Sensors in device", "GetDeviceSDRInfo.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_DEC, NULL, 0,
                  "Number of the Sensors in device", HFILL }},
            { &hf_GetDeviceSDRInfo_datafield_Flag, {
                  "Flag", "GetDeviceSDRInfo.datafield.Flag",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Flag", HFILL }},
            { &hf_GetDeviceSDRInfo_datafield_Flag_Dynamicpopulation, {
                  "Dynamic population", "GetDeviceSDRInfo.datafield.Flag.Dynamicpopulation",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceSDRInfo_data_Flag_Dynamicpopulation_vals), 0x80,
                  "Dynamic population", HFILL }},
            { &hf_GetDeviceSDRInfo_datafield_Flag_Reserved, {
                  "Reserved", "GetDeviceSDRInfo.datafield.Flag.Reserved",
                  FT_UINT8, BASE_HEX, NULL, 0x70,
                  "Reserved", HFILL }},
            { &hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs3, {
                  "Device LUN 3", "GetDeviceSDRInfo.datafield.Flag.DeviceLUN3",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceSDRInfo_data_Flag_DeviceLUNs_vals), 0x08,
                  "Device LUN 3", HFILL }},
            { &hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs2, {
                  "Device LUN 2", "GetDeviceSDRInfo.datafield.Flag.DeviceLUNs2",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceSDRInfo_data_Flag_DeviceLUNs_vals), 0x04,
                  "Device LUN 2", HFILL }},
            { &hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs1, {
                  "Device LUN 1", "GetDeviceSDRInfo.datafield.Flag.DeviceLUNs1",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceSDRInfo_data_Flag_DeviceLUNs_vals), 0x02,
                  "Device LUN 1", HFILL }},
            { &hf_GetDeviceSDRInfo_datafield_Flag_DeviceLUNs0, {
                  "Device LUN 0", "GetDeviceSDRInfo.datafield.Flag.DeviceLUNs0",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceSDRInfo_data_Flag_DeviceLUNs_vals), 0x01,
                  "Device LUN 0", HFILL }},
            { &hf_GetDeviceSDRInfo_datafield_SensorPopulationChangeIndicator, {
                  "SensorPopulation Change Indicator ", "GetDeviceSDRInfo.datafield.SensorPopulationChangeIndicator",
                  FT_UINT32, BASE_HEX, NULL, 0,
                  "Sensor Population Change Indicator", HFILL }},
      };

      /*  Data field of Reserve Device SDR Repository command, added by lane */
      static hf_register_info hf_ReserveDeviceSDRRepository_datafield[] = {
            { &hf_ReserveDeviceSDRRepository_datafield_ReservationID, {
                  "Reservation ID", "ReserveDeviceSDRRepository.datafield.ReservationID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Reservation ID", HFILL }},
      };

      /*  Data field of Get Device SDR command, added by lane */
      static hf_register_info hf_GetDeviceSDR_datafield[] = {
            { &hf_GetDeviceSDR_datafield_ReservationID, {
                  "Reservation ID", "GetDeviceSDR.datafield.ReservationID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Reservation ID", HFILL }},
            { &hf_GetDeviceSDR_datafield_RecordID, {
                  "Record ID of record to Get", "GetDeviceSDR.datafield.RecordID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Record ID of record to Get", HFILL }},
            { &hf_GetDeviceSDR_datafield_OffsetIntoRecord, {
                  "Offset into record", "GetDeviceSDR.datafield.OffsetIntoRecord",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Offset into record", HFILL }},
            { &hf_GetDeviceSDR_datafield_BytesToRead, {
                  "Bytes to read (number)", "GetDeviceSDR.datafield.BytesToRead",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceSDR_data_BytesToRead_vals), 0,
                  "Bytes to read", HFILL }},
            { &hf_GetDeviceSDR_datafield_NextRecordID, {
                  "Record ID for next record", "GetDeviceSDR.datafield.ReservationID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Record ID for next record", HFILL }},          
      };

      /* Data field of Set Sensor Hysteresis command, added by lane */
      static hf_register_info hf_SetSensorHysteresis_datafield[] = {
            { &hf_SetSensorHysteresis_datafield_SensorNumber, {
                  "Sensor Number", "SetSensorHysteresis.datafield.SensorNumber",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Sensor Number", HFILL }},
            { &hf_SetSensorHysteresis_datafield_ReservedForHysteresisMask, {
                  "Reserved for future ' Hysteresis Mask ' definition", "SetSensorHysteresis.datafield.ReservedForHysteresisMask",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Reserved For Hysteresis Mask", HFILL }},
            { &hf_SetSensorHysteresis_datafield_PositivegoingThresholdHysteresisValue, {
                  "Positive-going Threshold Hysteresis Value", "SetSensorHysteresis.datafield.PositivegoingThresholdHysteresisValue",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Positive-going Threshold Hysteresis Value", HFILL }},
            { &hf_SetSensorHysteresis_datafield_NegativegoingThresholdHysteresisValue, {
                  "Negative-going Threshold Hysteresis Value", "SetSensorHysteresis.datafield.NegativegoingThresholdHysteresisValue",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Negative-going Threshold Hysteresis Value", HFILL }},
      };

      /* Data field of Get Sensor Hysteresis command, added by lane */
      static hf_register_info hf_GetSensorHysteresis_datafield[] = {
            { &hf_GetSensorHysteresis_datafield_SensorNumber, {
                  "Sensor Number", "GetSensorHysteresis.datafield.SensorNumber",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Sensor Number", HFILL }},
            { &hf_GetSensorHysteresis_datafield_ReservedForHysteresisMask, {
                  "Reserved for future ' Hysteresis Mask ' definition", "GetSensorHysteresis.datafield.ReservedForHysteresisMask",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Reserved For Hysteresis Mask", HFILL }},
            { &hf_GetSensorHysteresis_datafield_PositivegoingThresholdHysteresisValue, {
                  "Positive-going Threshold Hysteresis Value", "GetSensorHysteresis.datafield.PositivegoingThresholdHysteresisValue",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Positive-going Threshold Hysteresis Value", HFILL }},
            { &hf_GetSensorHysteresis_datafield_NegativegoingThresholdHysteresisValue, {
                  "Negative-going Threshold Hysteresis Value", "GetSensorHysteresis.datafield.NegativegoingThresholdHysteresisValue",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Negative-going Threshold Hysteresis Value", HFILL }},
      };

      /*  Data field of Set Sensor Thresholds command, added by lane */
      static hf_register_info hf_SetSensorThresholds_datafield[] = {
            { &hf_SetSensorThresholds_datafield_SensorNumber, {
                  "Sensor Number", "SetSensorThresholds.datafield.SensorNumber",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Sensor Number", HFILL }},
            { &hf_SetSensorThresholds_datafield_ControlByte_Bit76, {
                  "Bit 7...6 Reserved", "SetSensorThresholds.datafield.ControlByte.Bit76",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Bit 7...6 Reserved", HFILL }},
            { &hf_SetSensorThresholds_datafield_ControlByte_Bit5, {
                  "upper non-recoverable threshold", "SetSensorThresholds.datafield.ControlByte.Bit5",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetSensorThresholds_data_ControlByte_Bit_vals), 0x20,
                  "upper non-recoverable threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_ControlByte_Bit4, {
                  "upper critical threshold", "SetSensorThresholds.datafield.ControlByte.Bit4",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetSensorThresholds_data_ControlByte_Bit_vals), 0x10,
                  "upper critical threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_ControlByte_Bit3, {
                  "upper non-critical threshold", "SetSensorThresholds.datafield.ControlByte.Bit3",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetSensorThresholds_data_ControlByte_Bit_vals), 0x08,
                  "upper non-critical threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_ControlByte_Bit2, {
                  "lower non-recoverable threshold", "SetSensorThresholds.datafield.ControlByte.Bit2",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetSensorThresholds_data_ControlByte_Bit_vals), 0x04,
                  "lower non-recoverable threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_ControlByte_Bit1, {
                  "lower critical threshold", "SetSensorThresholds.datafield.ControlByte.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetSensorThresholds_data_ControlByte_Bit_vals), 0x02,
                  "lower critical threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_ControlByte_Bit0, {
                  "lower non-critical threshold", "SetSensorThresholds.datafield.ControlByte.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetSensorThresholds_data_ControlByte_Bit_vals), 0x01,
                  "lower non-critical threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_LowerNonCriticalThreshold, {
                  "lower non-critical threshold", "SetSensorThresholds.datafield.LowerNonCriticalThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "lower non-critical threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_LowerCriticalThreshold, {
                  "lower critical threshold", "SetSensorThresholds.datafield.LowerCriticalThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "lower critical threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_LowerNonRecoverableThreshold, {
                  "lower non-recoverable threshold", "SetSensorThresholds.datafield.LowerNonRecoverableThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "lower non-recoverable threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_UpperNonCriticalThreshold, {
                  "upper non-critical threshold", "SetSensorThresholds.datafield.UpperNonCriticalThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "upper non-critical threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_UpperCriticalThreshold, {
                  "upper critical threshold", "SetSensorThresholds.datafield.UpperCriticalThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "upper critical threshold", HFILL }},
            { &hf_SetSensorThresholds_datafield_UpperNonRecoverableThreshold, {
                  "upper non-recoverable threshold", "SetSensorThresholds.datafield.UpperNonRecoverableThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "upper non-recoverable threshold", HFILL }},
      };

      /*  Data field of Get Sensor Thresholds command, added by lane */
      static hf_register_info hf_GetSensorThresholds_datafield[] = {
            { &hf_GetSensorThresholds_datafield_SensorNumber, {
                  "Sensor Number", "GetSensorThresholds.datafield.SensorNumber",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Sensor Number", HFILL }},
            { &hf_GetSensorThresholds_datafield_ControlByte_Bit76, {
                  "Bit 7...6 Reserved", "GetSensorThresholds.datafield.ControlByte.Bit76",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Bit 7...6 Reserved", HFILL }},
            { &hf_GetSensorThresholds_datafield_ControlByte_Bit5, {
                  "upper non-recoverable threshold", "GetSensorThresholds.datafield.ControlByte.Bit5",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorThresholds_data_ControlByte_Bit_vals), 0x20,
                  "upper non-recoverable threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_ControlByte_Bit4, {
                  "upper critical threshold", "GetSensorThresholds.datafield.ControlByte.Bit4",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorThresholds_data_ControlByte_Bit_vals), 0x10,
                  "upper critical threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_ControlByte_Bit3, {
                  "upper non-critical threshold", "GetSensorThresholds.datafield.ControlByte.Bit3",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorThresholds_data_ControlByte_Bit_vals), 0x08,
                  "upper non-critical threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_ControlByte_Bit2, {
                  "lower non-recoverable threshold", "GetSensorThresholds.datafield.ControlByte.Bit2",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorThresholds_data_ControlByte_Bit_vals), 0x04,
                  "lower non-recoverable threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_ControlByte_Bit1, {
                  "lower critical threshold", "GetSensorThresholds.datafield.ControlByte.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorThresholds_data_ControlByte_Bit_vals), 0x02,
                  "lower critical threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_ControlByte_Bit0, {
                  "lower non-critical threshold", "GetSensorThresholds.datafield.ControlByte.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorThresholds_data_ControlByte_Bit_vals), 0x01,
                  "lower non-critical threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_LowerNonCriticalThreshold, {
                  "lower non-critical threshold", "GetSensorThresholds.datafield.LowerNonCriticalThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "lower non-critical threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_LowerCriticalThreshold, {
                  "lower critical threshold", "GetSensorThresholds.datafield.LowerCriticalThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "lower critical threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_LowerNonRecoverableThreshold, {
                  "lower non-recoverable threshold", "GetSensorThresholds.datafield.LowerNonRecoverableThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "lower non-recoverable threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_UpperNonCriticalThreshold, {
                  "upper non-critical threshold", "GetSensorThresholds.datafield.UpperNonCriticalThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "upper non-critical threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_UpperCriticalThreshold, {
                  "upper critical threshold", "GetSensorThresholds.datafield.UpperCriticalThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "upper critical threshold", HFILL }},
            { &hf_GetSensorThresholds_datafield_UpperNonRecoverableThreshold, {
                  "upper non-recoverable threshold", "GetSensorThresholds.datafield.UpperNonRecoverableThreshold",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "upper non-recoverable threshold", HFILL }},
      };
      
      /*  Data field of Get Sensor Reading command, added by lane */
      static hf_register_info hf_GetSensorReading_datafield[] = {
            { &hf_GetSensorReading_datafield_SensorNumber, {
                  "Sensor Number", "GetSensorReading.datafield.SensorNumber",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Sensor Number", HFILL }},
            { &hf_GetSensorReading_datafield_Sensorreading, {
                  "Sensor Reading", "GetSensorReading.datafield.Sensorreading",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Sensor Reading", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte2_Bit7, {
                  "Bit 7", "GetSensorReading.datafield.ResponseDataByte2.Bit7",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte2_Bit7_vals), 0x80,
                  "Bit 7", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte2_Bit6, {
                  "Bit 6", "GetSensorReading.datafield.ResponseDataByte2.Bit6",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte2_Bit6_vals), 0x40,
                  "Bit 6", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte2_Bit5, {
                  "Bit 5", "GetSensorReading.datafield.ResponseDataByte2.Bit5",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte2_Bit5_vals), 0x20,
                  "Bit 5", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte2_Bit40, {
                  "Bit 4...0 Reserved", "GetSensorReading.datafield.ResponseDataByte2.Bit5",
                  FT_UINT8, BASE_HEX, NULL, 0x1f,
                  "Bit 4...0 Reserved", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit7, {
                  "Bit 7", "GetSensorReading.datafield.ResponseDataByte3.Bit7",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit7_vals), 0x80,
                  "Bit 7", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit6, {
                  "Bit 6", "GetSensorReading.datafield.ResponseDataByte3.Bit6",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit6_vals), 0x40,
                  "Bit 6", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit5, {
                  "Bit 5", "GetSensorReading.datafield.ResponseDataByte3.Bit5",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit5_vals), 0x20,
                  "Bit 5", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit4, {
                  "Bit 4", "GetSensorReading.datafield.ResponseDataByte3.Bit4",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit4_vals), 0x10,
                  "Bit 4", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit3, {
                  "Bit 3", "GetSensorReading.datafield.ResponseDataByte3.Bit3",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit3_vals), 0x08,
                  "Bit 3", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit2, {
                  "Bit 2", "GetSensorReading.datafield.ResponseDataByte3.Bit2",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit2_vals), 0x04,
                  "Bit 2", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit1, {
                  "Bit 1", "GetSensorReading.datafield.ResponseDataByte3.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit1_vals), 0x02,
                  "Bit 1", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit0, {
                  "Bit 0", "GetSensorReading.datafield.ResponseDataByte3.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit0_vals), 0x01,
                  "Bit 0", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte4_Bit7, {
                  "Bit 7", "GetSensorReading.datafield.ResponseDataByte4.Bit7",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte4_Bit7_vals), 0x80,
                  "Bit 7", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte4_Bit6, {
                  "Bit 6", "GetSensorReading.datafield.ResponseDataByte4.Bit6",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte4_Bit6_vals), 0x40,
                  "Bit 6", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte4_Bit5, {
                  "Bit 5", "GetSensorReading.datafield.ResponseDataByte4.Bit5",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte4_Bit5_vals), 0x20,
                  "Bit 5", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte4_Bit4, {
                  "Bit 4", "GetSensorReading.datafield.ResponseDataByte4.Bit4",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte4_Bit4_vals), 0x10,
                  "Bit 4", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte4_Bit3, {
                  "Bit 3", "GetSensorReading.datafield.ResponseDataByte3.Bit3",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte4_Bit3_vals), 0x08,
                  "Bit 3", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte4_Bit2, {
                  "Bit 2", "GetSensorReading.datafield.ResponseDataByte4.Bit2",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte4_Bit2_vals), 0x04,
                  "Bit 2", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte4_Bit1, {
                  "Bit 1", "GetSensorReading.datafield.ResponseDataByte4.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte4_Bit1_vals), 0x02,
                  "Bit 1", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte4_Bit0, {
                  "Bit 0", "GetSensorReading.datafield.ResponseDataByte4.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte4_Bit0_vals), 0x01,
                  "Bit 0", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit76_threshold, {
                  "Bit 7...6 Reserved", "GetSensorReading.datafield.ResponseDataByte3.Bit76_threshold",
                  FT_UINT8, BASE_HEX, NULL, 0xc0,
                  "Bit 7...6 Reserved", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit5_threshold, {
                  "Bit 5", "GetSensorReading.datafield.ResponseDataByte3.Bit5_threshold",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit5_threshold_vals), 0x20,
                  "Bit 5", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit4_threshold, {
                  "Bit 4", "GetSensorReading.datafield.ResponseDataByte3.Bit4_threshold",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit4_threshold_vals), 0x10,
                  "Bit 4", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit3_threshold, {
                  "Bit 3", "GetSensorReading.datafield.ResponseDataByte3.Bit3_threshold",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit3_threshold_vals), 0x08,
                  "Bit 3", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit2_threshold, {
                  "Bit 2", "GetSensorReading.datafield.ResponseDataByte3.Bit2_threshold",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit2_threshold_vals), 0x04,
                  "Bit 2", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit1_threshold, {
                  "Bit 1", "GetSensorReading.datafield.ResponseDataByte3.Bit1_threshold",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit1_threshold_vals), 0x02,
                  "Bit 1", HFILL }},
            { &hf_GetSensorReading_datafield_ResponseDataByte3_Bit0_threshold, {
                  "Bit 0", "GetSensorReading.datafield.ResponseDataByte3.Bit0_threshold",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSensorReading_data_ResponseDataByte3_Bit0_threshold_vals), 0x01,
                  "Bit 0", HFILL }},
};

/********* APP, NetFN = 0x06 *********/

      /* Data field of Get Device ID command, added by lane */
      static hf_register_info hf_GetDeviceID_datafield[] = {
            { &hf_GetDeviceID_datafield_DeviceID, {
                  "Device ID", "GetDeviceID.datafield.DeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Device ID field", HFILL }},
            { &hf_GetDeviceID_datafield_DeviceSDR, {
                  "Device SDR", "GetDeviceID.datafield.DeviceSDR",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_DeviceSDR_vals), 0x80,
                  "Device SDR ", HFILL }},
            { &hf_GetDeviceID_datafield_DeviceRevision, {
                  "Device Revision", "GetDeviceID.datafield.DeviceRevision",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_Data_DeviceRevision_vals), 0x0f,
                  "Device Revision binary code", HFILL }},
            { &hf_GetDeviceID_datafield_DeviceAvailable, {
                  "Device Available", "GetDeviceID.datafield.DeviceAvailable",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_DeviceAvailable_vals), 0x80,
                  "Device Available", HFILL }},
            { &hf_GetDeviceID_datafield_MajorFirmwareRevision, {
                  "Major Firmware Revision", "GetDeviceID.datafield.MajorFirmwareRevision",
                  FT_UINT8, BASE_DEC, NULL, 0x7f,
                  "Major Firmware Revision", HFILL }},
            { &hf_GetDeviceID_datafield_MinorFirmwareRevision, {
                  "Minor Firmware Revision", "GetDeviceID.datafield.MinorFirmwareRevision",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Minor Firmware Revision", HFILL }},      
            { &hf_GetDeviceID_datafield_IPMIRevision, {
                  "IPMI Revision", "GetDeviceID.datafield.IPMIRevision",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_Data_IPMIRevision_vals), 0,
                  "IPMI Revision", HFILL }},
            { &hf_GetDeviceID_datafield_ADS_Chasis, {
                  "Chasis Device", "GetDeviceID.datafield.Chasis",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_ADS_vals), 0x80,
                  "Chasis Device", HFILL }},
            { &hf_GetDeviceID_datafield_ADS_Bridge, {
                  "Bridge Device", "GetDeviceID.datafield.Bridge",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_ADS_vals), 0x40,
                  "Bridge Device", HFILL }},
            { &hf_GetDeviceID_datafield_ADS_IPMBEventGenerator, {
                  "IPMB Event Generator", "GetDeviceID.datafield.IPMBEventGenerator",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_ADS_vals), 0x20,
                  "IPMB Event Generator", HFILL }},
            { &hf_GetDeviceID_datafield_ADS_IPMBEventReceiver, {
                  "IPMB Event Receiver", "GetDeviceID.datafield.IPMBEventReceiver",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_ADS_vals), 0x10,
                  "IPMB Event Receiver", HFILL }},
            { &hf_GetDeviceID_datafield_ADS_FRUInventoryDevice, {
                  "FRU Inventory Device", "GetDeviceID.datafield.FRUInventoryDevice",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_ADS_vals), 0x08,
                  "FRU Inventory Device", HFILL }},
            { &hf_GetDeviceID_datafield_ADS_SELDevice, {
                  "SEL Device", "GetDeviceID.datafield.SELDevice",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_ADS_vals), 0x04,
                  "SEL Device", HFILL }},
            { &hf_GetDeviceID_datafield_ADS_SDRRepositoryDevice, {
                  "SDR Repository Device", "GetDeviceID.datafield.SDRRepositoryDevice",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_ADS_vals), 0x02,
                  "SDR Repository Device", HFILL }},
            { &hf_GetDeviceID_datafield_ADS_SensorDevice, {
                  "Sensor Device", "GetDeviceID.datafield.SensorDevice",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetDeviceID_data_ADS_vals), 0x01,
                  "Sensor Device", HFILL }},
            { &hf_GetDeviceID_datafield_ManufactureID, {
                  "Manufacture ID", "GetDeviceID.datafield.ManufactureID",
                  FT_UINT24, BASE_HEX, NULL, 0,
                  "Manufacture ID", HFILL }},
            { &hf_GetDeviceID_datafield_ProductID, {
                  "Product ID", "GetDeviceID.datafield.ProductID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Product ID", HFILL }}, 
            { &hf_GetDeviceID_datafield_AFRI, {
                  "Auxiliary Firmware Revision Infomation", "GetDeviceID.datafield.AuxiliaryFirmwareRevisionInfomation",
                  FT_UINT32, BASE_HEX, NULL, 0,
                  "Auxiliary Firmware Revision Infomation", HFILL }},
      };


/********* Storage, NetFN = 0x0a *********/

      /* Data field of Get FRU Inventory Area Info, added by lane */
      static hf_register_info hf_GetFRUInventoryAreaInfo_datafield[] = {
            { &hf_GetFRUInventoryAreaInfo_datafield_FRUDeviceID, {
                  "FRU Device ID", "GetFRUInventoryAreaInfo.datafield.ReservationID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_GetFRUInventoryAreaInfo_datafield_FRUInventoryAreaSize, {
                  "FRU Inventory area size in bytes", "GetFRUInventoryAreaInfo.datafield.FRUInventoryAreaSize",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "FRU Inventory area size in bytes", HFILL }},
            { &hf_GetFRUInventoryAreaInfo_datafield_ResponseDataByte4_Bit71, {
                  "Reserved", "GetFRUInventoryAreaInfo.datafield.ResponseDataByte4.Bit71",
                  FT_UINT8, BASE_HEX, NULL, 0xfe,
                  "Reserved", HFILL }},
            { &hf_GetFRUInventoryAreaInfo_datafield_ResponseDataByte4_Bit0, {
                  "Device is accessed by bytes or words ?", "GetFRUInventoryAreaInfo.datafield.ResponseDataByte4.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRUInventoryAreaInfo_Data_ResponseDataByte4_Bit0_vals), 0x01,
                  "Device is accessed by bytes or words ?", HFILL }},
      };
      
      /* Data field of Get SEL Info command, added by lane */
      static hf_register_info hf_GetSELInfo_datafield[] = {
            { &hf_GetSELInfo_datafield_SELVersion, {
                  "SEL Version", "GetSELInfo.datafield.SELVersion",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSELInfo_Data_SELVersion_vals), 0,
                  "SEL Version", HFILL }},
            { &hf_GetSELInfo_datafield_Entries, {
                  "Number of log entries in SEL", "GetSELInfo.datafield.Entries",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Number of log entries in SEL", HFILL }},
            { &hf_GetSELInfo_datafield_FreeSpace, {
                  "Free Space in bytes", "GetSELInfo.datafield.FreeSpace",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Free Space in bytes", HFILL }},
            { &hf_GetSELInfo_datafield_AdditionTimestamp, {
                  "Most recent addition timestamp", "GetSELInfo.datafield.AdditionTimestamp",
                  FT_UINT32, BASE_HEX, NULL, 0,
                  "Most recent addition timestamp", HFILL }},
            { &hf_GetSELInfo_datafield_EraseTimestamp, {
                  "Most recent erase timestamp", "GetSELInfo.datafield.EraseTimestamp",
                  FT_UINT32, BASE_HEX, NULL, 0,
                  "Most recent erase timestamp", HFILL }},
            { &hf_GetSELInfo_datafield_OperationSupport_Bit7, {
                  "Overflow Flag", "GetSELInfo.datafield.OperationSupport.Bit7",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSELInfo_Data_OperationSupport_Bit7_vals), 0x80,
                  "Overflow Flag", HFILL }},    
            { &hf_GetSELInfo_datafield_OperationSupport_Reserved, {
                  "Reserved", "GetSELInfo.datafield.OperationSupport.Reserved",
                  FT_UINT8, BASE_HEX, NULL, 0x70,
                  "Reserved", HFILL }},
            { &hf_GetSELInfo_datafield_OperationSupport_Bit3, {
                  "Delete SEL command supported ?", "GetSELInfo.datafield.OperationSupport.Bit3",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSELInfo_Data_OperationSupport_Bit3to0_vals), 0x08,
                  "Delete SEL command supported ?", HFILL }},
            { &hf_GetSELInfo_datafield_OperationSupport_Bit2, {
                  "Partial Add SEL Entry command supported ?", "GetSELInfo.datafield.OperationSupport.Bit2",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSELInfo_Data_OperationSupport_Bit3to0_vals), 0x04,
                  "Partial Add SEL Entry command supported ?", HFILL }},
            { &hf_GetSELInfo_datafield_OperationSupport_Bit1, {
                  "Reserve SEL command supported ?", "GetSELInfo.datafield.OperationSupport.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSELInfo_Data_OperationSupport_Bit3to0_vals), 0x02,
                  "Reserve SEL command supported ?", HFILL }},
            { &hf_GetSELInfo_datafield_OperationSupport_Bit0, {
                  "Get SEL Allocation Information command supported ?", "GetSELInfo.datafield.OperationSupport.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetSELInfo_Data_OperationSupport_Bit3to0_vals), 0x01,
                  "Get SEL Allocation Information command supported ?", HFILL }},
      };

      /* Data field of Reserve SEL command, added by lane */
      static hf_register_info hf_ReserveSEL_datafield[] = {
            { &hf_ReserveSEL_datafield_ReservationID, {
                  "Reservation ID", "GetSELInfo.datafield.ReservationID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Reservation ID", HFILL }},
      };

      /* Data field of Get SEL Entry command, added by lane */
      static hf_register_info hf_GetSELEntry_datafield[] = {
            { &hf_GetSELEntry_datafield_ReservationID, {
                  "Reservation ID", "GetSELEntry.datafield.ReservationID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Reservation ID", HFILL }},
            { &hf_GetSELEntry_datafield_SELRecordID, {
                  "SEL Record ID", "GetSELEntry.datafield.SELRecordID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "SEL Record ID", HFILL }},
            { &hf_GetSELEntry_datafield_OffsetIntoRecord, {
                  "Offset into record", "GetSELEntry.datafield.OffsetIntoRecord",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Offset into record", HFILL }},
            { &hf_GetSELEntry_datafield_BytesToRead, {
                  "Bytes to read", "GetSELEntry.datafield.BytesToRead",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Bytes to read", HFILL }},
            { &hf_GetSELEntry_datafield_NextSELRecordID, {
                  "Next SEL Record ID", "GetSELEntry.datafield.NextSELRecordID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Next SEL Record ID", HFILL }},
      };

      /* Data field of Clear SEL command, added by lane */
      static hf_register_info hf_ClearSEL_datafield[] = {
            { &hf_ClearSEL_datafield_ReservationID, {
                  "Reservation ID", "ClearSEL.datafield.ReservationID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Reservation ID", HFILL }},
            { &hf_ClearSEL_datafield_Byte3, {
                  "'C' (0x43)", "ClearSEL.datafield.SELRecordID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "'C' (0x43)", HFILL }},
            { &hf_ClearSEL_datafield_Byte4, {
                  "'L' (0x4C)", "ClearSEL.datafield.OffsetIntoRecord",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "'L' (0x4C)", HFILL }},
            { &hf_ClearSEL_datafield_Byte5, {
                  "'R' (0x52)", "ClearSEL.datafield.BytesToRead",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "'R' (0x52)", HFILL }},
            { &hf_ClearSEL_datafield_Byte6, {
                  "Action for Clear SEL", "ClearSEL.datafield.NextSELRecordID",
                  FT_UINT8, BASE_HEX, VALS(cmd_ClearSEL_Data_Byte6_vals), 0,
                  "Action for Clear SEL", HFILL }},
            { &hf_ClearSEL_datafield_ErasureProgress_Reserved, {
                  "Reserved", "ClearSEL.datafield.ErasureProgress.Reserved",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Reserved", HFILL }},
            { &hf_ClearSEL_datafield_ErasureProgress_EraProg, {
                  "Erasure Progress", "ClearSEL.datafield.ErasureProgress.EraProg",
                  FT_UINT8, BASE_HEX, VALS(cmd_ClearSEL_Data_ErasureProgress_EraProg_vals), 0x0f,
                  "Erasure Progress", HFILL }},
      };
      

/********* PICMG, NetFN = 0x2c *********/

      /* Data field of Get PICMG Properties command, added by lane */
      static hf_register_info hf_GetPICMGProperties_datafield[] = {
            { &hf_GetPICMGProperties_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "GetPICMGProperties.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_GetPICMGProperties_datafield_PICMGExtensionVersion, {
                  "PICMG Extension Version", "GetPICMGProperties.datafield.PICMGExtensionVersion",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetPICMGProperties_data_PICMGExtensionVersion_vals), 0,
                  "PICMG Extension Version", HFILL }},
            { &hf_GetPICMGProperties_datafield_MaxFRUDeviceID, {
                  "Max FRU Device ID", "GetPICMGProperties.datafield.MaxFRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Max FRU Device ID", HFILL }},
            { &hf_GetPICMGProperties_datafield_FRUDeviceIDforIPMController, {
                  "FRU Device ID for IPM Controller", "GetPICMGProperties.datafield.FRUDeviceIDforIPMController",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID for IPM Controller", HFILL }},         
      };

      /* Data field of FRU Control command, added by lane */
      static hf_register_info hf_FRUControl_datafield[] = {
            { &hf_FRUControl_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "FRUControl.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_FRUControl_datafield_FRUDeviceID, {
                  "FRU Device ID", "FRUControl.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_FRUControl_datafield_FRUControlOption, {
                  "FRU Control Option", "FRUControl.datafield.FRUControlOption",
                  FT_UINT8, BASE_HEX, VALS(cmd_FRUControl_data_FRUControlOption_vals), 0,
                  "FRU Control Option", HFILL }},
      };

      /* Data field of Get FRU Led Properties command, added by lane */
      static hf_register_info hf_GetFRULedProperties_datafield[] = {
            { &hf_GetFRULedProperties_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "GetFRULedProperties.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_GetFRULedProperties_datafield_FRUDeviceID, {
                  "FRU Device ID", "GetFRULedProperties.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_GetFRULedProperties_datafield_LedProperties_Reserved, {
                  "Reserved", "GetFRULedProperties.datafield.LedProperties.Reserved",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Reserved", HFILL }},
            { &hf_GetFRULedProperties_datafield_LedProperties_LED3, {
                  "LED3", "GetFRULedProperties.datafield.LedProperties.LED3",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedProperties_data_LedProperties_LED3_vals), 0x08,
                  "LED3", HFILL }},
            { &hf_GetFRULedProperties_datafield_LedProperties_LED2, {
                  "LED2", "GetFRULedProperties.datafield.LedProperties.LED2",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedProperties_data_LedProperties_LED2_vals), 0x04,
                  "LED2", HFILL }},
            { &hf_GetFRULedProperties_datafield_LedProperties_LED1, {
                  "LED1", "GetFRULedProperties.datafield.LedProperties.LED1",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedProperties_data_LedProperties_LED1_vals), 0x02,
                  "LED1", HFILL }},
            { &hf_GetFRULedProperties_datafield_LedProperties_BlueLED, {
                  "BlueLED", "GetFRULedProperties.datafield.LedProperties.BlueLED",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedProperties_data_LedProperties_BLUELED_vals), 0x01,
                  "BlueLED", HFILL }},
            { &hf_GetFRULedProperties_datafield_ApplicationSpecificLEDCount, {
                  "Application Specific LED Count", "GetFRULedProperties.datafield.ApplicationSpecificLEDCount",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Application Specific LED Count", HFILL }},
      };

      /* Data field of Get Led Color Capabilities command, added by lane */
      static hf_register_info hf_GetLedColorCapabilities_datafield[] = {
            { &hf_GetLedColorCapabilities_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "GetLedColorCapabilities.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_FRUDeviceID, {
                  "FRU Device ID", "GetLedColorCapabilities.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_LEDID, {
                  "LED ID", "GetLedColorCapabilities.datafield.LEDID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "LED ID", HFILL }},
            /* LED Color Capabilities */  
            { &hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_Reserved_7, {
                  "Reserved", "GetLedColorCapabilities.datafield.LEDColorCapabilities.Reserved.bit7",
                  FT_UINT8, BASE_HEX, NULL, 0x80,
                  "Reserved", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_WHITE, {
                  "LED Support WHITE ?", "GetLedColorCapabilities.datafield.LEDColorCapabilities.WHITE",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetLedColorCapabilities_data_LEDColorCapabilities_vals), 0x40,
                  "LED Support WHITE ?", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_ORANGE, {
                  "LED Support ORANGE ?", "GetLedColorCapabilities.datafield.LEDColorCapabilities.ORANGE",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetLedColorCapabilities_data_LEDColorCapabilities_vals), 0x20,
                  "LED Support ORANGE ?", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_AMBER, {
                  "LED Support AMBER ?", "GetLedColorCapabilities.datafield.LEDColorCapabilities.AMBER",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetLedColorCapabilities_data_LEDColorCapabilities_vals), 0x10,
                  "LED Support AMBER ?", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_GREEN, {
                  "LED Support GREEN ?", "GetLedColorCapabilities.datafield.LEDColorCapabilities.GREEN",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetLedColorCapabilities_data_LEDColorCapabilities_vals), 0x08,
                  "LED Support GREEN ?", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_RED, {
                  "LED Support RED ?", "GetLedColorCapabilities.datafield.LEDColorCapabilities.RED",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetLedColorCapabilities_data_LEDColorCapabilities_vals), 0x04,
                  "LED Support RED ?", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_BLUE, {
                  "LED Support BLUE ?", "GetLedColorCapabilities.datafield.LEDColorCapabilities.BLUE",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetLedColorCapabilities_data_LEDColorCapabilities_vals), 0x02,
                  "LED Support BLUE ?", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_LEDColorCapabilities_Reserved_0, {
                  "Reserved", "GetLedColorCapabilities.datafield.LEDColorCapabilities.Reserved.bit0",
                  FT_UINT8, BASE_HEX, NULL, 0x01,
                  "Reserved", HFILL }},
            /* Default LED Color in Local Control State*/   
            { &hf_GetLedColorCapabilities_datafield_DefaultLEDColorLocalControl_Reserved_74, {
                  "Reserved", "GetLedColorCapabilities.datafield.DefaultLEDColorLocalControl.Reserved.bit7-4",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Reserved", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_DefaultLEDColorLocalControl_Color, {
                  "Default LED Color (Local Control State)", "GetLedColorCapabilities.datafield.DefaultLEDColorLocalControl.Color",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetLedColorCapabilities_data_DefaultLEDColor_vals), 0x0f,
                  "Default LED Color (Local Control State)", HFILL }},
            /* Default LED Color in Override State */ 
            { &hf_GetLedColorCapabilities_datafield_DefaultLEDColorOverride_Reserved_74, {
                  "Reserved", "GetLedColorCapabilities.datafield.DefaultLEDColorOverride.Reserved.bit7-4",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Reserved", HFILL }},
            { &hf_GetLedColorCapabilities_datafield_DefaultLEDColorOverride_Color, {
                  "Default LED Color (Override State)", "GetLedColorCapabilities.datafield.DefaultLEDColorOverride.Color",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetLedColorCapabilities_data_DefaultLEDColor_vals), 0x0f,
                  "Default LED Color (Override State)", HFILL }},                   
      };

      /* Data field of Set FRU Led State, added by lane */
      static hf_register_info hf_SetFRULedState_datafield[] = {
            { &hf_SetFRULedState_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "SetFRULedState.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_SetFRULedState_datafield_FRUDeviceID, {
                  "FRU Device ID", "SetFRULedState.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_SetFRULedState_datafield_LEDID, {
                  "LED ID", "SetFRULedState.datafield.LEDID",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRULedState_data_LEDID_vals), 0,
                  "LED ID", HFILL }},
            { &hf_SetFRULedState_datafield_LEDFunction, {
                  "LED Function", "SetFRULedState.datafield.LEDFunction",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRULedState_data_LEDFunction_vals), 0,
                  "LED Function", HFILL }},
            { &hf_SetFRULedState_datafield_Offduration, {
                  "Off-duration", "SetFRULedState.datafield.Offduration",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Off-duration", HFILL }},
            { &hf_SetFRULedState_datafield_Onduration, {
                  "On-duration", "SetFRULedState.datafield.Onduration",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "On-duration", HFILL }},
            { &hf_SetFRULedState_datafield_Color_Reserved, {
                  "Bit 7...4 Reserved", "SetFRULedState.datafield.Color.Reserved",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Bit 7...4 Reserved", HFILL }},     
            { &hf_SetFRULedState_datafield_Color_ColorVal, {
                  "Color", "SetFRULedState.datafield.Color.ColorVal",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRULedState_data_Color_ColorVal_vals), 0x0f,
                  "Color", HFILL }},
      };

      /* Data field of Get FRU Led State, added by lane */
      static hf_register_info hf_GetFRULedState_datafield[] = {
            { &hf_GetFRULedState_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "GetFRULedState.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_GetFRULedState_datafield_FRUDeviceID, {
                  "FRU Device ID", "GetFRULedState.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_GetFRULedState_datafield_LEDID, {
                  "LED ID", "GetFRULedState.datafield.LEDID",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedState_data_LEDID_vals), 0,
                  "LED ID", HFILL }},
            { &hf_GetFRULedState_datafield_LEDState_Reserved, {
                  "Bit 7...3 Reserved", "GetFRULedState.datafield.LEDFunction",
                  FT_UINT8, BASE_HEX, NULL, 0xf8,
                  "Bit 7...3 Reserved", HFILL }},
            { &hf_GetFRULedState_datafield_LEDState_Bit2, {
                  "Lamp Test", "GetFRULedState.datafield.LEDState.Bit2",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedState_data_LEDState_Bit21_vals), 0x04,
                  "Lamp Test", HFILL }},
            { &hf_GetFRULedState_datafield_LEDState_Bit1, {
                  "Override State", "GetFRULedState.datafield.LEDState.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedState_data_LEDState_Bit21_vals), 0x02,
                  "Override State", HFILL }},   
            { &hf_GetFRULedState_datafield_LEDState_Bit0, {
                  "IPM Controller has a Local Control State ?", "GetFRULedState.datafield.LEDState.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedState_data_LEDState_Bit0_vals), 0x01,
                  "IPM Controller has a Local Control State ?", HFILL }},
            { &hf_GetFRULedState_datafield_LocalControlLEDFunction, {
                  "Local Control LED Function", "GetFRULedState.datafield.LocalControlLEDFunction",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedState_data_LocalControlLEDFunction_vals), 0,
                  "Local Control LED Function", HFILL }},
            { &hf_GetFRULedState_datafield_LocalControlOffduration, {
                  "Local Control Off-duration", "GetFRULedState.datafield.LocalControlOffduration",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Local Control Off-duration", HFILL }},
            { &hf_GetFRULedState_datafield_LocalControlOnduration, {
                  "Local Control On-duration", "GetFRULedState.datafield.LocalControlOnduration",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Local Control On-duration", HFILL }},
            { &hf_GetFRULedState_datafield_LocalControlColor_Reserved, {
                  "Bit 7...4 Reserved", "GetFRULedState.datafield.LocalControlColor.Reserved",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Bit 7...4 Reserved", HFILL }},     
            { &hf_GetFRULedState_datafield_LocalControlColor_ColorVal, {
                  "Color", "GetFRULedState.datafield.LocalControlColor.ColorVal",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedState_data_ColorVal_vals), 0x0f,
                  "Color", HFILL }},
            { &hf_GetFRULedState_datafield_OverrideStateLEDFunction, {
                  "Override State LED Function", "GetFRULedState.datafield.OverrideStateLEDFunction",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedState_data_OverrideStateLEDFunction_vals), 0,
                  "Override State LED Function", HFILL }},
            { &hf_GetFRULedState_datafield_OverrideStateOffduration, {
                  "Override State Off-duration", "GetFRULedState.datafield.OverrideStateOffduration",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Override State Off-duration", HFILL }},
            { &hf_GetFRULedState_datafield_OverrideStateOnduration, {
                  "Override State On-duration", "GetFRULedState.datafield.OverrideStateOnduration",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Override State On-duration", HFILL }},
            { &hf_GetFRULedState_datafield_OverrideStateColor_Reserved, {
                  "Bit 7...4 Reserved", "GetFRULedState.datafield.OverrideStateColor.Reserved",
                  FT_UINT8, BASE_HEX, NULL, 0xf0,
                  "Bit 7...4 Reserved", HFILL }},     
            { &hf_GetFRULedState_datafield_OverrideStateColor_ColorVal, {
                  "Color", "GetFRULedState.datafield.OverrideStateColor.ColorVal",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRULedState_data_ColorVal_vals), 0x0f,
                  "Color", HFILL }},
            { &hf_GetFRULedState_datafield_LampTestDuration, {
                  "Lamp Test Duration", "GetFRULedState.datafield.LampTestDuration",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Lamp Test Duration", HFILL }},
      };

      /* Data field of Set FRU Activation command, added by lane */
      static hf_register_info hf_SetFRUActivation_datafield[] = {
            { &hf_SetFRUActivation_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "SetFRUActivation.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_SetFRUActivation_datafield_FRUDeviceID, {
                  "FRU Device ID", "SetFRUActivation.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_SetFRUActivation_datafield_FRUActivationDeactivation, {
                  "FRU Activation/Deactivation", "SetFRUActivation.datafield.FRUActivationDeactivation",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRUActivation_data_FRUActivationDeactivation_vals), 0,
                  "FRU Activation/Deactivation", HFILL }},        
      };

      /* Data field of Set FRU Activation Policy command, added by lane */
      static hf_register_info hf_SetFRUActivationPolicy_datafield[] = {
            { &hf_SetFRUActivationPolicy_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "SetFRUActivationPolicy.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUDeviceID, {
                  "FRU Device ID", "SetFRUActivationPolicy.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit72, {
                  "Bit 7...2 Reserverd", "SetFRUActivationPolicy.datafield.FRUActivationPolicyMaskBit.Bit72",
                  FT_UINT8, BASE_HEX, NULL, 0xfc,
                  "Bit 7...2 Reserverd", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit1, {
                  "Bit 1", "SetFRUActivationPolicy.datafield.FRUActivationPolicyMaskBit.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRUActivationPolicy_data_PFRUActivationPolicyMaskBit_Bit1_vals), 0x02,
                  "Bit 1", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUActivationPolicyMaskBit_Bit0, {
                  "Bit 0", "SetFRUActivationPolicy.datafield.FRUActivationPolicyMaskBit.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRUActivationPolicy_data_PFRUActivationPolicyMaskBit_Bit0_vals), 0x01,
                  "Bit 0", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit72, {
                  "Bit 7...2 Reserverd", "SetFRUActivationPolicy.datafield.FRUActivationPolicySetBit.Bit72",
                  FT_UINT8, BASE_HEX, NULL, 0xfc,
                  "Bit 7...2 Reserverd", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit1, {
                  "Set or Clear Deactivation-Locked", "SetFRUActivationPolicy.datafield.FRUActivationPolicySetBit.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRUActivationPolicy_data_PFRUActivationPolicySetBit_Bit1_vals), 0x02,
                  "Set or Clear Deactivation-Locked", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit0, {
                  "Set or Clear Locked", "SetFRUActivationPolicy.datafield.FRUActivationPolicySetBit.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRUActivationPolicy_data_PFRUActivationPolicySetBit_Bit0_vals), 0x01,
                  "Set or Clear Locked", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit1_ignored, {
                  "Set or Clear Deactivation-Locked", "SetFRUActivationPolicy.datafield.FRUActivationPolicySetBit.Bit1_ignored",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRUActivationPolicy_data_PFRUActivationPolicySetBit_Bit1_ignored_vals), 0x02,
                  "Set or Clear Deactivation-Locked", HFILL }},
            { &hf_SetFRUActivationPolicy_datafield_FRUActivationPolicySetBit_Bit0_ignored, {
                  "Set or Clear Locked", "SetFRUActivationPolicy.datafield.FRUActivationPolicySetBit.Bit0_ignored",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFRUActivationPolicy_data_PFRUActivationPolicySetBit_Bit0_ignored_vals), 0x01,
                  "Set or Clear Locked", HFILL }},    
      };

      /* Data field of Get FRU Activation Policy command, added by lane */
      static hf_register_info hf_GetFRUActivationPolicy_datafield[] = {
            { &hf_GetFRUActivationPolicy_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "GetFRUActivationPolicy.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_GetFRUActivationPolicy_datafield_FRUDeviceID, {
                  "FRU Device ID", "GetFRUActivationPolicy.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit72, {
                  "Bit 7...2 Reserverd", "GetFRUActivationPolicy.datafield.FRUActivationPolicy.Bit72",
                  FT_UINT8, BASE_HEX, NULL, 0xfc,
                  "Bit 7...2 Reserverd", HFILL }},
            { &hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit1, {
                  "Deactivation-Locked Bit", "GetFRUActivationPolicy.datafield.FRUActivationPolicy.Bit1",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRUActivationPolicy_data_FRUActivationPolicy_Bit1_vals), 0x02,
                  "Deactivation-Locked Bit", HFILL }},
            { &hf_GetFRUActivationPolicy_datafield_FRUActivationPolicy_Bit0, {
                  "Locked Bit", "GetFRUActivationPolicy.datafield.FRUActivationPolicy.Bit0",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFRUActivationPolicy_data_FRUActivationPolicy_Bit0_vals), 0x01,
                  "Locked Bit", HFILL }},
      };
      
      /* Data field of Get Device Locator Record ID, added by lane */
      static hf_register_info hf_GetDeviceLocatorRecordID_datafield[] = {
            { &hf_GetDeviceLocatorRecordID_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "GetDeviceLocatorRecordID.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_GetDeviceLocatorRecordID_datafield_FRUDeviceID, {
                  "FRU Device ID", "GetDeviceLocatorRecordID.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_GetDeviceLocatorRecordID_datafield_RecordID, {
                  "Record ID", "GetDeviceLocatorRecordID.datafield.RecordID",
                  FT_UINT16, BASE_HEX, NULL, 0,
                  "Record ID", HFILL }},
      };

      /* Data field of Set Power Level command, added by lane */
      static hf_register_info hf_SetPowerLevel_datafield[] = {
            { &hf_SetPowerLevel_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "SetPowerLevel.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_SetPowerLevel_datafield_FRUDeviceID, {
                  "FRU Device ID", "SetPowerLevel.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_SetPowerLevel_datafield_PowerLevel, {
                  "Power Level", "SetPowerLevel.datafield.PowerLevel",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetPowerLevel_data_PowerLevel_vals), 0,
                  "Power Level", HFILL }},
            { &hf_SetPowerLevel_datafield_SetPresentLevelsToDesiredLevels, {
                  "Set Present Levels to Desired Levels", "SetPowerLevel.datafield.SetPresentLevelsToDesiredLevels",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetPowerLevel_data_SetPresentLevelsToDesiredLevels_vals), 0,
                  "Set Present Levels to Desired Levels", HFILL }},           
      };

      /* Data field of Get Power Level command, added by lane */
      static hf_register_info hf_GetPowerLevel_datafield[] = {
            { &hf_GetPowerLevel_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "GetPowerLevel.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_GetPowerLevel_datafield_FRUDeviceID, {
                  "FRU Device ID", "GetPowerLevel.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_GetPowerLevel_datafield_PowerType, {
                  "Power Type", "GetPowerLevel.datafield.PowerType",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetPowerLevel_data_PowerType_vals), 0,
                  "Power Type", HFILL }},
            { &hf_GetPowerLevel_datafield_Properties, {
                  "Properties", "GetPowerLevel.datafield.Properties",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Properties", HFILL }},
            { &hf_GetPowerLevel_datafield_Properties_DynamicPowerCon, {
                  "Dynamic Power Configuration", "GetPowerLevel.datafield.Properties.DynamicPowerCon",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetPowerLevel_data_Properties_DynamicPowerCon_vals), 0x80,
                  "Dynamic Power Configuration", HFILL }},
            { &hf_GetPowerLevel_datafield_Properties_Reserved, {
                  "Reserved", "GetPowerLevel.datafield.Properties.Reserved",
                  FT_UINT8, BASE_HEX, NULL, 0x60,
                  "Reserved", HFILL }},
            { &hf_GetPowerLevel_datafield_Properties_PowerLevel, {
                  "Power Level", "GetPowerLevel.datafield.Properties.PowerLevel",
                  FT_UINT8, BASE_HEX, NULL, 0x1f,
                  "Power Level", HFILL }},
            { &hf_GetPowerLevel_datafield_DelayToStablePower, {
                  "Delay To Stable Power", "GetPowerLevel.datafield.DelayToStablePower",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Delay To Stable Power", HFILL }},
            { &hf_GetPowerLevel_datafield_PowerMultiplier, {
                  "Power Multiplier", "GetPowerLevel.datafield.PowerMultiplier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Power Multiplier", HFILL }},
            { &hf_GetPowerLevel_datafield_PowerDraw, {
                  "Power Draw", "GetPowerLevel.datafield.PowerDraw",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Power Draw", HFILL }},
      };

/* Data field of Set Fan Level command, added by lane */
      static hf_register_info hf_SetFanLevel_datafield[] = {
            { &hf_SetFanLevel_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "SetFanLevel.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_SetFanLevel_datafield_FRUDeviceID, {
                  "FRU Device ID", "SetFanLevel.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_SetFanLevel_datafield_FanLevel, {
                  "Fan Level", "SetFanLevel.datafield.FanLevel",
                  FT_UINT8, BASE_HEX, VALS(cmd_SetFanLevel_data_FanLevel_vals), 0,
                  "Fan Level", HFILL }},
      };

/* Data field of Get Fan Level command, added by lane */
      static hf_register_info hf_GetFanLevel_datafield[] = {
            { &hf_GetFanLevel_datafield_PICMGIdentifier, {
                  "PICMG Identifier", "GetFanLevel.datafield.PICMGIdentifier",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "PICMG Identifier", HFILL }},
            { &hf_GetFanLevel_datafield_FRUDeviceID, {
                  "FRU Device ID", "GetFanLevel.datafield.FRUDeviceID",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "FRU Device ID", HFILL }},
            { &hf_GetFanLevel_datafield_OverrideFanLevel, {
                  "Override Fan Level", "GetFanLevel.datafield.OverrideFanLevel",
                  FT_UINT8, BASE_HEX, VALS(cmd_GetFanLevel_data_OverrideFanLevel_vals), 0,
                  "Override Fan Level", HFILL }},
            { &hf_GetFanLevel_datafield_LocalControlFanLevel, {
                  "Local Control Fan Level", "GetFanLevel.datafield.LocalControlFanLevel",
                  FT_UINT8, BASE_HEX, NULL, 0,
                  "Local Control Fan Level", HFILL }},
      };



/***************************************************************************************************/

static gint *ett[] = {
            &ett_ipmi,
            &ett_ipmi_session,
            &ett_ipmi_msg_nlfield,
            &ett_ipmi_msg_slfield,

            /********* Sensor/Event, NetFN = 0x04 *********/
            /* Platform Event Message, added by lane */
            &ett_cmd_PEM_EventDirAndEventType,
            &ett_cmd_PEM_EventData1_threshold,
            &ett_cmd_PEM_EventData1_discrete,
            &ett_cmd_PEM_EventData2_discrete,
            &ett_cmd_PEM_EventData1_OEM,
            &ett_cmd_PEM_EventData2_OEM,
            /* Get Device SDR Info, added by lane*/
            &ett_cmd_GetDeviceSDRInfo_Flag,
            /* Set Sensor Thresholds, added by lane */
            &ett_cmd_SetSensorThresholds_ControlByte,
            /* Get Sensor Thresholds, added by lane */
            &ett_cmd_GetSensorThresholds_ControlByte,
            /* Get Sensor Reading, added by lane */
            &ett_cmd_GetSensorReading_ResponseDataByte2,
            &ett_cmd_GetSensorReading_ResponseDataByte3,
            &ett_cmd_GetSensorReading_ResponseDataByte3_threshold,
            &ett_cmd_GetSensorReading_ResponseDataByte4,
            
            /********* APP, NetFN = 0x06 *********/
            /*Get Device ID, added by lane */
            &ett_cmd_GetDeviceID_data_dr,
            &ett_cmd_GetDeviceID_data_fr,
            &ett_cmd_GetDeviceID_data_ads,
            
            /********* Storage, NetFN = 0x0a *********/
            /* Get FRU Inventory Area Info, added by lane */
            &ett_cmd_GetFRUInventoryAreaInfo_data_ResponseDataByte4,
            /* Get SEL Info, added by lane */
            &ett_cmd_GetSELInfo_data_OperationSupport,
            /* Clear SEL, added by lane */
            &ett_cmd_ClearSEL_data_ErasureProgress,

            /********* PICMG, NetFN = 0X2c *********/
            /* Get FRU Led Propertiesl, added by lane*/
            &ett_cmd_GetFRULedProperties_data_LedProperties,
            /* Get Led Color Capabilities , added by lane */
            &ett_cmd_GetLedColorCapabilities_data_LEDColorCapabilities,
            &ett_cmd_GetLedColorCapabilities_data_DefaultLEDColorLocalControl,
            &ett_cmd_GetLedColorCapabilities_data_DefaultLEDColorOverride,
            /* Set FRU Led State, added by lane */
            &ett_cmd_SetFRULedState_data_Color,
            /* Get FRU Led State, added by lane */
            &ett_cmd_GetFRULedState_data_LEDState,
            &ett_cmd_GetFRULedState_data_LocalControlColor,
            &ett_cmd_GetFRULedState_data_OverrideStateColor,
            /* Set FRU Activation Policy, added by lane */
            &ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicyMaskBit,
            &ett_cmd_SetFRUActivationPolicy_data_FRUActivationPolicySetBit,
            /* Get FRU Activation Policy, added by lane */
            &ett_cmd_GetFRUActivationPolicy_data_FRUActivationPolicy,
            /* Get Power Level, added by lane*/
            &ett_cmd_GetPowerLevel_data_Properties,
            
      };

      proto_ipmi = proto_register_protocol(
            "Intelligent Platform Management Interface", "IPMI", "ipmi");

      proto_register_field_array(proto_ipmi, hf_session,
                     array_length(hf_session));
      proto_register_field_array(proto_ipmi, hf_msg,
                     array_length(hf_msg));
      proto_register_field_array(proto_ipmi, hf_msg_field,
                     array_length(hf_msg_field));

      /********* Sensor/Event, NetFN = 0x04 *********/
      
      /* Platform Event Message, added by lane */
      proto_register_field_array(proto_ipmi, hf_PEM_datafield,
                     array_length(hf_PEM_datafield));
      /* Get Device SDR Info, added by lane*/
      proto_register_field_array(proto_ipmi, hf_GetDeviceSDRInfo_datafield,
                     array_length(hf_GetDeviceSDRInfo_datafield));
      /* Get Device SDR, added by lane*/
      proto_register_field_array(proto_ipmi, hf_GetDeviceSDR_datafield,
                     array_length(hf_GetDeviceSDR_datafield));
      /* Reserve Device SDR Repository, added by lane */
      proto_register_field_array(proto_ipmi, hf_ReserveDeviceSDRRepository_datafield,
                     array_length(hf_ReserveDeviceSDRRepository_datafield));
      /* Set Sensor Hysteresis, added by lane */
      proto_register_field_array(proto_ipmi, hf_SetSensorHysteresis_datafield,
                     array_length(hf_SetSensorHysteresis_datafield));
      /* Get Sensor Hysteresis, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetSensorHysteresis_datafield,
                     array_length(hf_GetSensorHysteresis_datafield));
      /* Set Sensor Thresholds, added by lane */
      proto_register_field_array(proto_ipmi, hf_SetSensorThresholds_datafield,
                     array_length(hf_SetSensorThresholds_datafield));
      /* Get Sensor Thresholds, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetSensorThresholds_datafield,
                     array_length(hf_GetSensorThresholds_datafield));
      /* Get Sensor Reading, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetSensorReading_datafield,
                     array_length(hf_GetSensorReading_datafield));

      /********* APP, NetFN = 0x06 *********/
      
      /*Get Device ID, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetDeviceID_datafield,
                     array_length(hf_GetDeviceID_datafield));
      

      /********* Storage, NetFN = 0x0a *********/

      /* Get FRU Inventory Area Info, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetFRUInventoryAreaInfo_datafield,
                     array_length(hf_GetFRUInventoryAreaInfo_datafield));
      /* Get SEL Info, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetSELInfo_datafield,
                     array_length(hf_GetSELInfo_datafield));
      /* Reserve SEL, added by lane */
      proto_register_field_array(proto_ipmi, hf_ReserveSEL_datafield,
                     array_length(hf_ReserveSEL_datafield));
      /* Get SEL Entry, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetSELEntry_datafield,
                     array_length(hf_GetSELEntry_datafield));
      /* Get SEL Entry, added by lane */
      proto_register_field_array(proto_ipmi, hf_ClearSEL_datafield,
                     array_length(hf_ClearSEL_datafield));

      /********* PICMG, NetFN = 0X2c *********/
      
      /*Get PICMG Properties, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetPICMGProperties_datafield,
                     array_length(hf_GetPICMGProperties_datafield));
      /*FRU Control, added by lane */
      proto_register_field_array(proto_ipmi, hf_FRUControl_datafield,
                     array_length(hf_FRUControl_datafield));
      /* Get FRU Led Properties, added by lane*/
      proto_register_field_array(proto_ipmi, hf_GetFRULedProperties_datafield,
                     array_length(hf_GetFRULedProperties_datafield));
      /* Get Led Color Capabilities ,, added by lane*/
      proto_register_field_array(proto_ipmi, hf_GetLedColorCapabilities_datafield,
                     array_length(hf_GetLedColorCapabilities_datafield));
      /* Set FRU Led State, added by lane */
      proto_register_field_array(proto_ipmi, hf_SetFRULedState_datafield,
                     array_length(hf_SetFRULedState_datafield));
      /* Get FRU Led State, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetFRULedState_datafield,
                     array_length(hf_GetFRULedState_datafield));
      /* Set FRU Activation Policy, added by lane */
      proto_register_field_array(proto_ipmi, hf_SetFRUActivationPolicy_datafield,
                     array_length(hf_SetFRUActivationPolicy_datafield));
      /* Get FRU Activation Policy, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetFRUActivationPolicy_datafield,
                     array_length(hf_GetFRUActivationPolicy_datafield));
      /* Set FRU Activation, added by lane */
      proto_register_field_array(proto_ipmi, hf_SetFRUActivation_datafield,
                     array_length(hf_SetFRUActivation_datafield));
      /* Get Device Locator Record ID, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetDeviceLocatorRecordID_datafield,
                     array_length(hf_GetDeviceLocatorRecordID_datafield));
      /* Set Power Level, added by lane */
      proto_register_field_array(proto_ipmi, hf_SetPowerLevel_datafield,
                     array_length(hf_SetPowerLevel_datafield));
      /* Get Power Level, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetPowerLevel_datafield,
                     array_length(hf_GetPowerLevel_datafield));
      /* Set Fan Level, added by lane */
      proto_register_field_array(proto_ipmi, hf_SetFanLevel_datafield,
                     array_length(hf_SetFanLevel_datafield));
      /* Get Fan Level, added by lane */
      proto_register_field_array(proto_ipmi, hf_GetFanLevel_datafield,
                     array_length(hf_GetFanLevel_datafield));
      
/****************************************************************************/

      proto_register_subtree_array(ett, array_length(ett));
      
}

void
proto_reg_handoff_ipmi(void)
{
      dissector_handle_t ipmi_handle;

      data_handle = find_dissector("data");

      ipmi_handle = create_dissector_handle(dissect_ipmi, proto_ipmi);
      dissector_add("rmcp.class", RMCP_CLASS_IPMI, ipmi_handle);
}

typedef  void (*P_FUN)(proto_tree *tree, proto_tree *ipmi_tree, packet_info *pinfo, tvbuff_t *tvb, gint *poffset, guint8 len, guint8 response, guint8 authtype);

/* added hereinafter by lane */ 
void
dissect_ipmi_data(proto_tree *tree, proto_tree *ipmi_tree,  packet_info *pinfo,
                              tvbuff_t *tvb, gint *poffset, guint8 len, guint8 netfn, guint8 cmd, 
                              guint8 response, guint8 authtype)
{
      tvbuff_t    *next_tvb;
      guint i;
      
      for (i = 0; i < NUM_OF_CMD_ARRAY; i++)    {
            if(((netfn&0xfe)==ipmi_cmd_array[i].netfn) && (cmd==ipmi_cmd_array[i].cmd))   {
                  if(ipmi_cmd_array[i].dissectfunc) {
                        ( (P_FUN)ipmi_cmd_array[i].dissectfunc )(tree, ipmi_tree, pinfo, tvb, poffset, len, response, authtype);
                        return;
                  }
                  else  {
                        next_tvb = tvb_new_subset(tvb, *poffset, len, len);
                        call_dissector(data_handle, next_tvb, pinfo, tree);
                        *poffset += len;
                        return;
                  }
             }
      }
      next_tvb = tvb_new_subset(tvb, *poffset, len, len);
      call_dissector(data_handle, next_tvb, pinfo, tree);
      (*poffset) += len;
      return;

}

/************************************************************************************/




Generated by  Doxygen 1.6.0   Back to index