Beispiel #1
0
        private BOOL IsLegalDirection(int iRegIndex)
        {
            WDC_REG reg = m_regs[iRegIndex];

            if (((RW.READ == m_direction) &&
                 (WDC_DIRECTION.WDC_WRITE == reg.direction)) ||
                ((RW.WRITE == m_direction) &&
                 (WDC_DIRECTION.WDC_READ == reg.direction)))
            {
                return(false);
            }

            return(true);
        }
Beispiel #2
0
        private void ReadAllRegs()
        {
            WDC_REG reg      = m_regs[0];
            DWORD   dwStatus = (DWORD)wdc_err.WD_STATUS_SUCCESS;

            TraceLog("displaying all registers (" + m_device.ToString(false) +
                     ")", (wdc_err)dwStatus);
            for (int i = 0; i < m_regs.GetLength(0); ++i)
            {
                reg = m_regs[i];
                if (!IsLegalDirection(i))
                {
                    txtData.Text = "register " + reg.sName + "is write-only" +
                                   Environment.NewLine;
                }
                else
                {
                    switch (reg.dwSize)
                    {
                    case wdc_lib_consts.WDC_SIZE_8:
                    {
                        dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                                   wdc_lib_decl.WDC_PciReadCfg8(m_device.Handle,
                                                                reg.dwOffset, ref m_bData) :
                                   wdc_lib_decl.WDC_ReadAddr8(m_device.Handle,
                                                              reg.dwAddrSpace, reg.dwOffset, ref m_bData);
                        break;
                    }

                    case wdc_lib_consts.WDC_SIZE_16:
                    {
                        dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                                   wdc_lib_decl.WDC_PciReadCfg16(m_device.Handle,
                                                                 reg.dwOffset, ref m_wData) :
                                   wdc_lib_decl.WDC_ReadAddr16(m_device.Handle,
                                                               reg.dwAddrSpace, reg.dwOffset, ref m_wData);
                        break;
                    }

                    case wdc_lib_consts.WDC_SIZE_32:
                    {
                        dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                                   wdc_lib_decl.WDC_PciReadCfg32(m_device.Handle,
                                                                 reg.dwOffset, ref m_u32Data) :
                                   wdc_lib_decl.WDC_ReadAddr32(m_device.Handle,
                                                               reg.dwAddrSpace, reg.dwOffset,
                                                               ref m_u32Data);
                        break;
                    }

                    case wdc_lib_consts.WDC_SIZE_64:
                    {
                        dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                                   wdc_lib_decl.WDC_PciReadCfg64(m_device.Handle,
                                                                 reg.dwOffset, ref m_u64Data) :
                                   wdc_lib_decl.WDC_ReadAddr64(m_device.Handle,
                                                               reg.dwAddrSpace, reg.dwOffset, ref m_u64Data);
                        break;
                    }
                    }
                    TraceLog((((DWORD)wdc_err.WD_STATUS_SUCCESS == dwStatus)?
                              "read from register " + reg.sName + " 0x" +
                              ((reg.dwSize == wdc_lib_consts.WDC_SIZE_8)?
                               m_bData.ToString("X2"):
                               ((reg.dwSize == wdc_lib_consts.WDC_SIZE_16)?
                                m_wData.ToString("X4") :
                                ((reg.dwSize == wdc_lib_consts.WDC_SIZE_32)?
                                 m_u32Data.ToString("X8") : m_u64Data.ToString("X16")))) :
                              "failed to complete the transaction on register " +
                              reg.sName), (wdc_err)dwStatus);
                }
            }
        }
