hwserv_drv.c revision 209ff23f 
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    hwserv_drv.c
28
29Abstract:
30
31		Functions defined in the Command Decoder Specification document
32
33Revision History:
34
35	NEG:27.09.2002	Initiated.
36--*/
37#include "CD_binding.h"
38#include "CD_hw_services.h"
39
40//trace settings
41#if DEBUG_OUTPUT_DEVICE & 1
42	#define TRACE_USING_STDERR          //define it to use stderr as trace output,
43#endif
44#if DEBUG_OUTPUT_DEVICE & 2
45	#define TRACE_USING_RS232
46#endif
47#if DEBUG_OUTPUT_DEVICE & 4
48	#define TRACE_USING_LPT
49#endif
50
51
52#if DEBUG_PARSER == 4
53	#define IO_TRACE					//IO access trace switch, undefine it to turn off
54	#define PCI_TRACE					//PCI access trace switch, undefine it to turn off
55	#define MEM_TRACE					//MEM access trace switch, undefine it to turn off
56#endif
57
58UINT32 CailReadATIRegister(VOID*,UINT32);
59VOID   CailWriteATIRegister(VOID*,UINT32,UINT32);
60VOID*  CailAllocateMemory(VOID*,UINT16);
61VOID   CailReleaseMemory(VOID *,VOID *);
62VOID   CailDelayMicroSeconds(VOID *,UINT32 );
63VOID   CailReadPCIConfigData(VOID*,VOID*,UINT32,UINT16);
64VOID   CailWritePCIConfigData(VOID*,VOID*,UINT32,UINT16);
65UINT32 CailReadFBData(VOID*,UINT32);
66VOID   CailWriteFBData(VOID*,UINT32,UINT32);
67ULONG  CailReadPLL(VOID *Context ,ULONG Address);
68VOID   CailWritePLL(VOID *Context,ULONG Address,ULONG Data);
69ULONG  CailReadMC(VOID *Context ,ULONG Address);
70VOID   CailWriteMC(VOID *Context ,ULONG Address,ULONG Data);
71
72
73#if DEBUG_PARSER>0
74VOID   CailVideoDebugPrint(VOID*,ULONG_PTR, UINT16);
75#endif
76// Delay function
77#if ( defined ENABLE_PARSER_DELAY || defined ENABLE_ALL_SERVICE_FUNCTIONS )
78
79VOID	DelayMilliseconds(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
80{
81	    CailDelayMicroSeconds(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->SourceData32*1000);
82}
83
84VOID	DelayMicroseconds(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
85{
86	    CailDelayMicroSeconds(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->SourceData32);
87}
88#endif
89
90VOID	PostCharOutput(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
91{
92}
93
94VOID	CallerDebugFunc(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
95{
96}
97
98
99// PCI READ Access
100
101#if ( defined ENABLE_PARSER_PCIREAD8 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
102UINT8   ReadPCIReg8(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
103{
104    UINT8 rvl;
105    CailReadPCIConfigData(pWorkingTableData->pDeviceData->CAIL,&rvl,pWorkingTableData->Index,sizeof(UINT8));
106	return rvl;
107}
108#endif
109
110
111#if ( defined ENABLE_PARSER_PCIREAD16 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
112UINT16	ReadPCIReg16(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
113{
114
115    UINT16 rvl;
116    CailReadPCIConfigData(pWorkingTableData->pDeviceData->CAIL,&rvl,pWorkingTableData->Index,sizeof(UINT16));
117    return rvl;
118
119}
120#endif
121
122
123
124#if ( defined ENABLE_PARSER_PCIREAD32 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
125UINT32  ReadPCIReg32   (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
126{
127
128    UINT32 rvl;
129    CailReadPCIConfigData(pWorkingTableData->pDeviceData->CAIL,&rvl,pWorkingTableData->Index,sizeof(UINT32));
130    return rvl;
131}
132#endif
133
134
135// PCI WRITE Access
136
137#if ( defined ENABLE_PARSER_PCIWRITE8 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
138VOID	WritePCIReg8	(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
139{
140
141    CailWritePCIConfigData(pWorkingTableData->pDeviceData->CAIL,&(pWorkingTableData->DestData32),pWorkingTableData->Index,sizeof(UINT8));
142
143}
144
145#endif
146
147
148#if ( defined ENABLE_PARSER_PCIWRITE16 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
149VOID    WritePCIReg16  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
150{
151
152        CailWritePCIConfigData(pWorkingTableData->pDeviceData->CAIL,&(pWorkingTableData->DestData32),pWorkingTableData->Index,sizeof(UINT16));
153}
154
155#endif
156
157
158#if ( defined ENABLE_PARSER_PCIWRITE32 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
159VOID    WritePCIReg32  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
160{
161    CailWritePCIConfigData(pWorkingTableData->pDeviceData->CAIL,&(pWorkingTableData->DestData32),pWorkingTableData->Index,sizeof(UINT32));
162}
163#endif
164
165
166
167
168// System IO Access
169#if ( defined ENABLE_PARSER_SYS_IOREAD8 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
170UINT8   ReadSysIOReg8    (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
171{
172    UINT8 rvl;
173    rvl=0;
174    //rvl= (UINT8) ReadGenericPciCfg(dev,reg,sizeof(UINT8));
175	return rvl;
176}
177#endif
178
179
180#if ( defined ENABLE_PARSER_SYS_IOREAD16 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
181UINT16	ReadSysIOReg16(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
182{
183
184    UINT16 rvl;
185    rvl=0;
186    //rvl= (UINT16) ReadGenericPciCfg(dev,reg,sizeof(UINT16));
187    return rvl;
188
189}
190#endif
191
192
193
194#if ( defined ENABLE_PARSER_SYS_IOREAD32 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
195UINT32  ReadSysIOReg32   (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
196{
197
198    UINT32 rvl;
199    rvl=0;
200    //rvl= (UINT32) ReadGenericPciCfg(dev,reg,sizeof(UINT32));
201    return rvl;
202}
203#endif
204
205
206// PCI WRITE Access
207
208#if ( defined ENABLE_PARSER_SYS_IOWRITE8 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
209VOID	WriteSysIOReg8	(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
210{
211
212    //WriteGenericPciCfg(dev,reg,sizeof(UINT8),(UINT32)value);
213}
214
215#endif
216
217
218#if ( defined ENABLE_PARSER_SYS_IOWRITE16 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
219VOID    WriteSysIOReg16  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
220{
221
222    //WriteGenericPciCfg(dev,reg,sizeof(UINT16),(UINT32)value);
223}
224
225#endif
226
227
228#if ( defined ENABLE_PARSER_SYS_IOWRITE32 || defined ENABLE_ALL_SERVICE_FUNCTIONS )
229VOID    WriteSysIOReg32  (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
230{
231    //WriteGenericPciCfg(dev,reg,sizeof(UINT32),(UINT32)value);
232}
233#endif
234
235// ATI Registers Memory Mapped Access
236
237#if ( defined ENABLE_PARSER_REGISTERS_MEMORY_ACCESS || defined ENABLE_ALL_SERVICE_FUNCTIONS)
238
239UINT32	ReadReg32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
240{
241    return CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
242}
243
244VOID	WriteReg32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
245{
246    CailWriteATIRegister(pWorkingTableData->pDeviceData->CAIL,(UINT16)pWorkingTableData->Index,pWorkingTableData->DestData32 );
247}
248
249
250VOID	ReadIndReg32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
251{
252    pWorkingTableData->IndirectData = CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,*(UINT16*)(pWorkingTableData->IndirectIOTablePointer+1));
253}
254
255VOID	WriteIndReg32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
256{
257    CailWriteATIRegister(pWorkingTableData->pDeviceData->CAIL,*(UINT16*)(pWorkingTableData->IndirectIOTablePointer+1),pWorkingTableData->IndirectData );
258}
259
260#endif
261
262// ATI Registers IO Mapped Access
263
264#if ( defined ENABLE_PARSER_REGISTERS_IO_ACCESS || defined ENABLE_ALL_SERVICE_FUNCTIONS )
265UINT32	ReadRegIO (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
266{
267    //return CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
268    return 0;
269}
270VOID	WriteRegIO(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
271{
272      //  return CailWriteATIRegister(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index,pWorkingTableData->DestData32 );
273}
274#endif
275
276// access to Frame buffer, dummy function, need more information to implement it
277UINT32	ReadFrameBuffer32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
278{
279
280    return CailReadFBData(pWorkingTableData->pDeviceData->CAIL, (pWorkingTableData->Index <<2 ));
281
282}
283
284VOID	WriteFrameBuffer32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
285{
286    CailWriteFBData(pWorkingTableData->pDeviceData->CAIL,(pWorkingTableData->Index <<2), pWorkingTableData->DestData32);
287
288}
289
290
291VOID *AllocateMemory(DEVICE_DATA *pDeviceData , UINT16 MemSize)
292{
293    if(MemSize)
294        return(CailAllocateMemory(pDeviceData->CAIL,MemSize));
295    else
296        return NULL;
297}
298
299
300VOID ReleaseMemory(DEVICE_DATA *pDeviceData , WORKING_TABLE_DATA* pWorkingTableData)
301{
302    if( pWorkingTableData)
303        CailReleaseMemory(pDeviceData->CAIL, pWorkingTableData);
304}
305
306
307UINT32	ReadMC32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
308{
309    UINT32 ReadData;
310    ReadData=(UINT32)CailReadMC(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
311    return ReadData;
312}
313
314VOID	WriteMC32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
315{
316    CailWriteMC(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index,pWorkingTableData->DestData32);
317}
318
319UINT32	ReadPLL32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
320{
321    UINT32 ReadData;
322    ReadData=(UINT32)CailReadPLL(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
323    return ReadData;
324
325}
326
327VOID	WritePLL32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
328{
329    CailWritePLL(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index,pWorkingTableData->DestData32);
330
331}
332
333
334
335#if DEBUG_PARSER>0
336VOID CD_print_string	(DEVICE_DATA *pDeviceData, UINT8 *str)
337{
338    CailVideoDebugPrint( pDeviceData->CAIL, (ULONG_PTR) str, PARSER_STRINGS);
339}
340
341VOID CD_print_value	(DEVICE_DATA *pDeviceData, ULONG_PTR value, UINT16 value_type )
342{
343    CailVideoDebugPrint( pDeviceData->CAIL, (ULONG_PTR)value, value_type);
344}
345
346#endif
347
348// EOF
349