← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/programs/Xserver/hw/xfree86/drivers/ati/r128_probe.c

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unix/xc/programs/Xserver/hw/xfree86/drivers/ati/r128_probe.c
 
1
/* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/ati/r128_probe.c,v 1.18 2003/02/09 15:33:17 tsi Exp $ */
 
2
/*
 
3
 * Copyright 1999, 2000 ATI Technologies Inc., Markham, Ontario,
 
4
 *                      Precision Insight, Inc., Cedar Park, Texas, and
 
5
 *                      VA Linux Systems Inc., Fremont, California.
 
6
 *
 
7
 * All Rights Reserved.
 
8
 *
 
9
 * Permission is hereby granted, free of charge, to any person obtaining
 
10
 * a copy of this software and associated documentation files (the
 
11
 * "Software"), to deal in the Software without restriction, including
 
12
 * without limitation on the rights to use, copy, modify, merge,
 
13
 * publish, distribute, sublicense, and/or sell copies of the Software,
 
14
 * and to permit persons to whom the Software is furnished to do so,
 
15
 * subject to the following conditions:
 
16
 *
 
17
 * The above copyright notice and this permission notice (including the
 
18
 * next paragraph) shall be included in all copies or substantial
 
19
 * portions of the Software.
 
20
 *
 
21
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 
22
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 
23
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 
24
 * NON-INFRINGEMENT.  IN NO EVENT SHALL ATI, PRECISION INSIGHT, VA LINUX
 
25
 * SYSTEMS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 
26
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 
27
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 
28
 * OTHER DEALINGS IN THE SOFTWARE.
 
29
 */
 
30
 
 
31
/*
 
32
 * Authors:
 
33
 *   Rickard E. Faith <faith@valinux.com>
 
34
 *   Kevin E. Martin <martin@valinux.com>
 
35
 *
 
36
 * Modified by Marc Aurele La France <tsi@xfree86.org> for ATI driver merge.
 
37
 */
 
38
 
 
39
#include "atimodule.h"
 
40
#include "ativersion.h"
 
41
 
 
42
#include "r128_probe.h"
 
43
#include "r128_version.h"
 
44
 
 
45
#include "xf86PciInfo.h"
 
46
 
 
47
#include "xf86.h"
 
48
#include "xf86_ansic.h"
 
49
#include "xf86Resources.h"
 
50
 
 
51
#ifdef XFree86LOADER
 
52
 
 
53
/*
 
54
 * The following exists to prevent the compiler from considering entry points
 
55
 * defined in a separate module from being constants.
 
56
 */
 
57
static xf86PreInitProc     * const volatile PreInitProc     = R128PreInit;
 
58
static xf86ScreenInitProc  * const volatile ScreenInitProc  = R128ScreenInit;
 
59
static xf86SwitchModeProc  * const volatile SwitchModeProc  = R128SwitchMode;
 
60
static xf86AdjustFrameProc * const volatile AdjustFrameProc = R128AdjustFrame;
 
61
static xf86EnterVTProc     * const volatile EnterVTProc     = R128EnterVT;
 
62
static xf86LeaveVTProc     * const volatile LeaveVTProc     = R128LeaveVT;
 
63
static xf86FreeScreenProc  * const volatile FreeScreenProc  = R128FreeScreen;
 
64
static xf86ValidModeProc   * const volatile ValidModeProc   = R128ValidMode;
 
65
 
 
66
#define R128PreInit     PreInitProc
 
67
#define R128ScreenInit  ScreenInitProc
 
68
#define R128SwitchMode  SwitchModeProc
 
69
#define R128AdjustFrame AdjustFrameProc
 
70
#define R128EnterVT     EnterVTProc
 
71
#define R128LeaveVT     LeaveVTProc
 
72
#define R128FreeScreen  FreeScreenProc
 
73
#define R128ValidMode   ValidModeProc
 
74
 
 
75
#endif
 