Beispiel #3
0
        private void ReadWriteReg()
        {
            WDC_REG reg      = m_regs[0];
            DWORD   dwStatus = (DWORD)wdc_err.WD_STATUS_SUCCESS;
            BOOL    bIsRead  = (m_direction == RW.READ);

            if (!IsLegalDirection(0))
            {
                txtData.Text += "you have chosen to " + (bIsRead?
                                                         "read from" : "write to") + " a register which is " +
                                (bIsRead? "write-only" : "read-only") + Environment.NewLine;
                return;
            }

            switch (reg.dwSize)
            {
            case wdc_lib_consts.WDC_SIZE_8:
            {
                if (RW.READ == m_direction)
                {
                    dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                               wdc_lib_decl.WDC_PciReadCfg8(m_device.Handle,
                                                            reg.dwOffset, ref m_bData) :
                               wdc_lib_decl.WDC_ReadAddr8(m_device.Handle,
                                                          reg.dwAddrSpace, reg.dwOffset, ref m_bData);
                }
                else
                {
                    dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                               wdc_lib_decl.WDC_PciWriteCfg8(m_device.Handle,
                                                             reg.dwOffset, m_bData) :
                               wdc_lib_decl.WDC_WriteAddr8(m_device.Handle,
                                                           reg.dwAddrSpace, reg.dwOffset, m_bData);
                }
                break;
            }

            case wdc_lib_consts.WDC_SIZE_16:
            {
                if (RW.READ == m_direction)
                {
                    dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                               wdc_lib_decl.WDC_PciReadCfg16(m_device.Handle,
                                                             reg.dwOffset, ref m_wData) :
                               wdc_lib_decl.WDC_ReadAddr16(m_device.Handle,
                                                           reg.dwAddrSpace, reg.dwOffset, ref m_wData);
                }
                else
                {
                    dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                               wdc_lib_decl.WDC_PciWriteCfg16(m_device.Handle,
                                                              reg.dwOffset, m_wData) :
                               wdc_lib_decl.WDC_WriteAddr16(m_device.Handle,
                                                            reg.dwAddrSpace, reg.dwOffset, m_wData);
                }
                break;
            }

            case wdc_lib_consts.WDC_SIZE_32:
            {
                if (RW.READ == m_direction)
                {
                    dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                               wdc_lib_decl.WDC_PciReadCfg32(m_device.Handle,
                                                             reg.dwOffset, ref m_u32Data) :
                               wdc_lib_decl.WDC_ReadAddr32(m_device.Handle,
                                                           reg.dwAddrSpace, reg.dwOffset, ref m_u32Data);
                }
                else
                {
                    dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                               wdc_lib_decl.WDC_PciWriteCfg32(m_device.Handle,
                                                              reg.dwOffset, m_u32Data) :
                               wdc_lib_decl.WDC_WriteAddr32(m_device.Handle,
                                                            reg.dwAddrSpace, reg.dwOffset, m_u32Data);
                }
                break;
            }

            case wdc_lib_consts.WDC_SIZE_64:
            {
                if (RW.READ == m_direction)
                {
                    dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                               wdc_lib_decl.WDC_PciReadCfg64(m_device.Handle,
                                                             reg.dwOffset, ref m_u64Data) :
                               wdc_lib_decl.WDC_ReadAddr64(m_device.Handle,
                                                           reg.dwAddrSpace, reg.dwOffset, ref m_u64Data);
                }
                else
                {
                    dwStatus = (m_regType == ACTION_TYPE.CFG) ?
                               wdc_lib_decl.WDC_PciWriteCfg64(m_device.Handle,
                                                              reg.dwOffset, m_u64Data) :
                               wdc_lib_decl.WDC_WriteAddr64(m_device.Handle,
                                                            reg.dwAddrSpace, reg.dwOffset, m_u64Data);
                }
                break;
            }
            }
            TraceLog((((DWORD)wdc_err.WD_STATUS_SUCCESS == dwStatus)?
                      (bIsRead? "read " : "wrote ") + "0x" +
                      ((reg.dwSize == wdc_lib_consts.WDC_SIZE_8)?
                       m_bData.ToString("X2"):
                       ((reg.dwSize == wdc_lib_consts.WDC_SIZE_16)?
                        m_wData.ToString("X4") :
                        ((reg.dwSize == wdc_lib_consts.WDC_SIZE_32)?
                         m_u32Data.ToString("X8") : m_u64Data.ToString("X16")))) +
                      (bIsRead? " from " : " to ") + "register " + reg.sName :
                      "failed to complete the transaction on register" + reg.sName),
                     (wdc_err)dwStatus);
        }