r128_probe.c revision 19019ffe 
1/*
2 * Copyright 1999, 2000 ATI Technologies Inc., Markham, Ontario,
3 *                      Precision Insight, Inc., Cedar Park, Texas, and
4 *                      VA Linux Systems Inc., Fremont, California.
5 *
6 * All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining
9 * a copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation on the rights to use, copy, modify, merge,
12 * publish, distribute, sublicense, and/or sell copies of the Software,
13 * and to permit persons to whom the Software is furnished to do so,
14 * subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial
18 * portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 * NON-INFRINGEMENT.  IN NO EVENT SHALL ATI, PRECISION INSIGHT, VA LINUX
24 * SYSTEMS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
25 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27 * OTHER DEALINGS IN THE SOFTWARE.
28 */
29
30#ifdef HAVE_CONFIG_H
31#include "config.h"
32#endif
33
34#include <string.h>
35
36/*
37 * Authors:
38 *   Rickard E. Faith <faith@valinux.com>
39 *   Kevin E. Martin <martin@valinux.com>
40 */
41
42#include "r128_probe.h"
43#include "r128_version.h"
44#include "atipcirename.h"
45
46#include "xf86.h"
47#include "xf86PciInfo.h"
48
49
50#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
51#include "xf86Resources.h"
52#endif
53
54#ifndef XSERVER_LIBPCIACCESS
55static Bool R128Probe(DriverPtr drv, int flags);
56#endif
57
58SymTabRec R128Chipsets[] = {
59    { PCI_CHIP_RAGE128LE, "ATI Rage 128 Mobility M3 LE (PCI)" },
60    { PCI_CHIP_RAGE128LF, "ATI Rage 128 Mobility M3 LF (AGP)" },
61    { PCI_CHIP_RAGE128MF, "ATI Rage 128 Mobility M4 MF (AGP)" },
62    { PCI_CHIP_RAGE128ML, "ATI Rage 128 Mobility M4 ML (AGP)" },
63    { PCI_CHIP_RAGE128PA, "ATI Rage 128 Pro GL PA (PCI/AGP)" },
64    { PCI_CHIP_RAGE128PB, "ATI Rage 128 Pro GL PB (PCI/AGP)" },
65    { PCI_CHIP_RAGE128PC, "ATI Rage 128 Pro GL PC (PCI/AGP)" },
66    { PCI_CHIP_RAGE128PD, "ATI Rage 128 Pro GL PD (PCI)" },
67    { PCI_CHIP_RAGE128PE, "ATI Rage 128 Pro GL PE (PCI/AGP)" },
68    { PCI_CHIP_RAGE128PF, "ATI Rage 128 Pro GL PF (AGP)" },
69    { PCI_CHIP_RAGE128PG, "ATI Rage 128 Pro VR PG (PCI/AGP)" },
70    { PCI_CHIP_RAGE128PH, "ATI Rage 128 Pro VR PH (PCI/AGP)" },
71    { PCI_CHIP_RAGE128PI, "ATI Rage 128 Pro VR PI (PCI/AGP)" },
72    { PCI_CHIP_RAGE128PJ, "ATI Rage 128 Pro VR PJ (PCI/AGP)" },
73    { PCI_CHIP_RAGE128PK, "ATI Rage 128 Pro VR PK (PCI/AGP)" },
74    { PCI_CHIP_RAGE128PL, "ATI Rage 128 Pro VR PL (PCI/AGP)" },
75    { PCI_CHIP_RAGE128PM, "ATI Rage 128 Pro VR PM (PCI/AGP)" },
76    { PCI_CHIP_RAGE128PN, "ATI Rage 128 Pro VR PN (PCI/AGP)" },
77    { PCI_CHIP_RAGE128PO, "ATI Rage 128 Pro VR PO (PCI/AGP)" },
78    { PCI_CHIP_RAGE128PP, "ATI Rage 128 Pro VR PP (PCI)" },
79    { PCI_CHIP_RAGE128PQ, "ATI Rage 128 Pro VR PQ (PCI/AGP)" },
80    { PCI_CHIP_RAGE128PR, "ATI Rage 128 Pro VR PR (PCI)" },
81    { PCI_CHIP_RAGE128PS, "ATI Rage 128 Pro VR PS (PCI/AGP)" },
82    { PCI_CHIP_RAGE128PT, "ATI Rage 128 Pro VR PT (PCI/AGP)" },
83    { PCI_CHIP_RAGE128PU, "ATI Rage 128 Pro VR PU (PCI/AGP)" },
84    { PCI_CHIP_RAGE128PV, "ATI Rage 128 Pro VR PV (PCI/AGP)" },
85    { PCI_CHIP_RAGE128PW, "ATI Rage 128 Pro VR PW (PCI/AGP)" },
86    { PCI_CHIP_RAGE128PX, "ATI Rage 128 Pro VR PX (PCI/AGP)" },
87    { PCI_CHIP_RAGE128RE, "ATI Rage 128 GL RE (PCI)" },
88    { PCI_CHIP_RAGE128RF, "ATI Rage 128 GL RF (AGP)" },
89    { PCI_CHIP_RAGE128RG, "ATI Rage 128 RG (AGP)" },
90    { PCI_CHIP_RAGE128RK, "ATI Rage 128 VR RK (PCI)" },
91    { PCI_CHIP_RAGE128RL, "ATI Rage 128 VR RL (AGP)" },
92    { PCI_CHIP_RAGE128SE, "ATI Rage 128 4X SE (PCI/AGP)" },
93    { PCI_CHIP_RAGE128SF, "ATI Rage 128 4X SF (PCI/AGP)" },
94    { PCI_CHIP_RAGE128SG, "ATI Rage 128 4X SG (PCI/AGP)" },
95    { PCI_CHIP_RAGE128SH, "ATI Rage 128 4X SH (PCI/AGP)" },
96    { PCI_CHIP_RAGE128SK, "ATI Rage 128 4X SK (PCI/AGP)" },
97    { PCI_CHIP_RAGE128SL, "ATI Rage 128 4X SL (PCI/AGP)" },
98    { PCI_CHIP_RAGE128SM, "ATI Rage 128 4X SM (AGP)" },
99    { PCI_CHIP_RAGE128SN, "ATI Rage 128 4X SN (PCI/AGP)" },
100    { PCI_CHIP_RAGE128TF, "ATI Rage 128 Pro ULTRA TF (AGP)" },
101    { PCI_CHIP_RAGE128TL, "ATI Rage 128 Pro ULTRA TL (AGP)" },
102    { PCI_CHIP_RAGE128TR, "ATI Rage 128 Pro ULTRA TR (AGP)" },
103    { PCI_CHIP_RAGE128TS, "ATI Rage 128 Pro ULTRA TS (AGP?)" },
104    { PCI_CHIP_RAGE128TT, "ATI Rage 128 Pro ULTRA TT (AGP?)" },
105    { PCI_CHIP_RAGE128TU, "ATI Rage 128 Pro ULTRA TU (AGP?)" },
106    { -1,                 NULL }
107};
108
109static PciChipsets R128PciChipsets[] = {
110    { PCI_CHIP_RAGE128LE, PCI_CHIP_RAGE128LE, RES_SHARED_VGA },
111    { PCI_CHIP_RAGE128LF, PCI_CHIP_RAGE128LF, RES_SHARED_VGA },
112    { PCI_CHIP_RAGE128MF, PCI_CHIP_RAGE128MF, RES_SHARED_VGA },
113    { PCI_CHIP_RAGE128ML, PCI_CHIP_RAGE128ML, RES_SHARED_VGA },
114    { PCI_CHIP_RAGE128PA, PCI_CHIP_RAGE128PA, RES_SHARED_VGA },
115    { PCI_CHIP_RAGE128PB, PCI_CHIP_RAGE128PB, RES_SHARED_VGA },
116    { PCI_CHIP_RAGE128PC, PCI_CHIP_RAGE128PC, RES_SHARED_VGA },
117    { PCI_CHIP_RAGE128PD, PCI_CHIP_RAGE128PD, RES_SHARED_VGA },
118    { PCI_CHIP_RAGE128PE, PCI_CHIP_RAGE128PE, RES_SHARED_VGA },
119    { PCI_CHIP_RAGE128PF, PCI_CHIP_RAGE128PF, RES_SHARED_VGA },
120    { PCI_CHIP_RAGE128PG, PCI_CHIP_RAGE128PG, RES_SHARED_VGA },
121    { PCI_CHIP_RAGE128PH, PCI_CHIP_RAGE128PH, RES_SHARED_VGA },
122    { PCI_CHIP_RAGE128PI, PCI_CHIP_RAGE128PI, RES_SHARED_VGA },
123    { PCI_CHIP_RAGE128PJ, PCI_CHIP_RAGE128PJ, RES_SHARED_VGA },
124    { PCI_CHIP_RAGE128PK, PCI_CHIP_RAGE128PK, RES_SHARED_VGA },
125    { PCI_CHIP_RAGE128PL, PCI_CHIP_RAGE128PL, RES_SHARED_VGA },
126    { PCI_CHIP_RAGE128PM, PCI_CHIP_RAGE128PM, RES_SHARED_VGA },
127    { PCI_CHIP_RAGE128PN, PCI_CHIP_RAGE128PN, RES_SHARED_VGA },
128    { PCI_CHIP_RAGE128PO, PCI_CHIP_RAGE128PO, RES_SHARED_VGA },
129    { PCI_CHIP_RAGE128PP, PCI_CHIP_RAGE128PP, RES_SHARED_VGA },
130    { PCI_CHIP_RAGE128PQ, PCI_CHIP_RAGE128PQ, RES_SHARED_VGA },
131    { PCI_CHIP_RAGE128PR, PCI_CHIP_RAGE128PR, RES_SHARED_VGA },
132    { PCI_CHIP_RAGE128PS, PCI_CHIP_RAGE128PS, RES_SHARED_VGA },
133    { PCI_CHIP_RAGE128PT, PCI_CHIP_RAGE128PT, RES_SHARED_VGA },
134    { PCI_CHIP_RAGE128PU, PCI_CHIP_RAGE128PU, RES_SHARED_VGA },
135    { PCI_CHIP_RAGE128PV, PCI_CHIP_RAGE128PV, RES_SHARED_VGA },
136    { PCI_CHIP_RAGE128PW, PCI_CHIP_RAGE128PW, RES_SHARED_VGA },
137    { PCI_CHIP_RAGE128PX, PCI_CHIP_RAGE128PX, RES_SHARED_VGA },
138    { PCI_CHIP_RAGE128RE, PCI_CHIP_RAGE128RE, RES_SHARED_VGA },
139    { PCI_CHIP_RAGE128RF, PCI_CHIP_RAGE128RF, RES_SHARED_VGA },
140    { PCI_CHIP_RAGE128RG, PCI_CHIP_RAGE128RG, RES_SHARED_VGA },
141    { PCI_CHIP_RAGE128RK, PCI_CHIP_RAGE128RK, RES_SHARED_VGA },
142    { PCI_CHIP_RAGE128RL, PCI_CHIP_RAGE128RL, RES_SHARED_VGA },
143    { PCI_CHIP_RAGE128SE, PCI_CHIP_RAGE128SE, RES_SHARED_VGA },
144    { PCI_CHIP_RAGE128SF, PCI_CHIP_RAGE128SF, RES_SHARED_VGA },
145    { PCI_CHIP_RAGE128SG, PCI_CHIP_RAGE128SG, RES_SHARED_VGA },
146    { PCI_CHIP_RAGE128SH, PCI_CHIP_RAGE128SH, RES_SHARED_VGA },
147    { PCI_CHIP_RAGE128SK, PCI_CHIP_RAGE128SK, RES_SHARED_VGA },
148    { PCI_CHIP_RAGE128SL, PCI_CHIP_RAGE128SL, RES_SHARED_VGA },
149    { PCI_CHIP_RAGE128SM, PCI_CHIP_RAGE128SM, RES_SHARED_VGA },
150    { PCI_CHIP_RAGE128SN, PCI_CHIP_RAGE128SN, RES_SHARED_VGA },
151    { PCI_CHIP_RAGE128TF, PCI_CHIP_RAGE128TF, RES_SHARED_VGA },
152    { PCI_CHIP_RAGE128TL, PCI_CHIP_RAGE128TL, RES_SHARED_VGA },
153    { PCI_CHIP_RAGE128TR, PCI_CHIP_RAGE128TR, RES_SHARED_VGA },
154    { PCI_CHIP_RAGE128TS, PCI_CHIP_RAGE128TS, RES_SHARED_VGA },
155    { PCI_CHIP_RAGE128TT, PCI_CHIP_RAGE128TT, RES_SHARED_VGA },
156    { PCI_CHIP_RAGE128TU, PCI_CHIP_RAGE128TU, RES_SHARED_VGA },
157    { -1,                 -1,                 RES_UNDEFINED }
158};
159
160#ifdef XSERVER_LIBPCIACCESS
161
162static const struct pci_id_match r128_device_match[] = {
163    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128LE, 0 ),
164    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128LF, 0 ),
165    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128MF, 0 ),
166    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128ML, 0 ),
167    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PA, 0 ),
168    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PB, 0 ),
169    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PC, 0 ),
170    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PD, 0 ),
171    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PE, 0 ),
172    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PF, 0 ),
173    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PG, 0 ),
174    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PH, 0 ),
175    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PI, 0 ),
176    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PJ, 0 ),
177    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PK, 0 ),
178    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PL, 0 ),
179    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PM, 0 ),
180    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PN, 0 ),
181    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PO, 0 ),
182    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PP, 0 ),
183    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PQ, 0 ),
184    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PR, 0 ),
185    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PS, 0 ),
186    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PT, 0 ),
187    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PU, 0 ),
188    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PV, 0 ),
189    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PW, 0 ),
190    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128PX, 0 ),
191    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128RE, 0 ),
192    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128RF, 0 ),
193    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128RG, 0 ),
194    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128RK, 0 ),
195    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128RL, 0 ),
196    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128SE, 0 ),
197    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128SF, 0 ),
198    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128SG, 0 ),
199    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128SH, 0 ),
200    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128SK, 0 ),
201    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128SL, 0 ),
202    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128SM, 0 ),
203    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128SN, 0 ),
204    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128TF, 0 ),
205    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128TL, 0 ),
206    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128TR, 0 ),
207    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128TS, 0 ),
208    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128TT, 0 ),
209    ATI_DEVICE_MATCH( PCI_CHIP_RAGE128TU, 0 ),
210    { 0, 0, 0 }
211};
212
213#endif /* XSERVER_LIBPCIACCESS */
214
215_X_EXPORT int gR128EntityIndex = -1;
216
217/* Return the options for supported chipset 'n'; NULL otherwise */
218static const OptionInfoRec *
219R128AvailableOptions(int chipid, int busid)
220{
221    return R128OptionsWeak();
222}
223
224/* Return the string name for supported chipset 'n'; NULL otherwise. */
225static void
226R128Identify(int flags)
227{
228    xf86PrintChipsets(R128_NAME,
229		      "Driver for ATI Rage 128 chipsets",
230		      R128Chipsets);
231}
232
233static Bool
234r128_get_scrninfo(int entity_num)
235{
236    ScrnInfoPtr   pScrn = NULL;
237    EntityInfoPtr pEnt;
238
239    pScrn = xf86ConfigPciEntity(pScrn, 0, entity_num, R128PciChipsets,
240                                NULL,
241                                NULL, NULL, NULL, NULL);
242
243    if (!pScrn)
244        return FALSE;
245
246    pScrn->driverVersion = R128_VERSION_CURRENT;
247    pScrn->driverName    = R128_DRIVER_NAME;
248    pScrn->name          = R128_NAME;
249#ifdef XSERVER_LIBPCIACCESS
250    pScrn->Probe         = NULL;
251#else
252    pScrn->Probe         = R128Probe;
253#endif
254    pScrn->PreInit       = R128PreInit;
255    pScrn->ScreenInit    = R128ScreenInit;
256    pScrn->SwitchMode    = R128SwitchMode;
257    pScrn->AdjustFrame   = R128AdjustFrame;
258    pScrn->EnterVT       = R128EnterVT;
259    pScrn->LeaveVT       = R128LeaveVT;
260    pScrn->FreeScreen    = R128FreeScreen;
261    pScrn->ValidMode     = R128ValidMode;
262
263    pEnt = xf86GetEntityInfo(entity_num);
264
265    /* mobility cards support Dual-Head, mark the entity as sharable*/
266    if (pEnt->chipset == PCI_CHIP_RAGE128LE ||
267        pEnt->chipset == PCI_CHIP_RAGE128LF ||
268        pEnt->chipset == PCI_CHIP_RAGE128MF ||
269        pEnt->chipset == PCI_CHIP_RAGE128ML)
270    {
271        static int instance = 0;
272        DevUnion* pPriv;
273
274        xf86SetEntitySharable(entity_num);
275
276        xf86SetEntityInstanceForScreen(pScrn,
277                                       pScrn->entityList[0],
278                                       instance);
279
280        if (gR128EntityIndex < 0)
281        {
282            gR128EntityIndex = xf86AllocateEntityPrivateIndex();
283
284            pPriv = xf86GetEntityPrivate(pScrn->entityList[0],
285                                         gR128EntityIndex);
286
287            if (!pPriv->ptr)
288            {
289                R128EntPtr pR128Ent;
290                pPriv->ptr = xnfcalloc(sizeof(R128EntRec), 1);
291                pR128Ent = pPriv->ptr;
292                pR128Ent->IsDRIEnabled = FALSE;
293                pR128Ent->BypassSecondary = FALSE;
294                pR128Ent->HasSecondary = FALSE;
295                pR128Ent->IsSecondaryRestored = FALSE;
296            }
297        }
298        instance++;
299    }
300
301    xfree(pEnt);
302
303    return TRUE;
304}
305
306#ifndef XSERVER_LIBPCIACCESS
307
308/* Return TRUE if chipset is present; FALSE otherwise. */
309static Bool
310R128Probe(DriverPtr drv, int flags)
311{
312    int           numUsed;
313    int           numDevSections;
314    int           *usedChips;
315    GDevPtr       *devSections;
316    Bool          foundScreen = FALSE;
317    int           i;
318
319    if (!xf86GetPciVideoInfo()) return FALSE;
320
321    numDevSections = xf86MatchDevice(R128_NAME, &devSections);
322
323    if (!numDevSections) return FALSE;
324
325    numUsed = xf86MatchPciInstances(R128_NAME,
326				    PCI_VENDOR_ATI,
327				    R128Chipsets,
328				    R128PciChipsets,
329				    devSections,
330				    numDevSections,
331				    drv,
332				    &usedChips);
333
334    if (numUsed<=0) return FALSE;
335
336    if (flags & PROBE_DETECT)
337	foundScreen = TRUE;
338    else for (i = 0; i < numUsed; i++) {
339	if (r128_get_scrninfo(usedChips[i]))
340	    foundScreen = TRUE;
341    }
342
343    xfree(usedChips);
344    xfree(devSections);
345
346    return foundScreen;
347}
348
349#else /* XSERVER_LIBPCIACCESS */
350
351static Bool
352r128_pci_probe(
353    DriverPtr          pDriver,
354    int                entity_num,
355    struct pci_device *device,
356    intptr_t           match_data
357)
358{
359    return r128_get_scrninfo(entity_num);
360}
361
362#endif /* XSERVER_LIBPCIACCESS */
363
364_X_EXPORT DriverRec R128 =
365{
366    R128_VERSION_CURRENT,
367    R128_DRIVER_NAME,
368    R128Identify,
369#ifdef XSERVER_LIBPCIACCESS
370    NULL,
371#else
372    R128Probe,
373#endif
374    R128AvailableOptions,
375    NULL,
376    0,
377    NULL,
378#ifdef XSERVER_LIBPCIACCESS
379    r128_device_match,
380    r128_pci_probe
381#endif
382};
383