wsfb_driver.c revision 0c2341a9
1/* 2 * Copyright © 2001-2012 Matthieu Herrb 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * - Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * - Redistributions in binary form must reproduce the above 12 * copyright notice, this list of conditions and the following 13 * disclaimer in the documentation and/or other materials provided 14 * with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 19 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 20 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 22 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 24 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 26 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 27 * POSSIBILITY OF SUCH DAMAGE. 28 * 29 */ 30 31/* 32 * Based on fbdev.c written by: 33 * 34 * Authors: Alan Hourihane, <alanh@fairlite.demon.co.uk> 35 * Michel Dänzer, <michdaen@iiic.ethz.ch> 36 */ 37 38#ifdef HAVE_CONFIG_H 39#include "config.h" 40#endif 41 42#include <errno.h> 43#include <fcntl.h> 44#include <unistd.h> 45#include <sys/ioctl.h> 46#include <sys/types.h> 47#include <sys/mman.h> 48#include <sys/time.h> 49#include <errno.h> 50#include <dev/wscons/wsconsio.h> 51 52/* All drivers need this. */ 53#include "xf86.h" 54#include "xf86_OSproc.h" 55 56#include "mipointer.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#include "fb.h" 65 66#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6 67#include "xf86Resources.h" 68#include "xf86RAC.h" 69#endif 70 71#ifdef XvExtension 72#include "xf86xv.h" 73#endif 74 75#include "wsfb.h" 76 77#ifdef X_PRIVSEP 78extern int priv_open_device(const char *); 79#else 80#define priv_open_device(n) open(n,O_RDWR|O_NONBLOCK|O_EXCL) 81#endif 82 83#if defined(__NetBSD__) 84#define WSFB_DEFAULT_DEV "/dev/ttyE0" 85#else 86#define WSFB_DEFAULT_DEV "/dev/ttyC0" 87#endif 88 89#define DEBUG 0 90 91#if DEBUG 92# define TRACE_ENTER(str) ErrorF("wsfb: " str " %d\n",pScrn->scrnIndex) 93# define TRACE_EXIT(str) ErrorF("wsfb: " str " done\n") 94# define TRACE(str) ErrorF("wsfb trace: " str "\n") 95#else 96# define TRACE_ENTER(str) 97# define TRACE_EXIT(str) 98# define TRACE(str) 99#endif 100 101/* Prototypes */ 102static pointer WsfbSetup(pointer, pointer, int *, int *); 103static Bool WsfbGetRec(ScrnInfoPtr); 104static void WsfbFreeRec(ScrnInfoPtr); 105static const OptionInfoRec * WsfbAvailableOptions(int, int); 106static void WsfbIdentify(int); 107static Bool WsfbProbe(DriverPtr, int); 108static Bool WsfbPreInit(ScrnInfoPtr, int); 109static Bool WsfbScreenInit(SCREEN_INIT_ARGS_DECL); 110static Bool WsfbCloseScreen(CLOSE_SCREEN_ARGS_DECL); 111static void *WsfbWindowLinear(ScreenPtr, CARD32, CARD32, int, CARD32 *, 112 void *); 113#ifdef HAVE_SHADOW_AFB 114static void *WsfbWindowAfb(ScreenPtr, CARD32, CARD32, int, CARD32 *, 115 void *); 116#endif 117static void WsfbPointerMoved(SCRN_ARG_TYPE, int, int); 118static Bool WsfbEnterVT(VT_FUNC_ARGS_DECL); 119static void WsfbLeaveVT(VT_FUNC_ARGS_DECL); 120static Bool WsfbSwitchMode(SWITCH_MODE_ARGS_DECL); 121static int WsfbValidMode(SCRN_ARG_TYPE, DisplayModePtr, Bool, int); 122static void WsfbLoadPalette(ScrnInfoPtr, int, int *, LOCO *, VisualPtr); 123static Bool WsfbSaveScreen(ScreenPtr, int); 124static void WsfbSave(ScrnInfoPtr); 125static void WsfbRestore(ScrnInfoPtr); 126 127/* DGA stuff */ 128#ifdef XFreeXDGA 129static Bool WsfbDGAOpenFramebuffer(ScrnInfoPtr, char **, unsigned char **, 130 int *, int *, int *); 131static Bool WsfbDGASetMode(ScrnInfoPtr, DGAModePtr); 132static void WsfbDGASetViewport(ScrnInfoPtr, int, int, int); 133static Bool WsfbDGAInit(ScrnInfoPtr, ScreenPtr); 134#endif 135 136static void WsfbShadowUpdateRGB16ToYUY2(ScreenPtr, shadowBufPtr); 137static void WsfbShadowUpdateSwap32(ScreenPtr, shadowBufPtr); 138static void WsfbShadowUpdateSplit(ScreenPtr, shadowBufPtr); 139 140static Bool WsfbDriverFunc(ScrnInfoPtr, xorgDriverFuncOp, pointer); 141 142/* Helper functions */ 143static int wsfb_open(const char *); 144static pointer wsfb_mmap(size_t, off_t, int); 145 146enum { WSFB_ROTATE_NONE = 0, 147 WSFB_ROTATE_CCW = 90, 148 WSFB_ROTATE_UD = 180, 149 WSFB_ROTATE_CW = 270 150}; 151 152/* 153 * This is intentionally screen-independent. 154 * It indicates the binding choice made in the first PreInit. 155 */ 156static int pix24bpp = 0; 157 158/* 159 * Screen-independent lookup table for RGB16 to YUV conversions. 160 */ 161static unsigned char *mapRGB16ToY = NULL; 162static unsigned char *mapRGB16ToU = NULL; 163static unsigned char *mapRGB16ToV = NULL; 164 165#define WSFB_VERSION 4000 166#define WSFB_NAME "wsfb" 167#define WSFB_DRIVER_NAME "wsfb" 168 169_X_EXPORT DriverRec WSFB = { 170 WSFB_VERSION, 171 (char *)WSFB_DRIVER_NAME, 172 WsfbIdentify, 173 WsfbProbe, 174 WsfbAvailableOptions, 175 NULL, 176 0, 177 WsfbDriverFunc 178}; 179 180/* Supported "chipsets" */ 181static SymTabRec WsfbChipsets[] = { 182 { 0, "wsfb" }, 183 { -1, NULL } 184}; 185 186/* Supported options */ 187typedef enum { 188 OPTION_SHADOW_FB, 189 OPTION_ROTATE, 190 OPTION_HW_CURSOR, 191 OPTION_SW_CURSOR 192} WsfbOpts; 193 194static const OptionInfoRec WsfbOptions[] = { 195 { OPTION_SHADOW_FB, "ShadowFB", OPTV_BOOLEAN, {0}, FALSE}, 196 { OPTION_ROTATE, "Rotate", OPTV_STRING, {0}, FALSE}, 197 { OPTION_HW_CURSOR, "HWCursor", OPTV_BOOLEAN, {1}, FALSE}, 198 { -1, NULL, OPTV_NONE, {0}, FALSE} 199}; 200 201static XF86ModuleVersionInfo WsfbVersRec = { 202 "wsfb", 203 MODULEVENDORSTRING, 204 MODINFOSTRING1, 205 MODINFOSTRING2, 206 XORG_VERSION_CURRENT, 207 PACKAGE_VERSION_MAJOR, 208 PACKAGE_VERSION_MINOR, 209 PACKAGE_VERSION_PATCHLEVEL, 210 ABI_CLASS_VIDEODRV, 211 ABI_VIDEODRV_VERSION, 212 NULL, 213 {0, 0, 0, 0} 214}; 215 216_X_EXPORT XF86ModuleData wsfbModuleData = { &WsfbVersRec, WsfbSetup, NULL }; 217 218static pointer 219WsfbSetup(pointer module, pointer opts, int *errmaj, int *errmin) 220{ 221 static Bool setupDone = FALSE; 222 223#if !defined(__OpenBSD__) && !defined(__NetBSD__) 224 return NULL; 225#endif 226 227 if (!setupDone) { 228 setupDone = TRUE; 229 xf86AddDriver(&WSFB, module, HaveDriverFuncs); 230 return (pointer)1; 231 } else { 232 if (errmaj != NULL) 233 *errmaj = LDR_ONCEONLY; 234 return NULL; 235 } 236} 237 238static Bool 239WsfbGetRec(ScrnInfoPtr pScrn) 240{ 241 242 if (pScrn->driverPrivate != NULL) 243 return TRUE; 244 245 pScrn->driverPrivate = xnfcalloc(sizeof(WsfbRec), 1); 246 return TRUE; 247} 248 249static void 250WsfbFreeRec(ScrnInfoPtr pScrn) 251{ 252 253 if (pScrn->driverPrivate == NULL) 254 return; 255 free(pScrn->driverPrivate); 256 pScrn->driverPrivate = NULL; 257} 258 259static const OptionInfoRec * 260WsfbAvailableOptions(int chipid, int busid) 261{ 262 return WsfbOptions; 263} 264 265static void 266WsfbIdentify(int flags) 267{ 268 xf86PrintChipsets(WSFB_NAME, "driver for wsdisplay framebuffer", 269 WsfbChipsets); 270} 271 272/* Open the framebuffer device. */ 273static int 274wsfb_open(const char *dev) 275{ 276 int fd = -1; 277 278 /* Try argument from xorg.conf first. */ 279 if (dev == NULL || ((fd = priv_open_device(dev)) == -1)) { 280 /* Second: environment variable. */ 281 dev = getenv("XDEVICE"); 282 if (dev == NULL || ((fd = priv_open_device(dev)) == -1)) { 283 /* Last try: default device. */ 284 dev = WSFB_DEFAULT_DEV; 285 if ((fd = priv_open_device(dev)) == -1) { 286 return -1; 287 } 288 } 289 } 290 return fd; 291} 292 293/* Map the framebuffer's memory. */ 294static pointer 295wsfb_mmap(size_t len, off_t off, int fd) 296{ 297 int pagemask, mapsize; 298 caddr_t addr; 299 pointer mapaddr; 300 301 pagemask = getpagesize() - 1; 302 mapsize = ((int) len + pagemask) & ~pagemask; 303 addr = 0; 304 305 /* 306 * Try and make it private first, that way once we get it, an 307 * interloper, e.g. another server, can't get this frame buffer, 308 * and if another server already has it, this one won't. 309 */ 310 mapaddr = (pointer) mmap(addr, mapsize, 311 PROT_READ | PROT_WRITE, MAP_SHARED, 312 fd, off); 313 if (mapaddr == MAP_FAILED) { 314 mapaddr = NULL; 315 } 316#if DEBUG 317 ErrorF("mmap returns: addr %p len 0x%x\n", mapaddr, mapsize); 318#endif 319 return mapaddr; 320} 321 322static Bool 323WsfbProbe(DriverPtr drv, int flags) 324{ 325 int i, fd, entity; 326 GDevPtr *devSections; 327 int numDevSections; 328 const char *dev; 329 Bool foundScreen = FALSE; 330 331 TRACE("probe start"); 332 333 /* For now, just bail out for PROBE_DETECT. */ 334 if (flags & PROBE_DETECT) 335 return FALSE; 336 337 if ((numDevSections = xf86MatchDevice(WSFB_DRIVER_NAME, 338 &devSections)) <= 0) 339 return FALSE; 340 341 for (i = 0; i < numDevSections; i++) { 342 ScrnInfoPtr pScrn = NULL; 343 344 dev = xf86FindOptionValue(devSections[i]->options, "device"); 345 if ((fd = wsfb_open(dev)) >= 0) { 346 entity = xf86ClaimFbSlot(drv, 0, devSections[i], TRUE); 347 pScrn = xf86ConfigFbEntity(NULL,0,entity, 348 NULL,NULL,NULL,NULL); 349 if (pScrn != NULL) { 350 foundScreen = TRUE; 351 pScrn->driverVersion = WSFB_VERSION; 352 pScrn->driverName = (char *)WSFB_DRIVER_NAME; 353 pScrn->name = (char *)WSFB_NAME; 354 pScrn->Probe = WsfbProbe; 355 pScrn->PreInit = WsfbPreInit; 356 pScrn->ScreenInit = WsfbScreenInit; 357 pScrn->SwitchMode = WsfbSwitchMode; 358 pScrn->AdjustFrame = NULL; 359 pScrn->EnterVT = WsfbEnterVT; 360 pScrn->LeaveVT = WsfbLeaveVT; 361 pScrn->ValidMode = WsfbValidMode; 362 363 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 364 "using %s\n", dev != NULL ? dev : 365 "default device"); 366 } 367 } 368 } 369 free(devSections); 370 TRACE("probe done"); 371 return foundScreen; 372} 373 374static Bool 375WsfbPreInit(ScrnInfoPtr pScrn, int flags) 376{ 377 WsfbPtr fPtr; 378 int default_depth, bitsperpixel, wstype; 379 const char *dev; 380 const char *s; 381 Gamma zeros = {0.0, 0.0, 0.0}; 382 DisplayModePtr mode; 383 MessageType from; 384 385 if (flags & PROBE_DETECT) return FALSE; 386 387 TRACE_ENTER("PreInit"); 388 389 if (pScrn->numEntities != 1) return FALSE; 390 391 pScrn->monitor = pScrn->confScreen->monitor; 392 393 WsfbGetRec(pScrn); 394 fPtr = WSFBPTR(pScrn); 395 396 fPtr->pEnt = xf86GetEntityInfo(pScrn->entityList[0]); 397 398#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6 399 pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT; 400 pScrn->racIoFlags = pScrn->racMemFlags; 401#endif 402 403 dev = xf86FindOptionValue(fPtr->pEnt->device->options, "device"); 404 fPtr->fd = wsfb_open(dev); 405 if (fPtr->fd == -1) { 406 return FALSE; 407 } 408 409 if (ioctl(fPtr->fd, WSDISPLAYIO_GTYPE, &wstype) == -1) { 410 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 411 "ioctl WSDISPLAY_GTYPE: %s\n", 412 strerror(errno)); 413 wstype = WSDISPLAY_TYPE_UNKNOWN; 414 } 415 416 if (ioctl(fPtr->fd, WSDISPLAYIO_GET_FBINFO, &fPtr->fbi) != 0) { 417 struct wsdisplay_fbinfo info; 418 struct wsdisplayio_fbinfo *fbi = &fPtr->fbi; 419 int lb; 420 421 xf86Msg(X_WARNING, "ioctl(WSDISPLAYIO_GET_FBINFO) failed, " \ 422 "falling back to old method\n"); 423 if (ioctl(fPtr->fd, WSDISPLAYIO_GINFO, &info) == -1) { 424 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 425 "ioctl WSDISPLAY_GINFO: %s\n", 426 strerror(errno)); 427 return FALSE; 428 } 429 if (ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, &lb) == -1) { 430 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 431 "ioctl WSDISPLAYIO_LINEBYTES: %s\n", 432 strerror(errno)); 433 return FALSE; 434 } 435 /* ok, fake up a new style fbinfo */ 436 fbi->fbi_width = info.width; 437 fbi->fbi_height = info.height; 438 fbi->fbi_stride = lb; 439 fbi->fbi_bitsperpixel = info.depth; 440 if (info.depth > 16) { 441 fbi->fbi_pixeltype = WSFB_RGB; 442 if (wstype == WSDISPLAY_TYPE_SUN24 || 443 wstype == WSDISPLAY_TYPE_SUNCG12 || 444 wstype == WSDISPLAY_TYPE_SUNCG14 || 445 wstype == WSDISPLAY_TYPE_SUNTCX || 446 wstype == WSDISPLAY_TYPE_SUNFFB || 447 wstype == WSDISPLAY_TYPE_XVR1000 || 448 wstype == WSDISPLAY_TYPE_VC4) { 449 fbi->fbi_subtype.fbi_rgbmasks.red_offset = 0; 450 fbi->fbi_subtype.fbi_rgbmasks.red_size = 8; 451 fbi->fbi_subtype.fbi_rgbmasks.green_offset = 8; 452 fbi->fbi_subtype.fbi_rgbmasks.green_size = 8; 453 fbi->fbi_subtype.fbi_rgbmasks.blue_offset = 16; 454 fbi->fbi_subtype.fbi_rgbmasks.blue_size = 8; 455 } else { 456 fbi->fbi_subtype.fbi_rgbmasks.red_offset = 16; 457 fbi->fbi_subtype.fbi_rgbmasks.red_size = 8; 458 fbi->fbi_subtype.fbi_rgbmasks.green_offset = 8; 459 fbi->fbi_subtype.fbi_rgbmasks.green_size = 8; 460 fbi->fbi_subtype.fbi_rgbmasks.blue_offset = 0; 461 fbi->fbi_subtype.fbi_rgbmasks.blue_size = 8; 462 } 463 fbi->fbi_subtype.fbi_rgbmasks.alpha_offset = 0; 464 fbi->fbi_subtype.fbi_rgbmasks.alpha_size = 0; 465 } else if (info.depth <= 8) { 466 fbi->fbi_pixeltype = WSFB_CI; 467 fbi->fbi_subtype.fbi_cmapinfo.cmap_entries = info.cmsize; 468 } 469 fbi->fbi_flags = 0; 470 fbi->fbi_fbsize = lb * info.height; 471#ifdef WSDISPLAY_TYPE_LUNA 472 if (wstype == WSDISPLAY_TYPE_LUNA) { 473 /* 474 * XXX 475 * LUNA's FB seems to have 64 dot (8 byte) offset. 476 * This might be able to be changed in kernel 477 * lunafb driver, but current setting was pulled 478 * from 4.4BSD-Lite2/luna68k. 479 */ 480 fbi->fbi_fboffset = 8; 481 } else 482#endif 483 fbi->fbi_fboffset = 0; 484 } 485 xf86Msg(X_INFO, "fboffset %x\n", (int)fPtr->fbi.fbi_fboffset); 486 /* 487 * Allocate room for saving the colormap. 488 */ 489 if (fPtr->fbi.fbi_pixeltype == WSFB_CI && 490 fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries > 0) { 491 fPtr->saved_cmap.red = 492 (unsigned char *)malloc(fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries); 493 if (fPtr->saved_cmap.red == NULL) { 494 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 495 "Cannot malloc %d bytes\n", 496 fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries); 497 return FALSE; 498 } 499 fPtr->saved_cmap.green = 500 (unsigned char *)malloc(fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries); 501 if (fPtr->saved_cmap.green == NULL) { 502 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 503 "Cannot malloc %d bytes\n", 504 fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries); 505 free(fPtr->saved_cmap.red); 506 return FALSE; 507 } 508 fPtr->saved_cmap.blue = 509 (unsigned char *)malloc(fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries); 510 if (fPtr->saved_cmap.blue == NULL) { 511 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 512 "Cannot malloc %d bytes\n", 513 fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries); 514 free(fPtr->saved_cmap.red); 515 free(fPtr->saved_cmap.green); 516 return FALSE; 517 } 518 } 519 520 /* Handle depth */ 521 default_depth = fPtr->fbi.fbi_bitsperpixel <= 24 ? fPtr->fbi.fbi_bitsperpixel : 24; 522 bitsperpixel = fPtr->fbi.fbi_bitsperpixel == 15 ? 16 : fPtr->fbi.fbi_bitsperpixel; 523#if defined(__NetBSD__) && defined(WSDISPLAY_TYPE_LUNA) 524 if (wstype == WSDISPLAY_TYPE_LUNA) { 525 /* 526 * LUNA's color framebuffers support 4bpp or 8bpp 527 * but they have multiple 1bpp VRAM planes like ancient VGA. 528 */ 529#ifdef HAVE_SHADOW_AFB 530 if (bitsperpixel == 8) { 531 /* 532 * For 8bpp one, we can use the bitplane ops with 533 * shadow update proc as amiga. 534 */ 535 fPtr->planarAfb = TRUE; 536 } else 537#endif 538 { 539 /* 540 * For 4bpp one (or there is no planar support), 541 * just use only the first one plane 542 * as 1bpp monochrome server. 543 * 544 * Note OpenBSD/luna88k workarounds this by 545 * switching depth and palette settings by 546 * WSDISPLAYIO_SETGFXMODE ioctl. 547 */ 548 default_depth = 1; 549 bitsperpixel = 1; 550 } 551 } 552#endif 553#ifdef WSDISPLAY_TYPE_AMIGACC 554 if (wstype == WSDISPLAY_TYPE_AMIGACC) { 555 /* 556 * Video memory is organized in bitplanes. 557 * 8bpp or 1bpp supported in this driver. 558 * With 8bpp conversion to bitplane format 559 * is done in shadow update proc. 560 * With 1bpp no conversion needed. 561 */ 562#ifdef HAVE_SHADOW_AFB 563 if (bitsperpixel == 8) { 564 fPtr->planarAfb = TRUE; 565 } else 566#endif 567 { 568 default_depth = 1; 569 bitsperpixel = 1; 570 } 571 } 572#endif 573 574 if (!xf86SetDepthBpp(pScrn, default_depth, default_depth, 575 bitsperpixel, 576 bitsperpixel >= 24 ? Support24bppFb|Support32bppFb : 0)) 577 return FALSE; 578 579 /* Check consistency. */ 580 if (pScrn->bitsPerPixel != bitsperpixel) { 581 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 582 "specified depth (%d) or bpp (%d) doesn't match " 583 "framebuffer depth (%d)\n", pScrn->depth, 584 pScrn->bitsPerPixel, bitsperpixel); 585 return FALSE; 586 } 587 xf86PrintDepthBpp(pScrn); 588 589 /* Get the depth24 pixmap format. */ 590 if (pScrn->depth == 24 && pix24bpp == 0) 591 pix24bpp = xf86GetBppFromDepth(pScrn, 24); 592 593#ifdef WSDISPLAY_TYPE_VAX_MONO 594 if (wstype == WSDISPLAY_TYPE_VAX_MONO) { 595 pScrn->bitmapBitOrder = LSBFirst; 596 } 597#endif 598 599 /* Handle options. */ 600 xf86CollectOptions(pScrn, NULL); 601 fPtr->Options = (OptionInfoRec *)malloc(sizeof(WsfbOptions)); 602 if (fPtr->Options == NULL) 603 return FALSE; 604 memcpy(fPtr->Options, WsfbOptions, sizeof(WsfbOptions)); 605 xf86ProcessOptions(pScrn->scrnIndex, fPtr->pEnt->device->options, 606 fPtr->Options); 607 608 /* Use shadow framebuffer by default, on depth >= 8 */ 609 xf86Msg(X_INFO, "fbi_flags: %x\n", fPtr->fbi.fbi_flags); 610 if ((pScrn->depth >= 8) && 611 ((fPtr->fbi.fbi_flags & WSFB_VRAM_IS_RAM) == 0)) { 612 fPtr->shadowFB = xf86ReturnOptValBool(fPtr->Options, 613 OPTION_SHADOW_FB, TRUE); 614 } else 615 if (xf86ReturnOptValBool(fPtr->Options, 616 OPTION_SHADOW_FB, FALSE)) { 617 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 618 "Shadow FB option ignored on depth < 8\n"); 619 } 620 if (fPtr->fbi.fbi_flags & WSFB_VRAM_IS_SPLIT) { 621 if (!fPtr->shadowFB) { 622 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 623 "Shadow FB forced on for split framebuffer\n"); 624 fPtr->shadowFB = TRUE; 625 } 626 } 627 628 fPtr->useRGB16ToYUY2 = FALSE; 629#ifdef WSDISPLAY_TYPE_HOLLYWOOD 630 if (wstype == WSDISPLAY_TYPE_HOLLYWOOD) { 631 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 632 "Enabling RGB16->YUY2 conversion for Hollywood\n"); 633 fPtr->useRGB16ToYUY2 = TRUE; 634 if (!fPtr->shadowFB) { 635 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 636 "Shadow FB forced on for RGB16->YUY2 conversion\n"); 637 fPtr->shadowFB = TRUE; 638 } 639 /* 640 * Hollywood has a YUY2 framebuffer, but we treat it as 641 * RGB565 and convert with a custom shadowproc. 642 */ 643 fPtr->fbi.fbi_pixeltype = WSFB_RGB; 644 } 645#endif 646 /* Rotation */ 647 fPtr->rotate = WSFB_ROTATE_NONE; 648 if ((s = xf86GetOptValString(fPtr->Options, OPTION_ROTATE))) { 649 if (pScrn->depth >= 8) { 650 if (!xf86NameCmp(s, "CW")) { 651 fPtr->shadowFB = TRUE; 652 fPtr->rotate = WSFB_ROTATE_CW; 653 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 654 "Rotating screen clockwise\n"); 655 } else if (!xf86NameCmp(s, "CCW")) { 656 fPtr->shadowFB = TRUE; 657 fPtr->rotate = WSFB_ROTATE_CCW; 658 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 659 "Rotating screen counter clockwise\n"); 660 } else if (!xf86NameCmp(s, "UD")) { 661 fPtr->shadowFB = TRUE; 662 fPtr->rotate = WSFB_ROTATE_UD; 663 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 664 "Rotating screen upside down\n"); 665 } else { 666 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 667 "\"%s\" is not a valid value for Option " 668 "\"Rotate\"\n", s); 669 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 670 "Valid options are \"CW\", \"CCW\"," 671 " or \"UD\"\n"); 672 } 673 } else { 674 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 675 "Option \"Rotate\" ignored on depth < 8\n"); 676 } 677 } 678 679 680 fPtr->useSwap32 = FALSE; 681 /* Color weight */ 682 if (fPtr->fbi.fbi_pixeltype == WSFB_RGB) { 683 rgb zeros = { 0, 0, 0 }, masks; 684 685 if (fPtr->fbi.fbi_subtype.fbi_rgbmasks.red_size > 0) { 686 uint32_t msk; 687 688 /* 689 * see if we need to byte-swap pixels 690 * XXX this requires a shadow FB and is incompatible 691 * (for now ) with rotation 692 */ 693 if ((fPtr->fbi.fbi_bitsperpixel == 32) && 694 (fPtr->fbi.fbi_subtype.fbi_rgbmasks.blue_offset == 24) && 695 (fPtr->rotate == WSFB_ROTATE_NONE) && 696 (fPtr->shadowFB == TRUE)) { 697 /* 698 * looks like BGRA - set the swap flag and flip 699 * the offsets 700 */ 701 xf86Msg(X_INFO, "endian-flipped RGB framebuffer " 702 "detected, using WsfbShadowUpdateSwap32()\n"); 703 fPtr->fbi.fbi_subtype.fbi_rgbmasks.blue_offset = 0; 704 fPtr->fbi.fbi_subtype.fbi_rgbmasks.green_offset = 8; 705 fPtr->fbi.fbi_subtype.fbi_rgbmasks.red_offset = 16; 706 fPtr->fbi.fbi_subtype.fbi_rgbmasks.alpha_offset = 24; 707 fPtr->useSwap32 = TRUE; 708 } 709 710 msk = 0xffffffff; 711 msk = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.red_size; 712 msk = ~msk; 713 masks.red = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.red_offset; 714 715 msk = 0xffffffff; 716 msk = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.green_size; 717 msk = ~msk; 718 masks.green = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.green_offset; 719 720 msk = 0xffffffff; 721 msk = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.blue_size; 722 msk = ~msk; 723 masks.blue = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.blue_offset; 724 xf86Msg(X_INFO, "masks generated: %08lx %08lx %08lx\n", 725 (unsigned long)masks.red, 726 (unsigned long)masks.green, 727 (unsigned long)masks.blue); 728 } else { 729 masks.red = 0; 730 masks.green = 0; 731 masks.blue = 0; 732 } 733 734 if (!xf86SetWeight(pScrn, zeros, masks)) 735 return FALSE; 736 } 737 738 /* Visual init */ 739 if (!xf86SetDefaultVisual(pScrn, -1)) 740 return FALSE; 741 742 /* We don't currently support DirectColor at > 8bpp . */ 743 if (pScrn->depth > 8 && pScrn->defaultVisual != TrueColor) { 744 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual" 745 " (%s) is not supported at depth %d\n", 746 xf86GetVisualName(pScrn->defaultVisual), 747 pScrn->depth); 748 return FALSE; 749 } 750 751 xf86SetGamma(pScrn,zeros); 752 753 pScrn->progClock = TRUE; 754 pScrn->rgbBits = (pScrn->depth >= 8) ? 8 : pScrn->depth; 755 pScrn->chipset = (char *)"wsfb"; 756 pScrn->videoRam = fPtr->fbi.fbi_fbsize; 757 758 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Vidmem: %dk\n", 759 pScrn->videoRam/1024); 760 761 /* Fake video mode struct. */ 762 mode = (DisplayModePtr)malloc(sizeof(DisplayModeRec)); 763 mode->prev = mode; 764 mode->next = mode; 765 mode->name = (char *)"wsfb current mode"; 766 mode->status = MODE_OK; 767 mode->type = M_T_BUILTIN; 768 mode->Clock = 0; 769 mode->HDisplay = fPtr->fbi.fbi_width; 770 mode->HSyncStart = 0; 771 mode->HSyncEnd = 0; 772 mode->HTotal = 0; 773 mode->HSkew = 0; 774 mode->VDisplay = fPtr->fbi.fbi_height; 775 mode->VSyncStart = 0; 776 mode->VSyncEnd = 0; 777 mode->VTotal = 0; 778 mode->VScan = 0; 779 mode->Flags = 0; 780 if (pScrn->modes != NULL) { 781 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 782 "Ignoring mode specification from screen section\n"); 783 } 784 pScrn->currentMode = pScrn->modes = mode; 785 pScrn->virtualX = fPtr->fbi.fbi_width; 786 pScrn->virtualY = fPtr->fbi.fbi_height; 787 pScrn->displayWidth = pScrn->virtualX; 788 789 /* Set the display resolution. */ 790 xf86SetDpi(pScrn, 0, 0); 791 792 from = X_DEFAULT; 793 fPtr->HWCursor = TRUE; 794 if (xf86GetOptValBool(fPtr->Options, OPTION_HW_CURSOR, &fPtr->HWCursor)) 795 from = X_CONFIG; 796 if (xf86ReturnOptValBool(fPtr->Options, OPTION_SW_CURSOR, FALSE)) { 797 from = X_CONFIG; 798 fPtr->HWCursor = FALSE; 799 } 800 xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n", 801 fPtr->HWCursor ? "HW" : "SW"); 802 803 804 /* Load shadow if needed. */ 805 if (fPtr->shadowFB) { 806 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 807 "Using \"Shadow Framebuffer\"\n"); 808 if (xf86LoadSubModule(pScrn, "shadow") == NULL) { 809 WsfbFreeRec(pScrn); 810 return FALSE; 811 } 812 } 813 if (xf86LoadSubModule(pScrn, "fb") == NULL) { 814 WsfbFreeRec(pScrn); 815 return FALSE; 816 } 817 818 if (xf86LoadSubModule(pScrn, "ramdac") == NULL) { 819 WsfbFreeRec(pScrn); 820 return FALSE; 821 } 822 823 TRACE_EXIT("PreInit"); 824 return TRUE; 825} 826 827static void 828wsfbUpdateRotatePacked(ScreenPtr pScreen, shadowBufPtr pBuf) 829{ 830 shadowUpdateRotatePacked(pScreen, pBuf); 831} 832 833static void 834wsfbUpdatePacked(ScreenPtr pScreen, shadowBufPtr pBuf) 835{ 836 shadowUpdatePacked(pScreen, pBuf); 837} 838 839static Bool 840WsfbCreateScreenResources(ScreenPtr pScreen) 841{ 842 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 843 WsfbPtr fPtr = WSFBPTR(pScrn); 844 PixmapPtr pPixmap; 845 Bool ret; 846 void (*shadowproc)(ScreenPtr, shadowBufPtr); 847 ShadowWindowProc windowproc = WsfbWindowLinear; 848 849 pScreen->CreateScreenResources = fPtr->CreateScreenResources; 850 ret = pScreen->CreateScreenResources(pScreen); 851 pScreen->CreateScreenResources = WsfbCreateScreenResources; 852 853 if (!ret) 854 return FALSE; 855 856 pPixmap = pScreen->GetScreenPixmap(pScreen); 857 if (fPtr->fbi.fbi_flags & WSFB_VRAM_IS_SPLIT) { 858 shadowproc = WsfbShadowUpdateSplit; 859 } else if (fPtr->useRGB16ToYUY2) { 860 /* Build RGB16 to Y, U, and V lookup tables */ 861 if (mapRGB16ToY == NULL) { 862 mapRGB16ToY = malloc(0x30000); 863 if (mapRGB16ToY == NULL) { 864 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 865 "Cannot malloc %d bytes for RGB16->YUY2\n", 866 0x30000); 867 return FALSE; 868 } 869 mapRGB16ToU = mapRGB16ToY + 0x10000; 870 mapRGB16ToV = mapRGB16ToY + 0x20000; 871 for (unsigned int n = 0; n < 0x10000; n++) { 872 /* RGB565 values, scaled to 8 bits */ 873 const double R = (((n >> 11) & 0x1f) * 255) / 31; 874 const double G = (((n >> 5) & 0x3f) * 255) / 63; 875 const double B = (((n >> 0) & 0x1f) * 255) / 31; 876 877 /* Convert to YUV */ 878 mapRGB16ToY[n] = 879 0.257 * R + 0.504 * G + 0.098 * B + 16; 880 mapRGB16ToU[n] = 881 -0.148 * R - 0.291 * G + 0.439 * B + 128; 882 mapRGB16ToV[n] = 883 0.439 * R - 0.368 * G - 0.071 * B + 128; 884 } 885 } 886 887 shadowproc = WsfbShadowUpdateRGB16ToYUY2; 888 } else if (fPtr->useSwap32) { 889 shadowproc = WsfbShadowUpdateSwap32; 890 } else if (fPtr->rotate) { 891 shadowproc = wsfbUpdateRotatePacked; 892 } else 893#ifdef HAVE_SHADOW_AFB 894 if (fPtr->planarAfb) { 895 shadowproc = shadowUpdateAfb8; 896 windowproc = WsfbWindowAfb; 897 } else 898#endif 899 { 900 shadowproc = wsfbUpdatePacked; 901 } 902 903 if (!shadowAdd(pScreen, pPixmap, shadowproc, 904 windowproc, fPtr->rotate, NULL)) { 905 return FALSE; 906 } 907 return TRUE; 908} 909 910 911static Bool 912WsfbShadowInit(ScreenPtr pScreen) 913{ 914 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 915 WsfbPtr fPtr = WSFBPTR(pScrn); 916 917 if (!shadowSetup(pScreen)) 918 return FALSE; 919 fPtr->CreateScreenResources = pScreen->CreateScreenResources; 920 pScreen->CreateScreenResources = WsfbCreateScreenResources; 921 922 return TRUE; 923} 924 925static Bool 926WsfbScreenInit(SCREEN_INIT_ARGS_DECL) 927{ 928 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 929 WsfbPtr fPtr = WSFBPTR(pScrn); 930 VisualPtr visual; 931 int ret, flags, ncolors; 932 int wsmode = WSDISPLAYIO_MODE_DUMBFB; 933 int wstype; 934 int width; 935 size_t len; 936 937 TRACE_ENTER("WsfbScreenInit"); 938#if DEBUG 939 ErrorF("\tbitsPerPixel=%d, depth=%d, defaultVisual=%s\n" 940 "\tmask: %x,%x,%x, offset: %u,%u,%u\n", 941 pScrn->bitsPerPixel, 942 pScrn->depth, 943 xf86GetVisualName(pScrn->defaultVisual), 944 pScrn->mask.red,pScrn->mask.green,pScrn->mask.blue, 945 pScrn->offset.red,pScrn->offset.green,pScrn->offset.blue); 946#endif 947 switch (fPtr->fbi.fbi_bitsperpixel) { 948 case 1: 949 case 4: 950 case 8: 951 len = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 952#ifdef HAVE_SHADOW_AFB 953 if (fPtr->planarAfb) { 954 /* 955 * stride is "bytes per line" for each plane so 956 * we need a number of planes to mmap in planar case. 957 */ 958 len *= fPtr->fbi.fbi_bitsperpixel; 959 } 960#endif 961 962 break; 963 case 15: 964 case 16: 965 if (fPtr->fbi.fbi_stride == fPtr->fbi.fbi_width) { 966 len = fPtr->fbi.fbi_width * fPtr->fbi.fbi_height * sizeof(short); 967 } else { 968 len = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 969 } 970 break; 971 case 24: 972 if (fPtr->fbi.fbi_stride == fPtr->fbi.fbi_width) { 973 len = fPtr->fbi.fbi_width * fPtr->fbi.fbi_height * 3; 974 } else { 975 len = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 976 } 977 break; 978 case 32: 979 if (fPtr->fbi.fbi_stride == fPtr->fbi.fbi_width) { 980 len = fPtr->fbi.fbi_width * fPtr->fbi.fbi_height * sizeof(int); 981 } else { 982 len = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 983 } 984 break; 985 default: 986 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 987 "unsupported depth %d\n", fPtr->fbi.fbi_bitsperpixel); 988 return FALSE; 989 } 990 /* Switch to graphics mode - required before mmap. */ 991 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &wsmode) == -1) { 992 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 993 "ioctl WSDISPLAYIO_SMODE: %s\n", 994 strerror(errno)); 995 return FALSE; 996 } 997 /* Get wsdisplay type to handle quirks */ 998 if (ioctl(fPtr->fd, WSDISPLAYIO_GTYPE, &wstype) == -1) { 999 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1000 "ioctl WSDISPLAY_GTYPE: %s\n", 1001 strerror(errno)); 1002 return FALSE; 1003 } 1004 len = max(len, fPtr->fbi.fbi_fbsize); 1005 fPtr->fbmem = wsfb_mmap(len + fPtr->fbi.fbi_fboffset, 0, fPtr->fd); 1006 1007 if (fPtr->fbmem == NULL) { 1008 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1009 "wsfb_mmap: %s\n", strerror(errno)); 1010 return FALSE; 1011 } 1012 fPtr->fbmem_len = len; 1013 1014 WsfbSave(pScrn); 1015 pScrn->vtSema = TRUE; 1016 1017 /* MI layer */ 1018 miClearVisualTypes(); 1019 if (pScrn->bitsPerPixel > 8) { 1020 if (!miSetVisualTypes(pScrn->depth, TrueColorMask, 1021 pScrn->rgbBits, TrueColor)) 1022 return FALSE; 1023 } else { 1024 if (!miSetVisualTypes(pScrn->depth, 1025 miGetDefaultVisualMask(pScrn->depth), 1026 pScrn->rgbBits, pScrn->defaultVisual)) 1027 return FALSE; 1028 } 1029 if (!miSetPixmapDepths()) 1030 return FALSE; 1031 1032 if (fPtr->rotate == WSFB_ROTATE_CW 1033 || fPtr->rotate == WSFB_ROTATE_CCW) { 1034 int tmp = pScrn->virtualX; 1035 pScrn->virtualX = pScrn->displayWidth = pScrn->virtualY; 1036 pScrn->virtualY = tmp; 1037 } 1038 if (fPtr->rotate && !fPtr->PointerMoved) { 1039 fPtr->PointerMoved = pScrn->PointerMoved; 1040 pScrn->PointerMoved = WsfbPointerMoved; 1041 } 1042 1043 fPtr->fbstart = fPtr->fbmem + fPtr->fbi.fbi_fboffset; 1044 1045 if (fPtr->shadowFB) { 1046 if (fPtr->rotate) { 1047 /* 1048 * Note Rotate and Shadow FB options are valid 1049 * only on depth >= 8. 1050 */ 1051 len = pScrn->virtualX * pScrn->virtualY * 1052 (pScrn->bitsPerPixel >> 3); 1053 } else 1054#ifdef HAVE_SHADOW_AFB 1055 if (fPtr->planarAfb) { 1056 /* always 8bpp */ 1057 len = pScrn->virtualX * pScrn->virtualY; 1058 } else 1059#endif 1060 { 1061 len = fPtr->fbi.fbi_stride * pScrn->virtualY; 1062 } 1063 fPtr->shadow = calloc(1, len); 1064 1065 if (!fPtr->shadow) { 1066 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1067 "Failed to allocate shadow framebuffer\n"); 1068 return FALSE; 1069 } 1070 } 1071 1072 /* 1073 * fbScreenInit() seems to require "pixel width of frame buffer" 1074 * but it is actually "stride in pixel" of frame buffer, 1075 * per xorg/xserver/tree/fb/fbscreen.c. 1076 */ 1077 if (fPtr->rotate) { 1078 width = pScrn->displayWidth; 1079 } else 1080#ifdef HAVE_SHADOW_AFB 1081 if (fPtr->planarAfb) { 1082 width = pScrn->displayWidth; 1083 } else 1084#endif 1085 { 1086 if (pScrn->bitsPerPixel > 8) { 1087 width = 1088 fPtr->fbi.fbi_stride / (pScrn->bitsPerPixel >> 3); 1089 } else { 1090 width = 1091 fPtr->fbi.fbi_stride * (8 / pScrn->bitsPerPixel); 1092 } 1093 } 1094 switch (pScrn->bitsPerPixel) { 1095 case 1: 1096 ret = fbScreenInit(pScreen, 1097 fPtr->fbstart, 1098 pScrn->virtualX, pScrn->virtualY, 1099 pScrn->xDpi, pScrn->yDpi, 1100 width, pScrn->bitsPerPixel); 1101 break; 1102 case 4: 1103 case 8: 1104 case 16: 1105 case 24: 1106 case 32: 1107 ret = fbScreenInit(pScreen, 1108 fPtr->shadowFB ? fPtr->shadow : fPtr->fbstart, 1109 pScrn->virtualX, pScrn->virtualY, 1110 pScrn->xDpi, pScrn->yDpi, 1111 width, 1112 pScrn->bitsPerPixel); 1113 break; 1114 default: 1115 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1116 "Unsupported bpp: %d\n", pScrn->bitsPerPixel); 1117 return FALSE; 1118 } /* case */ 1119 1120 if (!ret) 1121 return FALSE; 1122 1123 if (pScrn->bitsPerPixel > 8) { 1124 /* Fixup RGB ordering. */ 1125 visual = pScreen->visuals + pScreen->numVisuals; 1126 while (--visual >= pScreen->visuals) { 1127 if ((visual->class | DynamicClass) == DirectColor) { 1128 visual->offsetRed = pScrn->offset.red; 1129 visual->offsetGreen = pScrn->offset.green; 1130 visual->offsetBlue = pScrn->offset.blue; 1131 visual->redMask = pScrn->mask.red; 1132 visual->greenMask = pScrn->mask.green; 1133 visual->blueMask = pScrn->mask.blue; 1134 } 1135 } 1136 } 1137 1138 if (pScrn->bitsPerPixel >= 8) { 1139 if (!fbPictureInit(pScreen, NULL, 0)) 1140 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 1141 "RENDER extension initialisation failed.\n"); 1142 } 1143 if (fPtr->shadowFB && !WsfbShadowInit(pScreen)) { 1144 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1145 "shadow framebuffer initialization failed\n"); 1146 return FALSE; 1147 } 1148 1149#ifdef XFreeXDGA 1150 if (!fPtr->rotate) 1151 WsfbDGAInit(pScrn, pScreen); 1152 else 1153 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Rotated display, " 1154 "disabling DGA\n"); 1155#endif 1156 if (fPtr->rotate) { 1157 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 1158 "Enabling Driver Rotation, " "disabling RandR\n"); 1159#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 24 1160 xf86DisableRandR(); 1161#endif 1162 if (pScrn->bitsPerPixel == 24) 1163 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 1164 "Rotation might be broken in 24 bpp\n"); 1165 } 1166 1167 xf86SetBlackWhitePixels(pScreen); 1168 xf86SetBackingStore(pScreen); 1169 1170 /* Software cursor. */ 1171 miDCInitialize(pScreen, xf86GetPointerScreenFuncs()); 1172 1173 /* check for hardware cursor support */ 1174 if (fPtr->HWCursor) 1175 WsfbSetupCursor(pScreen); 1176 1177 /* 1178 * Colormap 1179 * 1180 * Note that, even on less than 8 bit depth frame buffers, we 1181 * expect the colormap to be programmable with 8 bit values. 1182 * As of now, this is indeed the case on all OpenBSD supported 1183 * graphics hardware. 1184 */ 1185 if (!miCreateDefColormap(pScreen)) 1186 return FALSE; 1187 flags = CMAP_RELOAD_ON_MODE_SWITCH; 1188 1189 ncolors = 0; 1190 if (fPtr->fbi.fbi_pixeltype == WSFB_CI) { 1191 ncolors = fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries; 1192 } 1193 1194 /* On StaticGray visuals, fake a 256 entries colormap. */ 1195 if (ncolors == 0) 1196 ncolors = 256; 1197 if(!xf86HandleColormaps(pScreen, ncolors, 8, WsfbLoadPalette, 1198 NULL, flags)) 1199 return FALSE; 1200 1201#if defined(__NetBSD__) && defined(WSDISPLAY_TYPE_LUNA) 1202 if (wstype == WSDISPLAY_TYPE_LUNA) { 1203 ncolors = fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries; 1204 if (ncolors > 0 1205#ifdef HAVE_SHADOW_AFB 1206 && !fPtr->planarAfb 1207#endif 1208 ) { 1209 /* 1210 * Override palette to use 4bpp/8bpp framebuffers as 1211 * monochrome server by using only the first plane. 1212 * See also comment in WsfbPreInit(). 1213 */ 1214 struct wsdisplay_cmap cmap; 1215 uint8_t r[256], g[256], b[256]; 1216 int p; 1217 1218 for (p = 0; p < ncolors; p++) 1219 r[p] = g[p] = b[p] = (p & 1) ? 0xff : 0; 1220 cmap.index = 0; 1221 cmap.count = ncolors; 1222 cmap.red = r; 1223 cmap.green = g; 1224 cmap.blue = b; 1225 if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP, &cmap) == -1) { 1226 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1227 "ioctl WSDISPLAYIO_PUTCMAP: %s\n", 1228 strerror(errno)); 1229 } 1230 } 1231 } 1232#endif 1233 1234 pScreen->SaveScreen = WsfbSaveScreen; 1235 1236#ifdef XvExtension 1237 { 1238 XF86VideoAdaptorPtr *ptr; 1239 1240 int n = xf86XVListGenericAdaptors(pScrn,&ptr); 1241 if (n) { 1242 xf86XVScreenInit(pScreen,ptr,n); 1243 } 1244 } 1245#endif 1246 1247 /* Wrap the current CloseScreen function. */ 1248 fPtr->CloseScreen = pScreen->CloseScreen; 1249 pScreen->CloseScreen = WsfbCloseScreen; 1250 1251 TRACE_EXIT("WsfbScreenInit"); 1252 return TRUE; 1253} 1254 1255static Bool 1256WsfbCloseScreen(CLOSE_SCREEN_ARGS_DECL) 1257{ 1258 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 1259 PixmapPtr pPixmap; 1260 WsfbPtr fPtr = WSFBPTR(pScrn); 1261 1262 1263 TRACE_ENTER("WsfbCloseScreen"); 1264 1265 pPixmap = pScreen->GetScreenPixmap(pScreen); 1266 if (fPtr->shadowFB) 1267 shadowRemove(pScreen, pPixmap); 1268 1269 if (pScrn->vtSema) { 1270 WsfbRestore(pScrn); 1271 if (munmap(fPtr->fbmem, fPtr->fbmem_len + fPtr->fbi.fbi_fboffset) == -1) { 1272 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1273 "munmap: %s\n", strerror(errno)); 1274 } 1275 1276 fPtr->fbmem = NULL; 1277 } 1278#ifdef XFreeXDGA 1279 if (fPtr->pDGAMode) { 1280 free(fPtr->pDGAMode); 1281 fPtr->pDGAMode = NULL; 1282 fPtr->nDGAMode = 0; 1283 } 1284#endif 1285 pScrn->vtSema = FALSE; 1286 1287 /* Unwrap CloseScreen. */ 1288 pScreen->CloseScreen = fPtr->CloseScreen; 1289 TRACE_EXIT("WsfbCloseScreen"); 1290 return (*pScreen->CloseScreen)(CLOSE_SCREEN_ARGS); 1291} 1292 1293static void * 1294WsfbWindowLinear(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode, 1295 CARD32 *size, void *closure) 1296{ 1297 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 1298 WsfbPtr fPtr = WSFBPTR(pScrn); 1299 1300 if (fPtr->fbi.fbi_stride) 1301 *size = fPtr->fbi.fbi_stride; 1302 else { 1303 if (ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, size) == -1) 1304 return NULL; 1305 fPtr->fbi.fbi_stride = *size; 1306 } 1307 return ((CARD8 *)fPtr->fbstart + row * fPtr->fbi.fbi_stride + offset); 1308} 1309 1310#ifdef HAVE_SHADOW_AFB 1311/* 1312 * For use with shadowUpdateAfb8 1313 * 1314 * For video memory layout with non-interleaved bitplanes. 1315 */ 1316static void * 1317WsfbWindowAfb(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode, 1318 CARD32 *size, void *closure) 1319{ 1320 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 1321 WsfbPtr fPtr = WSFBPTR(pScrn); 1322 1323 /* size is offset from start of bitplane to next bitplane */ 1324 *size = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 1325 return ((CARD8 *)fPtr->fbstart + row * fPtr->fbi.fbi_stride + offset); 1326} 1327#endif 1328 1329static void 1330WsfbPointerMoved(SCRN_ARG_TYPE arg, int x, int y) 1331{ 1332 SCRN_INFO_PTR(arg); 1333 WsfbPtr fPtr = WSFBPTR(pScrn); 1334 int newX, newY; 1335 1336 switch (fPtr->rotate) 1337 { 1338 case WSFB_ROTATE_CW: 1339 /* 90 degrees CW rotation. */ 1340 newX = pScrn->pScreen->height - y - 1; 1341 newY = x; 1342 break; 1343 1344 case WSFB_ROTATE_CCW: 1345 /* 90 degrees CCW rotation. */ 1346 newX = y; 1347 newY = pScrn->pScreen->width - x - 1; 1348 break; 1349 1350 case WSFB_ROTATE_UD: 1351 /* 180 degrees UD rotation. */ 1352 newX = pScrn->pScreen->width - x - 1; 1353 newY = pScrn->pScreen->height - y - 1; 1354 break; 1355 1356 default: 1357 /* No rotation. */ 1358 newX = x; 1359 newY = y; 1360 break; 1361 } 1362 1363 /* Pass adjusted pointer coordinates to wrapped PointerMoved function. */ 1364 (*fPtr->PointerMoved)(arg, newX, newY); 1365} 1366 1367static Bool 1368WsfbEnterVT(VT_FUNC_ARGS_DECL) 1369{ 1370 SCRN_INFO_PTR(arg); 1371 WsfbPtr fPtr = WSFBPTR(pScrn); 1372 int mode; 1373 1374 TRACE_ENTER("EnterVT"); 1375 pScrn->vtSema = TRUE; 1376 1377 /* Restore the graphics mode. */ 1378 mode = WSDISPLAYIO_MODE_DUMBFB; 1379 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) { 1380 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1381 "error setting graphics mode %s\n", strerror(errno)); 1382 } 1383 1384 TRACE_EXIT("EnterVT"); 1385 return TRUE; 1386} 1387 1388static void 1389WsfbLeaveVT(VT_FUNC_ARGS_DECL) 1390{ 1391 SCRN_INFO_PTR(arg); 1392 WsfbPtr fPtr = WSFBPTR(pScrn); 1393 int mode; 1394 1395 TRACE_ENTER("LeaveVT"); 1396 1397 /* 1398 * stuff to do: 1399 * - turn off hw cursor 1400 * - restore colour map if WSFB_CI 1401 * - ioctl(WSDISPLAYIO_MODE_EMUL) to notify the kernel driver that 1402 * we're backing off 1403 */ 1404 1405 if (fPtr->fbi.fbi_pixeltype == WSFB_CI && 1406 fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries > 0) { 1407 /* reset colormap for text mode */ 1408 if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP, 1409 &(fPtr->saved_cmap)) == -1) { 1410 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1411 "error restoring colormap %s\n", 1412 strerror(errno)); 1413 } 1414 } 1415 1416 /* Restore the text mode. */ 1417 mode = WSDISPLAYIO_MODE_EMUL; 1418 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) { 1419 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1420 "error setting text mode %s\n", strerror(errno)); 1421 } 1422 1423 pScrn->vtSema = FALSE; 1424 TRACE_EXIT("LeaveVT"); 1425} 1426 1427static Bool 1428WsfbSwitchMode(SWITCH_MODE_ARGS_DECL) 1429{ 1430#if DEBUG 1431 SCRN_INFO_PTR(arg); 1432#endif 1433 1434 TRACE_ENTER("SwitchMode"); 1435 /* Nothing else to do. */ 1436 return TRUE; 1437} 1438 1439static int 1440WsfbValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode, Bool verbose, int flags) 1441{ 1442#if DEBUG 1443 SCRN_INFO_PTR(arg); 1444#endif 1445 1446 TRACE_ENTER("ValidMode"); 1447 return MODE_OK; 1448} 1449 1450static void 1451WsfbLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, 1452 LOCO *colors, VisualPtr pVisual) 1453{ 1454 WsfbPtr fPtr = WSFBPTR(pScrn); 1455 struct wsdisplay_cmap cmap; 1456 unsigned char red[256],green[256],blue[256]; 1457 int i, indexMin=256, indexMax=0; 1458 1459 TRACE_ENTER("LoadPalette"); 1460 1461 /* nothing to do if there is no color palette support */ 1462 if (fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries == 0) 1463 return; 1464 1465 cmap.count = 1; 1466 cmap.red = red; 1467 cmap.green = green; 1468 cmap.blue = blue; 1469 1470 if (numColors == 1) { 1471 /* Optimisation */ 1472 cmap.index = indices[0]; 1473 red[0] = colors[indices[0]].red; 1474 green[0] = colors[indices[0]].green; 1475 blue[0] = colors[indices[0]].blue; 1476 if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1) 1477 ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno)); 1478 } else { 1479 /* 1480 * Change all colors in 2 ioctls 1481 * and limit the data to be transferred. 1482 */ 1483 for (i = 0; i < numColors; i++) { 1484 if (indices[i] < indexMin) 1485 indexMin = indices[i]; 1486 if (indices[i] > indexMax) 1487 indexMax = indices[i]; 1488 } 1489 cmap.index = indexMin; 1490 cmap.count = indexMax - indexMin + 1; 1491 cmap.red = &red[indexMin]; 1492 cmap.green = &green[indexMin]; 1493 cmap.blue = &blue[indexMin]; 1494 /* Get current map. */ 1495 if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP, &cmap) == -1) 1496 ErrorF("ioctl FBIOGETCMAP: %s\n", strerror(errno)); 1497 /* Change the colors that require updating. */ 1498 for (i = 0; i < numColors; i++) { 1499 red[indices[i]] = colors[indices[i]].red; 1500 green[indices[i]] = colors[indices[i]].green; 1501 blue[indices[i]] = colors[indices[i]].blue; 1502 } 1503 /* Write the colormap back. */ 1504 if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1) 1505 ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno)); 1506 } 1507 TRACE_EXIT("LoadPalette"); 1508} 1509 1510static Bool 1511WsfbSaveScreen(ScreenPtr pScreen, int mode) 1512{ 1513 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 1514 WsfbPtr fPtr = WSFBPTR(pScrn); 1515 int state; 1516 1517 TRACE_ENTER("SaveScreen"); 1518 1519 if (!pScrn->vtSema) 1520 return TRUE; 1521 1522 if (mode != SCREEN_SAVER_FORCER) { 1523 state = xf86IsUnblank(mode)?WSDISPLAYIO_VIDEO_ON: 1524 WSDISPLAYIO_VIDEO_OFF; 1525 ioctl(fPtr->fd, 1526 WSDISPLAYIO_SVIDEO, &state); 1527 } 1528 TRACE_EXIT("SaveScreen"); 1529 return TRUE; 1530} 1531 1532 1533static void 1534WsfbSave(ScrnInfoPtr pScrn) 1535{ 1536 WsfbPtr fPtr = WSFBPTR(pScrn); 1537 1538 TRACE_ENTER("WsfbSave"); 1539 1540 /* nothing to save if we don't run in colour-indexed mode */ 1541 if (fPtr->fbi.fbi_pixeltype != WSFB_CI) 1542 return; 1543 1544 /* nothing to do if no color palette support */ 1545 if (fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries == 0) 1546 return; 1547 1548 fPtr->saved_cmap.index = 0; 1549 fPtr->saved_cmap.count = fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries; 1550 if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP, 1551 &(fPtr->saved_cmap)) == -1) { 1552 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1553 "error saving colormap %s\n", strerror(errno)); 1554 } 1555 TRACE_EXIT("WsfbSave"); 1556 1557} 1558 1559static void 1560WsfbRestore(ScrnInfoPtr pScrn) 1561{ 1562 WsfbPtr fPtr = WSFBPTR(pScrn); 1563 int mode; 1564 1565 TRACE_ENTER("WsfbRestore"); 1566 1567 if (fPtr->fbi.fbi_pixeltype == WSFB_CI && 1568 fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries > 0) { 1569 /* reset colormap for text mode */ 1570 if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP, 1571 &(fPtr->saved_cmap)) == -1) { 1572 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1573 "error restoring colormap %s\n", 1574 strerror(errno)); 1575 } 1576 } 1577 1578 /* Clear the screen. */ 1579 memset(fPtr->fbstart, 0, fPtr->fbmem_len); 1580 1581 /* Restore the text mode. */ 1582 mode = WSDISPLAYIO_MODE_EMUL; 1583 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) { 1584 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1585 "error setting text mode %s\n", strerror(errno)); 1586 } 1587 TRACE_EXIT("WsfbRestore"); 1588} 1589 1590#ifdef XFreeXDGA 1591/*********************************************************************** 1592 * DGA stuff 1593 ***********************************************************************/ 1594 1595static Bool 1596WsfbDGAOpenFramebuffer(ScrnInfoPtr pScrn, char **DeviceName, 1597 unsigned char **ApertureBase, int *ApertureSize, 1598 int *ApertureOffset, int *flags) 1599{ 1600 *DeviceName = NULL; /* No special device */ 1601 *ApertureBase = (unsigned char *)(pScrn->memPhysBase); 1602 *ApertureSize = pScrn->videoRam; 1603 *ApertureOffset = pScrn->fbOffset; 1604 *flags = 0; 1605 1606 return TRUE; 1607} 1608 1609static Bool 1610WsfbDGASetMode(ScrnInfoPtr pScrn, DGAModePtr pDGAMode) 1611{ 1612 DisplayModePtr pMode; 1613 int frameX0, frameY0; 1614 1615 if (pDGAMode) { 1616 pMode = pDGAMode->mode; 1617 frameX0 = frameY0 = 0; 1618 } else { 1619 if (!(pMode = pScrn->currentMode)) 1620 return TRUE; 1621 1622 frameX0 = pScrn->frameX0; 1623 frameY0 = pScrn->frameY0; 1624 } 1625 1626 if (!(*pScrn->SwitchMode)(SWITCH_MODE_ARGS(pScrn, pMode))) 1627 return FALSE; 1628 (*pScrn->AdjustFrame)(ADJUST_FRAME_ARGS(pScrn, frameX0, frameY0)); 1629 1630 return TRUE; 1631} 1632 1633static void 1634WsfbDGASetViewport(ScrnInfoPtr pScrn, int x, int y, int flags) 1635{ 1636 (*pScrn->AdjustFrame)(ADJUST_FRAME_ARGS(pScrn, x, y)); 1637} 1638 1639static int 1640WsfbDGAGetViewport(ScrnInfoPtr pScrn) 1641{ 1642 return (0); 1643} 1644 1645static DGAFunctionRec WsfbDGAFunctions = 1646{ 1647 WsfbDGAOpenFramebuffer, 1648 NULL, /* CloseFramebuffer */ 1649 WsfbDGASetMode, 1650 WsfbDGASetViewport, 1651 WsfbDGAGetViewport, 1652 NULL, /* Sync */ 1653 NULL, /* FillRect */ 1654 NULL, /* BlitRect */ 1655 NULL, /* BlitTransRect */ 1656}; 1657 1658static void 1659WsfbDGAAddModes(ScrnInfoPtr pScrn) 1660{ 1661 WsfbPtr fPtr = WSFBPTR(pScrn); 1662 DisplayModePtr pMode = pScrn->modes; 1663 DGAModePtr pDGAMode; 1664 1665 do { 1666 pDGAMode = realloc(fPtr->pDGAMode, 1667 (fPtr->nDGAMode + 1) * sizeof(DGAModeRec)); 1668 if (!pDGAMode) 1669 break; 1670 1671 fPtr->pDGAMode = pDGAMode; 1672 pDGAMode += fPtr->nDGAMode; 1673 (void)memset(pDGAMode, 0, sizeof(DGAModeRec)); 1674 1675 ++fPtr->nDGAMode; 1676 pDGAMode->mode = pMode; 1677 pDGAMode->flags = DGA_CONCURRENT_ACCESS | DGA_PIXMAP_AVAILABLE; 1678 pDGAMode->byteOrder = pScrn->imageByteOrder; 1679 pDGAMode->depth = pScrn->depth; 1680 pDGAMode->bitsPerPixel = pScrn->bitsPerPixel; 1681 pDGAMode->red_mask = pScrn->mask.red; 1682 pDGAMode->green_mask = pScrn->mask.green; 1683 pDGAMode->blue_mask = pScrn->mask.blue; 1684 pDGAMode->visualClass = pScrn->bitsPerPixel > 8 ? 1685 TrueColor : PseudoColor; 1686 pDGAMode->xViewportStep = 1; 1687 pDGAMode->yViewportStep = 1; 1688 pDGAMode->viewportWidth = pMode->HDisplay; 1689 pDGAMode->viewportHeight = pMode->VDisplay; 1690 1691 if (fPtr->fbi.fbi_stride) 1692 pDGAMode->bytesPerScanline = fPtr->fbi.fbi_stride; 1693 else { 1694 ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, 1695 &fPtr->fbi.fbi_stride); 1696 pDGAMode->bytesPerScanline = fPtr->fbi.fbi_stride; 1697 } 1698 1699 pDGAMode->imageWidth = pMode->HDisplay; 1700 pDGAMode->imageHeight = pMode->VDisplay; 1701 pDGAMode->pixmapWidth = pDGAMode->imageWidth; 1702 pDGAMode->pixmapHeight = pDGAMode->imageHeight; 1703 pDGAMode->maxViewportX = pScrn->virtualX - 1704 pDGAMode->viewportWidth; 1705 pDGAMode->maxViewportY = pScrn->virtualY - 1706 pDGAMode->viewportHeight; 1707 1708 pDGAMode->address = fPtr->fbstart; 1709 1710 pMode = pMode->next; 1711 } while (pMode != pScrn->modes); 1712} 1713 1714static Bool 1715WsfbDGAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen) 1716{ 1717 WsfbPtr fPtr = WSFBPTR(pScrn); 1718 1719 if (pScrn->depth < 8) 1720 return FALSE; 1721 1722 if (!fPtr->nDGAMode) 1723 WsfbDGAAddModes(pScrn); 1724 1725 return (DGAInit(pScreen, &WsfbDGAFunctions, 1726 fPtr->pDGAMode, fPtr->nDGAMode)); 1727} 1728#endif 1729 1730static Bool 1731WsfbDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op, 1732 pointer ptr) 1733{ 1734 xorgHWFlags *flag; 1735 1736 switch (op) { 1737 case GET_REQUIRED_HW_INTERFACES: 1738 flag = (CARD32*)ptr; 1739 (*flag) = 0; 1740 return TRUE; 1741 default: 1742 return FALSE; 1743 } 1744} 1745 1746static inline void 1747WsfbCopyRGB16ToYUY2(void *dest, void *src, int len) 1748{ 1749 uint16_t *src16 = src; 1750 uint32_t *dest32 = dest; 1751 1752 while (len > 0) { 1753 const uint16_t rgb0 = src16[0]; 1754 const uint16_t rgb1 = src16[1]; 1755 const uint16_t rgb = ((rgb0 >> 1) & ~0x8410) + 1756 ((rgb1 >> 1) & ~0x8410) + 1757 ((rgb0 & rgb1) & 0x0841); 1758 const uint32_t y0 = mapRGB16ToY[rgb0]; 1759 const uint32_t y1 = mapRGB16ToY[rgb1]; 1760 const uint32_t u = mapRGB16ToU[rgb]; 1761 const uint32_t v = mapRGB16ToV[rgb]; 1762 1763 *dest32 = (y0 << 24) | (u << 16) | (y1 << 8) | v; 1764 1765 dest32++; 1766 src16 += 2; 1767 len -= 4; 1768 } 1769} 1770 1771void 1772WsfbShadowUpdateRGB16ToYUY2(ScreenPtr pScreen, shadowBufPtr pBuf) 1773{ 1774 RegionPtr damage = DamageRegion (pBuf->pDamage); 1775 PixmapPtr pShadow = pBuf->pPixmap; 1776 int nbox = RegionNumRects (damage); 1777 BoxPtr pbox = RegionRects (damage); 1778 FbBits *shaBase, *shaLine, *sha; 1779 FbStride shaStride; 1780 int scrBase, scrLine, scr; 1781 int shaBpp; 1782 int shaXoff, shaYoff; /* XXX assumed to be zero */ 1783 int x, y, w, h, width; 1784 int i; 1785 FbBits *winBase = NULL, *win; 1786 CARD32 winSize; 1787 1788 fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff); 1789 while (nbox--) 1790 { 1791 x = pbox->x1 * shaBpp; 1792 y = pbox->y1; 1793 w = (pbox->x2 - pbox->x1) * shaBpp; 1794 h = pbox->y2 - pbox->y1; 1795 1796 scrLine = (x >> FB_SHIFT); 1797 shaLine = shaBase + y * shaStride + (x >> FB_SHIFT); 1798 1799 x &= FB_MASK; 1800 w = (w + x + FB_MASK) >> FB_SHIFT; 1801 1802 while (h--) 1803 { 1804 winSize = 0; 1805 scrBase = 0; 1806 width = w; 1807 scr = scrLine; 1808 sha = shaLine; 1809 while (width) { 1810 /* how much remains in this window */ 1811 i = scrBase + winSize - scr; 1812 if (i <= 0 || scr < scrBase) 1813 { 1814 winBase = (FbBits *) (*pBuf->window) (pScreen, 1815 y, 1816 scr * sizeof (FbBits), 1817 SHADOW_WINDOW_WRITE, 1818 &winSize, 1819 pBuf->closure); 1820 if(!winBase) 1821 return; 1822 scrBase = scr; 1823 winSize /= sizeof (FbBits); 1824 i = winSize; 1825 } 1826 win = winBase + (scr - scrBase); 1827 if (i > width) 1828 i = width; 1829 width -= i; 1830 scr += i; 1831 WsfbCopyRGB16ToYUY2(win, sha, i * sizeof(FbBits)); 1832 sha += i; 1833 } 1834 shaLine += shaStride; 1835 y++; 1836 } 1837 pbox++; 1838 } 1839} 1840 1841static inline void 1842memcpy32sw(void *dest, void *src, int len) 1843{ 1844 uint32_t *d = dest, *s = src; 1845 1846#if DEBUG 1847 if ((((long)dest & 3) + ((long)src & 3) + (len & 3)) != 0) { 1848 xf86Msg(X_ERROR, "unaligned %s\n", __func__); 1849 return; 1850 } 1851#endif 1852 while (len > 0) { 1853 *d = bswap32(*s); 1854 d++; 1855 s++; 1856 len -= 4; 1857 } 1858} 1859 1860/* adapted from miext/shadow/shpacked.c::shadowUpdatePacked() */ 1861void 1862WsfbShadowUpdateSwap32(ScreenPtr pScreen, shadowBufPtr pBuf) 1863{ 1864 RegionPtr damage = DamageRegion (pBuf->pDamage); 1865 PixmapPtr pShadow = pBuf->pPixmap; 1866 int nbox = RegionNumRects (damage); 1867 BoxPtr pbox = RegionRects (damage); 1868 FbBits *shaBase, *shaLine, *sha; 1869 FbStride shaStride; 1870 int scrBase, scrLine, scr; 1871 int shaBpp; 1872 int shaXoff, shaYoff; /* XXX assumed to be zero */ 1873 int x, y, w, h, width; 1874 int i; 1875 FbBits *winBase = NULL, *win; 1876 CARD32 winSize; 1877 1878 fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff); 1879 while (nbox--) 1880 { 1881 x = pbox->x1 * shaBpp; 1882 y = pbox->y1; 1883 w = (pbox->x2 - pbox->x1) * shaBpp; 1884 h = pbox->y2 - pbox->y1; 1885 1886 scrLine = (x >> FB_SHIFT); 1887 shaLine = shaBase + y * shaStride + (x >> FB_SHIFT); 1888 1889 x &= FB_MASK; 1890 w = (w + x + FB_MASK) >> FB_SHIFT; 1891 1892 while (h--) 1893 { 1894 winSize = 0; 1895 scrBase = 0; 1896 width = w; 1897 scr = scrLine; 1898 sha = shaLine; 1899 while (width) { 1900 /* how much remains in this window */ 1901 i = scrBase + winSize - scr; 1902 if (i <= 0 || scr < scrBase) 1903 { 1904 winBase = (FbBits *) (*pBuf->window) (pScreen, 1905 y, 1906 scr * sizeof (FbBits), 1907 SHADOW_WINDOW_WRITE, 1908 &winSize, 1909 pBuf->closure); 1910 if(!winBase) 1911 return; 1912 scrBase = scr; 1913 winSize /= sizeof (FbBits); 1914 i = winSize; 1915 } 1916 win = winBase + (scr - scrBase); 1917 if (i > width) 1918 i = width; 1919 width -= i; 1920 scr += i; 1921 memcpy32sw(win, sha, i * sizeof(FbBits)); 1922 sha += i; 1923 } 1924 shaLine += shaStride; 1925 y++; 1926 } 1927 pbox++; 1928 } 1929} 1930 1931void 1932WsfbShadowUpdateSplit(ScreenPtr pScreen, shadowBufPtr pBuf) 1933{ 1934 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 1935 WsfbPtr fPtr = WSFBPTR(pScrn); 1936 RegionPtr damage = DamageRegion (pBuf->pDamage); 1937 PixmapPtr pShadow = pBuf->pPixmap; 1938 int nbox = RegionNumRects (damage); 1939 BoxPtr pbox = RegionRects (damage); 1940 FbBits *shaBase, *shaLine, *sha; 1941 FbStride shaStride; 1942 int scrBase, scrLine, scr; 1943 int shaBpp; 1944 int shaXoff, shaYoff; /* XXX assumed to be zero */ 1945 int x, y, w, h, width; 1946 int i; 1947 FbBits *winBase = NULL, *win, *win2; 1948 unsigned long split = fPtr->fbi.fbi_fbsize / 2; 1949 CARD32 winSize; 1950 1951 fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff); 1952 while (nbox--) 1953 { 1954 x = pbox->x1 * shaBpp; 1955 y = pbox->y1; 1956 w = (pbox->x2 - pbox->x1) * shaBpp; 1957 h = pbox->y2 - pbox->y1; 1958 1959 scrLine = (x >> FB_SHIFT); 1960 shaLine = shaBase + y * shaStride + (x >> FB_SHIFT); 1961 1962 x &= FB_MASK; 1963 w = (w + x + FB_MASK) >> FB_SHIFT; 1964 1965 while (h--) 1966 { 1967 winSize = 0; 1968 scrBase = 0; 1969 width = w; 1970 scr = scrLine; 1971 sha = shaLine; 1972 while (width) { 1973 /* how much remains in this window */ 1974 i = scrBase + winSize - scr; 1975 if (i <= 0 || scr < scrBase) 1976 { 1977 winBase = (FbBits *) (*pBuf->window) (pScreen, 1978 y, 1979 scr * sizeof (FbBits), 1980 SHADOW_WINDOW_WRITE, 1981 &winSize, 1982 pBuf->closure); 1983 if(!winBase) 1984 return; 1985 scrBase = scr; 1986 winSize /= sizeof (FbBits); 1987 i = winSize; 1988 } 1989 win = winBase + (scr - scrBase); 1990 win2 = (FbBits *)(split + (unsigned long)win); 1991 if (i > width) 1992 i = width; 1993 width -= i; 1994 scr += i; 1995 memcpy(win, sha, i * sizeof(FbBits)); 1996 memcpy(win2, sha, i * sizeof(FbBits)); 1997 sha += i; 1998 } 1999 shaLine += shaStride; 2000 y++; 2001 } 2002 pbox++; 2003 } 2004} 2005