76
 
 
77
SymTabRec R128Chipsets[] = {
 
78
    /* FIXME: The chipsets with (PCI/AGP) are not known wether they are AGP or
 
79
     *        PCI, so I've labeled them as such in hopes users will submit
 
80
     *        data if we're unable to gather it from official documentation
 
81
     */
 
82
    { PCI_CHIP_RAGE128LE, "ATI Rage 128 Mobility M3 LE (PCI)" },
 
83
    { PCI_CHIP_RAGE128LF, "ATI Rage 128 Mobility M3 LF (AGP)" },
 
84
    { PCI_CHIP_RAGE128MF, "ATI Rage 128 Mobility M4 MF (AGP)" },
 
85
    { PCI_CHIP_RAGE128ML, "ATI Rage 128 Mobility M4 ML (AGP)" },
 
86
    { PCI_CHIP_RAGE128PA, "ATI Rage 128 Pro GL PA (PCI/AGP)" },
 
87
    { PCI_CHIP_RAGE128PB, "ATI Rage 128 Pro GL PB (PCI/AGP)" },
 
88
    { PCI_CHIP_RAGE128PC, "ATI Rage 128 Pro GL PC (PCI/AGP)" },
 
89
    { PCI_CHIP_RAGE128PD, "ATI Rage 128 Pro GL PD (PCI)" },
 
90
    { PCI_CHIP_RAGE128PE, "ATI Rage 128 Pro GL PE (PCI/AGP)" },
 
91
    { PCI_CHIP_RAGE128PF, "ATI Rage 128 Pro GL PF (AGP)" },
 
92
    { PCI_CHIP_RAGE128PG, "ATI Rage 128 Pro VR PG (PCI/AGP)" },
 
93
    { PCI_CHIP_RAGE128PH, "ATI Rage 128 Pro VR PH (PCI/AGP)" },
 
94
    { PCI_CHIP_RAGE128PI, "ATI Rage 128 Pro VR PI (PCI/AGP)" },
 
95
    { PCI_CHIP_RAGE128PJ, "ATI Rage 128 Pro VR PJ (PCI/AGP)" },
 
96
    { PCI_CHIP_RAGE128PK, "ATI Rage 128 Pro VR PK (PCI/AGP)" },
 
97
    { PCI_CHIP_RAGE128PL, "ATI Rage 128 Pro VR PL (PCI/AGP)" },
 
98
    { PCI_CHIP_RAGE128PM, "ATI Rage 128 Pro VR PM (PCI/AGP)" },
 
99
    { PCI_CHIP_RAGE128PN, "ATI Rage 128 Pro VR PN (PCI/AGP)" },
 
100
    { PCI_CHIP_RAGE128PO, "ATI Rage 128 Pro VR PO (PCI/AGP)" },
 
101
    { PCI_CHIP_RAGE128PP, "ATI Rage 128 Pro VR PP (PCI)" },
 
102
    { PCI_CHIP_RAGE128PQ, "ATI Rage 128 Pro VR PQ (PCI/AGP)" },
 
103
    { PCI_CHIP_RAGE128PR, "ATI Rage 128 Pro VR PR (PCI)" },
 
104
    { PCI_CHIP_RAGE128PS, "ATI Rage 128 Pro VR PS (PCI/AGP)" },
 
105
    { PCI_CHIP_RAGE128PT, "ATI Rage 128 Pro VR PT (PCI/AGP)" },
 
106
    { PCI_CHIP_RAGE128PU, "ATI Rage 128 Pro VR PU (PCI/AGP)" },
 
107
    { PCI_CHIP_RAGE128PV, "ATI Rage 128 Pro VR PV (PCI/AGP)" },
 
108
    { PCI_CHIP_RAGE128PW, "ATI Rage 128 Pro VR PW (PCI/AGP)" },
 
109
    { PCI_CHIP_RAGE128PX, "ATI Rage 128 Pro VR PX (PCI/AGP)" },
 
110
    { PCI_CHIP_RAGE128RE, "ATI Rage 128 GL RE (PCI)" },
 
111
    { PCI_CHIP_RAGE128RF, "ATI Rage 128 GL RF (AGP)" },
 
112
    { PCI_CHIP_RAGE128RG, "ATI Rage 128 RG (AGP)" },
 
113
    { PCI_CHIP_RAGE128RK, "ATI Rage 128 VR RK (PCI)" },
 
114
    { PCI_CHIP_RAGE128RL, "ATI Rage 128 VR RL (AGP)" },
 
115
    { PCI_CHIP_RAGE128SE, "ATI Rage 128 4X SE (PCI/AGP)" },
 
116
    { PCI_CHIP_RAGE128SF, "ATI Rage 128 4X SF (PCI/AGP)" },
 
117
    { PCI_CHIP_RAGE128SG, "ATI Rage 128 4X SG (PCI/AGP)" },
 
118
    { PCI_CHIP_RAGE128SH, "ATI Rage 128 4X SH (PCI/AGP)" },
 
119
    { PCI_CHIP_RAGE128SK, "ATI Rage 128 4X SK (PCI/AGP)" },
 
120
    { PCI_CHIP_RAGE128SL, "ATI Rage 128 4X SL (PCI/AGP)" },
 
121
    { PCI_CHIP_RAGE128SM, "ATI Rage 128 4X SM (AGP)" },
 
122
    { PCI_CHIP_RAGE128SN, "ATI Rage 128 4X SN (PCI/AGP)" },
 
123
    { PCI_CHIP_RAGE128TF, "ATI Rage 128 Pro ULTRA TF (AGP)" },
 
124
    { PCI_CHIP_RAGE128TL, "ATI Rage 128 Pro ULTRA TL (AGP)" },
 
125
    { PCI_CHIP_RAGE128TR, "ATI Rage 128 Pro ULTRA TR (AGP)" },
 
126
    { PCI_CHIP_RAGE128TS, "ATI Rage 128 Pro ULTRA TS (AGP?)" },
 
127
    { PCI_CHIP_RAGE128TT, "ATI Rage 128 Pro ULTRA TT (AGP?)" },
 
128
    { PCI_CHIP_RAGE128TU, "ATI Rage 128 Pro ULTRA TU (AGP?)" },
 
129
    { -1,                 NULL }
 
130
};
 
