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