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