Subversion Repositories Kolibri OS

Rev

Rev 1029 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright 2006-2007 Advanced Micro Devices, Inc.  
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8.  * and/or sell copies of the Software, and to permit persons to whom the
  9.  * Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice shall be included in
  12.  * all copies or substantial portions of the Software.
  13.  *
  14.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17.  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20.  * OTHER DEALINGS IN THE SOFTWARE.
  21.  */
  22.  
  23. /**
  24.  
  25. Module Name:
  26.  
  27.     CD_Operations.c
  28.  
  29. Abstract:
  30.  
  31.                 Functions Implementing Command Operations and other common functions
  32.  
  33. Revision History:
  34.  
  35.         NEG:27.09.2002  Initiated.
  36. --*/
  37. #define __SW_4
  38.  
  39. #include "Decoder.h"
  40. #include        "atombios.h"
  41.  
  42.  
  43.  
  44. VOID PutDataRegister(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  45. VOID PutDataPS(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  46. VOID PutDataWS(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  47. VOID PutDataFB(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  48. VOID PutDataPLL(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  49. VOID PutDataMC(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  50.  
  51. UINT32 GetParametersDirect32(PARSER_TEMP_DATA STACK_BASED *     pParserTempData);
  52. UINT32 GetParametersDirect16(PARSER_TEMP_DATA STACK_BASED *     pParserTempData);
  53. UINT32 GetParametersDirect8(PARSER_TEMP_DATA STACK_BASED *      pParserTempData);
  54.  
  55. UINT32 GetParametersRegister(PARSER_TEMP_DATA STACK_BASED *     pParserTempData);
  56. UINT32 GetParametersPS(PARSER_TEMP_DATA STACK_BASED *   pParserTempData);
  57. UINT32 GetParametersWS(PARSER_TEMP_DATA STACK_BASED *   pParserTempData);
  58. UINT32 GetParametersFB(PARSER_TEMP_DATA STACK_BASED *   pParserTempData);
  59. UINT32 GetParametersPLL(PARSER_TEMP_DATA STACK_BASED *  pParserTempData);
  60. UINT32 GetParametersMC(PARSER_TEMP_DATA STACK_BASED *   pParserTempData);
  61.  
  62. VOID SkipParameters16(PARSER_TEMP_DATA STACK_BASED *    pParserTempData);
  63. VOID SkipParameters8(PARSER_TEMP_DATA STACK_BASED *     pParserTempData);
  64.  
  65. UINT32 GetParametersIndirect(PARSER_TEMP_DATA STACK_BASED *     pParserTempData);
  66. UINT32 GetParametersDirect(PARSER_TEMP_DATA STACK_BASED *       pParserTempData);
  67.  
  68. UINT16* GetDataMasterTablePointer(DEVICE_DATA STACK_BASED*  pDeviceData);
  69. UINT8 GetTrueIndexInMasterTable(PARSER_TEMP_DATA STACK_BASED * pParserTempData, UINT8 IndexInMasterTable);
  70.  
  71.  
  72. WRITE_IO_FUNCTION WritePCIFunctions[8] =   {
  73.     WritePCIReg32,
  74.     WritePCIReg16, WritePCIReg16, WritePCIReg16,
  75.     WritePCIReg8,WritePCIReg8,WritePCIReg8,WritePCIReg8
  76. };
  77. WRITE_IO_FUNCTION WriteIOFunctions[8] =    {
  78.     WriteSysIOReg32,
  79.     WriteSysIOReg16,WriteSysIOReg16,WriteSysIOReg16,
  80.     WriteSysIOReg8,WriteSysIOReg8,WriteSysIOReg8,WriteSysIOReg8
  81. };
  82. READ_IO_FUNCTION ReadPCIFunctions[8] =      {
  83.     (READ_IO_FUNCTION)ReadPCIReg32,
  84.     (READ_IO_FUNCTION)ReadPCIReg16,
  85.     (READ_IO_FUNCTION)ReadPCIReg16,
  86.     (READ_IO_FUNCTION)ReadPCIReg16,
  87.     (READ_IO_FUNCTION)ReadPCIReg8,
  88.     (READ_IO_FUNCTION)ReadPCIReg8,
  89.     (READ_IO_FUNCTION)ReadPCIReg8,
  90.     (READ_IO_FUNCTION)ReadPCIReg8
  91. };
  92. READ_IO_FUNCTION ReadIOFunctions[8] =       {
  93.     (READ_IO_FUNCTION)ReadSysIOReg32,
  94.     (READ_IO_FUNCTION)ReadSysIOReg16,
  95.     (READ_IO_FUNCTION)ReadSysIOReg16,
  96.     (READ_IO_FUNCTION)ReadSysIOReg16,
  97.     (READ_IO_FUNCTION)ReadSysIOReg8,
  98.     (READ_IO_FUNCTION)ReadSysIOReg8,
  99.     (READ_IO_FUNCTION)ReadSysIOReg8,
  100.     (READ_IO_FUNCTION)ReadSysIOReg8
  101. };
  102. READ_IO_FUNCTION GetParametersDirectArray[8]={
  103.     GetParametersDirect32,
  104.     GetParametersDirect16,GetParametersDirect16,GetParametersDirect16,
  105.     GetParametersDirect8,GetParametersDirect8,GetParametersDirect8,
  106.     GetParametersDirect8
  107. };
  108.  
  109. COMMANDS_DECODER PutDataFunctions[6]   =     {
  110.     PutDataRegister,
  111.     PutDataPS,
  112.     PutDataWS,
  113.     PutDataFB,
  114.     PutDataPLL,
  115.     PutDataMC
  116. };
  117. CD_GET_PARAMETERS GetDestination[6]   =     {
  118.     GetParametersRegister,
  119.     GetParametersPS,
  120.     GetParametersWS,
  121.     GetParametersFB,
  122.     GetParametersPLL,
  123.     GetParametersMC
  124. };
  125.  
  126. COMMANDS_DECODER SkipDestination[6]   =     {
  127.     SkipParameters16,
  128.     SkipParameters8,
  129.     SkipParameters8,
  130.     SkipParameters8,
  131.     SkipParameters8,
  132.     SkipParameters8
  133. };
  134.  
  135. CD_GET_PARAMETERS GetSource[8]   =          {
  136.     GetParametersRegister,
  137.     GetParametersPS,
  138.     GetParametersWS,
  139.     GetParametersFB,
  140.     GetParametersIndirect,
  141.     GetParametersDirect,
  142.     GetParametersPLL,
  143.     GetParametersMC
  144. };
  145.  
  146. UINT32 AlignmentMask[8] =                   {0xFFFFFFFF,0xFFFF,0xFFFF,0xFFFF,0xFF,0xFF,0xFF,0xFF};
  147. UINT8  SourceAlignmentShift[8] =            {0,0,8,16,0,8,16,24};
  148. UINT8  DestinationAlignmentShift[4] =       {0,8,16,24};
  149.  
  150. #define INDIRECTIO_ID         1
  151. #define INDIRECTIO_END_OF_ID  9
  152.  
  153. VOID IndirectIOCommand(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  154. VOID IndirectIOCommand_MOVE(PARSER_TEMP_DATA STACK_BASED * pParserTempData, UINT32 temp);
  155. VOID IndirectIOCommand_MOVE_INDEX(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  156. VOID IndirectIOCommand_MOVE_ATTR(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  157. VOID IndirectIOCommand_MOVE_DATA(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  158. VOID IndirectIOCommand_SET(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  159. VOID IndirectIOCommand_CLEAR(PARSER_TEMP_DATA STACK_BASED * pParserTempData);
  160.  
  161.  
  162. INDIRECT_IO_PARSER_COMMANDS  IndirectIOParserCommands[10]={
  163.     {IndirectIOCommand,1},
  164.     {IndirectIOCommand,2},
  165.     {ReadIndReg32,3},
  166.     {WriteIndReg32,3},
  167.     {IndirectIOCommand_CLEAR,3},
  168.     {IndirectIOCommand_SET,3},
  169.     {IndirectIOCommand_MOVE_INDEX,4},
  170.     {IndirectIOCommand_MOVE_ATTR,4},
  171.     {IndirectIOCommand_MOVE_DATA,4},
  172.     {IndirectIOCommand,3}
  173. };
  174.  
  175.  
  176. VOID IndirectIOCommand(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  177. {
  178. }
  179.  
  180.  
  181. VOID IndirectIOCommand_MOVE_INDEX(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  182. {
  183.     pParserTempData->IndirectData &= ~((0xFFFFFFFF >> (32-pParserTempData->IndirectIOTablePointer[1])) << pParserTempData->IndirectIOTablePointer[3]);
  184.     pParserTempData->IndirectData |=(((pParserTempData->Index >> pParserTempData->IndirectIOTablePointer[2]) &
  185.                                       (0xFFFFFFFF >> (32-pParserTempData->IndirectIOTablePointer[1]))) << pParserTempData->IndirectIOTablePointer[3]);
  186. }
  187.  
  188. VOID IndirectIOCommand_MOVE_ATTR(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  189. {
  190.     pParserTempData->IndirectData &= ~((0xFFFFFFFF >> (32-pParserTempData->IndirectIOTablePointer[1])) << pParserTempData->IndirectIOTablePointer[3]);
  191.     pParserTempData->IndirectData |=(((pParserTempData->AttributesData >> pParserTempData->IndirectIOTablePointer[2])
  192.                                       & (0xFFFFFFFF >> (32-pParserTempData->IndirectIOTablePointer[1]))) << pParserTempData->IndirectIOTablePointer[3]);
  193. }
  194.  
  195. VOID IndirectIOCommand_MOVE_DATA(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  196. {
  197.     pParserTempData->IndirectData &= ~((0xFFFFFFFF >> (32-pParserTempData->IndirectIOTablePointer[1])) << pParserTempData->IndirectIOTablePointer[3]);
  198.     pParserTempData->IndirectData |=(((pParserTempData->DestData32 >> pParserTempData->IndirectIOTablePointer[2])
  199.                                       & (0xFFFFFFFF >> (32-pParserTempData->IndirectIOTablePointer[1]))) << pParserTempData->IndirectIOTablePointer[3]);
  200. }
  201.  
  202.  
  203. VOID IndirectIOCommand_SET(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  204. {
  205.     pParserTempData->IndirectData |= ((0xFFFFFFFF >> (32-pParserTempData->IndirectIOTablePointer[1])) << pParserTempData->IndirectIOTablePointer[2]);
  206. }
  207.  
  208. VOID IndirectIOCommand_CLEAR(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  209. {
  210.     pParserTempData->IndirectData &= ~((0xFFFFFFFF >> (32-pParserTempData->IndirectIOTablePointer[1])) << pParserTempData->IndirectIOTablePointer[2]);
  211. }
  212.  
  213.  
  214. UINT32 IndirectInputOutput(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  215. {
  216.     // if ((pParserTempData->IndirectData & 0x7f)==INDIRECT_IO_MM) pParserTempData->IndirectData|=pParserTempData->CurrentPortID;
  217. //  pParserTempData->IndirectIOTablePointer=pParserTempData->IndirectIOTable;
  218.     while (*pParserTempData->IndirectIOTablePointer)
  219.     {
  220.         if ((pParserTempData->IndirectIOTablePointer[0] == INDIRECTIO_ID) &&
  221.             (pParserTempData->IndirectIOTablePointer[1] == pParserTempData->IndirectData))
  222.         {
  223.             pParserTempData->IndirectIOTablePointer+=IndirectIOParserCommands[*pParserTempData->IndirectIOTablePointer].csize;
  224.             while (*pParserTempData->IndirectIOTablePointer != INDIRECTIO_END_OF_ID)
  225.             {
  226.                 IndirectIOParserCommands[*pParserTempData->IndirectIOTablePointer].func(pParserTempData);
  227.                 pParserTempData->IndirectIOTablePointer+=IndirectIOParserCommands[*pParserTempData->IndirectIOTablePointer].csize;
  228.             }
  229.             pParserTempData->IndirectIOTablePointer-=*(UINT16*)(pParserTempData->IndirectIOTablePointer+1);
  230.             pParserTempData->IndirectIOTablePointer++;
  231.             return pParserTempData->IndirectData;
  232.         } else pParserTempData->IndirectIOTablePointer+=IndirectIOParserCommands[*pParserTempData->IndirectIOTablePointer].csize;
  233.     }
  234.     return 0;
  235. }
  236.  
  237.  
  238.  
  239. VOID PutDataRegister(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  240. {
  241.     pParserTempData->Index=(UINT32)pParserTempData->pCmd->Parameters.WordXX.PA_Destination;
  242.     pParserTempData->Index+=pParserTempData->CurrentRegBlock;
  243.     switch(pParserTempData->Multipurpose.CurrentPort){
  244.         case ATI_RegsPort:
  245.             if (pParserTempData->CurrentPortID == INDIRECT_IO_MM)
  246.             {
  247.                 if (pParserTempData->Index==0) pParserTempData->DestData32 <<= 2;
  248.                 WriteReg32( pParserTempData);
  249.             } else
  250.             {
  251.                 pParserTempData->IndirectData=pParserTempData->CurrentPortID+INDIRECT_IO_WRITE;
  252.                 IndirectInputOutput(pParserTempData);
  253.             }
  254.             break;
  255.         case PCI_Port:
  256.             WritePCIFunctions[pParserTempData->pCmd->Header.Attribute.SourceAlignment](pParserTempData);
  257.             break;
  258.         case SystemIO_Port:
  259.             WriteIOFunctions[pParserTempData->pCmd->Header.Attribute.SourceAlignment](pParserTempData);
  260.             break;
  261.     }
  262. }
  263.  
  264. VOID PutDataPS(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  265. {
  266.     *(pParserTempData->pDeviceData->pParameterSpace+pParserTempData->pCmd->Parameters.ByteXX.PA_Destination)=
  267.         pParserTempData->DestData32;
  268. }
  269.  
  270. VOID PutDataWS(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  271. {
  272.     if (pParserTempData->pCmd->Parameters.ByteXX.PA_Destination < WS_QUOTIENT_C)
  273.         *(pParserTempData->pWorkingTableData->pWorkSpace+pParserTempData->pCmd->Parameters.ByteXX.PA_Destination) = pParserTempData->DestData32;
  274.     else
  275.         switch (pParserTempData->pCmd->Parameters.ByteXX.PA_Destination)
  276.         {
  277.             case WS_REMINDER_C:
  278.                 pParserTempData->MultiplicationOrDivision.Division.Reminder32=pParserTempData->DestData32;
  279.                 break;
  280.             case WS_QUOTIENT_C:
  281.                 pParserTempData->MultiplicationOrDivision.Division.Quotient32=pParserTempData->DestData32;
  282.                 break;
  283.             case WS_DATAPTR_C:
  284. #ifndef         UEFI_BUILD
  285.                 pParserTempData->CurrentDataBlock=(UINT16)pParserTempData->DestData32;
  286. #else
  287.                 pParserTempData->CurrentDataBlock=(UINTN)pParserTempData->DestData32;
  288. #endif
  289.                 break;
  290.             case WS_SHIFT_C:
  291.                 pParserTempData->Shift2MaskConverter=(UINT8)pParserTempData->DestData32;
  292.                 break;
  293.             case WS_FB_WINDOW_C:
  294.                 pParserTempData->CurrentFB_Window=pParserTempData->DestData32;
  295.                 break;
  296.             case WS_ATTRIBUTES_C:
  297.                 pParserTempData->AttributesData=(UINT16)pParserTempData->DestData32;
  298.                 break;
  299.         }
  300.  
  301. }
  302.  
  303. VOID PutDataFB(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  304. {
  305.     pParserTempData->Index=(UINT32)pParserTempData->pCmd->Parameters.ByteXX.PA_Destination;
  306.     //Make an Index from address first, then add to the Index
  307.     pParserTempData->Index+=(pParserTempData->CurrentFB_Window>>2);
  308.     WriteFrameBuffer32(pParserTempData);
  309. }
  310.  
  311. VOID PutDataPLL(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  312. {
  313.     pParserTempData->Index=(UINT32)pParserTempData->pCmd->Parameters.ByteXX.PA_Destination;
  314.     WritePLL32( pParserTempData );
  315. }
  316.  
  317. VOID PutDataMC(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  318. {
  319.     pParserTempData->Index=(UINT32)pParserTempData->pCmd->Parameters.ByteXX.PA_Destination;
  320.     WriteMC32( pParserTempData );
  321. }
  322.  
  323.  
  324. VOID SkipParameters8(PARSER_TEMP_DATA STACK_BASED *     pParserTempData)
  325. {
  326.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT8);
  327. }
  328.  
  329. VOID SkipParameters16(PARSER_TEMP_DATA STACK_BASED *    pParserTempData)
  330. {
  331.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT16);
  332. }
  333.  
  334.  
  335. UINT32 GetParametersRegister(PARSER_TEMP_DATA STACK_BASED *     pParserTempData)
  336. {
  337.     pParserTempData->Index=*(UINT16*)pParserTempData->pWorkingTableData->IP;
  338.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT16);
  339.     pParserTempData->Index+=pParserTempData->CurrentRegBlock;
  340.     switch(pParserTempData->Multipurpose.CurrentPort)
  341.     {
  342.         case PCI_Port:
  343.             return ReadPCIFunctions[pParserTempData->pCmd->Header.Attribute.SourceAlignment](pParserTempData);
  344.         case SystemIO_Port:
  345.             return ReadIOFunctions[pParserTempData->pCmd->Header.Attribute.SourceAlignment](pParserTempData);
  346.         case ATI_RegsPort:
  347.         default:
  348.             if (pParserTempData->CurrentPortID == INDIRECT_IO_MM) return ReadReg32( pParserTempData );
  349.             else
  350.             {
  351.                 pParserTempData->IndirectData=pParserTempData->CurrentPortID+INDIRECT_IO_READ;
  352.                 return IndirectInputOutput(pParserTempData);
  353.             }
  354.     }
  355. }
  356.  
  357. UINT32 GetParametersPS(PARSER_TEMP_DATA STACK_BASED *   pParserTempData)
  358. {
  359.     pParserTempData->Index=*pParserTempData->pWorkingTableData->IP;
  360.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT8);
  361.     return *(pParserTempData->pDeviceData->pParameterSpace+pParserTempData->Index);
  362. }
  363.  
  364. UINT32 GetParametersWS(PARSER_TEMP_DATA STACK_BASED *   pParserTempData)
  365. {
  366.     pParserTempData->Index=*pParserTempData->pWorkingTableData->IP;
  367.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT8);
  368.     if (pParserTempData->Index < WS_QUOTIENT_C)
  369.         return *(pParserTempData->pWorkingTableData->pWorkSpace+pParserTempData->Index);
  370.     else
  371.         switch (pParserTempData->Index)
  372.         {
  373.             case WS_REMINDER_C:
  374.                 return pParserTempData->MultiplicationOrDivision.Division.Reminder32;
  375.             case WS_QUOTIENT_C:
  376.                 return pParserTempData->MultiplicationOrDivision.Division.Quotient32;
  377.             case WS_DATAPTR_C:
  378.                 return (UINT32)pParserTempData->CurrentDataBlock;
  379.             case WS_OR_MASK_C:
  380.                 return ((UINT32)1) << pParserTempData->Shift2MaskConverter;
  381.             case WS_AND_MASK_C:
  382.                 return ~(((UINT32)1) << pParserTempData->Shift2MaskConverter);
  383.             case WS_FB_WINDOW_C:
  384.                 return pParserTempData->CurrentFB_Window;
  385.             case WS_ATTRIBUTES_C:
  386.                 return pParserTempData->AttributesData;
  387.         }
  388.     return 0;
  389.  
  390. }
  391.  
  392. UINT32 GetParametersFB(PARSER_TEMP_DATA STACK_BASED *   pParserTempData)
  393. {
  394.     pParserTempData->Index=*pParserTempData->pWorkingTableData->IP;
  395.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT8);
  396.     pParserTempData->Index+=(pParserTempData->CurrentFB_Window>>2);
  397.     return ReadFrameBuffer32(pParserTempData);
  398. }
  399.  
  400. UINT32 GetParametersPLL(PARSER_TEMP_DATA STACK_BASED *  pParserTempData)
  401. {
  402.     pParserTempData->Index=*pParserTempData->pWorkingTableData->IP;
  403.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT8);
  404.     return ReadPLL32( pParserTempData );
  405. }
  406.  
  407. UINT32 GetParametersMC(PARSER_TEMP_DATA STACK_BASED *   pParserTempData)
  408. {
  409.     pParserTempData->Index=*pParserTempData->pWorkingTableData->IP;
  410.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT8);
  411.     return ReadMC32( pParserTempData );
  412. }
  413.  
  414.  
  415. UINT32 GetParametersIndirect(PARSER_TEMP_DATA STACK_BASED *     pParserTempData)
  416. {
  417.     pParserTempData->Index=*(UINT16*)pParserTempData->pWorkingTableData->IP;
  418.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT16);
  419.     return *(UINT32*)(RELATIVE_TO_BIOS_IMAGE(pParserTempData->Index)+pParserTempData->CurrentDataBlock);
  420. }
  421.  
  422. UINT32 GetParametersDirect8(PARSER_TEMP_DATA STACK_BASED *      pParserTempData)
  423. {
  424.     pParserTempData->CD_Mask.SrcAlignment=alignmentByte0;
  425.     pParserTempData->Index=*(UINT8*)pParserTempData->pWorkingTableData->IP;
  426.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT8);
  427.     return pParserTempData->Index;
  428. }
  429.  
  430. UINT32 GetParametersDirect16(PARSER_TEMP_DATA STACK_BASED *     pParserTempData)
  431. {
  432.     pParserTempData->CD_Mask.SrcAlignment=alignmentLowerWord;
  433.     pParserTempData->Index=*(UINT16*)pParserTempData->pWorkingTableData->IP;
  434.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT16);
  435.     return pParserTempData->Index;
  436. }
  437.  
  438. UINT32 GetParametersDirect32(PARSER_TEMP_DATA STACK_BASED *     pParserTempData)
  439. {
  440.     pParserTempData->CD_Mask.SrcAlignment=alignmentDword;
  441.     pParserTempData->Index=*(UINT32*)pParserTempData->pWorkingTableData->IP;
  442.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT32);
  443.     return pParserTempData->Index;
  444. }
  445.  
  446.  
  447. UINT32 GetParametersDirect(PARSER_TEMP_DATA STACK_BASED *       pParserTempData)
  448. {
  449.     return GetParametersDirectArray[pParserTempData->pCmd->Header.Attribute.SourceAlignment](pParserTempData);
  450. }
  451.  
  452.  
  453. VOID CommonSourceDataTransformation(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  454. {
  455.     pParserTempData->SourceData32 >>= SourceAlignmentShift[pParserTempData->CD_Mask.SrcAlignment];
  456.     pParserTempData->SourceData32 &=  AlignmentMask[pParserTempData->CD_Mask.SrcAlignment];
  457.     pParserTempData->SourceData32 <<= DestinationAlignmentShift[pParserTempData->CD_Mask.DestAlignment];
  458. }
  459.  
  460. VOID CommonOperationDataTransformation(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  461. {
  462.     pParserTempData->SourceData32 >>= SourceAlignmentShift[pParserTempData->CD_Mask.SrcAlignment];
  463.     pParserTempData->SourceData32 &= AlignmentMask[pParserTempData->CD_Mask.SrcAlignment];
  464.     pParserTempData->DestData32   >>= DestinationAlignmentShift[pParserTempData->CD_Mask.DestAlignment];
  465.     pParserTempData->DestData32   &= AlignmentMask[pParserTempData->CD_Mask.SrcAlignment];
  466. }
  467.  
  468. VOID ProcessMove(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  469. {
  470.     if (pParserTempData->CD_Mask.SrcAlignment!=alignmentDword)
  471.     {
  472.         pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  473.     } else
  474.     {
  475.         SkipDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  476.     }
  477.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  478.  
  479.     if (pParserTempData->CD_Mask.SrcAlignment!=alignmentDword)
  480.     {
  481.         pParserTempData->DestData32 &= ~(AlignmentMask[pParserTempData->CD_Mask.SrcAlignment] << DestinationAlignmentShift[pParserTempData->CD_Mask.DestAlignment]);
  482.         CommonSourceDataTransformation(pParserTempData);
  483.         pParserTempData->DestData32 |= pParserTempData->SourceData32;
  484.     } else
  485.     {
  486.         pParserTempData->DestData32=pParserTempData->SourceData32;
  487.     }
  488.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  489. }
  490.  
  491. VOID ProcessMask(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  492. {
  493.  
  494.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  495.     pParserTempData->SourceData32=GetParametersDirect(pParserTempData);
  496.     pParserTempData->Index=GetParametersDirect(pParserTempData);
  497.     pParserTempData->SourceData32 <<= DestinationAlignmentShift[pParserTempData->CD_Mask.DestAlignment];
  498.     pParserTempData->SourceData32 |= ~(AlignmentMask[pParserTempData->CD_Mask.SrcAlignment] << DestinationAlignmentShift[pParserTempData->CD_Mask.DestAlignment]);
  499.     pParserTempData->DestData32   &= pParserTempData->SourceData32;
  500.     pParserTempData->Index        &= AlignmentMask[pParserTempData->CD_Mask.SrcAlignment];
  501.     pParserTempData->Index        <<= DestinationAlignmentShift[pParserTempData->CD_Mask.DestAlignment];
  502.     pParserTempData->DestData32   |= pParserTempData->Index;
  503.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  504. }
  505.  
  506. VOID ProcessAnd(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  507. {
  508.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  509.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  510.     pParserTempData->SourceData32 >>= SourceAlignmentShift[pParserTempData->CD_Mask.SrcAlignment];
  511.     pParserTempData->SourceData32 <<= DestinationAlignmentShift[pParserTempData->CD_Mask.DestAlignment];
  512.     pParserTempData->SourceData32 |= ~(AlignmentMask[pParserTempData->CD_Mask.SrcAlignment] << DestinationAlignmentShift[pParserTempData->CD_Mask.DestAlignment]);
  513.     pParserTempData->DestData32   &= pParserTempData->SourceData32;
  514.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  515. }
  516.  
  517. VOID ProcessOr(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  518. {
  519.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  520.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  521.     CommonSourceDataTransformation(pParserTempData);
  522.     pParserTempData->DestData32 |= pParserTempData->SourceData32;
  523.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  524. }
  525.  
  526. VOID ProcessXor(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  527. {
  528.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  529.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  530.     CommonSourceDataTransformation(pParserTempData);
  531.     pParserTempData->DestData32 ^= pParserTempData->SourceData32;
  532.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  533. }
  534.  
  535. VOID ProcessShl(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  536. {
  537.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  538.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  539.     CommonSourceDataTransformation(pParserTempData);
  540.     pParserTempData->DestData32 <<= pParserTempData->SourceData32;
  541.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  542. }
  543.  
  544. VOID ProcessShr(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  545. {
  546.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  547.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  548.     CommonSourceDataTransformation(pParserTempData);
  549.     pParserTempData->DestData32 >>= pParserTempData->SourceData32;
  550.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  551. }
  552.  
  553.  
  554. VOID ProcessADD(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  555. {
  556.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  557.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  558.     CommonSourceDataTransformation(pParserTempData);
  559.     pParserTempData->DestData32 += pParserTempData->SourceData32;
  560.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  561. }
  562.  
  563. VOID ProcessSUB(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  564. {
  565.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  566.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  567.     CommonSourceDataTransformation(pParserTempData);
  568.     pParserTempData->DestData32 -= pParserTempData->SourceData32;
  569.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  570. }
  571.  
  572. VOID ProcessMUL(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  573. {
  574.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  575.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  576.     CommonOperationDataTransformation(pParserTempData);
  577.     pParserTempData->MultiplicationOrDivision.Multiplication.Low32Bit=pParserTempData->DestData32 * pParserTempData->SourceData32;
  578. }
  579.  
  580. VOID ProcessDIV(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  581. {
  582.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  583.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  584.  
  585.     CommonOperationDataTransformation(pParserTempData);
  586.     pParserTempData->MultiplicationOrDivision.Division.Quotient32=
  587.         pParserTempData->DestData32 / pParserTempData->SourceData32;
  588.     pParserTempData->MultiplicationOrDivision.Division.Reminder32=
  589.         pParserTempData->DestData32 % pParserTempData->SourceData32;
  590. }
  591.  
  592.  
  593. VOID ProcessCompare(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  594. {
  595.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  596.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  597.  
  598.     CommonOperationDataTransformation(pParserTempData);
  599.  
  600.     // Here we just set flags based on evaluation
  601.     if (pParserTempData->DestData32==pParserTempData->SourceData32)
  602.         pParserTempData->CompareFlags = Equal;
  603.     else
  604.         pParserTempData->CompareFlags =
  605.             (UINT8)((pParserTempData->DestData32<pParserTempData->SourceData32) ? Below : Above);
  606.  
  607. }
  608.  
  609. VOID ProcessClear(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  610. {
  611.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  612.     pParserTempData->DestData32 &= ~(AlignmentMask[pParserTempData->CD_Mask.SrcAlignment] << SourceAlignmentShift[pParserTempData->CD_Mask.SrcAlignment]);
  613.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  614.  
  615. }
  616.  
  617. VOID ProcessShift(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  618. {
  619.     UINT32 mask = AlignmentMask[pParserTempData->CD_Mask.SrcAlignment] << SourceAlignmentShift[pParserTempData->CD_Mask.SrcAlignment];
  620.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  621.     pParserTempData->SourceData32=GetParametersDirect8(pParserTempData);
  622.  
  623.     // save original value of the destination
  624.     pParserTempData->Index = pParserTempData->DestData32 & ~mask;
  625.     pParserTempData->DestData32 &= mask;
  626.  
  627.     if (pParserTempData->pCmd->Header.Opcode < SHIFT_RIGHT_REG_OPCODE)
  628.         pParserTempData->DestData32 <<= pParserTempData->SourceData32; else
  629.             pParserTempData->DestData32 >>= pParserTempData->SourceData32;
  630.  
  631.     // Clear any bits shifted out of masked area...
  632.     pParserTempData->DestData32 &= mask;
  633.     // ... and restore the area outside of masked with original values
  634.     pParserTempData->DestData32 |= pParserTempData->Index;
  635.  
  636.     // write data back
  637.     PutDataFunctions[pParserTempData->ParametersType.Destination](pParserTempData);
  638. }
  639.  
  640. VOID ProcessTest(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  641. {
  642.     pParserTempData->DestData32=GetDestination[pParserTempData->ParametersType.Destination](pParserTempData);
  643.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  644.     CommonOperationDataTransformation(pParserTempData);
  645.     pParserTempData->CompareFlags =
  646.         (UINT8)((pParserTempData->DestData32 & pParserTempData->SourceData32) ? NotEqual : Equal);
  647.  
  648. }
  649.  
  650. VOID ProcessSetFB_Base(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  651. {
  652.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  653.     pParserTempData->SourceData32 >>= SourceAlignmentShift[pParserTempData->CD_Mask.SrcAlignment];
  654.     pParserTempData->SourceData32 &= AlignmentMask[pParserTempData->CD_Mask.SrcAlignment];
  655.     pParserTempData->CurrentFB_Window=pParserTempData->SourceData32;
  656. }
  657.  
  658. VOID ProcessSwitch(PARSER_TEMP_DATA STACK_BASED * pParserTempData){
  659.     pParserTempData->SourceData32=GetSource[pParserTempData->ParametersType.Source](pParserTempData);
  660.     pParserTempData->SourceData32 >>= SourceAlignmentShift[pParserTempData->CD_Mask.SrcAlignment];
  661.     pParserTempData->SourceData32 &= AlignmentMask[pParserTempData->CD_Mask.SrcAlignment];
  662.     while ( *(UINT16*)pParserTempData->pWorkingTableData->IP != (((UINT16)NOP_OPCODE << 8)+NOP_OPCODE))
  663.     {
  664.         if (*pParserTempData->pWorkingTableData->IP == 'c')
  665.         {
  666.             pParserTempData->pWorkingTableData->IP++;
  667.             pParserTempData->DestData32=GetParametersDirect(pParserTempData);
  668.             pParserTempData->Index=GetParametersDirect16(pParserTempData);
  669.             if (pParserTempData->SourceData32 == pParserTempData->DestData32)
  670.             {
  671.                 pParserTempData->pWorkingTableData->IP= RELATIVE_TO_TABLE(pParserTempData->Index);
  672.                 return;
  673.             }
  674.         }
  675.     }
  676.     pParserTempData->pWorkingTableData->IP+=sizeof(UINT16);
  677. }
  678.  
  679.  
  680. VOID    cmdSetDataBlock(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  681. {
  682.     UINT8 value;
  683.     UINT16* pMasterDataTable;
  684.     value=((COMMAND_TYPE_1*)pParserTempData->pWorkingTableData->IP)->Parameters.ByteXX.PA_Destination;
  685.     if (value == 0) pParserTempData->CurrentDataBlock=0; else
  686.     {
  687.         if (value == DB_CURRENT_COMMAND_TABLE)
  688.         {
  689.             pParserTempData->CurrentDataBlock= (UINT16)(pParserTempData->pWorkingTableData->pTableHead-pParserTempData->pDeviceData->pBIOS_Image);
  690.         } else
  691.         {
  692.             pMasterDataTable = GetDataMasterTablePointer(pParserTempData->pDeviceData);
  693.             pParserTempData->CurrentDataBlock= (TABLE_UNIT_TYPE)((PTABLE_UNIT_TYPE)pMasterDataTable)[value];
  694.         }
  695.     }
  696.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_VALUE_BYTE);
  697. }
  698.  
  699. VOID    cmdSet_ATI_Port(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  700. {
  701.     pParserTempData->Multipurpose.CurrentPort=ATI_RegsPort;
  702.     pParserTempData->CurrentPortID = (UINT8)((COMMAND_TYPE_1*)pParserTempData->pWorkingTableData->IP)->Parameters.WordXX.PA_Destination;
  703.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_OFFSET16);
  704. }
  705.  
  706. VOID    cmdSet_Reg_Block(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  707. {
  708.     pParserTempData->CurrentRegBlock = ((COMMAND_TYPE_1*)pParserTempData->pWorkingTableData->IP)->Parameters.WordXX.PA_Destination;
  709.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_OFFSET16);
  710. }
  711.  
  712.  
  713. //Atavism!!! Review!!!
  714. VOID    cmdSet_X_Port(PARSER_TEMP_DATA STACK_BASED * pParserTempData){
  715.     pParserTempData->Multipurpose.CurrentPort=pParserTempData->ParametersType.Destination;
  716.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_ONLY);
  717.  
  718. }
  719.  
  720. VOID    cmdDelay_Millisec(PARSER_TEMP_DATA STACK_BASED * pParserTempData){
  721.     pParserTempData->SourceData32 =
  722.         ((COMMAND_TYPE_1*)pParserTempData->pWorkingTableData->IP)->Parameters.ByteXX.PA_Destination;
  723.     DelayMilliseconds(pParserTempData);
  724.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_VALUE_BYTE);
  725. }
  726. VOID    cmdDelay_Microsec(PARSER_TEMP_DATA STACK_BASED * pParserTempData){
  727.     pParserTempData->SourceData32 =
  728.         ((COMMAND_TYPE_1*)pParserTempData->pWorkingTableData->IP)->Parameters.ByteXX.PA_Destination;
  729.     DelayMicroseconds(pParserTempData);
  730.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_VALUE_BYTE);
  731. }
  732.  
  733. VOID ProcessPostChar(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  734. {
  735.     pParserTempData->SourceData32 =
  736.         ((COMMAND_TYPE_1*)pParserTempData->pWorkingTableData->IP)->Parameters.ByteXX.PA_Destination;
  737.     PostCharOutput(pParserTempData);
  738.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_VALUE_BYTE);
  739. }
  740.  
  741. VOID ProcessDebug(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  742. {
  743.     pParserTempData->SourceData32 =
  744.         ((COMMAND_TYPE_1*)pParserTempData->pWorkingTableData->IP)->Parameters.ByteXX.PA_Destination;
  745.     CallerDebugFunc(pParserTempData);
  746.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_VALUE_BYTE);
  747. }
  748.  
  749.  
  750. VOID ProcessDS(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  751. {
  752.     pParserTempData->pWorkingTableData->IP+=((COMMAND_TYPE_1*)pParserTempData->pWorkingTableData->IP)->Parameters.WordXX.PA_Destination+sizeof(COMMAND_TYPE_OPCODE_OFFSET16);
  753. }
  754.  
  755.  
  756. VOID    cmdCall_Table(PARSER_TEMP_DATA STACK_BASED * pParserTempData){
  757.     UINT16*     MasterTableOffset;
  758.     pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_VALUE_BYTE);
  759.     MasterTableOffset = GetCommandMasterTablePointer(pParserTempData->pDeviceData);
  760.     if(((PTABLE_UNIT_TYPE)MasterTableOffset)[((COMMAND_TYPE_OPCODE_VALUE_BYTE*)pParserTempData->pCmd)->Value]!=0 )  // if the offset is not ZERO
  761.     {
  762.         pParserTempData->CommandSpecific.IndexInMasterTable=GetTrueIndexInMasterTable(pParserTempData,((COMMAND_TYPE_OPCODE_VALUE_BYTE*)pParserTempData->pCmd)->Value);
  763.         pParserTempData->Multipurpose.PS_SizeInDwordsUsedByCallingTable =
  764.             (((ATOM_COMMON_ROM_COMMAND_TABLE_HEADER *)pParserTempData->pWorkingTableData->pTableHead)->TableAttribute.PS_SizeInBytes>>2);
  765.         pParserTempData->pDeviceData->pParameterSpace+=
  766.             pParserTempData->Multipurpose.PS_SizeInDwordsUsedByCallingTable;
  767.         pParserTempData->Status=CD_CALL_TABLE;
  768.         pParserTempData->pCmd=(GENERIC_ATTRIBUTE_COMMAND*)MasterTableOffset;
  769.     }
  770. }
  771.  
  772.  
  773. VOID    cmdNOP_(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  774. {
  775. }
  776.  
  777.  
  778. static VOID NotImplemented(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  779. {
  780.     pParserTempData->Status = CD_NOT_IMPLEMENTED;
  781. }
  782.  
  783.  
  784. VOID ProcessJump(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  785. {
  786.     if ((pParserTempData->ParametersType.Destination == NoCondition) ||
  787.         (pParserTempData->ParametersType.Destination == pParserTempData->CompareFlags ))
  788.     {
  789.  
  790.         pParserTempData->pWorkingTableData->IP= RELATIVE_TO_TABLE(((COMMAND_TYPE_OPCODE_OFFSET16*)pParserTempData->pWorkingTableData->IP)->CD_Offset16);
  791.     } else
  792.     {
  793.         pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_OFFSET16);
  794.     }
  795. }
  796.  
  797. VOID ProcessJumpE(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  798. {
  799.     if ((pParserTempData->CompareFlags == Equal) ||
  800.         (pParserTempData->CompareFlags == pParserTempData->ParametersType.Destination))
  801.     {
  802.  
  803.         pParserTempData->pWorkingTableData->IP= RELATIVE_TO_TABLE(((COMMAND_TYPE_OPCODE_OFFSET16*)pParserTempData->pWorkingTableData->IP)->CD_Offset16);
  804.     } else
  805.     {
  806.         pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_OFFSET16);
  807.     }
  808. }
  809.  
  810. VOID ProcessJumpNE(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
  811. {
  812.     if (pParserTempData->CompareFlags != Equal)
  813.     {
  814.  
  815.         pParserTempData->pWorkingTableData->IP= RELATIVE_TO_TABLE(((COMMAND_TYPE_OPCODE_OFFSET16*)pParserTempData->pWorkingTableData->IP)->CD_Offset16);
  816.     } else
  817.     {
  818.         pParserTempData->pWorkingTableData->IP+=sizeof(COMMAND_TYPE_OPCODE_OFFSET16);
  819.     }
  820. }
  821.  
  822.  
  823.  
  824. COMMANDS_PROPERTIES CallTable[] =
  825. {
  826.     { NULL, 0,0},
  827.     { ProcessMove,      destRegister,     sizeof(COMMAND_HEADER)},
  828.     { ProcessMove,      destParamSpace,   sizeof(COMMAND_HEADER)},
  829.     { ProcessMove,      destWorkSpace,    sizeof(COMMAND_HEADER)},
  830.     { ProcessMove,      destFrameBuffer,  sizeof(COMMAND_HEADER)},
  831.     { ProcessMove,      destPLL,          sizeof(COMMAND_HEADER)},
  832.     { ProcessMove,      destMC,           sizeof(COMMAND_HEADER)},
  833.     { ProcessAnd,       destRegister,     sizeof(COMMAND_HEADER)},
  834.     { ProcessAnd,       destParamSpace,   sizeof(COMMAND_HEADER)},
  835.     { ProcessAnd,       destWorkSpace,    sizeof(COMMAND_HEADER)},
  836.     { ProcessAnd,       destFrameBuffer,  sizeof(COMMAND_HEADER)},
  837.     { ProcessAnd,       destPLL,          sizeof(COMMAND_HEADER)},
  838.     { ProcessAnd,       destMC,           sizeof(COMMAND_HEADER)},
  839.     { ProcessOr,        destRegister,     sizeof(COMMAND_HEADER)},
  840.     { ProcessOr,        destParamSpace,   sizeof(COMMAND_HEADER)},
  841.     { ProcessOr,        destWorkSpace,    sizeof(COMMAND_HEADER)},
  842.     { ProcessOr,        destFrameBuffer,  sizeof(COMMAND_HEADER)},
  843.     { ProcessOr,        destPLL,          sizeof(COMMAND_HEADER)},
  844.     { ProcessOr,        destMC,           sizeof(COMMAND_HEADER)},
  845.     { ProcessShift,     destRegister,     sizeof(COMMAND_HEADER)},
  846.     { ProcessShift,     destParamSpace,   sizeof(COMMAND_HEADER)},
  847.     { ProcessShift,     destWorkSpace,    sizeof(COMMAND_HEADER)},
  848.     { ProcessShift,     destFrameBuffer,  sizeof(COMMAND_HEADER)},
  849.     { ProcessShift,     destPLL,          sizeof(COMMAND_HEADER)},
  850.     { ProcessShift,     destMC,           sizeof(COMMAND_HEADER)},
  851.     { ProcessShift,     destRegister,     sizeof(COMMAND_HEADER)},
  852.     { ProcessShift,     destParamSpace,   sizeof(COMMAND_HEADER)},
  853.     { ProcessShift,     destWorkSpace,    sizeof(COMMAND_HEADER)},
  854.     { ProcessShift,     destFrameBuffer,  sizeof(COMMAND_HEADER)},
  855.     { ProcessShift,     destPLL,          sizeof(COMMAND_HEADER)},
  856.     { ProcessShift,     destMC,           sizeof(COMMAND_HEADER)},
  857.     { ProcessMUL,       destRegister,     sizeof(COMMAND_HEADER)},
  858.     { ProcessMUL,       destParamSpace,   sizeof(COMMAND_HEADER)},
  859.     { ProcessMUL,       destWorkSpace,    sizeof(COMMAND_HEADER)},
  860.     { ProcessMUL,       destFrameBuffer,  sizeof(COMMAND_HEADER)},
  861.     { ProcessMUL,       destPLL,          sizeof(COMMAND_HEADER)},
  862.     { ProcessMUL,       destMC,           sizeof(COMMAND_HEADER)},
  863.     { ProcessDIV,       destRegister,     sizeof(COMMAND_HEADER)},
  864.     { ProcessDIV,       destParamSpace,   sizeof(COMMAND_HEADER)},
  865.     { ProcessDIV,       destWorkSpace,    sizeof(COMMAND_HEADER)},
  866.     { ProcessDIV,       destFrameBuffer,  sizeof(COMMAND_HEADER)},
  867.     { ProcessDIV,       destPLL,          sizeof(COMMAND_HEADER)},
  868.     { ProcessDIV,       destMC,           sizeof(COMMAND_HEADER)},
  869.     { ProcessADD,       destRegister,     sizeof(COMMAND_HEADER)},
  870.     { ProcessADD,       destParamSpace,   sizeof(COMMAND_HEADER)},
  871.     { ProcessADD,       destWorkSpace,    sizeof(COMMAND_HEADER)},
  872.     { ProcessADD,       destFrameBuffer,  sizeof(COMMAND_HEADER)},
  873.     { ProcessADD,       destPLL,          sizeof(COMMAND_HEADER)},
  874.     { ProcessADD,       destMC,           sizeof(COMMAND_HEADER)},
  875.     { ProcessSUB,       destRegister,     sizeof(COMMAND_HEADER)},
  876.     { ProcessSUB,       destParamSpace,   sizeof(COMMAND_HEADER)},
  877.     { ProcessSUB,       destWorkSpace,    sizeof(COMMAND_HEADER)},
  878.     { ProcessSUB,       destFrameBuffer,  sizeof(COMMAND_HEADER)},
  879.     { ProcessSUB,       destPLL,          sizeof(COMMAND_HEADER)},
  880.     { ProcessSUB,       destMC,           sizeof(COMMAND_HEADER)},
  881.     { cmdSet_ATI_Port,  ATI_RegsPort,     0},
  882.     { cmdSet_X_Port,    PCI_Port,         0},
  883.     { cmdSet_X_Port,    SystemIO_Port,    0},
  884.     { cmdSet_Reg_Block, 0,                0},
  885.     { ProcessSetFB_Base,0,                sizeof(COMMAND_HEADER)},
  886.     { ProcessCompare,   destRegister,     sizeof(COMMAND_HEADER)},
  887.     { ProcessCompare,   destParamSpace,   sizeof(COMMAND_HEADER)},
  888.     { ProcessCompare,   destWorkSpace,    sizeof(COMMAND_HEADER)},
  889.     { ProcessCompare,   destFrameBuffer,  sizeof(COMMAND_HEADER)},
  890.     { ProcessCompare,   destPLL,          sizeof(COMMAND_HEADER)},
  891.     { ProcessCompare,   destMC,           sizeof(COMMAND_HEADER)},
  892.     { ProcessSwitch,    0,                      sizeof(COMMAND_HEADER)},
  893.     { ProcessJump,                      NoCondition,      0},
  894.     { ProcessJump,          Equal,            0},
  895.     { ProcessJump,      Below,            0},
  896.     { ProcessJump,      Above,            0},
  897.     { ProcessJumpE,     Below,            0},
  898.     { ProcessJumpE,     Above,            0},
  899.     { ProcessJumpNE,            0,                0},
  900.     { ProcessTest,      destRegister,     sizeof(COMMAND_HEADER)},
  901.     { ProcessTest,      destParamSpace,   sizeof(COMMAND_HEADER)},
  902.     { ProcessTest,      destWorkSpace,    sizeof(COMMAND_HEADER)},
  903.     { ProcessTest,      destFrameBuffer,  sizeof(COMMAND_HEADER)},
  904.     { ProcessTest,      destPLL,          sizeof(COMMAND_HEADER)},
  905.     { ProcessTest,      destMC,           sizeof(COMMAND_HEADER)},
  906.     { cmdDelay_Millisec,0,                0},
  907.     { cmdDelay_Microsec,0,                0},
  908.     { cmdCall_Table,            0,                0},
  909.     /*cmdRepeat*/           { NotImplemented,   0,                0},
  910.     { ProcessClear,     destRegister,     sizeof(COMMAND_HEADER)},
  911.     { ProcessClear,     destParamSpace,   sizeof(COMMAND_HEADER)},
  912.     { ProcessClear,     destWorkSpace,    sizeof(COMMAND_HEADER)},
  913.     { ProcessClear,     destFrameBuffer,  sizeof(COMMAND_HEADER)},
  914.     { ProcessClear,     destPLL,          sizeof(COMMAND_HEADER)},
  915.     { ProcessClear,     destMC,           sizeof(COMMAND_HEADER)},
  916.     { cmdNOP_,                0,                sizeof(COMMAND_TYPE_OPCODE_ONLY)},
  917.     /*cmdEOT*/        { cmdNOP_,                      0,                sizeof(COMMAND_TYPE_OPCODE_ONLY)},
  918.     { ProcessMask,      destRegister,     sizeof(COMMAND_HEADER)},
  919.     { ProcessMask,      destParamSpace,   sizeof(COMMAND_HEADER)},
  920.     { ProcessMask,      destWorkSpace,    sizeof(COMMAND_HEADER)},
  921.     { ProcessMask,      destFrameBuffer,  sizeof(COMMAND_HEADER)},
  922.     { ProcessMask,      destPLL,          sizeof(COMMAND_HEADER)},
  923.     { ProcessMask,      destMC,           sizeof(COMMAND_HEADER)},
  924.     /*cmdPost_Card*/    { ProcessPostChar,  0,                0},
  925.     /*cmdBeep*/             { NotImplemented,   0,                0},
  926.     /*cmdSave_Reg*/       { NotImplemented,   0,                0},
  927.     /*cmdRestore_Reg*/{ NotImplemented,   0,                0},
  928.     { cmdSetDataBlock,  0,                0},
  929.     { ProcessXor,        destRegister,     sizeof(COMMAND_HEADER)},
  930.     { ProcessXor,        destParamSpace,   sizeof(COMMAND_HEADER)},
  931.     { ProcessXor,        destWorkSpace,    sizeof(COMMAND_HEADER)},
  932.     { ProcessXor,        destFrameBuffer,  sizeof(COMMAND_HEADER)},
  933.     { ProcessXor,        destPLL,          sizeof(COMMAND_HEADER)},
  934.     { ProcessXor,        destMC,           sizeof(COMMAND_HEADER)},
  935.  
  936.     { ProcessShl,        destRegister,     sizeof(COMMAND_HEADER)},
  937.     { ProcessShl,        destParamSpace,   sizeof(COMMAND_HEADER)},
  938.     { ProcessShl,        destWorkSpace,    sizeof(COMMAND_HEADER)},
  939.     { ProcessShl,        destFrameBuffer,  sizeof(COMMAND_HEADER)},
  940.     { ProcessShl,        destPLL,          sizeof(COMMAND_HEADER)},
  941.     { ProcessShl,        destMC,           sizeof(COMMAND_HEADER)},
  942.  
  943.     { ProcessShr,        destRegister,     sizeof(COMMAND_HEADER)},
  944.     { ProcessShr,        destParamSpace,   sizeof(COMMAND_HEADER)},
  945.     { ProcessShr,        destWorkSpace,    sizeof(COMMAND_HEADER)},
  946.     { ProcessShr,        destFrameBuffer,  sizeof(COMMAND_HEADER)},
  947.     { ProcessShr,        destPLL,          sizeof(COMMAND_HEADER)},
  948.     { ProcessShr,        destMC,           sizeof(COMMAND_HEADER)},
  949.     /*cmdDebug*/                { ProcessDebug,  0,                0},
  950.     { ProcessDS,  0,                0},
  951.  
  952. };
  953.  
  954. // EOF
  955.