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