131
 
 
132
PciChipsets R128PciChipsets[] = {
 
133
    { PCI_CHIP_RAGE128LE, PCI_CHIP_RAGE128LE, RES_SHARED_VGA },
 
134
    { PCI_CHIP_RAGE128LF, PCI_CHIP_RAGE128LF, RES_SHARED_VGA },
 
135
    { PCI_CHIP_RAGE128MF, PCI_CHIP_RAGE128MF, RES_SHARED_VGA },
 
136
    { PCI_CHIP_RAGE128ML, PCI_CHIP_RAGE128ML, RES_SHARED_VGA },
 
137
    { PCI_CHIP_RAGE128PA, PCI_CHIP_RAGE128PA, RES_SHARED_VGA },
 
138
    { PCI_CHIP_RAGE128PB, PCI_CHIP_RAGE128PB, RES_SHARED_VGA },
 
139
    { PCI_CHIP_RAGE128PC, PCI_CHIP_RAGE128PC, RES_SHARED_VGA },
 
140
    { PCI_CHIP_RAGE128PD, PCI_CHIP_RAGE128PD, RES_SHARED_VGA },
 
141
    { PCI_CHIP_RAGE128PE, PCI_CHIP_RAGE128PE, RES_SHARED_VGA },
 
142
    { PCI_CHIP_RAGE128PF, PCI_CHIP_RAGE128PF, RES_SHARED_VGA },
 
143
    { PCI_CHIP_RAGE128PG, PCI_CHIP_RAGE128PG, RES_SHARED_VGA },
 
144
    { PCI_CHIP_RAGE128PH, PCI_CHIP_RAGE128PH, RES_SHARED_VGA },
 
145
    { PCI_CHIP_RAGE128PI, PCI_CHIP_RAGE128PI, RES_SHARED_VGA },
 
146
    { PCI_CHIP_RAGE128PJ, PCI_CHIP_RAGE128PJ, RES_SHARED_VGA },
 
147
    { PCI_CHIP_RAGE128PK, PCI_CHIP_RAGE128PK, RES_SHARED_VGA },
 
148
    { PCI_CHIP_RAGE128PL, PCI_CHIP_RAGE128PL, RES_SHARED_VGA },
 
149
    { PCI_CHIP_RAGE128PM, PCI_CHIP_RAGE128PM, RES_SHARED_VGA },
 
150
    { PCI_CHIP_RAGE128PN, PCI_CHIP_RAGE128PN, RES_SHARED_VGA },
 
151
    { PCI_CHIP_RAGE128PO, PCI_CHIP_RAGE128PO, RES_SHARED_VGA },
 
152
    { PCI_CHIP_RAGE128PP, PCI_CHIP_RAGE128PP, RES_SHARED_VGA },
 
153
    { PCI_CHIP_RAGE128PQ, PCI_CHIP_RAGE128PQ, RES_SHARED_VGA },
 
154
    { PCI_CHIP_RAGE128PR, PCI_CHIP_RAGE128PR, RES_SHARED_VGA },
 
155
    { PCI_CHIP_RAGE128PS, PCI_CHIP_RAGE128PS, RES_SHARED_VGA },
 
156
    { PCI_CHIP_RAGE128PT, PCI_CHIP_RAGE128PT, RES_SHARED_VGA },
 
157
    { PCI_CHIP_RAGE128PU, PCI_CHIP_RAGE128PU, RES_SHARED_VGA },
 
158
    { PCI_CHIP_RAGE128PV, PCI_CHIP_RAGE128PV, RES_SHARED_VGA },
 
159
    { PCI_CHIP_RAGE128PW, PCI_CHIP_RAGE128PW, RES_SHARED_VGA },
 
160
    { PCI_CHIP_RAGE128PX, PCI_CHIP_RAGE128PX, RES_SHARED_VGA },
 
161
    { PCI_CHIP_RAGE128RE, PCI_CHIP_RAGE128RE, RES_SHARED_VGA },
 
162
    { PCI_CHIP_RAGE128RF, PCI_CHIP_RAGE128RF, RES_SHARED_VGA },
 
163
    { PCI_CHIP_RAGE128RG, PCI_CHIP_RAGE128RG, RES_SHARED_VGA },
 
164
    { PCI_CHIP_RAGE128RK, PCI_CHIP_RAGE128RK, RES_SHARED_VGA },
 
165
    { PCI_CHIP_RAGE128RL, PCI_CHIP_RAGE128RL, RES_SHARED_VGA },
 
166
    { PCI_CHIP_RAGE128SE, PCI_CHIP_RAGE128SE, RES_SHARED_VGA },
 
167
    { PCI_CHIP_RAGE128SF, PCI_CHIP_RAGE128SF, RES_SHARED_VGA },
 
168
    { PCI_CHIP_RAGE128SG, PCI_CHIP_RAGE128SG, RES_SHARED_VGA },
 
169
    { PCI_CHIP_RAGE128SH, PCI_CHIP_RAGE128SH, RES_SHARED_VGA },
 
170
    { PCI_CHIP_RAGE128SK, PCI_CHIP_RAGE128SK, RES_SHARED_VGA },
 
171
    { PCI_CHIP_RAGE128SL, PCI_CHIP_RAGE128SL, RES_SHARED_VGA },
 
172
    { PCI_CHIP_RAGE128SM, PCI_CHIP_RAGE128SM, RES_SHARED_VGA },
 
173
    { PCI_CHIP_RAGE128SN, PCI_CHIP_RAGE128SN, RES_SHARED_VGA },
 
174
    { PCI_CHIP_RAGE128TF, PCI_CHIP_RAGE128TF, RES_SHARED_VGA },
 
175
    { PCI_CHIP_RAGE128TL, PCI_CHIP_RAGE128TL, RES_SHARED_VGA },
 
176
    { PCI_CHIP_RAGE128TR, PCI_CHIP_RAGE128TR, RES_SHARED_VGA },
 
177
    { PCI_CHIP_RAGE128TS, PCI_CHIP_RAGE128TS, RES_SHARED_VGA },
 
178
    { PCI_CHIP_RAGE128TT, PCI_CHIP_RAGE128TT, RES_SHARED_VGA },
 
179
    { PCI_CHIP_RAGE128TU, PCI_CHIP_RAGE128TU, RES_SHARED_VGA },
 
180
    { -1,                 -1,                 RES_UNDEFINED }
 
181
};
 
