← Back to branch summary

~ubuntu-branches/ubuntu/edgy/xorg-server/edgy-updates

« back to all changes in this revision

Viewing changes to hw/kdrive/smi/smi.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Parra Novo
  • Date: 2006-07-25 20:06:28 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20060725200628-gjmmd9gxfxdc4ejs
Tags: 1:1.1.1-0ubuntu1
* New Upstream version
* Changed Build-Depends from mesa-swrast-source to mesa-swx11-source,
  following Debian package nomenclature
* Re-did 12_security_policy_in_etc.diff for 1.1.1
* Dropped 15_security_allocate_local.diff (applied upstream)
* Dropped 16_SECURITY_setuid.diff (applied upstream)
* Dropped 000_ubuntu_fix_read_kernel_mapping.patch (applied upstream)
* Dropped 002_ubuntu_fix_for_certain_intel_chipsets.patch (applied upstream)
* Updated versioned Build-Depends on mesa-swx11-source to version
  6.5.0.cvs.20060725-0ubuntu1
* Added arrayobj.c, arrayobj.h, bitset.h & rbadaptors.h to
  GL/symlink-mesa.sh (linked from mesa-swx11-source)
* Added arrayobj.c to default build target on GL/mesa/main

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/kdrive/smi/smi.c
 
1
/*
 
2
 * Copyright � 2001 Keith Packard
 
3
 *
 
4
 * Permission to use, copy, modify, distribute, and sell this software and its
 
5
 * documentation for any purpose is hereby granted without fee, provided that
 
6
 * the above copyright notice appear in all copies and that both that
 
7
 * copyright notice and this permission notice appear in supporting
 
8
 * documentation, and that the name of Keith Packard not be used in
 
9
 * advertising or publicity pertaining to distribution of the software without
 
10
 * specific, written prior permission.  Keith Packard makes no
 
11
 * representations about the suitability of this software for any purpose.  It
 
12
 * is provided "as is" without express or implied warranty.
 
13
 *
 
14
 * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 
15
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 
16
 * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 
17
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 
18
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 
19
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 
20
 * PERFORMANCE OF THIS SOFTWARE.
 
21
 */
 
22
/* $XFree86: xc/programs/Xserver/hw/kdrive/smi/smi.c,v 1.11 2002/10/18 06:31:17 keithp Exp $ */
 
23
 
 
24
#ifdef HAVE_CONFIG_H
 
25
#include <kdrive-config.h>
 
26
#endif
 
27
#include "smi.h"
 
28
#include "kaa.h"
 
29
#include <sys/io.h>
 
30
 
 
31
static Bool
 
32
smiCardInit (KdCardInfo *card)
 
33
{
 
34
    SmiCardInfo *smic;
 
35
 
 
36
    ENTER ();
 
37
    smic = (SmiCardInfo *) xalloc (sizeof (SmiCardInfo));
 
38
    if (!smic)
 
39
        return FALSE;
 
40
    memset (smic, '\0', sizeof (SmiCardInfo));
 
41
    
 
42
    (void) smiMapReg (card, smic);
 
43
 
 
44
    if (!subInitialize (card, &smic->sub))
 
45
    {
 
46
        xfree (smic);
 
47
        return FALSE;
 
48
    }
 
49
 
 
50
    card->driver = smic;
 
51
    LEAVE();
 
52
    return TRUE;
 
53
}
 
54
 
 
55
static Bool
 
56
smiScreenInit (KdScreenInfo *screen)
 
57
{
 
58
    SmiCardInfo         *smic = screen->card->driver;
 
59
    SmiScreenInfo       *smis;
 
60
 
 
61
    ENTER();
 
62
    smis = (SmiScreenInfo *) xalloc (sizeof (SmiScreenInfo));
 
63
    if (!smis)
 
64
        return FALSE;
 
65
    memset (smis, '\0', sizeof (SmiScreenInfo));
 
66
    screen->driver = smis;
 
67
    if (!subScreenInitialize (screen, &smis->sub))
 
68
    {
 
69
        xfree (smis);
 
70
        return FALSE;
 
71
    }
 
72
    if (!smic->reg_base)
 
73
        screen->dumb = TRUE;
 
74
    screen->softCursor = TRUE;
 
75
#if SMI_VESA
 
76
    smis->screen = smis->sub.fb;
 
77
#else
 
78
    smis->screen = smic->sub.fb;
 
79
#endif
 
80
    LEAVE();
 
81
    return TRUE;
 
82
}
 
83
 
 
84
static Bool
 
85
smiInitScreen (ScreenPtr pScreen)
 
