开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 驱动编程 > 查看源码
RegistersForm.cs
资源名称：PLX_code_dotnet_10.rar　[点击查看]
上传用户：huajielb
上传日期：2022-07-29
资源大小：626k
文件大小：29k
源码类别：

驱动编程

开发平台：

Visual C++

RegistersForm.cs：源码内容
  1. using System;
  2. using System.Drawing;
  3. using System.Collections;
  4. using System.ComponentModel;
  5. using System.Windows.Forms;
  7. using Jungo.wdapi_dotnet;
  8. using Jungo.plx_lib;
  9. using wdc_err = Jungo.wdapi_dotnet.WD_ERROR_CODES;
  10. using UINT64 = System.UInt64;
  11. using DWORD = System.UInt32;
  12. using UINT32 = System.UInt32;
  13. using WORD = System.UInt16;
  14. using BYTE = System.Byte;
  15. using BOOL = System.Boolean;
  17. namespace Jungo.PLX_Sample
  18. {
  19.     public class RegistersForm : System.Windows.Forms.Form
  20.     {
  21.         private Exception m_excp;
  22.         private PLX_Device m_device;
  23.         private WDC_REG[] m_regs;
  24.         private RW m_direction;
  25.         private DWORD m_dwOffset;
  26.         private ACTION_TYPE m_regType;
  27.         private BYTE m_bData;
  28.         private WORD m_wData;
  29.         private UINT32 m_u32Data;
  30.         private UINT64 m_u64Data;
  31.         private System.Windows.Forms.TextBox txtOffset;
  32.         private System.Windows.Forms.Label lblOffset;
  33.         private System.Windows.Forms.Label label3;
  34.         private System.Windows.Forms.Label lblRegs;
  35.         private System.Windows.Forms.Button btReadAll;
  36.         private System.Windows.Forms.ComboBox cmboRegs;
  37.         private System.Windows.Forms.TextBox txtData;
  38.         private System.Windows.Forms.Button btExit;
  39.         private System.Windows.Forms.Button btRead;
  40.         private System.Windows.Forms.Button btWrite;
  41.         private System.Windows.Forms.Button btLog;
  42.         private System.Windows.Forms.TextBox txtInput;
  43.         private System.Windows.Forms.Label label2;
  44.         private System.Windows.Forms.Label lblInput;
  46.         private System.ComponentModel.Container components = null;
  48.         public RegistersForm(PLX_Device dev, ACTION_TYPE regType)
  49.         {
  50.             InitializeComponent();
  52.             m_device = dev;
  53.             m_regType = regType;
  55.             switch(regType)
  56.             {
  57.             case ACTION_TYPE.CFG:
  58.                 {
  59.                     this.Text = "Read/Write Configuration Space by Registers";
  60.                     lblRegs.Visible = true;
  61.                     lblRegs.Text = "Choose a Cfg Register";
  62.                     cmboRegs.Visible = true;
  63.                     WDC_REG[] regs = PLX_Regs.gPLX_CfgRegs;
  64.                     for (int i=0; i<regs.GetLength(0); ++i)
  65.                     {
  66.                         cmboRegs.Items.AddRange(new object[] {regs[i].sName +
  67.                             " size: " + regs[i].dwSize.ToString("X") +
  68.                                                         " - " + regs[i].sDesc});
  69.                     }
  70.                     break;
  71.                 }
  72.             case ACTION_TYPE.RT:
  73.                 {
  74.                     this.Text = "Read/Write RunTime Registers";
  75.                     lblRegs.Visible = true;
  76.                     lblRegs.Text = "Choose a RunTime Register";
  77.                     cmboRegs.Visible = true;
  78.                     WDC_REG[] regs = m_device.IsMaster? PLX_Regs.gPLX_M_Regs :
  79.                         PLX_Regs.gPLX_T_Regs;
  80.                     for (int i=0; i<regs.GetLength(0); ++i)
  81.                     {
  82.                         cmboRegs.Items.AddRange(new object[]{regs[i].sName +
  83.                             " size: " + regs[i].dwSize.ToString("X") +
  84.                                                         " - " + regs[i].sDesc});
  85.                     }
  86.                     break;
  87.                 }
  88.             case ACTION_TYPE.EEPROM:
  89.                 {
  90.                     this.Text = "Read/Write EEPROM";
  91.                     lblRegs.Visible = false;
  92.                     cmboRegs.Visible = false;
  94.                     txtOffset = new System.Windows.Forms.TextBox();
  95.                     txtOffset.Visible = true;
  96.                     txtOffset.Location = new
  97.                         System.Drawing.Point(txtInput.Left, cmboRegs.Top);
  98.                     txtOffset.Name = "txtOffset";
  99.                     txtOffset.Size = new System.Drawing.Size(txtInput.Width,
  100.                         txtInput.Height);
  101.                     txtOffset.TabIndex = 0;
  102.                     txtOffset.Text = "";
  103.                     txtOffset.Parent = this;
  105.                     lblOffset = new Label();
  106.                     string sOffMult = m_device.EEprom.IsVPD()? 
  107.                         wdc_lib_consts.WDC_SIZE_32.ToString():
  108.                         wdc_lib_consts.WDC_SIZE_16.ToString();
  109.                     lblOffset.Text = "Enter offset (must be a multiple of " + 
  110.                         sOffMult + "):";
  111.                     lblOffset.Visible = true;
  112.                     lblOffset.Location = new
  113.                         System.Drawing.Point(lblInput.Left, cmboRegs.Top);
  114.                     lblOffset.Name = "lblOffset";
  115.                     lblOffset.Size = new 
  116.                         System.Drawing.Size(lblInput.Width-5, lblInput.Height);
  117.                     lblOffset.TabIndex = 19;
  118.                     lblOffset.Parent = this;
  120.                     label3 = new Label();
  121.                     label3.Location = new
  122.                         System.Drawing.Point(label2.Left, cmboRegs.Top);
  123.                     label3.Name = "label3";
  124.                     label3.Size = new System.Drawing.Size(16, 23);
  125.                     label3.TabIndex = 20;
  126.                     label3.Text = "0x";
  127.                     label3.Parent = this;
  129.                     break;
  130.                 }                                        
  131.             }
  132.         }
  134.         protected override void Dispose( bool disposing )
  135.         {
  136.             if( disposing )
  137.             {
  138.                 if(components != null)
  139.                 {
  140.                     components.Dispose();
  141.                 }
  142.             }
  143.             base.Dispose( disposing );
  144.         }
  146. #region Windows Form Designer generated code
  147.         private void InitializeComponent()
  148.         {
  149.             this.cmboRegs = new System.Windows.Forms.ComboBox();
  150.             this.txtData = new System.Windows.Forms.TextBox();
  151.             this.lblRegs = new System.Windows.Forms.Label();
  152.             this.btReadAll = new System.Windows.Forms.Button();
  153.             this.btExit = new System.Windows.Forms.Button();
  154.             this.btRead = new System.Windows.Forms.Button();
  155.             this.txtInput = new System.Windows.Forms.TextBox();
  156.             this.btWrite = new System.Windows.Forms.Button();
  157.             this.btLog = new System.Windows.Forms.Button();
  158.             this.lblInput = new System.Windows.Forms.Label();
  159.             this.label2 = new System.Windows.Forms.Label();
  160.             this.SuspendLayout();
  161.             // cmboRegs
  162.             this.cmboRegs.Location = new System.Drawing.Point(40, 32);
  163.             this.cmboRegs.Name = "cmboRegs";
  164.             this.cmboRegs.Size = new System.Drawing.Size(360, 21);
  165.             this.cmboRegs.TabIndex = 0;
  166.             this.cmboRegs.Text = "---- ----";
  167.             // txtData
  168.             this.txtData.AutoSize = false;
  169.             this.txtData.Location = new System.Drawing.Point(40, 112);
  170.             this.txtData.Multiline = true;
  171.             this.txtData.Name = "txtData";
  172.             this.txtData.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
  173.             this.txtData.Size = new System.Drawing.Size(360, 136);
  174.             this.txtData.TabIndex = 8;
  175.             this.txtData.Text = "";
  176.             // lblRegs
  177.             this.lblRegs.Location = new System.Drawing.Point(48, 8);
  178.             this.lblRegs.Name = "lblRegs";
  179.             this.lblRegs.Size = new System.Drawing.Size(256, 23);
  180.             this.lblRegs.TabIndex = 9;
  181.             this.lblRegs.Text = "Choose a RunTime Register";
  182.             // btReadAll
  183.             this.btReadAll.Location = new System.Drawing.Point(176, 264);
  184.             this.btReadAll.Name = "btReadAll";
  185.             this.btReadAll.TabIndex = 3;
  186.             this.btReadAll.Text = "Read All ";
  187.             this.btReadAll.Click += 
  188.                 new System.EventHandler(this.btReadAll_Click);
  189.             // btExit
  190.             this.btExit.DialogResult = System.Windows.Forms.DialogResult.Cancel;
  191.             this.btExit.Location = new System.Drawing.Point(432, 192);
  192.             this.btExit.Name = "btExit";
  193.             this.btExit.TabIndex = 6;
  194.             this.btExit.Text = "Exit";
  195.             // btRead
  196.             this.btRead.Location = new System.Drawing.Point(48, 264);
  197.             this.btRead.Name = "btRead";
  198.             this.btRead.TabIndex = 2;
  199.             this.btRead.Text = "Read";
  200.             this.btRead.Click += new System.EventHandler(this.btRead_Click);
  201.             // txtInput
  202.             this.txtInput.Location = new System.Drawing.Point(256, 72);
  203.             this.txtInput.Name = "txtInput";
  204.             this.txtInput.Size = new System.Drawing.Size(144, 20);
  205.             this.txtInput.TabIndex = 1;
  206.             this.txtInput.Text = "";
  207.             // btWrite
  208.             this.btWrite.Location = new System.Drawing.Point(304, 264);
  209.             this.btWrite.Name = "btWrite";
  210.             this.btWrite.TabIndex = 4;
  211.             this.btWrite.Text = "Write";
  212.             this.btWrite.Click += new System.EventHandler(this.btWrite_Click);
  213.             // btLog
  214.             this.btLog.Location = new System.Drawing.Point(432, 136);
  215.             this.btLog.Name = "btLog";
  216.             this.btLog.TabIndex = 5;
  217.             this.btLog.Text = "Clear Log";
  218.             this.btLog.Click += new System.EventHandler(this.btLog_Click);
  219.             // lblInput
  220.             this.lblInput.Location = new System.Drawing.Point(40, 72);
  221.             this.lblInput.Name = "lblInput";
  222.             this.lblInput.Size = new System.Drawing.Size(208, 23);
  223.             this.lblInput.TabIndex = 17;
  224.             this.lblInput.Text = "Enter Input in hex (Write Transactions):";
  225.             // label2
  226.             this.label2.Location = new System.Drawing.Point(240, 72);
  227.             this.label2.Name = "label2";
  228.             this.label2.Size = new System.Drawing.Size(16, 23);
  229.             this.label2.TabIndex = 18;
  230.             this.label2.Text = "0x";
  231.             // RegistersForm
  232.             this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
  233.             this.CancelButton = this.btExit;
  234.             this.ClientSize = new System.Drawing.Size(520, 301);
  235.             this.Controls.Add(this.label2);
  236.             this.Controls.Add(this.lblInput);
  237.             this.Controls.Add(this.btLog);
  238.             this.Controls.Add(this.btWrite);
  239.             this.Controls.Add(this.txtInput);
  240.             this.Controls.Add(this.btRead);
  241.             this.Controls.Add(this.btExit);
  242.             this.Controls.Add(this.btReadAll);
  243.             this.Controls.Add(this.lblRegs);
  244.             this.Controls.Add(this.txtData);
  245.             this.Controls.Add(this.cmboRegs);
  246.             this.Name = "RegistersForm";
  247.             this.StartPosition = 
  248.                 System.Windows.Forms.FormStartPosition.CenterScreen;
  249.             this.Text = "Registers";
  250.             this.ResumeLayout(false);
  252.         }
  253. #endregion
  255.         public bool GetInput()
  256.         {
  257.             DialogResult result = DialogResult.Retry;
  259.             while((result = ShowDialog()) == DialogResult.Retry);
  261.             return true;
  262.         }
  264.         private void btClick(object sender, System.EventArgs e)
  265.         {
  266.             DialogResult = DialogResult.None;
  268.             try
  269.             {
  270.                 if(m_regType == ACTION_TYPE.EEPROM)
  271.                     TranslateInput_EEPROM();
  272.                 else
  273.                     TranslateInput_Regs();                                
  274.             }
  275.             catch
  276.             {
  277.                 MessageBox.Show(m_excp.Message,"Input Entry Error",
  278.                     MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
  279.                 DialogResult = DialogResult.Retry;
  280.                 return;
  281.             }         
  283.             if(m_regType == ACTION_TYPE.EEPROM)
  284.                 ReadWriteEEPROM();
  285.             else
  286.             {
  287.                 if(m_direction == RW.READ_ALL)
  288.                     ReadAllRegs();
  289.                 else
  290.                     ReadWriteReg();
  291.             }
  292.         }
  294.         private void btRead_Click(object sender, System.EventArgs e)
  295.         {
  296.             m_direction = RW.READ;
  297.             btClick(sender, e);
  298.         }
  300.         private void btWrite_Click(object sender, System.EventArgs e)
  301.         {
  302.             m_direction = RW.WRITE;
  303.             btClick(sender, e);                        
  304.         }
  306.         private void btReadAll_Click(object sender, System.EventArgs e)
  307.         {
  308.             m_direction = RW.READ_ALL;
  309.             btClick(sender, e);
  310.         }
  312.         private void TranslateInput_Regs()
  313.         {
  314.             if(m_direction != RW.READ_ALL)
  315.             {
  316.                 m_regs = new WDC_REG[1];
  317.                 m_excp = new Exception("Select a Register");
  318.                 int iSelectedReg = cmboRegs.SelectedIndex;
  319.                 if ((uint)iSelectedReg == 0xffffffff)
  320.                     throw m_excp;
  322.                 m_regs[0] = (m_regType == ACTION_TYPE.CFG)? 
  323.                     PLX_Regs.gPLX_CfgRegs[iSelectedReg]:
  324.                     (m_device.IsMaster)?
  325.                     PLX_Regs.gPLX_M_Regs[iSelectedReg]:
  326.                     PLX_Regs.gPLX_T_Regs[iSelectedReg];
  328.                 if(m_direction == RW.WRITE)
  329.                 {
  330.                     m_excp = new Exception("Enter the data to write. "
  331.                         + "Entered value should be a hex number");
  332.                     if(txtInput.Text == "")
  333.                         throw m_excp;
  334.                     DWORD dwSize = m_regs[0].dwSize;
  335.                     switch(dwSize)
  336.                     {
  337.                     case wdc_lib_consts.WDC_SIZE_8:
  338.                         {
  339.                             m_bData = Convert.ToByte(txtInput.Text, 16);
  340.                             break;
  341.                         }
  342.                     case wdc_lib_consts.WDC_SIZE_16:
  343.                         {
  344.                             m_wData = Convert.ToUInt16(txtInput.Text, 16);
  345.                             break;
  346.                         }
  347.                     case wdc_lib_consts.WDC_SIZE_32:
  348.                         {
  349.                             m_u32Data = Convert.ToUInt32(txtInput.Text, 16);
  350.                             break;
  351.                         }
  352.                     case wdc_lib_consts.WDC_SIZE_64:
  353.                         {
  354.                             m_u64Data = Convert.ToUInt64(txtInput.Text, 16);
  355.                             break;
  356.                         }
  357.                     }
  358.                 }
  359.             }
  360.             else
  361.             {                                
  362.                 m_regs = (m_regType == ACTION_TYPE.CFG)? 
  363.                     PLX_Regs.gPLX_CfgRegs: (m_device.IsMaster)?
  364.                     PLX_Regs.gPLX_M_Regs: PLX_Regs.gPLX_T_Regs;
  365.             }                        
  366.         }
  368.         private BOOL IsLegalDirection(int iRegIndex)
  369.         {
  370.             WDC_REG reg = m_regs[iRegIndex];
  372.             if (((RW.READ == m_direction) && 
  373.                 (WDC_DIRECTION.WDC_WRITE == reg.direction)) ||
  374.                 ((RW.WRITE == m_direction) && 
  375.                 (WDC_DIRECTION.WDC_READ == reg.direction)))
  376.                 return false;
  378.             return true;
  379.         }
  381.         private void ReadWriteReg()
  382.         {
  383.             WDC_REG reg = m_regs[0];
  384.             DWORD dwStatus = (DWORD)wdc_err.WD_STATUS_SUCCESS;
  385.             BOOL bIsRead = (m_direction == RW.READ);
  387.             if(!IsLegalDirection(0))
  388.             {
  389.                 txtData.Text += "you have chosen to " + (bIsRead? 
  390.                     "read from" : "write to") + " a register which is " +
  391.                     (bIsRead? "write-only" : "read-only") + Environment.NewLine;
  392.                 return;
  393.             }
  395.             switch (reg.dwSize)
  396.             {
  397.             case wdc_lib_consts.WDC_SIZE_8:
  398.                 {
  399.                     if (RW.READ == m_direction)
  400.                         dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  401.                             wdc_lib_decl.WDC_PciReadCfg8(m_device.Handle,
  402.                                 reg.dwOffset, ref m_bData) :
  403.                             wdc_lib_decl.WDC_ReadAddr8(m_device.Handle,
  404.                                 reg.dwAddrSpace, reg.dwOffset, ref m_bData);
  405.                     else
  406.                     {
  407.                         dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  408.                             wdc_lib_decl.WDC_PciWriteCfg8(m_device.Handle,
  409.                                 reg.dwOffset, m_bData) :
  410.                             wdc_lib_decl.WDC_WriteAddr8(m_device.Handle,
  411.                                 reg.dwAddrSpace, reg.dwOffset, m_bData);
  412.                     }
  413.                     break;
  414.                 }
  415.             case wdc_lib_consts.WDC_SIZE_16:
  416.                 {
  417.                     if (RW.READ == m_direction)
  418.                         dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  419.                             wdc_lib_decl.WDC_PciReadCfg16(m_device.Handle,
  420.                                 reg.dwOffset, ref m_wData) :
  421.                             wdc_lib_decl.WDC_ReadAddr16(m_device.Handle,
  422.                                 reg.dwAddrSpace, reg.dwOffset, ref m_wData);
  423.                     else
  424.                     {
  425.                         dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  426.                             wdc_lib_decl.WDC_PciWriteCfg16(m_device.Handle,
  427.                                 reg.dwOffset, m_wData) :
  428.                             wdc_lib_decl.WDC_WriteAddr16(m_device.Handle,
  429.                                 reg.dwAddrSpace, reg.dwOffset, m_wData);
  430.                     }
  431.                     break;
  432.                 }
  433.             case wdc_lib_consts.WDC_SIZE_32:
  434.                 {
  435.                     if (RW.READ == m_direction)
  436.                         dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  437.                             wdc_lib_decl.WDC_PciReadCfg32(m_device.Handle,
  438.                                 reg.dwOffset, ref m_u32Data) :
  439.                             wdc_lib_decl.WDC_ReadAddr32(m_device.Handle,
  440.                                 reg.dwAddrSpace, reg.dwOffset, ref m_u32Data);
  441.                     else
  442.                     {
  443.                         dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  444.                             wdc_lib_decl.WDC_PciWriteCfg32(m_device.Handle,
  445.                                 reg.dwOffset, m_u32Data) :
  446.                             wdc_lib_decl.WDC_WriteAddr32(m_device.Handle,
  447.                                 reg.dwAddrSpace, reg.dwOffset, m_u32Data);
  448.                     }
  449.                     break;
  450.                 }
  451.             case wdc_lib_consts.WDC_SIZE_64:
  452.                 {
  453.                     if (RW.READ == m_direction)
  454.                         dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  455.                             wdc_lib_decl.WDC_PciReadCfg64(m_device.Handle,
  456.                                 reg.dwOffset, ref m_u64Data) :
  457.                             wdc_lib_decl.WDC_ReadAddr64(m_device.Handle,
  458.                                 reg.dwAddrSpace, reg.dwOffset, ref m_u64Data);
  459.                     else
  460.                     {
  461.                         dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  462.                             wdc_lib_decl.WDC_PciWriteCfg64(m_device.Handle,
  463.                                 reg.dwOffset, m_u64Data) :
  464.                             wdc_lib_decl.WDC_WriteAddr64(m_device.Handle,
  465.                                 reg.dwAddrSpace, reg.dwOffset, m_u64Data);
  466.                     }
  467.                     break;
  468.                 }
  469.             }        
  470.             TraceLog((((DWORD)wdc_err.WD_STATUS_SUCCESS == dwStatus)?
  471.                 (bIsRead? "read " : "wrote ") + "0x" +
  472.                 ((reg.dwSize == wdc_lib_consts.WDC_SIZE_8)? 
  473.                 m_bData.ToString("X2"): 
  474.                 ((reg.dwSize == wdc_lib_consts.WDC_SIZE_16)?
  475.                 m_wData.ToString("X4") :
  476.                 ((reg.dwSize == wdc_lib_consts.WDC_SIZE_32)?
  477.                 m_u32Data.ToString("X8") : m_u64Data.ToString("X16")))) +
  478.                 (bIsRead? " from " : " to ") + "register " + reg.sName :
  479.                 "failed to complete the transaction on register" + reg.sName),
  480.                     (wdc_err)dwStatus); 
  481.         }
  483.         private void ReadAllRegs()
  484.         {
  485.             WDC_REG reg = m_regs[0];
  486.             DWORD dwStatus = (DWORD)wdc_err.WD_STATUS_SUCCESS;
  488.             TraceLog("displaying all registers (" + m_device.ToString(false) +
  489.                 ")", (wdc_err)dwStatus);
  490.             for(int i = 0; i < m_regs.GetLength(0); ++i)
  491.             {
  492.                 reg = m_regs[i];
  493.                 if(!IsLegalDirection(i))
  494.                     txtData.Text = "register " + reg.sName + "is write-only" + 
  495.                         Environment.NewLine;
  496.                 else
  497.                 {
  498.                     switch (reg.dwSize)
  499.                     {
  500.                     case wdc_lib_consts.WDC_SIZE_8:
  501.                         {
  502.                             dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  503.                                 wdc_lib_decl.WDC_PciReadCfg8(m_device.Handle,
  504.                                     reg.dwOffset, ref m_bData) :
  505.                                 wdc_lib_decl.WDC_ReadAddr8(m_device.Handle,
  506.                                     reg.dwAddrSpace, reg.dwOffset, ref m_bData);
  507.                             break;
  508.                         }
  509.                     case wdc_lib_consts.WDC_SIZE_16:
  510.                         {
  511.                             dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  512.                                 wdc_lib_decl.WDC_PciReadCfg16(m_device.Handle,
  513.                                     reg.dwOffset, ref m_wData) :
  514.                                 wdc_lib_decl.WDC_ReadAddr16(m_device.Handle,
  515.                                     reg.dwAddrSpace, reg.dwOffset, ref m_wData);
  516.                             break;
  517.                         }
  518.                     case wdc_lib_consts.WDC_SIZE_32:
  519.                         {
  520.                             dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  521.                                 wdc_lib_decl.WDC_PciReadCfg32(m_device.Handle,
  522.                                     reg.dwOffset, ref m_u32Data) :
  523.                                 wdc_lib_decl.WDC_ReadAddr32(m_device.Handle,
  524.                                     reg.dwAddrSpace, reg.dwOffset, 
  525.                                     ref m_u32Data);
  526.                             break;
  527.                         }
  528.                     case wdc_lib_consts.WDC_SIZE_64:
  529.                         {
  530.                             dwStatus = (m_regType == ACTION_TYPE.CFG) ? 
  531.                                 wdc_lib_decl.WDC_PciReadCfg64(m_device.Handle,
  532.                                     reg.dwOffset, ref m_u64Data) :
  533.                                 wdc_lib_decl.WDC_ReadAddr64(m_device.Handle,
  534.                                     reg.dwAddrSpace, reg.dwOffset, ref m_u64Data);
  535.                             break;
  536.                         }
  537.                     }        
  538.                     TraceLog((((DWORD)wdc_err.WD_STATUS_SUCCESS == dwStatus)?
  539.                         "read from register " + reg.sName + " 0x" +
  540.                         ((reg.dwSize == wdc_lib_consts.WDC_SIZE_8)?
  541.                         m_bData.ToString("X2"):  
  542.                         ((reg.dwSize == wdc_lib_consts.WDC_SIZE_16)?
  543.                         m_wData.ToString("X4") :
  544.                         ((reg.dwSize == wdc_lib_consts.WDC_SIZE_32)?
  545.                         m_u32Data.ToString("X8") : m_u64Data.ToString("X16")))) :
  546.                         "failed to complete the transaction on register " + 
  547.                         reg.sName), (wdc_err)dwStatus);
  548.                 }                        
  549.             }
  550.         }
  552.         private void TranslateInput_EEPROM()
  553.         {
  554.             bool bIsVPD = m_device.EEprom.IsVPD();
  555.             if(m_direction != RW.READ_ALL)
  556.             {
  557.                 DWORD dwMult = (bIsVPD ? wdc_lib_consts.WDC_SIZE_32 : 
  558.                     wdc_lib_consts.WDC_SIZE_16);
  559.                 m_excp = new Exception("the offset entered is not a multiple " +
  560.                     "of " + dwMult.ToString());
  561.                 m_dwOffset = (DWORD)Convert.ToByte(txtOffset.Text, 16);
  562.                 if((m_dwOffset % dwMult) != 0)
  563.                     throw m_excp;
  565.                 if(m_direction == RW.WRITE)
  566.                 {
  567.                     m_excp = new Exception("Enter the data to write. "
  568.                         + "Entered value should be a hex number");
  569.                 
  570.                     if(txtInput.Text == "")
  571.                         throw m_excp;
  573.                     if(bIsVPD)
  574.                         m_u32Data = Convert.ToUInt32(txtInput.Text, 16);
  575.                     else
  576.                         m_wData = Convert.ToUInt16(txtInput.Text, 16);
  577.                 }                                
  578.             }
  579.         }
  581.         private void ReadWriteEEPROM()
  582.         {
  583.             bool bIsVPD = m_device.EEprom.IsVPD();
  584.             DWORD dwStatus = (DWORD)wdc_err.WD_STATUS_SUCCESS;
  585.             string str;
  587.             switch(m_direction)
  588.             {
  589.             case RW.READ:
  590.                 {
  591.                     dwStatus = bIsVPD? m_device.EEprom.EEPROM_Read(m_dwOffset,
  592.                         ref m_u32Data):
  593.                         ((EEPROM_RT)m_device.EEprom).EEPROM_Read16(m_dwOffset,
  594.                             ref m_wData);
  595.                     if(dwStatus == (DWORD)wdc_err.WD_STATUS_SUCCESS)
  596.                     {
  597.                         str = "read 0x" + (bIsVPD? m_u32Data.ToString("X") :
  598.                             m_wData.ToString("X")) + " from offset " 
  599.                             + m_dwOffset.ToString("X");
  600.                     }
  601.                     else
  602.                         str = "Failed reading from offset " +
  603.                             m_dwOffset.ToString("X");
  605.                     TraceLog(str, (wdc_err)dwStatus);                        
  606.                     break;
  607.                 }
  608.             case RW.WRITE:
  609.                 {
  610.                     dwStatus = bIsVPD? m_device.EEprom.EEPROM_Write(m_dwOffset,
  611.                         m_u32Data):
  612.                         ((EEPROM_RT)m_device.EEprom).EEPROM_Write16(m_dwOffset,
  613.                             m_wData);
  614.                     if(dwStatus == (DWORD)wdc_err.WD_STATUS_SUCCESS)
  615.                     {
  616.                         str = "Wrote 0x" + (bIsVPD? m_u32Data.ToString("X") :
  617.                             m_wData.ToString("X")) + " to offset " + 
  618.                             m_dwOffset.ToString("X");
  619.                     }
  620.                     else
  621.                         str = "Failed writing to offset " + 
  622.                             m_dwOffset.ToString("X");
  623.                     
  624.                     TraceLog(str, (wdc_err)dwStatus);
  625.                     break;
  626.                 }
  627.             case RW.READ_ALL:
  628.                 {
  629.                     string sDisplay = "displaying EEPROM (" +
  630.                         m_device.ToString(false) + ")" ;
  632.                     for (DWORD dwOffset = 0; dwOffset < 0xff; dwOffset += 4)
  633.                     {
  634.                         if((dwOffset % 0x10) == 0)
  635.                         {
  636.                             TraceLog(sDisplay, (wdc_err)dwStatus);
  637.                             sDisplay = dwOffset.ToString("X2") + ": " ;
  638.                         }
  639.                         dwStatus = m_device.EEprom.EEPROM_Read(dwOffset,
  640.                             ref m_u32Data);
  641.                         if((DWORD)wdc_err.WD_STATUS_SUCCESS != dwStatus)
  642.                         {
  643.                             sDisplay += Environment.NewLine + "Error " +
  644.                                 "occurred while reading offset 0x" + 
  645.                                 dwOffset.ToString("X") + "of the serial " +
  646.                                 "EEPROM. Error 0x" + dwStatus.ToString("X") +
  647.                                 ": " + utils.Stat2Str((DWORD)dwStatus);
  648.                             break; 
  649.                         }
  650.                         sDisplay += m_u32Data.ToString("X8") + "  ";
  651.                     }
  652.                     TraceLog(sDisplay, (wdc_err)dwStatus);
  653.                     break;
  654.                 }
  655.             }
  656.         }
  658.         private void btLog_Click(object sender, System.EventArgs e)
  659.         {
  660.             txtData.Clear();
  661.         }
  663.         private void TraceLog(string str, wdc_err status)
  664.         {
  665.             txtData.Text += str + Environment.NewLine;
  667.             string sForm = (m_regType == ACTION_TYPE.EEPROM)? 
  668.                 "EEPROM R/W Form: " : (m_regType == ACTION_TYPE.CFG)? 
  669.                 "CFG Registers R/W Form: " : "RT Registers R/W Form: ";
  671.             if(m_direction == RW.READ_ALL)
  672.             {
  673.                 Log.TraceLog(sForm + str);
  674.                 return;
  675.             }
  676.             
  677.             string sMsg = sForm + str + " (" + m_device.ToString(false) + ")";
  678.             if(status == wdc_err.WD_STATUS_SUCCESS)
  679.                 Log.TraceLog(sMsg);
  680.             else
  681.                 Log.ErrLog(sMsg);            
  682.         }
  683.     }
  684. }