182
 
 
183
/* Return the options for supported chipset 'n'; NULL otherwise */
 
184
const OptionInfoRec *
 
185
R128AvailableOptions(int chipid, int busid)
 
186
{
 
187
    int i;
 
188
 
 
189
    /*
 
190
     * Return options defined in the r128 submodule which will have been
 
191
     * loaded by this point.
 
192
     */
 
193
    if ((chipid >> 16) == PCI_VENDOR_ATI)
 
194
        chipid -= PCI_VENDOR_ATI << 16;
 
195
    for (i = 0; R128PciChipsets[i].PCIid > 0; i++) {
 
196
        if (chipid == R128PciChipsets[i].PCIid)
 
197
            return R128Options;
 
198
    }
 
199
    return NULL;
 
200
}
 
201
 
 
202
/* Return the string name for supported chipset 'n'; NULL otherwise. */
 
203
void
 
204
R128Identify(int flags)
 
205
{
 
206
    xf86PrintChipsets(R128_NAME,
 
207
                      "Driver for ATI Rage 128 chipsets",
 
208
                      R128Chipsets);
 
209
}
 
210
 
 
211
/* Return TRUE if chipset is present; FALSE otherwise. */
 
212
Bool
 
213
R128Probe(DriverPtr drv, int flags)
 
