wsfb_driver.c revision 5d492fd2
1/* $OpenBSD: wsfb_driver.c,v 1.19 2003/04/27 16:42:32 matthieu Exp $ */ 2/* 3 * Copyright (c) 2001 Matthieu Herrb 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * - Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * - Redistributions in binary form must reproduce the above 13 * copyright notice, this list of conditions and the following 14 * disclaimer in the documentation and/or other materials provided 15 * with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 20 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 21 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 25 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 27 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 * 30 */ 31 32/* 33 * Based on fbdev.c written by: 34 * 35 * Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk> 36 * Michel Dänzer, <michdaen@iiic.ethz.ch> 37 */ 38 39#ifdef HAVE_CONFIG_H 40#include "config.h" 41#endif 42 43#include <fcntl.h> 44#include <sys/types.h> 45#include <sys/time.h> 46#include <dev/wscons/wsconsio.h> 47 48/* all driver need this */ 49#include "xf86.h" 50#include "xf86_OSproc.h" 51#include "xf86_ansic.h" 52 53#include "mipointer.h" 54#include "mibstore.h" 55#include "micmap.h" 56#include "colormapst.h" 57#include "xf86cmap.h" 58#include "shadow.h" 59#include "dgaproc.h" 60 61/* for visuals */ 62#include "xf1bpp.h" 63#include "xf4bpp.h" 64#include "fb.h" 65 66#include "xf86Resources.h" 67#include "xf86RAC.h" 68 69#ifdef XvExtension 70#include "xf86xv.h" 71#endif 72 73#include "wsfb.h" 74 75/* #include "wsconsio.h" */ 76 77#ifndef XFree86LOADER 78#include <sys/mman.h> 79#endif 80 81#ifdef USE_PRIVSEP 82extern int priv_open_device(const char *); 83#else 84#define priv_open_device(n) open(n,O_RDWR|O_NONBLOCK|O_EXCL) 85#endif 86 87#if defined(__NetBSD__) 88#define WSFB_DEFAULT_DEV "/dev/ttyE0" 89#else 90#define WSFB_DEFAULT_DEV "/dev/ttyC0" 91#endif 92 93#define DEBUG 0 94 95#if DEBUG 96# define TRACE_ENTER(str) ErrorF("wsfb: " str " %d\n",pScrn->scrnIndex) 97# define TRACE_EXIT(str) ErrorF("wsfb: " str " done\n") 98# define TRACE(str) ErrorF("wsfb trace: " str "\n") 99#else 100# define TRACE_ENTER(str) 101# define TRACE_EXIT(str) 102# define TRACE(str) 103#endif 104 105/* Prototypes */ 106#ifdef XFree86LOADER 107static pointer WsfbSetup(pointer, pointer, int *, int *); 108#endif 109static Bool WsfbGetRec(ScrnInfoPtr); 110static void WsfbFreeRec(ScrnInfoPtr); 111static const OptionInfoRec * WsfbAvailableOptions(int, int); 112static void WsfbIdentify(int); 113static Bool WsfbProbe(DriverPtr, int); 114static Bool WsfbPreInit(ScrnInfoPtr, int); 115static Bool WsfbScreenInit(int, ScreenPtr, int, char **); 116static Bool WsfbCloseScreen(int, ScreenPtr); 117static void *WsfbWindowLinear(ScreenPtr, CARD32, CARD32, int, CARD32 *, 118 void *); 119static void WsfbPointerMoved(int, int, int); 120static Bool WsfbEnterVT(int, int); 121static void WsfbLeaveVT(int, int); 122static Bool WsfbSwitchMode(int, DisplayModePtr, int); 123static int WsfbValidMode(int, DisplayModePtr, Bool, int); 124static void WsfbLoadPalette(ScrnInfoPtr, int, int *, LOCO *, VisualPtr); 125static Bool WsfbSaveScreen(ScreenPtr, int); 126static void WsfbSave(ScrnInfoPtr); 127static void WsfbRestore(ScrnInfoPtr); 128 129/* dga stuff */ 130#ifdef XFreeXDGA 131static Bool WsfbDGAOpenFramebuffer(ScrnInfoPtr, char **, unsigned char **, 132 int *, int *, int *); 133static Bool WsfbDGASetMode(ScrnInfoPtr, DGAModePtr); 134static void WsfbDGASetViewport(ScrnInfoPtr, int, int, int); 135static Bool WsfbDGAInit(ScrnInfoPtr, ScreenPtr); 136#endif 137static Bool WsfbDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op, 138 pointer ptr); 139 140/* helper functions */ 141static int wsfb_open(char *); 142static pointer wsfb_mmap(size_t, off_t, int); 143 144enum { WSFB_ROTATE_NONE = 0, 145 WSFB_ROTATE_CCW = 90, 146 WSFB_ROTATE_UD = 180, 147 WSFB_ROTATE_CW = 270 148}; 149 150/* 151 * This is intentionally screen-independent. It indicates the binding 152 * choice made in the first PreInit. 153 */ 154static int pix24bpp = 0; 155 156#define WSFB_VERSION 4000 157#define WSFB_NAME "wsfb" 158#define WSFB_DRIVER_NAME "wsfb" 159 160_X_EXPORT DriverRec WSFB = { 161 WSFB_VERSION, 162 WSFB_DRIVER_NAME, 163 WsfbIdentify, 164 WsfbProbe, 165 WsfbAvailableOptions, 166 NULL, 167 0, 168 WsfbDriverFunc 169}; 170 171/* Supported "chipsets" */ 172static SymTabRec WsfbChipsets[] = { 173 { 0, "wsfb" }, 174 { -1, NULL } 175}; 176 177/* Supported options */ 178typedef enum { 179 OPTION_SHADOW_FB, 180 OPTION_ROTATE, 181 OPTION_HW_CURSOR, 182 OPTION_SW_CURSOR 183} WsfbOpts; 184 185static const OptionInfoRec WsfbOptions[] = { 186 { OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, {0}, FALSE}, 187 { OPTION_ROTATE, "Rotate", OPTV_STRING, {0}, FALSE}, 188 { -1, NULL, OPTV_NONE, {0}, FALSE} 189}; 190 191/* Symbols needed from other modules */ 192static const char *fbSymbols[] = { 193 "fbPictureInit", 194 "fbScreenInit", 195 NULL 196}; 197static const char *shadowSymbols[] = { 198 "shadowAdd", 199 "shadowSetup", 200 "shadowUpdatePacked", 201 "shadowUpdatePackedWeak", 202 "shadowUpdateRotatePacked", 203 "shadowUpdateRotatePackedWeak", 204 NULL 205}; 206 207static const char *ramdacSymbols[] = { 208 "xf86CreateCursorInfoRec", 209 "xf86DestroyCursorInfoRec", 210 "xf86InitCursor", 211 NULL 212}; 213 214#ifdef XFree86LOADER 215static XF86ModuleVersionInfo WsfbVersRec = { 216 "wsfb", 217 MODULEVENDORSTRING, 218 MODINFOSTRING1, 219 MODINFOSTRING2, 220 XORG_VERSION_CURRENT, 221 PACKAGE_VERSION_MAJOR, 222 PACKAGE_VERSION_MINOR, 223 PACKAGE_VERSION_PATCHLEVEL, 224 ABI_CLASS_VIDEODRV, 225 ABI_VIDEODRV_VERSION, 226 NULL, 227 {0, 0, 0, 0} 228}; 229 230_X_EXPORT XF86ModuleData wsfbModuleData = { &WsfbVersRec, WsfbSetup, NULL }; 231 232static pointer 233WsfbSetup(pointer module, pointer opts, int *errmaj, int *errmin) 234{ 235 static Bool setupDone = FALSE; 236 const char *osname; 237 238 /* Check that we're being loaded on a OpenBSD or NetBSD system */ 239 LoaderGetOS(&osname, NULL, NULL, NULL); 240 if (!osname || (strcmp(osname, "openbsd") != 0 && 241 strcmp(osname, "netbsd") != 0)) { 242 if (errmaj) 243 *errmaj = LDR_BADOS; 244 if (errmin) 245 *errmin = 0; 246 return NULL; 247 } 248 if (!setupDone) { 249 setupDone = TRUE; 250 xf86AddDriver(&WSFB, module, HaveDriverFuncs); 251 LoaderRefSymLists(fbSymbols, shadowSymbols, ramdacSymbols, 252 NULL); 253 return (pointer)1; 254 } else { 255 if (errmaj != NULL) 256 *errmaj = LDR_ONCEONLY; 257 return NULL; 258 } 259} 260#endif /* XFree86LOADER */ 261 262static Bool 263WsfbGetRec(ScrnInfoPtr pScrn) 264{ 265 266 if (pScrn->driverPrivate != NULL) 267 return TRUE; 268 269 pScrn->driverPrivate = xnfcalloc(sizeof(WsfbRec), 1); 270 return TRUE; 271} 272 273static void 274WsfbFreeRec(ScrnInfoPtr pScrn) 275{ 276 277 if (pScrn->driverPrivate == NULL) 278 return; 279 xfree(pScrn->driverPrivate); 280 pScrn->driverPrivate = NULL; 281} 282 283static const OptionInfoRec * 284WsfbAvailableOptions(int chipid, int busid) 285{ 286 return WsfbOptions; 287} 288 289static void 290WsfbIdentify(int flags) 291{ 292 xf86PrintChipsets(WSFB_NAME, "driver for wsdisplay framebuffer", 293 WsfbChipsets); 294} 295 296/* Open the framebuffer device */ 297static int 298wsfb_open(char *dev) 299{ 300 int fd = -1; 301 302 /* try argument from XF86Config first */ 303 if (dev == NULL || ((fd = priv_open_device(dev)) == -1)) { 304 /* second: environment variable */ 305 dev = getenv("XDEVICE"); 306 if (dev == NULL || ((fd = priv_open_device(dev)) == -1)) { 307 /* last try: default device */ 308 dev = WSFB_DEFAULT_DEV; 309 if ((fd = priv_open_device(dev)) == -1) { 310 return -1; 311 } 312 } 313 } 314 return fd; 315} 316 317/* Map the framebuffer's memory */ 318static pointer 319wsfb_mmap(size_t len, off_t off, int fd) 320{ 321 int pagemask, mapsize; 322 caddr_t addr; 323 pointer mapaddr; 324 325 pagemask = getpagesize() - 1; 326 mapsize = ((int) len + pagemask) & ~pagemask; 327 addr = 0; 328 329 /* 330 * try and make it private first, that way once we get it, an 331 * interloper, e.g. another server, can't get this frame buffer, 332 * and if another server already has it, this one won't. 333 */ 334 mapaddr = (pointer) mmap(addr, mapsize, 335 PROT_READ | PROT_WRITE, MAP_SHARED, 336 fd, off); 337 if (mapaddr == MAP_FAILED) { 338 mapaddr = NULL; 339 } 340#if DEBUG 341 ErrorF("mmap returns: addr %p len 0x%x\n", mapaddr, mapsize); 342#endif 343 return mapaddr; 344} 345 346static Bool 347WsfbProbe(DriverPtr drv, int flags) 348{ 349 int i, fd, entity; 350 GDevPtr *devSections; 351 int numDevSections; 352 char *dev; 353 Bool foundScreen = FALSE; 354 355 TRACE("probe start"); 356 357 /* For now, just bail out for PROBE_DETECT. */ 358 if (flags & PROBE_DETECT) 359 return FALSE; 360 361 if ((numDevSections = xf86MatchDevice(WSFB_DRIVER_NAME, 362 &devSections)) <= 0) 363 return FALSE; 364 365 for (i = 0; i < numDevSections; i++) { 366 ScrnInfoPtr pScrn = NULL; 367 368 dev = xf86FindOptionValue(devSections[i]->options, "device"); 369 if ((fd = wsfb_open(dev)) >= 0) { 370 entity = xf86ClaimFbSlot(drv, 0, devSections[i], TRUE); 371 pScrn = xf86ConfigFbEntity(NULL,0,entity, 372 NULL,NULL,NULL,NULL); 373 if (pScrn != NULL) { 374 foundScreen = TRUE; 375 pScrn->driverVersion = WSFB_VERSION; 376 pScrn->driverName = WSFB_DRIVER_NAME; 377 pScrn->name = WSFB_NAME; 378 pScrn->Probe = WsfbProbe; 379 pScrn->PreInit = WsfbPreInit; 380 pScrn->ScreenInit = WsfbScreenInit; 381 pScrn->SwitchMode = WsfbSwitchMode; 382 pScrn->AdjustFrame = NULL; 383 pScrn->EnterVT = WsfbEnterVT; 384 pScrn->LeaveVT = WsfbLeaveVT; 385 pScrn->ValidMode = WsfbValidMode; 386 387 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 388 "using %s\n", dev != NULL ? dev : 389 "default device"); 390 } 391 } 392 } 393 xfree(devSections); 394 TRACE("probe done"); 395 return foundScreen; 396} 397 398static Bool 399WsfbPreInit(ScrnInfoPtr pScrn, int flags) 400{ 401 WsfbPtr fPtr; 402 int default_depth, wstype; 403 char *dev, *s; 404 char *mod = NULL; 405 const char *reqSym = NULL; 406 Gamma zeros = {0.0, 0.0, 0.0}; 407 DisplayModePtr mode; 408 MessageType from; 409 410 if (flags & PROBE_DETECT) return FALSE; 411 412 TRACE_ENTER("PreInit"); 413 414 if (pScrn->numEntities != 1) return FALSE; 415 416 pScrn->monitor = pScrn->confScreen->monitor; 417 418 WsfbGetRec(pScrn); 419 fPtr = WSFBPTR(pScrn); 420 421 fPtr->pEnt = xf86GetEntityInfo(pScrn->entityList[0]); 422 423 pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT; 424 pScrn->racIoFlags = pScrn->racMemFlags; 425 426 dev = xf86FindOptionValue(fPtr->pEnt->device->options, "device"); 427 fPtr->fd = wsfb_open(dev); 428 if (fPtr->fd == -1) { 429 return FALSE; 430 } 431 432 if (ioctl(fPtr->fd, WSDISPLAYIO_GINFO, &fPtr->info) == -1) { 433 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 434 "ioctl WSDISPLAY_GINFO: %s\n", 435 strerror(errno)); 436 return FALSE; 437 } 438 if (ioctl(fPtr->fd, WSDISPLAYIO_GTYPE, &wstype) == -1) { 439 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 440 "ioctl WSDISPLAY_GTYPE: %s\n", 441 strerror(errno)); 442 return FALSE; 443 } 444 if (ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, &fPtr->linebytes) == -1) { 445 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 446 "ioctl WSDISPLAYIO_LINEBYTES: %s\n", 447 strerror(errno)); 448 return FALSE; 449 } 450 /* 451 * Allocate room for saving the colormap 452 */ 453 if (fPtr->info.cmsize != 0) { 454 fPtr->saved_cmap.red = 455 (unsigned char *)xalloc(fPtr->info.cmsize); 456 if (fPtr->saved_cmap.red == NULL) { 457 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 458 "Cannot malloc %d bytes\n", fPtr->info.cmsize); 459 return FALSE; 460 } 461 fPtr->saved_cmap.green = 462 (unsigned char *)xalloc(fPtr->info.cmsize); 463 if (fPtr->saved_cmap.green == NULL) { 464 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 465 "Cannot malloc %d bytes\n", fPtr->info.cmsize); 466 xfree(fPtr->saved_cmap.red); 467 return FALSE; 468 } 469 fPtr->saved_cmap.blue = 470 (unsigned char *)xalloc(fPtr->info.cmsize); 471 if (fPtr->saved_cmap.blue == NULL) { 472 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 473 "Cannot malloc %d bytes\n", fPtr->info.cmsize); 474 xfree(fPtr->saved_cmap.red); 475 xfree(fPtr->saved_cmap.green); 476 return FALSE; 477 } 478 } 479 480 /* Handle depth */ 481 default_depth = fPtr->info.depth <= 24 ? fPtr->info.depth : 24; 482 if (!xf86SetDepthBpp(pScrn, default_depth, default_depth, 483 fPtr->info.depth, 484 fPtr->info.depth >= 24 ? Support24bppFb|Support32bppFb : 0)) 485 return FALSE; 486 487 /* Check consistency */ 488 if (pScrn->bitsPerPixel != fPtr->info.depth) { 489 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 490 "specified depth (%d) or bpp (%d) doesn't match " 491 "framebuffer depth (%d)\n", pScrn->depth, 492 pScrn->bitsPerPixel, fPtr->info.depth); 493 return FALSE; 494 } 495 xf86PrintDepthBpp(pScrn); 496 497 /* Get the depth24 pixmap format */ 498 if (pScrn->depth == 24 && pix24bpp == 0) 499 pix24bpp = xf86GetBppFromDepth(pScrn, 24); 500 501 /* color weight */ 502 if (pScrn->depth > 8) { 503 rgb zeros = { 0, 0, 0 }, masks; 504 505 if (wstype == WSDISPLAY_TYPE_SUN24 || 506 wstype == WSDISPLAY_TYPE_SUNCG12 || 507 wstype == WSDISPLAY_TYPE_SUNCG14 || 508 wstype == WSDISPLAY_TYPE_SUNTCX || 509 wstype == WSDISPLAY_TYPE_SUNFFB) { 510 masks.red = 0x0000ff; 511 masks.green = 0x00ff00; 512 masks.blue = 0xff0000; 513 } else { 514 masks.red = 0; 515 masks.green = 0; 516 masks.blue = 0; 517 } 518 519 if (!xf86SetWeight(pScrn, zeros, masks)) 520 return FALSE; 521 } 522 523 /* visual init */ 524 if (!xf86SetDefaultVisual(pScrn, -1)) 525 return FALSE; 526 527 /* We don't currently support DirectColor at > 8bpp */ 528 if (pScrn->depth > 8 && pScrn->defaultVisual != TrueColor) { 529 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual" 530 " (%s) is not supported at depth %d\n", 531 xf86GetVisualName(pScrn->defaultVisual), 532 pScrn->depth); 533 return FALSE; 534 } 535 536 xf86SetGamma(pScrn,zeros); 537 538 pScrn->progClock = TRUE; 539 pScrn->rgbBits = 8; 540 pScrn->chipset = "wsfb"; 541 pScrn->videoRam = fPtr->linebytes * fPtr->info.height; 542 543 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Vidmem: %dk\n", 544 pScrn->videoRam/1024); 545 546 /* handle options */ 547 xf86CollectOptions(pScrn, NULL); 548 if (!(fPtr->Options = xalloc(sizeof(WsfbOptions)))) 549 return FALSE; 550 memcpy(fPtr->Options, WsfbOptions, sizeof(WsfbOptions)); 551 xf86ProcessOptions(pScrn->scrnIndex, fPtr->pEnt->device->options, 552 fPtr->Options); 553 554 /* use shadow framebuffer by default, on depth >= 8 */ 555 if (pScrn->depth >= 8) 556 fPtr->shadowFB = xf86ReturnOptValBool(fPtr->Options, 557 OPTION_SHADOW_FB, TRUE); 558 else 559 if (xf86ReturnOptValBool(fPtr->Options, 560 OPTION_SHADOW_FB, FALSE)) { 561 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 562 "Shadow FB option ignored on depth < 8"); 563 } 564 565 /* rotation */ 566 fPtr->rotate = WSFB_ROTATE_NONE; 567 if ((s = xf86GetOptValString(fPtr->Options, OPTION_ROTATE))) { 568 if (pScrn->depth >= 8) { 569 if (!xf86NameCmp(s, "CW")) { 570 fPtr->shadowFB = TRUE; 571 fPtr->rotate = WSFB_ROTATE_CW; 572 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 573 "Rotating screen clockwise\n"); 574 } else if (!xf86NameCmp(s, "CCW")) { 575 fPtr->shadowFB = TRUE; 576 fPtr->rotate = WSFB_ROTATE_CCW; 577 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 578 "Rotating screen counter clockwise\n"); 579 } else if (!xf86NameCmp(s, "UD")) { 580 fPtr->shadowFB = TRUE; 581 fPtr->rotate = WSFB_ROTATE_UD; 582 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 583 "Rotating screen upside down\n"); 584 } else { 585 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 586 "\"%s\" is not a valid value for Option " 587 "\"Rotate\"\n", s); 588 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 589 "Valid options are \"CW\", \"CCW\"," 590 " or \"UD\"\n"); 591 } 592 } else { 593 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 594 "Option \"Rotate\" ignored on depth < 8"); 595 } 596 } 597 598 /* fake video mode struct */ 599 mode = (DisplayModePtr)xalloc(sizeof(DisplayModeRec)); 600 mode->prev = mode; 601 mode->next = mode; 602 mode->name = "wsfb current mode"; 603 mode->status = MODE_OK; 604 mode->type = M_T_BUILTIN; 605 mode->Clock = 0; 606 mode->HDisplay = fPtr->info.width; 607 mode->HSyncStart = 0; 608 mode->HSyncEnd = 0; 609 mode->HTotal = 0; 610 mode->HSkew = 0; 611 mode->VDisplay = fPtr->info.height; 612 mode->VSyncStart = 0; 613 mode->VSyncEnd = 0; 614 mode->VTotal = 0; 615 mode->VScan = 0; 616 mode->Flags = 0; 617 if (pScrn->modes != NULL) { 618 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 619 "Ignoring mode specification from screen section\n"); 620 } 621 pScrn->currentMode = pScrn->modes = mode; 622 pScrn->virtualX = fPtr->info.width; 623 pScrn->virtualY = fPtr->info.height; 624 pScrn->displayWidth = pScrn->virtualX; 625 626 /* Set the display resolution */ 627 xf86SetDpi(pScrn, 0, 0); 628 629 from = X_DEFAULT; 630 fPtr->HWCursor = TRUE; 631 if (xf86GetOptValBool(fPtr->Options, OPTION_HW_CURSOR, &fPtr->HWCursor)) 632 from = X_CONFIG; 633 if (xf86ReturnOptValBool(fPtr->Options, OPTION_SW_CURSOR, FALSE)) { 634 from = X_CONFIG; 635 fPtr->HWCursor = FALSE; 636 } 637 xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n", 638 fPtr->HWCursor ? "HW" : "SW"); 639 640 /* Load bpp-specific modules */ 641 switch(pScrn->bitsPerPixel) { 642 case 1: 643 mod = "xf1bpp"; 644 reqSym = "xf1bppScreenInit"; 645 break; 646 case 4: 647 mod = "xf4bpp"; 648 reqSym = "xf4bppScreenInit"; 649 break; 650 default: 651 mod = "fb"; 652 break; 653 } 654 655 656 /* Load shadow if needed */ 657 if (fPtr->shadowFB) { 658 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 659 "Using \"Shadow Framebuffer\"\n"); 660 if (xf86LoadSubModule(pScrn, "shadow") == NULL) { 661 WsfbFreeRec(pScrn); 662 return FALSE; 663 } 664 xf86LoaderReqSymLists(shadowSymbols, NULL); 665 } 666 667 if (mod && xf86LoadSubModule(pScrn, mod) == NULL) { 668 WsfbFreeRec(pScrn); 669 return FALSE; 670 } 671 672 if (xf86LoadSubModule(pScrn, "ramdac") == NULL) { 673 WsfbFreeRec(pScrn); 674 return FALSE; 675 } 676 677 if (mod) { 678 if (reqSym) { 679 xf86LoaderReqSymbols(reqSym, NULL); 680 } else { 681 xf86LoaderReqSymLists(fbSymbols, NULL); 682 } 683 } 684 TRACE_EXIT("PreInit"); 685 return TRUE; 686} 687 688static Bool 689WsfbCreateScreenResources(ScreenPtr pScreen) 690{ 691 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 692 WsfbPtr fPtr = WSFBPTR(pScrn); 693 PixmapPtr pPixmap; 694 Bool ret; 695 696 pScreen->CreateScreenResources = fPtr->CreateScreenResources; 697 ret = pScreen->CreateScreenResources(pScreen); 698 pScreen->CreateScreenResources = WsfbCreateScreenResources; 699 700 if (!ret) 701 return FALSE; 702 703 pPixmap = pScreen->GetScreenPixmap(pScreen); 704 705 if (!shadowAdd(pScreen, pPixmap, fPtr->rotate ? 706 shadowUpdateRotatePackedWeak() : shadowUpdatePackedWeak(), 707 WsfbWindowLinear, fPtr->rotate, NULL)) { 708 return FALSE; 709 } 710 return TRUE; 711} 712 713 714static Bool 715WsfbShadowInit(ScreenPtr pScreen) 716{ 717 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 718 WsfbPtr fPtr = WSFBPTR(pScrn); 719 720 if (!shadowSetup(pScreen)) 721 return FALSE; 722 fPtr->CreateScreenResources = pScreen->CreateScreenResources; 723 pScreen->CreateScreenResources = WsfbCreateScreenResources; 724 725 return TRUE; 726} 727 728static Bool 729WsfbScreenInit(int scrnIndex, ScreenPtr pScreen, int argc, char **argv) 730{ 731 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 732 WsfbPtr fPtr = WSFBPTR(pScrn); 733 VisualPtr visual; 734 int ret, flags, ncolors; 735 int wsmode = WSDISPLAYIO_MODE_DUMBFB; 736 size_t len; 737 738 TRACE_ENTER("WsfbScreenInit"); 739#if DEBUG 740 ErrorF("\tbitsPerPixel=%d, depth=%d, defaultVisual=%s\n" 741 "\tmask: %x,%x,%x, offset: %u,%u,%u\n", 742 pScrn->bitsPerPixel, 743 pScrn->depth, 744 xf86GetVisualName(pScrn->defaultVisual), 745 pScrn->mask.red,pScrn->mask.green,pScrn->mask.blue, 746 pScrn->offset.red,pScrn->offset.green,pScrn->offset.blue); 747#endif 748 switch (fPtr->info.depth) { 749 case 1: 750 case 4: 751 case 8: 752 len = fPtr->linebytes*fPtr->info.height; 753 break; 754 case 16: 755 if (fPtr->linebytes == fPtr->info.width) { 756 len = fPtr->info.width*fPtr->info.height*sizeof(short); 757 } else { 758 len = fPtr->linebytes*fPtr->info.height; 759 } 760 break; 761 case 24: 762 if (fPtr->linebytes == fPtr->info.width) { 763 len = fPtr->info.width*fPtr->info.height*3; 764 } else { 765 len = fPtr->linebytes*fPtr->info.height; 766 } 767 break; 768 case 32: 769 if (fPtr->linebytes == fPtr->info.width) { 770 len = fPtr->info.width*fPtr->info.height*sizeof(int); 771 } else { 772 len = fPtr->linebytes*fPtr->info.height; 773 } 774 break; 775 default: 776 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 777 "unsupported depth %d\n", fPtr->info.depth); 778 return FALSE; 779 } 780 /* Switch to graphics mode - required before mmap */ 781 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &wsmode) == -1) { 782 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 783 "ioctl WSDISPLAYIO_SMODE: %s\n", 784 strerror(errno)); 785 return FALSE; 786 } 787 fPtr->fbmem = wsfb_mmap(len, 0, fPtr->fd); 788 789 if (fPtr->fbmem == NULL) { 790 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 791 "wsfb_mmap: %s\n", strerror(errno)); 792 return FALSE; 793 } 794 fPtr->fbmem_len = len; 795 796 WsfbSave(pScrn); 797 pScrn->vtSema = TRUE; 798 799 /* mi layer */ 800 miClearVisualTypes(); 801 if (pScrn->bitsPerPixel > 8) { 802 if (!miSetVisualTypes(pScrn->depth, TrueColorMask, 803 pScrn->rgbBits, TrueColor)) 804 return FALSE; 805 } else { 806 if (!miSetVisualTypes(pScrn->depth, 807 miGetDefaultVisualMask(pScrn->depth), 808 pScrn->rgbBits, pScrn->defaultVisual)) 809 return FALSE; 810 } 811 if (!miSetPixmapDepths()) 812 return FALSE; 813 814 if (fPtr->rotate == WSFB_ROTATE_CW 815 || fPtr->rotate == WSFB_ROTATE_CCW) { 816 int tmp = pScrn->virtualX; 817 pScrn->virtualX = pScrn->displayWidth = pScrn->virtualY; 818 pScrn->virtualY = tmp; 819 } 820 if (fPtr->rotate && !fPtr->PointerMoved) { 821 fPtr->PointerMoved = pScrn->PointerMoved; 822 pScrn->PointerMoved = WsfbPointerMoved; 823 } 824 825 fPtr->fbstart = fPtr->fbmem; 826 827 switch (pScrn->bitsPerPixel) { 828 case 1: 829 ret = xf1bppScreenInit(pScreen, fPtr->fbstart, 830 pScrn->virtualX, pScrn->virtualY, 831 pScrn->xDpi, pScrn->yDpi, 832 pScrn->displayWidth); 833 break; 834 case 4: 835 ret = xf4bppScreenInit(pScreen, fPtr->fbstart, 836 pScrn->virtualX, pScrn->virtualY, 837 pScrn->xDpi, pScrn->yDpi, 838 pScrn->displayWidth); 839 break; 840 case 8: 841 case 16: 842 case 24: 843 case 32: 844 ret = fbScreenInit(pScreen, 845 /*fPtr->shadowFB ? fPtr->shadow :*/ fPtr->fbstart, 846 pScrn->virtualX, pScrn->virtualY, 847 pScrn->xDpi, pScrn->yDpi, 848 pScrn->displayWidth, pScrn->bitsPerPixel); 849 break; 850 default: 851 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 852 "Unsupported bpp: %d", pScrn->bitsPerPixel); 853 return FALSE; 854 } /* case */ 855 856 if (!ret) 857 return FALSE; 858 859 if (pScrn->bitsPerPixel > 8) { 860 /* Fixup RGB ordering */ 861 visual = pScreen->visuals + pScreen->numVisuals; 862 while (--visual >= pScreen->visuals) { 863 if ((visual->class | DynamicClass) == DirectColor) { 864 visual->offsetRed = pScrn->offset.red; 865 visual->offsetGreen = pScrn->offset.green; 866 visual->offsetBlue = pScrn->offset.blue; 867 visual->redMask = pScrn->mask.red; 868 visual->greenMask = pScrn->mask.green; 869 visual->blueMask = pScrn->mask.blue; 870 } 871 } 872 } 873 874 if (pScrn->bitsPerPixel >= 8) { 875 if (!fbPictureInit(pScreen, NULL, 0)) 876 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 877 "RENDER extension initialisation failed."); 878 } 879 if (fPtr->shadowFB && !WsfbShadowInit(pScreen)) { 880 xf86DrvMsg(scrnIndex, X_ERROR, 881 "shadow framebuffer initialization failed\n"); 882 return FALSE; 883 } 884 885#ifdef XFreeXDGA 886 if (!fPtr->rotate) 887 WsfbDGAInit(pScrn, pScreen); 888 else 889 xf86DrvMsg(scrnIndex, X_INFO, "Rotated display, " 890 "disabling DGA\n"); 891#endif 892 if (fPtr->rotate) { 893 xf86DrvMsg(scrnIndex, X_INFO, "Enabling Driver Rotation, " 894 "disabling RandR\n"); 895 xf86DisableRandR(); 896 if (pScrn->bitsPerPixel == 24) 897 xf86DrvMsg(scrnIndex, X_WARNING, 898 "Rotation might be broken in 24 bpp\n"); 899 } 900 901 xf86SetBlackWhitePixels(pScreen); 902 miInitializeBackingStore(pScreen); 903 xf86SetBackingStore(pScreen); 904 905 /* software cursor */ 906 miDCInitialize(pScreen, xf86GetPointerScreenFuncs()); 907 908 /* check for hardware cursor support */ 909 if (fPtr->HWCursor) 910 WsfbSetupCursor(pScreen); 911 912 /* colormap */ 913 if (!miCreateDefColormap(pScreen)) 914 return FALSE; 915 flags = CMAP_RELOAD_ON_MODE_SWITCH; 916 ncolors = fPtr->info.cmsize; 917 /* on StaticGray visuals, fake a 256 entries colormap */ 918 if (ncolors == 0) 919 ncolors = 256; 920 if(!xf86HandleColormaps(pScreen, ncolors, 8, WsfbLoadPalette, 921 NULL, flags)) 922 return FALSE; 923 924 pScreen->SaveScreen = WsfbSaveScreen; 925 926#ifdef XvExtension 927 { 928 XF86VideoAdaptorPtr *ptr; 929 930 int n = xf86XVListGenericAdaptors(pScrn,&ptr); 931 if (n) { 932 xf86XVScreenInit(pScreen,ptr,n); 933 } 934 } 935#endif 936 937 /* Wrap the current CloseScreen function */ 938 fPtr->CloseScreen = pScreen->CloseScreen; 939 pScreen->CloseScreen = WsfbCloseScreen; 940 941 TRACE_EXIT("WsfbScreenInit"); 942 return TRUE; 943} 944 945static Bool 946WsfbCloseScreen(int scrnIndex, ScreenPtr pScreen) 947{ 948 ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; 949 WsfbPtr fPtr = WSFBPTR(pScrn); 950 951 TRACE_ENTER("WsfbCloseScreen"); 952 953 if (pScrn->vtSema) { 954 WsfbRestore(pScrn); 955 if (munmap(fPtr->fbmem, fPtr->fbmem_len) == -1) { 956 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 957 "munmap: %s\n", strerror(errno)); 958 } 959 960 fPtr->fbmem = NULL; 961 } 962#ifdef XFreeXDGA 963 if (fPtr->pDGAMode) { 964 xfree(fPtr->pDGAMode); 965 fPtr->pDGAMode = NULL; 966 fPtr->nDGAMode = 0; 967 } 968#endif 969 pScrn->vtSema = FALSE; 970 971 /* unwrap CloseScreen */ 972 pScreen->CloseScreen = fPtr->CloseScreen; 973 return (*pScreen->CloseScreen)(scrnIndex, pScreen); 974} 975 976static void * 977WsfbWindowLinear(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode, 978 CARD32 *size, void *closure) 979{ 980 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 981 WsfbPtr fPtr = WSFBPTR(pScrn); 982 983 if (fPtr->linebytes) 984 *size = fPtr->linebytes; 985 else { 986 if (ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, size) == -1) 987 return NULL; 988 fPtr->linebytes = *size; 989 } 990 return ((CARD8 *)fPtr->fbmem + row *fPtr->linebytes + offset); 991} 992 993static void 994WsfbPointerMoved(int index, int x, int y) 995{ 996 ScrnInfoPtr pScrn = xf86Screens[index]; 997 WsfbPtr fPtr = WSFBPTR(pScrn); 998 int newX, newY; 999 1000 switch (fPtr->rotate) 1001 { 1002 case WSFB_ROTATE_CW: 1003 /* 90 degrees CW rotation. */ 1004 newX = pScrn->pScreen->height - y - 1; 1005 newY = x; 1006 break; 1007 1008 case WSFB_ROTATE_CCW: 1009 /* 90 degrees CCW rotation. */ 1010 newX = y; 1011 newY = pScrn->pScreen->width - x - 1; 1012 break; 1013 1014 case WSFB_ROTATE_UD: 1015 /* 180 degrees UD rotation. */ 1016 newX = pScrn->pScreen->width - x - 1; 1017 newY = pScrn->pScreen->height - y - 1; 1018 break; 1019 1020 default: 1021 /* No rotation. */ 1022 newX = x; 1023 newY = y; 1024 break; 1025 } 1026 1027 /* Pass adjusted pointer coordinates to wrapped PointerMoved function. */ 1028 (*fPtr->PointerMoved)(index, newX, newY); 1029} 1030 1031static Bool 1032WsfbEnterVT(int scrnIndex, int flags) 1033{ 1034 ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; 1035 1036 TRACE_ENTER("EnterVT"); 1037 pScrn->vtSema = TRUE; 1038 return TRUE; 1039} 1040 1041static void 1042WsfbLeaveVT(int scrnIndex, int flags) 1043{ 1044#if DEBUG 1045 ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; 1046#endif 1047 1048 TRACE_ENTER("LeaveVT"); 1049} 1050 1051static Bool 1052WsfbSwitchMode(int scrnIndex, DisplayModePtr mode, int flags) 1053{ 1054#if DEBUG 1055 ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; 1056#endif 1057 1058 TRACE_ENTER("SwitchMode"); 1059 /* Nothing else to do */ 1060 return TRUE; 1061} 1062 1063static int 1064WsfbValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags) 1065{ 1066#if DEBUG 1067 ScrnInfoPtr pScrn = xf86Screens[scrnIndex]; 1068#endif 1069 1070 TRACE_ENTER("ValidMode"); 1071 return MODE_OK; 1072} 1073 1074static void 1075WsfbLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, 1076 LOCO *colors, VisualPtr pVisual) 1077{ 1078 WsfbPtr fPtr = WSFBPTR(pScrn); 1079 struct wsdisplay_cmap cmap; 1080 unsigned char red[256],green[256],blue[256]; 1081 int i, indexMin=256, indexMax=0; 1082 1083 TRACE_ENTER("LoadPalette"); 1084 1085 cmap.count = 1; 1086 cmap.red = red; 1087 cmap.green = green; 1088 cmap.blue = blue; 1089 1090 if (numColors == 1) { 1091 /* Optimisation */ 1092 cmap.index = indices[0]; 1093 red[0] = colors[indices[0]].red; 1094 green[0] = colors[indices[0]].green; 1095 blue[0] = colors[indices[0]].blue; 1096 if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1) 1097 ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno)); 1098 } else { 1099 /* Change all colors in 2 syscalls */ 1100 /* and limit the data to be transfered */ 1101 for (i = 0; i < numColors; i++) { 1102 if (indices[i] < indexMin) 1103 indexMin = indices[i]; 1104 if (indices[i] > indexMax) 1105 indexMax = indices[i]; 1106 } 1107 cmap.index = indexMin; 1108 cmap.count = indexMax - indexMin + 1; 1109 cmap.red = &red[indexMin]; 1110 cmap.green = &green[indexMin]; 1111 cmap.blue = &blue[indexMin]; 1112 /* Get current map */ 1113 if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP, &cmap) == -1) 1114 ErrorF("ioctl FBIOGETCMAP: %s\n", strerror(errno)); 1115 /* Change the colors that require updating */ 1116 for (i = 0; i < numColors; i++) { 1117 red[indices[i]] = colors[indices[i]].red; 1118 green[indices[i]] = colors[indices[i]].green; 1119 blue[indices[i]] = colors[indices[i]].blue; 1120 } 1121 /* Write the colormap back */ 1122 if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1) 1123 ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno)); 1124 } 1125 TRACE_EXIT("LoadPalette"); 1126} 1127 1128static Bool 1129WsfbSaveScreen(ScreenPtr pScreen, int mode) 1130{ 1131 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 1132 WsfbPtr fPtr = WSFBPTR(pScrn); 1133 int state; 1134 1135 TRACE_ENTER("SaveScreen"); 1136 1137 if (!pScrn->vtSema) 1138 return TRUE; 1139 1140 if (mode != SCREEN_SAVER_FORCER) { 1141 state = xf86IsUnblank(mode)?WSDISPLAYIO_VIDEO_ON: 1142 WSDISPLAYIO_VIDEO_OFF; 1143 ioctl(fPtr->fd, 1144 WSDISPLAYIO_SVIDEO, &state); 1145 } 1146 return TRUE; 1147} 1148 1149 1150static void 1151WsfbSave(ScrnInfoPtr pScrn) 1152{ 1153 WsfbPtr fPtr = WSFBPTR(pScrn); 1154 1155 TRACE_ENTER("WsfbSave"); 1156 1157 if (fPtr->info.cmsize == 0) 1158 return; 1159 1160 fPtr->saved_cmap.index = 0; 1161 fPtr->saved_cmap.count = fPtr->info.cmsize; 1162 if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP, 1163 &(fPtr->saved_cmap)) == -1) { 1164 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1165 "error saving colormap %s\n", strerror(errno)); 1166 } 1167 1168} 1169 1170static void 1171WsfbRestore(ScrnInfoPtr pScrn) 1172{ 1173 WsfbPtr fPtr = WSFBPTR(pScrn); 1174 int mode; 1175 1176 TRACE_ENTER("WsfbRestore"); 1177 1178 if (fPtr->info.cmsize != 0) { 1179 /* reset colormap for text mode */ 1180 if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP, 1181 &(fPtr->saved_cmap)) == -1) { 1182 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1183 "error restoring colormap %s\n", 1184 strerror(errno)); 1185 } 1186 } 1187 1188 /* Clear the screen */ 1189 memset(fPtr->fbmem, 0, fPtr->fbmem_len); 1190 1191 /* Restore the text mode */ 1192 mode = WSDISPLAYIO_MODE_EMUL; 1193 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) { 1194 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1195 "error setting text mode %s\n", strerror(errno)); 1196 } 1197 TRACE_EXIT("WsfbRestore"); 1198} 1199 1200#ifdef XFreeXDGA 1201/*********************************************************************** 1202 * DGA stuff 1203 ***********************************************************************/ 1204 1205static Bool 1206WsfbDGAOpenFramebuffer(ScrnInfoPtr pScrn, char **DeviceName, 1207 unsigned char **ApertureBase, int *ApertureSize, 1208 int *ApertureOffset, int *flags) 1209{ 1210 *DeviceName = NULL; /* No special device */ 1211 *ApertureBase = (unsigned char *)(pScrn->memPhysBase); 1212 *ApertureSize = pScrn->videoRam; 1213 *ApertureOffset = pScrn->fbOffset; 1214 *flags = 0; 1215 1216 return TRUE; 1217} 1218 1219static Bool 1220WsfbDGASetMode(ScrnInfoPtr pScrn, DGAModePtr pDGAMode) 1221{ 1222 DisplayModePtr pMode; 1223 int scrnIdx = pScrn->pScreen->myNum; 1224 int frameX0, frameY0; 1225 1226 if (pDGAMode) { 1227 pMode = pDGAMode->mode; 1228 frameX0 = frameY0 = 0; 1229 } else { 1230 if (!(pMode = pScrn->currentMode)) 1231 return TRUE; 1232 1233 frameX0 = pScrn->frameX0; 1234 frameY0 = pScrn->frameY0; 1235 } 1236 1237 if (!(*pScrn->SwitchMode)(scrnIdx, pMode, 0)) 1238 return FALSE; 1239 (*pScrn->AdjustFrame)(scrnIdx, frameX0, frameY0, 0); 1240 1241 return TRUE; 1242} 1243 1244static void 1245WsfbDGASetViewport(ScrnInfoPtr pScrn, int x, int y, int flags) 1246{ 1247 (*pScrn->AdjustFrame)(pScrn->pScreen->myNum, x, y, flags); 1248} 1249 1250static int 1251WsfbDGAGetViewport(ScrnInfoPtr pScrn) 1252{ 1253 return (0); 1254} 1255 1256static DGAFunctionRec WsfbDGAFunctions = 1257{ 1258 WsfbDGAOpenFramebuffer, 1259 NULL, /* CloseFramebuffer */ 1260 WsfbDGASetMode, 1261 WsfbDGASetViewport, 1262 WsfbDGAGetViewport, 1263 NULL, /* Sync */ 1264 NULL, /* FillRect */ 1265 NULL, /* BlitRect */ 1266 NULL, /* BlitTransRect */ 1267}; 1268 1269static void 1270WsfbDGAAddModes(ScrnInfoPtr pScrn) 1271{ 1272 WsfbPtr fPtr = WSFBPTR(pScrn); 1273 DisplayModePtr pMode = pScrn->modes; 1274 DGAModePtr pDGAMode; 1275 1276 do { 1277 pDGAMode = xrealloc(fPtr->pDGAMode, 1278 (fPtr->nDGAMode + 1) * sizeof(DGAModeRec)); 1279 if (!pDGAMode) 1280 break; 1281 1282 fPtr->pDGAMode = pDGAMode; 1283 pDGAMode += fPtr->nDGAMode; 1284 (void)memset(pDGAMode, 0, sizeof(DGAModeRec)); 1285 1286 ++fPtr->nDGAMode; 1287 pDGAMode->mode = pMode; 1288 pDGAMode->flags = DGA_CONCURRENT_ACCESS | DGA_PIXMAP_AVAILABLE; 1289 pDGAMode->byteOrder = pScrn->imageByteOrder; 1290 pDGAMode->depth = pScrn->depth; 1291 pDGAMode->bitsPerPixel = pScrn->bitsPerPixel; 1292 pDGAMode->red_mask = pScrn->mask.red; 1293 pDGAMode->green_mask = pScrn->mask.green; 1294 pDGAMode->blue_mask = pScrn->mask.blue; 1295 pDGAMode->visualClass = pScrn->bitsPerPixel > 8 ? 1296 TrueColor : PseudoColor; 1297 pDGAMode->xViewportStep = 1; 1298 pDGAMode->yViewportStep = 1; 1299 pDGAMode->viewportWidth = pMode->HDisplay; 1300 pDGAMode->viewportHeight = pMode->VDisplay; 1301 1302 if (fPtr->linebytes) 1303 pDGAMode->bytesPerScanline = fPtr->linebytes; 1304 else { 1305 ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, 1306 &fPtr->linebytes); 1307 pDGAMode->bytesPerScanline = fPtr->linebytes; 1308 } 1309 1310 pDGAMode->imageWidth = pMode->HDisplay; 1311 pDGAMode->imageHeight = pMode->VDisplay; 1312 pDGAMode->pixmapWidth = pDGAMode->imageWidth; 1313 pDGAMode->pixmapHeight = pDGAMode->imageHeight; 1314 pDGAMode->maxViewportX = pScrn->virtualX - 1315 pDGAMode->viewportWidth; 1316 pDGAMode->maxViewportY = pScrn->virtualY - 1317 pDGAMode->viewportHeight; 1318 1319 pDGAMode->address = fPtr->fbstart; 1320 1321 pMode = pMode->next; 1322 } while (pMode != pScrn->modes); 1323} 1324 1325static Bool 1326WsfbDGAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen) 1327{ 1328 WsfbPtr fPtr = WSFBPTR(pScrn); 1329 1330 if (pScrn->depth < 8) 1331 return FALSE; 1332 1333 if (!fPtr->nDGAMode) 1334 WsfbDGAAddModes(pScrn); 1335 1336 return (DGAInit(pScreen, &WsfbDGAFunctions, 1337 fPtr->pDGAMode, fPtr->nDGAMode)); 1338} 1339#endif 1340 1341static Bool 1342WsfbDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op, 1343 pointer ptr) 1344{ 1345 xorgHWFlags *flag; 1346 1347 switch (op) { 1348 case GET_REQUIRED_HW_INTERFACES: 1349 flag = (CARD32*)ptr; 1350 (*flag) = 0; 1351 return TRUE; 1352 default: 1353 return FALSE; 1354 } 1355} 1356 1357