86
{
 
87
    Bool    ret;
 
88
    ENTER ();
 
89
#if 0
 
90
#ifdef XV
 
91
    KdScreenPriv(pScreen);
 
92
    SmiCardInfo *smic = pScreenPriv->screen->card->driver;
 
93
    if (smic->media_reg && smic->reg)
 
94
        smiInitVideo(pScreen);
 
95
#endif
 
96
#endif
 
97
    ret = subInitScreen (pScreen);
 
98
    LEAVE();
 
99
    return ret;
 
100
}
 
101
 
 
102
#ifdef RANDR
 
103
static Bool
 
104
smiRandRSetConfig (ScreenPtr            pScreen,
 
105
                   Rotation             randr,
 
106
                   int                  rate,
 
107
                   RRScreenSizePtr      pSize)
 
108
{
 
109
    Bool    ret;
 
110
    
 
111
    ENTER ();
 
112
    kaaWaitSync (pScreen);
 
113
 
 
114
    ret = subRandRSetConfig (pScreen, randr, rate, pSize);
 
115
    LEAVE();
 
116
    return ret;
 
117
}
 
118
 
 
119
static Bool
 
120
smiRandRInit (ScreenPtr pScreen)
 
121
{
 
122
    rrScrPriv(pScreen);
 
123
 
 
124
    ENTER ();
 
125
    pScrPriv->rrSetConfig = smiRandRSetConfig;
 
126
    LEAVE ();
 
127
    return TRUE;
 
128
}
 
129
#endif
 
130
 
 
131
static Bool
 
132
smiFinishInitScreen (ScreenPtr pScreen)
 
133
{
 
134
    Bool    ret;
 
135
    ret = subFinishInitScreen (pScreen);
 
136
#ifdef RANDR
 
137
    smiRandRInit (pScreen);
 
138
#endif
 
139
    return ret;
 
140
}
 
141
 
 
142
void
 
143
smiPreserve (KdCardInfo *card)
 
144
{
 
145
    ENTER ();
 
146
    subPreserve(card);
 
147
    LEAVE();
 
148
}
 
149
 
 
150
Bool
 
151
smiMapReg (KdCardInfo *card, SmiCardInfo *smic)
 
152
{
 
153
    ENTER ();
 
154
    smic->io_base = 0;  /* only handles one SMI card at standard VGA address */
 
155
    smic->reg_base = (CARD8 *) KdMapDevice (SMI_REG_BASE(card),
 
156
                                            SMI_REG_SIZE(card));
 
157
    
 
158
    if (!smic->reg_base)
 
159
    {
 
160
        smic->dpr = 0;
 
161
        return FALSE;
 
162
    }
 
163
    
 
164
    KdSetMappedMode (SMI_REG_BASE(card),
 
165
                     SMI_REG_SIZE(card),
 
166
                     KD_MAPPED_MODE_REGISTERS);
 
167
    smic->dpr = (DPR *) (smic->reg_base + SMI_DPR_OFF(card));
 
168
    LEAVE ();
 
169
    return TRUE;
 
170
}
 
171
 
 
172
void
 
173
smiUnmapReg (KdCardInfo *card, SmiCardInfo *smic)
 
174
{
 
175
    ENTER ();
 
176
    if (smic->reg_base)
 
177
    {
 
178
        KdResetMappedMode (SMI_REG_BASE(card),
 
179
                           SMI_REG_SIZE(card),
 
180
                           KD_MAPPED_MODE_REGISTERS);
 
181
        KdUnmapDevice ((void *) smic->reg_base, SMI_REG_SIZE(card));
 
182
        smic->reg_base = 0;
 
183
        smic->dpr = 0;
 
184
    }
 
185
    LEAVE ();
 
186
}
 
187
 
 
188
void
 
189
smiOutb (CARD16 port, CARD8 val)
 
190
{
 
191
    asm volatile ("outb %b0,%w1" : : "a" (val), "d" (port));
 
192
}
 
193
 
 
194
CARD8
 
195
smiInb (CARD16 port)
 
196
{
 
197
    CARD8   v;
 
198
    asm volatile ("inb %w1,%b0" : "=a" (v) : "d" (port));
 
199
    return v;
 
200
}
 
201
 
 
202
CARD8
 
203
smiGetIndex (SmiCardInfo *smic, CARD16 addr, CARD16 data, CARD8 id)
 
204
{
 
205
    smiOutb (smic->io_base + addr, id);
 
206
    return smiInb (smic->io_base + data);
 
207
}
 
208
 
 
209
void
 
210
smiSetIndex (SmiCardInfo *smic, CARD16 addr, CARD16 data, CARD8 id, CARD8 val)
 
211
{
 
212
    smiOutb (smic->io_base + addr, id);
 
213
    smiOutb (smic->io_base + data, val);
 
214
}
 
215
 
 
216
void
 
217
smiSetMMIO (KdCardInfo *card, SmiCardInfo *smic)
 
