1c06b6b69Smrg
2c06b6b69Smrg/*
3c06b6b69Smrg * Copyright 1997
4c06b6b69Smrg * Digital Equipment Corporation. All rights reserved.
5c06b6b69Smrg * This software is furnished under license and may be used and copied only in
6c06b6b69Smrg * accordance with the following terms and conditions.  Subject to these
7c06b6b69Smrg * conditions, you may download, copy, install, use, modify and distribute
8c06b6b69Smrg * this software in source and/or binary form. No title or ownership is
9c06b6b69Smrg * transferred hereby.
10c06b6b69Smrg * 1) Any source code used, modified or distributed must reproduce and retain
11c06b6b69Smrg *    this copyright notice and list of conditions as they appear in the
12c06b6b69Smrg *    source file.
13c06b6b69Smrg *
14c06b6b69Smrg * 2) No right is granted to use any trade name, trademark, or logo of Digital
15c06b6b69Smrg *    Equipment Corporation. Neither the "Digital Equipment Corporation" name
16c06b6b69Smrg *    nor any trademark or logo of Digital Equipment Corporation may be used
17c06b6b69Smrg *    to endorse or promote products derived from this software without the
18c06b6b69Smrg *    prior written permission of Digital Equipment Corporation.
19c06b6b69Smrg *
20c06b6b69Smrg * 3) This software is provided "AS-IS" and any express or implied warranties,
21c06b6b69Smrg *    including but not limited to, any implied warranties of merchantability,
22c06b6b69Smrg *    fitness for a particular purpose, or non-infringement are disclaimed. In
23c06b6b69Smrg *    no event shall DIGITAL be liable for any damages whatsoever, and in
24c06b6b69Smrg *    particular, DIGITAL shall not be liable for special, indirect,
25c06b6b69Smrg *    consequential, or incidental damages or damages for lost profits, loss
26c06b6b69Smrg *    of revenue or loss of use, whether such damages arise in contract,
27c06b6b69Smrg *    negligence, tort, under statute, in equity, at law or otherwise, even if
28c06b6b69Smrg *    advised of the possibility of such damage.
29c06b6b69Smrg */
30c06b6b69Smrg
31c06b6b69Smrg#ifdef HAVE_CONFIG_H
32c06b6b69Smrg#include "config.h"
33c06b6b69Smrg#endif
34c06b6b69Smrg
35c06b6b69Smrg#define PSZ 8
36c06b6b69Smrg
37c06b6b69Smrg/*
38c06b6b69Smrg * Define DIRECT_REGISTER_ACCESS if you want to bypass the wrapped register
39c06b6b69Smrg * access functions
40c06b6b69Smrg */
41c06b6b69Smrg/* #define DIRECT_REGISTER_ACCESS */
42c06b6b69Smrg
43c06b6b69Smrg/* All drivers should typically include these */
44c06b6b69Smrg#include "xf86.h"
45c06b6b69Smrg#include "xf86_OSproc.h"
46c06b6b69Smrg
47c06b6b69Smrg/* Everything using inb/outb, etc needs "compiler.h" */
48c06b6b69Smrg#include "compiler.h"
49c06b6b69Smrg
50c06b6b69Smrg/* Drivers that need to access the PCI config space directly need this */
51c06b6b69Smrg#include "xf86Pci.h"
52c06b6b69Smrg
53c06b6b69Smrg/* Driver specific headers */
54c06b6b69Smrg#include "ct_driver.h"
55c06b6b69Smrg
56c06b6b69Smrg#if defined(__arm32__) && defined(__NetBSD__)
57c06b6b69Smrg#include <machine/sysarch.h>
58c06b6b69Smrg#define	arm32_drain_writebuf()	sysarch(1, 0)
59c06b6b69Smrg#elif defined(__arm32__)
60c06b6b69Smrg#define arm32_drain_writebuf()
61c06b6b69Smrg#endif
62c06b6b69Smrg
63a1d73b4bSmrg#define ChipsBank(pScreen) CHIPSPTR(xf86ScreenToScrn(pScreen))->Bank
64c06b6b69Smrg
65c06b6b69Smrg#ifdef DIRECT_REGISTER_ACCESS
66c06b6b69Smrgint
67c06b6b69SmrgCHIPSSetRead(ScreenPtr pScreen, int bank)
68c06b6b69Smrg{
69a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
70c06b6b69Smrg
71c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 3) & 0xFF) << 8) | 0x10));
72c06b6b69Smrg
73c06b6b69Smrg#ifdef	__arm32__
74c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
75c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
76c06b6b69Smrg	arm32_drain_writebuf();
77c06b6b69Smrg	ChipsBank(pScreen) = bank;
78c06b6b69Smrg    }
79c06b6b69Smrg#endif
80c06b6b69Smrg
81c06b6b69Smrg    return 0;
82c06b6b69Smrg}
83c06b6b69Smrg
84c06b6b69Smrg
85c06b6b69Smrgint
86c06b6b69SmrgCHIPSSetWrite(ScreenPtr pScreen, int bank)
87c06b6b69Smrg{
88a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
89c06b6b69Smrg
90c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 3) & 0xFF) << 8) | 0x11));
91c06b6b69Smrg
92c06b6b69Smrg#ifdef	__arm32__
93c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
94c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
95c06b6b69Smrg	arm32_drain_writebuf();
96c06b6b69Smrg	ChipsBank(pScreen) = bank;
97c06b6b69Smrg    }
98c06b6b69Smrg#endif
99c06b6b69Smrg
100c06b6b69Smrg    return 0;
101c06b6b69Smrg}
102c06b6b69Smrg
103c06b6b69Smrg
104c06b6b69Smrgint
105c06b6b69SmrgCHIPSSetReadWrite(ScreenPtr pScreen, int bank)
106c06b6b69Smrg{
107a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
108c06b6b69Smrg
109c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 3) & 0xFF) << 8) | 0x10));
110c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 3) & 0xFF) << 8) | 0x11));
111c06b6b69Smrg
112c06b6b69Smrg#ifdef	__arm32__
113c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
114c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
115c06b6b69Smrg	arm32_drain_writebuf();
116c06b6b69Smrg	ChipsBank(pScreen) = bank;
117c06b6b69Smrg    }
118c06b6b69Smrg#endif
119c06b6b69Smrg
120c06b6b69Smrg    return 0;
121c06b6b69Smrg}
122c06b6b69Smrg
123c06b6b69Smrgint
124c06b6b69SmrgCHIPSSetReadPlanar(ScreenPtr pScreen, int bank)
125c06b6b69Smrg{
126a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
127c06b6b69Smrg
128c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 5) & 0xFF) << 8) | 0x10));
129c06b6b69Smrg
130c06b6b69Smrg#ifdef	__arm32__
131c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
132c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
133c06b6b69Smrg	arm32_drain_writebuf();
134c06b6b69Smrg	ChipsBank(pScreen) = bank;
135c06b6b69Smrg    }
136c06b6b69Smrg#endif
137c06b6b69Smrg
138c06b6b69Smrg    return 0;
139c06b6b69Smrg}
140c06b6b69Smrg
141c06b6b69Smrgint
142c06b6b69SmrgCHIPSSetWritePlanar(ScreenPtr pScreen, int bank)
143c06b6b69Smrg{
144a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
145c06b6b69Smrg
146c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 5) & 0xFF) << 8) | 0x11));
147c06b6b69Smrg
148c06b6b69Smrg#ifdef	__arm32__
149c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
150c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
151c06b6b69Smrg	arm32_drain_writebuf();
152c06b6b69Smrg	ChipsBank(pScreen) = bank;
153c06b6b69Smrg    }
154c06b6b69Smrg#endif
155c06b6b69Smrg
156c06b6b69Smrg    return 0;
157c06b6b69Smrg}
158c06b6b69Smrg
159c06b6b69Smrgint
160c06b6b69SmrgCHIPSSetReadWritePlanar(ScreenPtr pScreen, int bank)
161c06b6b69Smrg{
162a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
163c06b6b69Smrg
164c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 5) & 0xFF) << 8) | 0x10));
165c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 5) & 0xFF) << 8) | 0x11));
166c06b6b69Smrg
167c06b6b69Smrg#ifdef	__arm32__
168c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
169c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
170c06b6b69Smrg	arm32_drain_writebuf();
171c06b6b69Smrg	ChipsBank(pScreen) = bank;
172c06b6b69Smrg    }
173c06b6b69Smrg#endif
174c06b6b69Smrg
175c06b6b69Smrg    return 0;
176c06b6b69Smrg}
177c06b6b69Smrg
178c06b6b69Smrgint
179c06b6b69SmrgCHIPSWINSetRead(ScreenPtr pScreen, int bank)
180c06b6b69Smrg{
181a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
182c06b6b69Smrg    register unsigned char tmp;
183c06b6b69Smrg
184c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 3) & 0xFF) << 8) | 0x10));
185c06b6b69Smrg    outb(cPtr->PIOBase + 0x3D6, 0x0C);
186c06b6b69Smrg    tmp = inb(cPtr->PIOBase + 0x3D7) & 0xEF;
187c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, (((((bank >> 1) & 0x10) | tmp) << 8) | 0x0C));
188c06b6b69Smrg
189c06b6b69Smrg#ifdef	__arm32__
190c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
191c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
192c06b6b69Smrg	arm32_drain_writebuf();
193c06b6b69Smrg	ChipsBank(pScreen) = bank;
194c06b6b69Smrg    }
195c06b6b69Smrg#endif
196c06b6b69Smrg
197c06b6b69Smrg    return 0;
198c06b6b69Smrg}
199c06b6b69Smrg
200c06b6b69Smrg
201c06b6b69Smrgint
202c06b6b69SmrgCHIPSWINSetWrite(ScreenPtr pScreen, int bank)
203c06b6b69Smrg{
204a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
205c06b6b69Smrg    register unsigned char tmp;
206c06b6b69Smrg
207c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 3) & 0xFF) << 8) | 0x11));
208c06b6b69Smrg    outb(cPtr->PIOBase + 0x3D6, 0x0C);
209c06b6b69Smrg    tmp = inb(cPtr->PIOBase + 0x3D7) & 0xBF;
210c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, (((((bank << 1) & 0x40) | tmp) << 8) | 0x0C));
211c06b6b69Smrg
212c06b6b69Smrg#ifdef	__arm32__
213c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
214c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
215c06b6b69Smrg	arm32_drain_writebuf();
216c06b6b69Smrg	ChipsBank(pScreen) = bank;
217c06b6b69Smrg    }
218c06b6b69Smrg#endif
219c06b6b69Smrg
220c06b6b69Smrg    return 0;
221c06b6b69Smrg}
222c06b6b69Smrg
223c06b6b69Smrgint
224c06b6b69SmrgCHIPSWINSetReadWrite(ScreenPtr pScreen, int bank)
225c06b6b69Smrg{
226a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
227c06b6b69Smrg    register unsigned char tmp;
228c06b6b69Smrg
229c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 3) & 0xFF) << 8) | 0x10));
230c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 3) & 0xFF) << 8) | 0x11));
231c06b6b69Smrg    outb(cPtr->PIOBase + 0x3D6, 0x0C);
232c06b6b69Smrg    tmp = inb(cPtr->PIOBase + 0x3D7) & 0xAF;
233c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6,
234c06b6b69Smrg	(((((bank << 1) & 0x40) | ((bank >> 1) & 0x10) | tmp) << 8) | 0x0C));
235c06b6b69Smrg
236c06b6b69Smrg#ifdef	__arm32__
237c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
238c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
239c06b6b69Smrg	arm32_drain_writebuf();
240c06b6b69Smrg	ChipsBank(pScreen) = bank;
241c06b6b69Smrg    }
242c06b6b69Smrg#endif
243c06b6b69Smrg
244c06b6b69Smrg    return 0;
245c06b6b69Smrg}
246c06b6b69Smrg
247c06b6b69Smrgint
248c06b6b69SmrgCHIPSWINSetReadPlanar(ScreenPtr pScreen, int bank)
249c06b6b69Smrg{
250a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
251c06b6b69Smrg    register unsigned char tmp;
252c06b6b69Smrg
253c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 5) & 0xFF) << 8) | 0x10));
254c06b6b69Smrg    outb(cPtr->PIOBase + 0x3D6, 0x0C);
255c06b6b69Smrg    tmp = inb(cPtr->PIOBase + 0x3D7) & 0xEF;
256c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, (((((bank << 1) & 0x10) | tmp) << 8) | 0x0C));
257c06b6b69Smrg
258c06b6b69Smrg#ifdef	__arm32__
259c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
260c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
261c06b6b69Smrg	arm32_drain_writebuf();
262c06b6b69Smrg	ChipsBank(pScreen) = bank;
263c06b6b69Smrg    }
264c06b6b69Smrg#endif
265c06b6b69Smrg
266c06b6b69Smrg    return 0;
267c06b6b69Smrg}
268c06b6b69Smrg
269c06b6b69Smrgint
270c06b6b69SmrgCHIPSWINSetWritePlanar(ScreenPtr pScreen, int bank)
271c06b6b69Smrg{
272a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
273c06b6b69Smrg    register unsigned char tmp;
274c06b6b69Smrg
275c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 5) & 0xFF) << 8) | 0x11));
276c06b6b69Smrg    outb(cPtr->PIOBase + 0x3D6, 0x0C);
277c06b6b69Smrg    tmp = inb(cPtr->PIOBase + 0x3D7) & 0xBF;
278c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, (((((bank << 3) & 0x40) | tmp) << 8) | 0x0C));
279c06b6b69Smrg
280c06b6b69Smrg#ifdef	__arm32__
281c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
282c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
283c06b6b69Smrg	arm32_drain_writebuf();
284c06b6b69Smrg	ChipsBank(pScreen) = bank;
285c06b6b69Smrg    }
286c06b6b69Smrg#endif
287c06b6b69Smrg
288c06b6b69Smrg    return 0;
289c06b6b69Smrg}
290c06b6b69Smrg
291c06b6b69Smrgint
292c06b6b69SmrgCHIPSWINSetReadWritePlanar(ScreenPtr pScreen, int bank)
293c06b6b69Smrg{
294a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
295c06b6b69Smrg    register unsigned char tmp;
296c06b6b69Smrg
297c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 5) & 0xFF) << 8) | 0x10));
298c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 5) & 0xFF) << 8) | 0x11));
299c06b6b69Smrg    outb(cPtr->PIOBase + 0x3D6, 0x0C);
300c06b6b69Smrg    tmp = inb(cPtr->PIOBase + 0x3D7) & 0xAF;
301c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6,
302c06b6b69Smrg	(((((bank << 3) & 0x40) | ((bank << 1) & 0x10) | tmp) << 8) | 0x0C));
303c06b6b69Smrg
304c06b6b69Smrg#ifdef	__arm32__
305c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
306c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
307c06b6b69Smrg	arm32_drain_writebuf();
308c06b6b69Smrg	ChipsBank(pScreen) = bank;
309c06b6b69Smrg    }
310c06b6b69Smrg#endif
311c06b6b69Smrg
312c06b6b69Smrg    return 0;
313c06b6b69Smrg}
314c06b6b69Smrg
315c06b6b69Smrgint
316c06b6b69SmrgCHIPSHiQVSetReadWrite(ScreenPtr pScreen, int bank)
317c06b6b69Smrg{
318a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
319c06b6b69Smrg
320c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, (((bank & 0x7F) << 8) | 0x0E));
321c06b6b69Smrg
322c06b6b69Smrg#ifdef	__arm32__
323c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
324c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
325c06b6b69Smrg	arm32_drain_writebuf();
326c06b6b69Smrg	ChipsBank(pScreen) = bank;
327c06b6b69Smrg    }
328c06b6b69Smrg#endif
329c06b6b69Smrg
330c06b6b69Smrg    return 0;
331c06b6b69Smrg}
332c06b6b69Smrg
333c06b6b69Smrgint
334c06b6b69SmrgCHIPSHiQVSetReadWritePlanar(ScreenPtr pScreen, int bank)
335c06b6b69Smrg{
336a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
337c06b6b69Smrg
338c06b6b69Smrg    outw(cPtr->PIOBase + 0x3D6, ((((bank << 2) & 0x7F) << 8) | 0x0E));
339c06b6b69Smrg
340c06b6b69Smrg#ifdef	__arm32__
341c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
342c06b6b69Smrg    if (bank != ChipsBank(pScreen)) {
343c06b6b69Smrg	arm32_drain_writebuf();
344c06b6b69Smrg	ChipsBank(pScreen) = bank;
345c06b6b69Smrg    }
346c06b6b69Smrg#endif
347c06b6b69Smrg
348c06b6b69Smrg    return 0;
349c06b6b69Smrg}
350c06b6b69Smrg
351c06b6b69Smrg#else /* DIRECT_REGISTER_ACCESS */
352c06b6b69Smrg
353c06b6b69Smrgint
354c06b6b69SmrgCHIPSSetRead(ScreenPtr pScreen, int bank)
355c06b6b69Smrg{
356a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
357c06b6b69Smrg
358c06b6b69Smrg    cPtr->writeXR(cPtr, 0x10, ((bank << 3) & 0xFF));
359c06b6b69Smrg
360c06b6b69Smrg#ifdef	__arm32__
361c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
362c06b6b69Smrg    if (bank != cPtr->Bank) {
363c06b6b69Smrg	arm32_drain_writebuf();
364c06b6b69Smrg	cPtr->Bank = bank;
365c06b6b69Smrg    }
366c06b6b69Smrg#endif
367c06b6b69Smrg
368c06b6b69Smrg    return 0;
369c06b6b69Smrg}
370c06b6b69Smrg
371c06b6b69Smrg
372c06b6b69Smrgint
373c06b6b69SmrgCHIPSSetWrite(ScreenPtr pScreen, int bank)
374c06b6b69Smrg{
375a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
376c06b6b69Smrg
377c06b6b69Smrg    cPtr->writeXR(cPtr, 0x11, ((bank << 3) & 0xFF));
378c06b6b69Smrg
379c06b6b69Smrg#ifdef	__arm32__
380c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
381c06b6b69Smrg    if (bank != cPtr->Bank) {
382c06b6b69Smrg	arm32_drain_writebuf();
383c06b6b69Smrg	cPtr->Bank = bank;
384c06b6b69Smrg    }
385c06b6b69Smrg#endif
386c06b6b69Smrg
387c06b6b69Smrg    return 0;
388c06b6b69Smrg}
389c06b6b69Smrg
390c06b6b69Smrg
391c06b6b69Smrgint
392c06b6b69SmrgCHIPSSetReadWrite(ScreenPtr pScreen, int bank)
393c06b6b69Smrg{
394a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
395c06b6b69Smrg
396c06b6b69Smrg    cPtr->writeXR(cPtr, 0x10, ((bank << 3) & 0xFF));
397c06b6b69Smrg    cPtr->writeXR(cPtr, 0x11, ((bank << 3) & 0xFF));
398c06b6b69Smrg
399c06b6b69Smrg#ifdef	__arm32__
400c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
401c06b6b69Smrg    if (bank != cPtr->Bank) {
402c06b6b69Smrg	arm32_drain_writebuf();
403c06b6b69Smrg	cPtr->Bank = bank;
404c06b6b69Smrg    }
405c06b6b69Smrg#endif
406c06b6b69Smrg
407c06b6b69Smrg    return 0;
408c06b6b69Smrg}
409c06b6b69Smrg
410c06b6b69Smrgint
411c06b6b69SmrgCHIPSSetReadPlanar(ScreenPtr pScreen, int bank)
412c06b6b69Smrg{
413a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
414c06b6b69Smrg
415c06b6b69Smrg    cPtr->writeXR(cPtr, 0x10, ((bank << 5) & 0xFF));
416c06b6b69Smrg
417c06b6b69Smrg#ifdef	__arm32__
418c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
419c06b6b69Smrg    if (bank != cPtr->Bank) {
420c06b6b69Smrg	arm32_drain_writebuf();
421c06b6b69Smrg	cPtr->Bank = bank;
422c06b6b69Smrg    }
423c06b6b69Smrg#endif
424c06b6b69Smrg
425c06b6b69Smrg    return 0;
426c06b6b69Smrg}
427c06b6b69Smrg
428c06b6b69Smrgint
429c06b6b69SmrgCHIPSSetWritePlanar(ScreenPtr pScreen, int bank)
430c06b6b69Smrg{
431a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
432c06b6b69Smrg
433c06b6b69Smrg    cPtr->writeXR(cPtr, 0x11, ((bank << 5) & 0xFF));
434c06b6b69Smrg
435c06b6b69Smrg#ifdef	__arm32__
436c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
437c06b6b69Smrg    if (bank != cPtr->Bank) {
438c06b6b69Smrg	arm32_drain_writebuf();
439c06b6b69Smrg	cPtr->Bank = bank;
440c06b6b69Smrg    }
441c06b6b69Smrg#endif
442c06b6b69Smrg
443c06b6b69Smrg    return 0;
444c06b6b69Smrg}
445c06b6b69Smrg
446c06b6b69Smrgint
447c06b6b69SmrgCHIPSSetReadWritePlanar(ScreenPtr pScreen, int bank)
448c06b6b69Smrg{
449a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
450c06b6b69Smrg
451c06b6b69Smrg    cPtr->writeXR(cPtr, 0x10, ((bank << 5) & 0xFF));
452c06b6b69Smrg    cPtr->writeXR(cPtr, 0x11, ((bank << 5) & 0xFF));
453c06b6b69Smrg
454c06b6b69Smrg#ifdef	__arm32__
455c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
456c06b6b69Smrg    if (bank != cPtr->Bank) {
457c06b6b69Smrg	arm32_drain_writebuf();
458c06b6b69Smrg	cPtr->Bank = bank;
459c06b6b69Smrg    }
460c06b6b69Smrg#endif
461c06b6b69Smrg
462c06b6b69Smrg    return 0;
463c06b6b69Smrg}
464c06b6b69Smrg
465c06b6b69Smrgint
466c06b6b69SmrgCHIPSWINSetRead(ScreenPtr pScreen, int bank)
467c06b6b69Smrg{
468a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
469c06b6b69Smrg    register unsigned char tmp;
470c06b6b69Smrg
471c06b6b69Smrg    cPtr->writeXR(cPtr, 0x10, ((bank << 3) & 0xFF));
472c06b6b69Smrg    tmp = cPtr->readXR(cPtr, 0x0C) & 0xEF;
473c06b6b69Smrg    cPtr->writeXR(cPtr, 0x0C, ((bank >> 1) & 0x10) | tmp);
474c06b6b69Smrg
475c06b6b69Smrg#ifdef	__arm32__
476c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
477c06b6b69Smrg    if (bank != cPtr->Bank) {
478c06b6b69Smrg	arm32_drain_writebuf();
479c06b6b69Smrg	cPtr->Bank = bank;
480c06b6b69Smrg    }
481c06b6b69Smrg#endif
482c06b6b69Smrg
483c06b6b69Smrg    return 0;
484c06b6b69Smrg}
485c06b6b69Smrg
486c06b6b69Smrg
487c06b6b69Smrgint
488c06b6b69SmrgCHIPSWINSetWrite(ScreenPtr pScreen, int bank)
489c06b6b69Smrg{
490a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
491c06b6b69Smrg    register unsigned char tmp;
492c06b6b69Smrg
493c06b6b69Smrg    cPtr->writeXR(cPtr, 0x11, ((bank << 3) & 0xFF));
494c06b6b69Smrg    tmp = cPtr->readXR(cPtr, 0x0C) & 0xBF;
495c06b6b69Smrg    cPtr->writeXR(cPtr, 0x0C, ((bank << 1) & 0x40) | tmp);
496c06b6b69Smrg
497c06b6b69Smrg#ifdef	__arm32__
498c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
499c06b6b69Smrg    if (bank != cPtr->Bank) {
500c06b6b69Smrg	arm32_drain_writebuf();
501c06b6b69Smrg	cPtr->Bank = bank;
502c06b6b69Smrg    }
503c06b6b69Smrg#endif
504c06b6b69Smrg
505c06b6b69Smrg    return 0;
506c06b6b69Smrg}
507c06b6b69Smrg
508c06b6b69Smrgint
509c06b6b69SmrgCHIPSWINSetReadWrite(ScreenPtr pScreen, int bank)
510c06b6b69Smrg{
511a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
512c06b6b69Smrg    register unsigned char tmp;
513c06b6b69Smrg
514c06b6b69Smrg    cPtr->writeXR(cPtr, 0x10, ((bank << 3) & 0xFF));
515c06b6b69Smrg    cPtr->writeXR(cPtr, 0x11, ((bank << 3) & 0xFF));
516c06b6b69Smrg    tmp = cPtr->readXR(cPtr, 0x0C) & 0xAF;
517c06b6b69Smrg    cPtr->writeXR(cPtr, 0x0C, ((bank << 1) & 0x40) | ((bank >> 1) & 0x10) | tmp);
518c06b6b69Smrg
519c06b6b69Smrg#ifdef	__arm32__
520c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
521c06b6b69Smrg    if (bank != cPtr->Bank) {
522c06b6b69Smrg	arm32_drain_writebuf();
523c06b6b69Smrg	cPtr->Bank = bank;
524c06b6b69Smrg    }
525c06b6b69Smrg#endif
526c06b6b69Smrg
527c06b6b69Smrg    return 0;
528c06b6b69Smrg}
529c06b6b69Smrg
530c06b6b69Smrgint
531c06b6b69SmrgCHIPSWINSetReadPlanar(ScreenPtr pScreen, int bank)
532c06b6b69Smrg{
533a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
534c06b6b69Smrg    register unsigned char tmp;
535c06b6b69Smrg
536c06b6b69Smrg    cPtr->writeXR(cPtr, 0x10, ((bank << 5) & 0xFF));
537c06b6b69Smrg    tmp = cPtr->readXR(cPtr, 0x0C) & 0xEF;
538c06b6b69Smrg    cPtr->writeXR(cPtr, 0x0C, ((bank << 1) & 0x10) | tmp);
539c06b6b69Smrg
540c06b6b69Smrg#ifdef	__arm32__
541c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
542c06b6b69Smrg    if (bank != cPtr->Bank) {
543c06b6b69Smrg	arm32_drain_writebuf();
544c06b6b69Smrg	cPtr->Bank = bank;
545c06b6b69Smrg    }
546c06b6b69Smrg#endif
547c06b6b69Smrg
548c06b6b69Smrg    return 0;
549c06b6b69Smrg}
550c06b6b69Smrg
551c06b6b69Smrgint
552c06b6b69SmrgCHIPSWINSetWritePlanar(ScreenPtr pScreen, int bank)
553c06b6b69Smrg{
554a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
555c06b6b69Smrg    register unsigned char tmp;
556c06b6b69Smrg
557c06b6b69Smrg    cPtr->writeXR(cPtr, 0x11, ((bank << 5) & 0xFF));
558c06b6b69Smrg    tmp = cPtr->readXR(cPtr, 0x0C) & 0xBF;
559c06b6b69Smrg    cPtr->writeXR(cPtr, 0x0C, ((bank << 3) & 0x40) | tmp);
560c06b6b69Smrg
561c06b6b69Smrg#ifdef	__arm32__
562c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
563c06b6b69Smrg    if (bank != cPtr->Bank) {
564c06b6b69Smrg	arm32_drain_writebuf();
565c06b6b69Smrg	cPtr->Bank = bank;
566c06b6b69Smrg    }
567c06b6b69Smrg#endif
568c06b6b69Smrg
569c06b6b69Smrg    return 0;
570c06b6b69Smrg}
571c06b6b69Smrg
572c06b6b69Smrgint
573c06b6b69SmrgCHIPSWINSetReadWritePlanar(ScreenPtr pScreen, int bank)
574c06b6b69Smrg{
575a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
576c06b6b69Smrg    register unsigned char tmp;
577c06b6b69Smrg
578c06b6b69Smrg    cPtr->writeXR(cPtr, 0x10, ((bank << 5) & 0xFF));
579c06b6b69Smrg    cPtr->writeXR(cPtr, 0x11, ((bank << 5) & 0xFF));
580c06b6b69Smrg    tmp = cPtr->readXR(cPtr, 0x0C) & 0xAF;
581c06b6b69Smrg    cPtr->writeXR(cPtr, 0x0C, ((bank << 3) & 0x40) | ((bank << 1) & 0x10) | tmp);
582c06b6b69Smrg
583c06b6b69Smrg#ifdef	__arm32__
584c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
585c06b6b69Smrg    if (bank != cPtr->Bank) {
586c06b6b69Smrg	arm32_drain_writebuf();
587c06b6b69Smrg	cPtr->Bank = bank;
588c06b6b69Smrg    }
589c06b6b69Smrg#endif
590c06b6b69Smrg
591c06b6b69Smrg    return 0;
592c06b6b69Smrg}
593c06b6b69Smrg
594c06b6b69Smrgint
595c06b6b69SmrgCHIPSHiQVSetReadWrite(ScreenPtr pScreen, int bank)
596c06b6b69Smrg{
597a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
598c06b6b69Smrg
599c06b6b69Smrg    cPtr->writeXR(cPtr, 0x0E, bank & 0x7F);
600c06b6b69Smrg
601c06b6b69Smrg#ifdef	__arm32__
602c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
603c06b6b69Smrg    if (bank != cPtr->Bank) {
604c06b6b69Smrg	arm32_drain_writebuf();
605c06b6b69Smrg	cPtr->Bank = bank;
606c06b6b69Smrg    }
607c06b6b69Smrg#endif
608c06b6b69Smrg
609c06b6b69Smrg    return 0;
610c06b6b69Smrg}
611c06b6b69Smrg
612c06b6b69Smrgint
613c06b6b69SmrgCHIPSHiQVSetReadWritePlanar(ScreenPtr pScreen, int bank)
614c06b6b69Smrg{
615a1d73b4bSmrg    CHIPSPtr cPtr = CHIPSPTR(xf86ScreenToScrn(pScreen));
616c06b6b69Smrg
617c06b6b69Smrg    cPtr->writeXR(cPtr, 0x0E, (bank << 2) & 0x7F);
618c06b6b69Smrg
619c06b6b69Smrg#ifdef	__arm32__
620c06b6b69Smrg    /* Must drain StrongARM write buffer on bank switch! */
621c06b6b69Smrg    if (bank != cPtr->Bank) {
622c06b6b69Smrg	arm32_drain_writebuf();
623c06b6b69Smrg	cPtr->Bank = bank;
624c06b6b69Smrg    }
625c06b6b69Smrg#endif
626c06b6b69Smrg
627c06b6b69Smrg    return 0;
628c06b6b69Smrg}
629c06b6b69Smrg#endif
630