← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/xserver-xorg-video-ati/intrepid-proposed

« back to all changes in this revision

Viewing changes to src/AtomBios/hwserv_drv.c

  • Committer: Bazaar Package Importer
  • Author(s): Brice Goglin
  • Date: 2008-02-19 08:24:35 UTC
  • mfrom: (1.1.11 upstream)
  • Revision ID: james.westby@ubuntu.com-20080219082435-9c1qzo9vclxebz1n
Tags: 1:6.8.0-1
http://bugs.debian.org/448577
* New upstream release.
  + Bring back to life planar-to-packed conversion for rs4xx,
    closes: #448577.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AtomBios/hwserv_drv.c
 
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
    hwserv_drv.c
 
28
    
 
29
Abstract:
 
30
 
 
31
                Functions defined in the Command Decoder Specification document
 
32
 
 
33
Revision 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
 
 
58
UINT32 CailReadATIRegister(VOID*,UINT32);
 
59
VOID   CailWriteATIRegister(VOID*,UINT32,UINT32);
 
60
VOID*  CailAllocateMemory(VOID*,UINT16);
 
61
VOID   CailReleaseMemory(VOID *,VOID *);
 
62
VOID   CailDelayMicroSeconds(VOID *,UINT32 );
 
63
VOID   CailReadPCIConfigData(VOID*,VOID*,UINT32,UINT16);
 
64
VOID   CailWritePCIConfigData(VOID*,VOID*,UINT32,UINT16);
 
65
UINT32 CailReadFBData(VOID*,UINT32);
 
66
VOID   CailWriteFBData(VOID*,UINT32,UINT32);
 
67
ULONG  CailReadPLL(VOID *Context ,ULONG Address);
 
68
VOID   CailWritePLL(VOID *Context,ULONG Address,ULONG Data);
 
69
ULONG  CailReadMC(VOID *Context ,ULONG Address);
 
70
VOID   CailWriteMC(VOID *Context ,ULONG Address,ULONG Data);
 
71
 
 
72
 
 
73
#if DEBUG_PARSER>0
 
74
VOID   CailVideoDebugPrint(VOID*,ULONG_PTR, UINT16);
 
75
#endif
 
76
// Delay function
 
77
#if ( defined ENABLE_PARSER_DELAY || defined ENABLE_ALL_SERVICE_FUNCTIONS )
 
78
 
 
79
VOID    DelayMilliseconds(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
80
{
 
81
            CailDelayMicroSeconds(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->SourceData32*1000);
 
82
}
 
83
 
 
84
VOID    DelayMicroseconds(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
85
{
 
86
            CailDelayMicroSeconds(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->SourceData32);
 
87
}
 
88
#endif
 
89
 
 
90
VOID    PostCharOutput(PARSER_TEMP_DATA STACK_BASED * pParserTempData)
 
91
{
 
92
}
 
93
 
 
94
VOID    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 )
 
102
UINT8   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 )
 
112
UINT16  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 )
 
125
UINT32  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 )
 
138
VOID    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 )
 
149
VOID    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 )
 
159
VOID    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 )
 
170
UINT8   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 )
 
181
UINT16  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 )
 
195
UINT32  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 )
 
209
VOID    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 )
 
219
VOID    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 )
 
229
VOID    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
 
 
239
UINT32  ReadReg32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
240
{
 
241
    return CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
 
242
}
 
243
 
 
244
VOID    WriteReg32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
245
{
 
246
    CailWriteATIRegister(pWorkingTableData->pDeviceData->CAIL,(UINT16)pWorkingTableData->Index,pWorkingTableData->DestData32 );
 
247
}
 
248
 
 
249
 
 
250
VOID    ReadIndReg32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
251
{
 
252
    pWorkingTableData->IndirectData = CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,*(UINT16*)(pWorkingTableData->IndirectIOTablePointer+1));
 
253
}
 
254
 
 
255
VOID    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 )
 
265
UINT32  ReadRegIO (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
266
{
 
267
    //return CailReadATIRegister(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index);
 
268
    return 0;
 
269
}
 
270
VOID    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  
 
277
UINT32  ReadFrameBuffer32 (PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
278
{
 
279
    
 
280
    return CailReadFBData(pWorkingTableData->pDeviceData->CAIL, (pWorkingTableData->Index <<2 ));
 
281
 
 
282
}
 
283
 
 
284
VOID    WriteFrameBuffer32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
285
{
 
286
    CailWriteFBData(pWorkingTableData->pDeviceData->CAIL,(pWorkingTableData->Index <<2), pWorkingTableData->DestData32);
 
287
 
 
288
}
 
289
 
 
290
 
 
291
VOID *AllocateMemory(DEVICE_DATA *pDeviceData , UINT16 MemSize)
 
292
{
 
293
    if(MemSize)
 
294
        return(CailAllocateMemory(pDeviceData->CAIL,MemSize));
 
295
    else
 
296
        return NULL;
 
297
}
 
298
 
 
299
 
 
300
VOID ReleaseMemory(DEVICE_DATA *pDeviceData , WORKING_TABLE_DATA* pWorkingTableData)
 
301
{
 
302
    if( pWorkingTableData)
 
303
        CailReleaseMemory(pDeviceData->CAIL, pWorkingTableData);
 
304
}
 
305
 
 
306
 
 
307
UINT32  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
 
 
314
VOID    WriteMC32(PARSER_TEMP_DATA STACK_BASED * pWorkingTableData)
 
315
{
 
316
    CailWriteMC(pWorkingTableData->pDeviceData->CAIL,pWorkingTableData->Index,pWorkingTableData->DestData32);    
 
317
}
 
318
 
 
319
UINT32  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
 
 
327
VOID    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
 
336
VOID CD_print_string    (DEVICE_DATA *pDeviceData, UINT8 *str)
 
337
{
 
338
    CailVideoDebugPrint( pDeviceData->CAIL, (ULONG_PTR) str, PARSER_STRINGS);
 
339
}
 
340
 
 
341
VOID 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