218
{
 
219
    ENTER ();
 
220
    if (!smic->reg_base)
 
221
        smiMapReg (card, smic);
 
222
    LEAVE();
 
223
}
 
224
 
 
225
void
 
226
smiResetMMIO (KdCardInfo *card, SmiCardInfo *smic)
 
227
{
 
228
    smiUnmapReg (card, smic);
 
229
}
 
230
 
 
231
static Bool
 
232
smiDPMS (ScreenPtr pScreen, int mode)
 
233
{
 
234
    Bool    ret;
 
235
    ENTER ();
 
236
    ret = subDPMS (pScreen, mode);
 
237
    LEAVE ();
 
238
    return ret;
 
239
}
 
240
 
 
241
Bool
 
242
smiEnable (ScreenPtr pScreen)
 
243
{
 
244
    KdScreenPriv(pScreen);
 
245
    SmiCardInfo *smic = pScreenPriv->card->driver;
 
246
 
 
247
    ENTER ();
 
248
    iopl (3);
 
249
    if (!subEnable (pScreen))
 
250
        return FALSE;
 
251
    
 
252
    smiSetMMIO (pScreenPriv->card, smic);
 
253
    smiDPMS (pScreen, KD_DPMS_NORMAL);
 
254
#if 0
 
255
#ifdef XV
 
256
    KdXVEnable (pScreen);
 
257
#endif
 
258
#endif
 
259
    LEAVE ();
 
260
    return TRUE;
 
261
}
 
262
 
 
263
void
 
264
smiDisable (ScreenPtr pScreen)
 
265
{
 
266
    KdScreenPriv(pScreen);
 
267
    SmiCardInfo *smic = pScreenPriv->card->driver;
 
268
 
 
269
    ENTER ();
 
270
#if 0
 
271
#ifdef XV
 
272
    KdXVDisable (pScreen);
 
273
#endif
 
274
#endif
 
275
    smiResetMMIO (pScreenPriv->card, smic);
 
276
    subDisable (pScreen);
 
277
    LEAVE ();
 
278
}
 
279
 
 
280
static void
 
281
smiRestore (KdCardInfo *card)
 
282
{
 
283
    ENTER ();
 
284
    subRestore (card);
 
285
    LEAVE();
 
286
}
 
287
 
 
288
static void
 
289
smiScreenFini (KdScreenInfo *screen)
 
290
{
 
291
    SmiScreenInfo       *smis = (SmiScreenInfo *) screen->driver;
 
292
 
 
293
    ENTER ();
 
294
    subScreenFini (screen);
 
295
    xfree (smis);
 
296
    screen->driver = 0;
 
297
    LEAVE ();
 
298
}
 
299
 
 
300
static void
 
301
smiCardFini (KdCardInfo *card)
 
302
{
 
303
    SmiCardInfo *smic = card->driver;
 
304
 
 
305
    ENTER ();
 
306
    smiUnmapReg (card, smic);
 
307
    subCardFini (card);
 
308
    LEAVE ();
 
309
}
 
310
 
 
311
#define smiCursorInit 0       /* initCursor */
 
312
#define smiCursorEnable 0    /* enableCursor */
 
313
#define smiCursorDisable 0   /* disableCursor */
 
314
#define smiCursorFini 0       /* finiCursor */
 
315
#define smiRecolorCursor 0   /* recolorCursor */
 
316
 
 
317
KdCardFuncs     smiFuncs = {
 
318
    smiCardInit,            /* cardinit */
 
319
    smiScreenInit,          /* scrinit */
 
320
    smiInitScreen,          /* initScreen */
 
321
    smiFinishInitScreen,    /* finishInitScreen */
 
322
    subCreateResources,     /* createRes */
 
323
    smiPreserve,            /* preserve */
 
324
    smiEnable,              /* enable */
 
325
    smiDPMS,                /* dpms */
 
326
    smiDisable,             /* disable */
 
327
    smiRestore,             /* restore */
 
328
    smiScreenFini,          /* scrfini */
 
329
    smiCardFini,            /* cardfini */
 
330
    
 
331
    smiCursorInit,          /* initCursor */
 
332
    smiCursorEnable,        /* enableCursor */
 
333
    smiCursorDisable,       /* disableCursor */
 
334
    smiCursorFini,          /* finiCursor */
 
335
    smiRecolorCursor,       /* recolorCursor */
 
336
    
 
337
    smiDrawInit,            /* initAccel */
 
338
    smiDrawEnable,          /* enableAccel */
 
339
    smiDrawDisable,         /* disableAccel */
 
340
    smiDrawFini,            /* finiAccel */
 
341
    
 
342
    subGetColors,           /* getColors */
 
343
    subPutColors,           /* putColors */
 
344
};