214
{
 
215
    int           numUsed;
 
216
    int           numDevSections, nATIGDev, nR128GDev;
 
217
    int           *usedChips;
 
218
    GDevPtr       *devSections, *ATIGDevs, *R128GDevs;
 
219
    EntityInfoPtr pEnt;
 
220
    Bool          foundScreen = FALSE;
 
221
    int           i;
 
222
 
 
223
    if (!xf86GetPciVideoInfo()) return FALSE;
 
224
 
 
225
    /* Collect unclaimed device sections for both driver names */
 
226
    nATIGDev = xf86MatchDevice(ATI_NAME, &ATIGDevs);
 
227
    nR128GDev = xf86MatchDevice(R128_NAME, &R128GDevs);
 
228
 
 
229
    if (!(numDevSections = nATIGDev + nR128GDev)) return FALSE;
 
230
 
 
231
    if (!ATIGDevs) {
 
232
        if (!(devSections = R128GDevs))
 
233
            numDevSections = 1;
 
234
        else
 
235
            numDevSections = nR128GDev;
 
236
    } if (!R128GDevs) {
 
237
        devSections = ATIGDevs;
 
238
        numDevSections = nATIGDev;
 
239
    } else {
 
240
        /* Combine into one list */
 
241
        devSections = xnfalloc((numDevSections + 1) * sizeof(GDevPtr));
 
242
        (void)memcpy(devSections,
 
243
                     ATIGDevs, nATIGDev * sizeof(GDevPtr));
 
244
        (void)memcpy(devSections + nATIGDev,
 
245
                     R128GDevs, nR128GDev * sizeof(GDevPtr));
 
246
        devSections[numDevSections] = NULL;
 
247
        xfree(ATIGDevs);
 
248
        xfree(R128GDevs);
 
249
    }
 
250
 
 
251
    numUsed = xf86MatchPciInstances(R128_NAME,
 
252
                                    PCI_VENDOR_ATI,
 
253
                                    R128Chipsets,
 
254
                                    R128PciChipsets,
 
255
                                    devSections,
 
256
                                    numDevSections,
 
257
                                    drv,
 
258
                                    &usedChips);
 
259
 
 
260
    if (numUsed<=0) return FALSE;
 
261
 
 
262
    if (flags & PROBE_DETECT)
 
263
        foundScreen = TRUE;
 
264
    else for (i = 0; i < numUsed; i++) {
 
265
        pEnt = xf86GetEntityInfo(usedChips[i]);
 
266
 
 
267
        if (pEnt->active) {
 
268
            ScrnInfoPtr pScrn = xf86AllocateScreen(drv, 0);
 
269
 
 
270
#ifdef XFree86LOADER
 
271
 
 
272
            if (!xf86LoadSubModule(pScrn, "r128")) {
 
273
                xf86Msg(X_ERROR,
 
274
                    R128_NAME ":  Failed to load \"r128\" module.\n");
 
275
                xf86DeleteScreen(pScrn->scrnIndex, 0);
 
276
                continue;
 
277
            }
 
278
 
 
279
            xf86LoaderReqSymLists(R128Symbols, NULL);
 
280
 
 
281
#endif
 
282
 
 
283
            pScrn->driverVersion = R128_VERSION_CURRENT;
 
284
            pScrn->driverName    = R128_DRIVER_NAME;
 
285
            pScrn->name          = R128_NAME;
 
286
            pScrn->Probe         = R128Probe;
 
287
            pScrn->PreInit       = R128PreInit;
 
288
            pScrn->ScreenInit    = R128ScreenInit;
 
289
            pScrn->SwitchMode    = R128SwitchMode;
 
290
            pScrn->AdjustFrame   = R128AdjustFrame;
 
291
            pScrn->EnterVT       = R128EnterVT;
 
292
            pScrn->LeaveVT       = R128LeaveVT;
 
293
            pScrn->FreeScreen    = R128FreeScreen;
 
294
            pScrn->ValidMode     = R128ValidMode;
 
295
 
 
296
            foundScreen          = TRUE;
 
297
 
 
298
            xf86ConfigActivePciEntity(pScrn, usedChips[i], R128PciChipsets,
 
299
                                      0, 0, 0, 0, 0);
 
300
        }
 
301
        xfree(pEnt);
 
302
    }
 
303
 
 
304
    xfree(usedChips);
 
305
    xfree(devSections);
 
306
 
 
307
    return foundScreen;
 
308
}