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, 4bpp, and 1bpp supported in this driver. 558 * With 8bpp/4bpp conversion to bitplane format 559 * is done in shadow update proc. In both cases 560 * shadow fb uses 8bpp memory layout and shadow 561 * update proc ignores the possible extra bits. 562 * With 1bpp no conversion needed. 563 */ 564#ifdef HAVE_SHADOW_AFB 565 if (bitsperpixel == 8) { 566 fPtr->planarAfb = TRUE; 567 } else if (bitsperpixel == 4) { 568 fPtr->planarAfb = TRUE; 569 default_depth = 4; 570 bitsperpixel = 8; 571 } else 572#endif 573 { 574 default_depth = 1; 575 bitsperpixel = 1; 576 } 577 } 578#endif 579 580 if (!xf86SetDepthBpp(pScrn, default_depth, default_depth, 581 bitsperpixel, 582 bitsperpixel >= 24 ? Support24bppFb|Support32bppFb : 0)) 583 return FALSE; 584 585 /* Check consistency. */ 586 if (pScrn->bitsPerPixel != bitsperpixel) { 587 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 588 "specified depth (%d) or bpp (%d) doesn't match " 589 "framebuffer depth (%d)\n", pScrn->depth, 590 pScrn->bitsPerPixel, bitsperpixel); 591 return FALSE; 592 } 593 xf86PrintDepthBpp(pScrn); 594 595 /* Get the depth24 pixmap format. */ 596 if (pScrn->depth == 24 && pix24bpp == 0) 597 pix24bpp = xf86GetBppFromDepth(pScrn, 24); 598 599#ifdef WSDISPLAY_TYPE_VAX_MONO 600 if (wstype == WSDISPLAY_TYPE_VAX_MONO) { 601 pScrn->bitmapBitOrder = LSBFirst; 602 } 603#endif 604 605 /* Handle options. */ 606 xf86CollectOptions(pScrn, NULL); 607 fPtr->Options = (OptionInfoRec *)malloc(sizeof(WsfbOptions)); 608 if (fPtr->Options == NULL) 609 return FALSE; 610 memcpy(fPtr->Options, WsfbOptions, sizeof(WsfbOptions)); 611 xf86ProcessOptions(pScrn->scrnIndex, fPtr->pEnt->device->options, 612 fPtr->Options); 613 614 /* Use shadow framebuffer by default, on depth >= 8 */ 615 xf86Msg(X_INFO, "fbi_flags: %x\n", fPtr->fbi.fbi_flags); 616 if ((pScrn->depth >= 8) && 617 ((fPtr->fbi.fbi_flags & WSFB_VRAM_IS_RAM) == 0)) { 618 fPtr->shadowFB = xf86ReturnOptValBool(fPtr->Options, 619 OPTION_SHADOW_FB, TRUE); 620 } else 621 if (xf86ReturnOptValBool(fPtr->Options, 622 OPTION_SHADOW_FB, FALSE)) { 623 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 624 "Shadow FB option ignored on depth < 8\n"); 625 } 626 if (fPtr->fbi.fbi_flags & WSFB_VRAM_IS_SPLIT) { 627 if (!fPtr->shadowFB) { 628 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 629 "Shadow FB forced on for split framebuffer\n"); 630 fPtr->shadowFB = TRUE; 631 } 632 } 633 634 fPtr->useRGB16ToYUY2 = FALSE; 635#ifdef WSDISPLAY_TYPE_HOLLYWOOD 636 if (wstype == WSDISPLAY_TYPE_HOLLYWOOD) { 637 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 638 "Enabling RGB16->YUY2 conversion for Hollywood\n"); 639 fPtr->useRGB16ToYUY2 = TRUE; 640 if (!fPtr->shadowFB) { 641 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 642 "Shadow FB forced on for RGB16->YUY2 conversion\n"); 643 fPtr->shadowFB = TRUE; 644 } 645 /* 646 * Hollywood has a YUY2 framebuffer, but we treat it as 647 * RGB565 and convert with a custom shadowproc. 648 */ 649 fPtr->fbi.fbi_pixeltype = WSFB_RGB; 650 } 651#endif 652#ifdef HAVE_SHADOW_AFB 653 if (fPtr->planarAfb) 654 { 655 if (!fPtr->shadowFB) { 656 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 657 "Shadow FB forced on for planar framebuffer\n"); 658 fPtr->shadowFB = TRUE; 659 } 660 } 661#endif 662 /* Rotation */ 663 fPtr->rotate = WSFB_ROTATE_NONE; 664 if ((s = xf86GetOptValString(fPtr->Options, OPTION_ROTATE))) { 665 if (pScrn->depth >= 8) { 666 if (!xf86NameCmp(s, "CW")) { 667 fPtr->shadowFB = TRUE; 668 fPtr->rotate = WSFB_ROTATE_CW; 669 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 670 "Rotating screen clockwise\n"); 671 } else if (!xf86NameCmp(s, "CCW")) { 672 fPtr->shadowFB = TRUE; 673 fPtr->rotate = WSFB_ROTATE_CCW; 674 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 675 "Rotating screen counter clockwise\n"); 676 } else if (!xf86NameCmp(s, "UD")) { 677 fPtr->shadowFB = TRUE; 678 fPtr->rotate = WSFB_ROTATE_UD; 679 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 680 "Rotating screen upside down\n"); 681 } else { 682 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 683 "\"%s\" is not a valid value for Option " 684 "\"Rotate\"\n", s); 685 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 686 "Valid options are \"CW\", \"CCW\"," 687 " or \"UD\"\n"); 688 } 689 } else { 690 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 691 "Option \"Rotate\" ignored on depth < 8\n"); 692 } 693 } 694 695 696 fPtr->useSwap32 = FALSE; 697 /* Color weight */ 698 if (fPtr->fbi.fbi_pixeltype == WSFB_RGB) { 699 rgb zeros = { 0, 0, 0 }, masks; 700 701 if (fPtr->fbi.fbi_subtype.fbi_rgbmasks.red_size > 0) { 702 uint32_t msk; 703 704 /* 705 * see if we need to byte-swap pixels 706 * XXX this requires a shadow FB and is incompatible 707 * (for now ) with rotation 708 */ 709 if ((fPtr->fbi.fbi_bitsperpixel == 32) && 710 (fPtr->fbi.fbi_subtype.fbi_rgbmasks.blue_offset == 24) && 711 (fPtr->rotate == WSFB_ROTATE_NONE) && 712 (fPtr->shadowFB == TRUE)) { 713 /* 714 * looks like BGRA - set the swap flag and flip 715 * the offsets 716 */ 717 xf86Msg(X_INFO, "endian-flipped RGB framebuffer " 718 "detected, using WsfbShadowUpdateSwap32()\n"); 719 fPtr->fbi.fbi_subtype.fbi_rgbmasks.blue_offset = 0; 720 fPtr->fbi.fbi_subtype.fbi_rgbmasks.green_offset = 8; 721 fPtr->fbi.fbi_subtype.fbi_rgbmasks.red_offset = 16; 722 fPtr->fbi.fbi_subtype.fbi_rgbmasks.alpha_offset = 24; 723 fPtr->useSwap32 = TRUE; 724 } 725 726 msk = 0xffffffff; 727 msk = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.red_size; 728 msk = ~msk; 729 masks.red = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.red_offset; 730 731 msk = 0xffffffff; 732 msk = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.green_size; 733 msk = ~msk; 734 masks.green = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.green_offset; 735 736 msk = 0xffffffff; 737 msk = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.blue_size; 738 msk = ~msk; 739 masks.blue = msk << fPtr->fbi.fbi_subtype.fbi_rgbmasks.blue_offset; 740 xf86Msg(X_INFO, "masks generated: %08lx %08lx %08lx\n", 741 (unsigned long)masks.red, 742 (unsigned long)masks.green, 743 (unsigned long)masks.blue); 744 } else { 745 masks.red = 0; 746 masks.green = 0; 747 masks.blue = 0; 748 } 749 750 if (!xf86SetWeight(pScrn, zeros, masks)) 751 return FALSE; 752 } 753 754 /* Visual init */ 755 if (!xf86SetDefaultVisual(pScrn, -1)) 756 return FALSE; 757 758 /* We don't currently support DirectColor at > 8bpp . */ 759 if (pScrn->depth > 8 && pScrn->defaultVisual != TrueColor) { 760 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual" 761 " (%s) is not supported at depth %d\n", 762 xf86GetVisualName(pScrn->defaultVisual), 763 pScrn->depth); 764 return FALSE; 765 } 766 767 xf86SetGamma(pScrn,zeros); 768 769 pScrn->progClock = TRUE; 770 pScrn->rgbBits = (pScrn->depth >= 8) ? 8 : pScrn->depth; 771 pScrn->chipset = (char *)"wsfb"; 772 pScrn->videoRam = fPtr->fbi.fbi_fbsize; 773 774 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Vidmem: %dk\n", 775 pScrn->videoRam/1024); 776 777 /* Fake video mode struct. */ 778 mode = (DisplayModePtr)malloc(sizeof(DisplayModeRec)); 779 mode->prev = mode; 780 mode->next = mode; 781 mode->name = (char *)"wsfb current mode"; 782 mode->status = MODE_OK; 783 mode->type = M_T_BUILTIN; 784 mode->Clock = 0; 785 mode->HDisplay = fPtr->fbi.fbi_width; 786 mode->HSyncStart = 0; 787 mode->HSyncEnd = 0; 788 mode->HTotal = 0; 789 mode->HSkew = 0; 790 mode->VDisplay = fPtr->fbi.fbi_height; 791 mode->VSyncStart = 0; 792 mode->VSyncEnd = 0; 793 mode->VTotal = 0; 794 mode->VScan = 0; 795 mode->Flags = 0; 796 if (pScrn->modes != NULL) { 797 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 798 "Ignoring mode specification from screen section\n"); 799 } 800 pScrn->currentMode = pScrn->modes = mode; 801 pScrn->virtualX = fPtr->fbi.fbi_width; 802 pScrn->virtualY = fPtr->fbi.fbi_height; 803 pScrn->displayWidth = pScrn->virtualX; 804 805 /* Set the display resolution. */ 806 xf86SetDpi(pScrn, 0, 0); 807 808 from = X_DEFAULT; 809 fPtr->HWCursor = TRUE; 810 if (xf86GetOptValBool(fPtr->Options, OPTION_HW_CURSOR, &fPtr->HWCursor)) 811 from = X_CONFIG; 812 if (xf86ReturnOptValBool(fPtr->Options, OPTION_SW_CURSOR, FALSE)) { 813 from = X_CONFIG; 814 fPtr->HWCursor = FALSE; 815 } 816 xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n", 817 fPtr->HWCursor ? "HW" : "SW"); 818 819 820 /* Load shadow if needed. */ 821 if (fPtr->shadowFB) { 822 xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, 823 "Using \"Shadow Framebuffer\"\n"); 824 if (xf86LoadSubModule(pScrn, "shadow") == NULL) { 825 WsfbFreeRec(pScrn); 826 return FALSE; 827 } 828 } 829 if (xf86LoadSubModule(pScrn, "fb") == NULL) { 830 WsfbFreeRec(pScrn); 831 return FALSE; 832 } 833 834 if (xf86LoadSubModule(pScrn, "ramdac") == NULL) { 835 WsfbFreeRec(pScrn); 836 return FALSE; 837 } 838 839 TRACE_EXIT("PreInit"); 840 return TRUE; 841} 842 843static void 844wsfbUpdateRotatePacked(ScreenPtr pScreen, shadowBufPtr pBuf) 845{ 846 shadowUpdateRotatePacked(pScreen, pBuf); 847} 848 849static void 850wsfbUpdatePacked(ScreenPtr pScreen, shadowBufPtr pBuf) 851{ 852 shadowUpdatePacked(pScreen, pBuf); 853} 854 855static Bool 856WsfbCreateScreenResources(ScreenPtr pScreen) 857{ 858 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 859 WsfbPtr fPtr = WSFBPTR(pScrn); 860 PixmapPtr pPixmap; 861 Bool ret; 862 void (*shadowproc)(ScreenPtr, shadowBufPtr); 863 ShadowWindowProc windowproc = WsfbWindowLinear; 864 865 pScreen->CreateScreenResources = fPtr->CreateScreenResources; 866 ret = pScreen->CreateScreenResources(pScreen); 867 pScreen->CreateScreenResources = WsfbCreateScreenResources; 868 869 if (!ret) 870 return FALSE; 871 872 pPixmap = pScreen->GetScreenPixmap(pScreen); 873 if (fPtr->fbi.fbi_flags & WSFB_VRAM_IS_SPLIT) { 874 shadowproc = WsfbShadowUpdateSplit; 875 } else if (fPtr->useRGB16ToYUY2) { 876 /* Build RGB16 to Y, U, and V lookup tables */ 877 if (mapRGB16ToY == NULL) { 878 mapRGB16ToY = malloc(0x30000); 879 if (mapRGB16ToY == NULL) { 880 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 881 "Cannot malloc %d bytes for RGB16->YUY2\n", 882 0x30000); 883 return FALSE; 884 } 885 mapRGB16ToU = mapRGB16ToY + 0x10000; 886 mapRGB16ToV = mapRGB16ToY + 0x20000; 887 for (unsigned int n = 0; n < 0x10000; n++) { 888 /* RGB565 values, scaled to 8 bits */ 889 const double R = (((n >> 11) & 0x1f) * 255) / 31; 890 const double G = (((n >> 5) & 0x3f) * 255) / 63; 891 const double B = (((n >> 0) & 0x1f) * 255) / 31; 892 893 /* Convert to YUV */ 894 mapRGB16ToY[n] = 895 0.257 * R + 0.504 * G + 0.098 * B + 16; 896 mapRGB16ToU[n] = 897 -0.148 * R - 0.291 * G + 0.439 * B + 128; 898 mapRGB16ToV[n] = 899 0.439 * R - 0.368 * G - 0.071 * B + 128; 900 } 901 } 902 903 shadowproc = WsfbShadowUpdateRGB16ToYUY2; 904 } else if (fPtr->useSwap32) { 905 shadowproc = WsfbShadowUpdateSwap32; 906 } else if (fPtr->rotate) { 907 shadowproc = wsfbUpdateRotatePacked; 908 } else 909#ifdef HAVE_SHADOW_AFB 910 if (fPtr->planarAfb && fPtr->fbi.fbi_bitsperpixel == 8) { 911 shadowproc = shadowUpdateAfb8; 912 windowproc = WsfbWindowAfb; 913 } else if (fPtr->planarAfb && fPtr->fbi.fbi_bitsperpixel == 4) { 914 shadowproc = shadowUpdateAfb4x8; 915 windowproc = WsfbWindowAfb; 916 } else 917#endif 918 { 919 shadowproc = wsfbUpdatePacked; 920 } 921 922 if (!shadowAdd(pScreen, pPixmap, shadowproc, 923 windowproc, fPtr->rotate, NULL)) { 924 return FALSE; 925 } 926 return TRUE; 927} 928 929 930static Bool 931WsfbShadowInit(ScreenPtr pScreen) 932{ 933 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 934 WsfbPtr fPtr = WSFBPTR(pScrn); 935 936 if (!shadowSetup(pScreen)) 937 return FALSE; 938 fPtr->CreateScreenResources = pScreen->CreateScreenResources; 939 pScreen->CreateScreenResources = WsfbCreateScreenResources; 940 941 return TRUE; 942} 943 944static Bool 945WsfbScreenInit(SCREEN_INIT_ARGS_DECL) 946{ 947 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 948 WsfbPtr fPtr = WSFBPTR(pScrn); 949 VisualPtr visual; 950 int ret, flags, ncolors; 951 int wsmode = WSDISPLAYIO_MODE_DUMBFB; 952 int wstype; 953 int width; 954 size_t len; 955 956 TRACE_ENTER("WsfbScreenInit"); 957#if DEBUG 958 ErrorF("\tbitsPerPixel=%d, depth=%d, defaultVisual=%s\n" 959 "\tmask: %x,%x,%x, offset: %u,%u,%u\n", 960 pScrn->bitsPerPixel, 961 pScrn->depth, 962 xf86GetVisualName(pScrn->defaultVisual), 963 pScrn->mask.red,pScrn->mask.green,pScrn->mask.blue, 964 pScrn->offset.red,pScrn->offset.green,pScrn->offset.blue); 965#endif 966 switch (fPtr->fbi.fbi_bitsperpixel) { 967 case 1: 968 case 4: 969 case 8: 970 len = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 971#ifdef HAVE_SHADOW_AFB 972 if (fPtr->planarAfb) { 973 /* 974 * stride is "bytes per line" for each plane so 975 * we need a number of planes to mmap in planar case. 976 */ 977 len *= fPtr->fbi.fbi_bitsperpixel; 978 } 979#endif 980 981 break; 982 case 15: 983 case 16: 984 if (fPtr->fbi.fbi_stride == fPtr->fbi.fbi_width) { 985 len = fPtr->fbi.fbi_width * fPtr->fbi.fbi_height * sizeof(short); 986 } else { 987 len = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 988 } 989 break; 990 case 24: 991 if (fPtr->fbi.fbi_stride == fPtr->fbi.fbi_width) { 992 len = fPtr->fbi.fbi_width * fPtr->fbi.fbi_height * 3; 993 } else { 994 len = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 995 } 996 break; 997 case 32: 998 if (fPtr->fbi.fbi_stride == fPtr->fbi.fbi_width) { 999 len = fPtr->fbi.fbi_width * fPtr->fbi.fbi_height * sizeof(int); 1000 } else { 1001 len = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 1002 } 1003 break; 1004 default: 1005 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1006 "unsupported depth %d\n", fPtr->fbi.fbi_bitsperpixel); 1007 return FALSE; 1008 } 1009 /* Switch to graphics mode - required before mmap. */ 1010 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &wsmode) == -1) { 1011 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1012 "ioctl WSDISPLAYIO_SMODE: %s\n", 1013 strerror(errno)); 1014 return FALSE; 1015 } 1016 /* Get wsdisplay type to handle quirks */ 1017 if (ioctl(fPtr->fd, WSDISPLAYIO_GTYPE, &wstype) == -1) { 1018 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1019 "ioctl WSDISPLAY_GTYPE: %s\n", 1020 strerror(errno)); 1021 return FALSE; 1022 } 1023 len = max(len, fPtr->fbi.fbi_fbsize); 1024 fPtr->fbmem = wsfb_mmap(len + fPtr->fbi.fbi_fboffset, 0, fPtr->fd); 1025 1026 if (fPtr->fbmem == NULL) { 1027 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1028 "wsfb_mmap: %s\n", strerror(errno)); 1029 return FALSE; 1030 } 1031 fPtr->fbmem_len = len; 1032 1033 WsfbSave(pScrn); 1034 pScrn->vtSema = TRUE; 1035 1036 /* MI layer */ 1037 miClearVisualTypes(); 1038 if (pScrn->bitsPerPixel > 8) { 1039 if (!miSetVisualTypes(pScrn->depth, TrueColorMask, 1040 pScrn->rgbBits, TrueColor)) 1041 return FALSE; 1042 } else { 1043 if (!miSetVisualTypes(pScrn->depth, 1044 miGetDefaultVisualMask(pScrn->depth), 1045 pScrn->rgbBits, pScrn->defaultVisual)) 1046 return FALSE; 1047 } 1048 if (!miSetPixmapDepths()) 1049 return FALSE; 1050 1051 if (fPtr->rotate == WSFB_ROTATE_CW 1052 || fPtr->rotate == WSFB_ROTATE_CCW) { 1053 int tmp = pScrn->virtualX; 1054 pScrn->virtualX = pScrn->displayWidth = pScrn->virtualY; 1055 pScrn->virtualY = tmp; 1056 } 1057 if (fPtr->rotate && !fPtr->PointerMoved) { 1058 fPtr->PointerMoved = pScrn->PointerMoved; 1059 pScrn->PointerMoved = WsfbPointerMoved; 1060 } 1061 1062 fPtr->fbstart = fPtr->fbmem + fPtr->fbi.fbi_fboffset; 1063 1064 if (fPtr->shadowFB) { 1065 if (fPtr->rotate) { 1066 /* 1067 * Note Rotate and Shadow FB options are valid 1068 * only on depth >= 8. 1069 */ 1070 len = pScrn->virtualX * pScrn->virtualY * 1071 (pScrn->bitsPerPixel >> 3); 1072 } else 1073#ifdef HAVE_SHADOW_AFB 1074 if (fPtr->planarAfb) { 1075 /* always 8bpp */ 1076 len = pScrn->virtualX * pScrn->virtualY; 1077 } else 1078#endif 1079 { 1080 len = fPtr->fbi.fbi_stride * pScrn->virtualY; 1081 } 1082 fPtr->shadow = calloc(1, len); 1083 1084 if (!fPtr->shadow) { 1085 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1086 "Failed to allocate shadow framebuffer\n"); 1087 return FALSE; 1088 } 1089 } 1090 1091 /* 1092 * fbScreenInit() seems to require "pixel width of frame buffer" 1093 * but it is actually "stride in pixel" of frame buffer, 1094 * per xorg/xserver/tree/fb/fbscreen.c. 1095 */ 1096 if (fPtr->rotate) { 1097 width = pScrn->displayWidth; 1098 } else 1099#ifdef HAVE_SHADOW_AFB 1100 if (fPtr->planarAfb) { 1101 width = pScrn->displayWidth; 1102 } else 1103#endif 1104 { 1105 if (pScrn->bitsPerPixel > 8) { 1106 width = 1107 fPtr->fbi.fbi_stride / (pScrn->bitsPerPixel >> 3); 1108 } else { 1109 width = 1110 fPtr->fbi.fbi_stride * (8 / pScrn->bitsPerPixel); 1111 } 1112 } 1113 switch (pScrn->bitsPerPixel) { 1114 case 1: 1115 ret = fbScreenInit(pScreen, 1116 fPtr->fbstart, 1117 pScrn->virtualX, pScrn->virtualY, 1118 pScrn->xDpi, pScrn->yDpi, 1119 width, pScrn->bitsPerPixel); 1120 break; 1121 case 4: 1122 case 8: 1123 case 16: 1124 case 24: 1125 case 32: 1126 ret = fbScreenInit(pScreen, 1127 fPtr->shadowFB ? fPtr->shadow : fPtr->fbstart, 1128 pScrn->virtualX, pScrn->virtualY, 1129 pScrn->xDpi, pScrn->yDpi, 1130 width, 1131 pScrn->bitsPerPixel); 1132 break; 1133 default: 1134 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1135 "Unsupported bpp: %d\n", pScrn->bitsPerPixel); 1136 return FALSE; 1137 } /* case */ 1138 1139 if (!ret) 1140 return FALSE; 1141 1142 if (pScrn->bitsPerPixel > 8) { 1143 /* Fixup RGB ordering. */ 1144 visual = pScreen->visuals + pScreen->numVisuals; 1145 while (--visual >= pScreen->visuals) { 1146 if ((visual->class | DynamicClass) == DirectColor) { 1147 visual->offsetRed = pScrn->offset.red; 1148 visual->offsetGreen = pScrn->offset.green; 1149 visual->offsetBlue = pScrn->offset.blue; 1150 visual->redMask = pScrn->mask.red; 1151 visual->greenMask = pScrn->mask.green; 1152 visual->blueMask = pScrn->mask.blue; 1153 } 1154 } 1155 } 1156 1157 if (pScrn->bitsPerPixel >= 8) { 1158 if (!fbPictureInit(pScreen, NULL, 0)) 1159 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 1160 "RENDER extension initialisation failed.\n"); 1161 } 1162 if (fPtr->shadowFB && !WsfbShadowInit(pScreen)) { 1163 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1164 "shadow framebuffer initialization failed\n"); 1165 return FALSE; 1166 } 1167 1168#ifdef XFreeXDGA 1169 if (!fPtr->rotate) 1170 WsfbDGAInit(pScrn, pScreen); 1171 else 1172 xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Rotated display, " 1173 "disabling DGA\n"); 1174#endif 1175 if (fPtr->rotate) { 1176 xf86DrvMsg(pScrn->scrnIndex, X_INFO, 1177 "Enabling Driver Rotation, " "disabling RandR\n"); 1178#if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 24 1179 xf86DisableRandR(); 1180#endif 1181 if (pScrn->bitsPerPixel == 24) 1182 xf86DrvMsg(pScrn->scrnIndex, X_WARNING, 1183 "Rotation might be broken in 24 bpp\n"); 1184 } 1185 1186 xf86SetBlackWhitePixels(pScreen); 1187 xf86SetBackingStore(pScreen); 1188 1189 /* Software cursor. */ 1190 miDCInitialize(pScreen, xf86GetPointerScreenFuncs()); 1191 1192 /* check for hardware cursor support */ 1193 if (fPtr->HWCursor) 1194 WsfbSetupCursor(pScreen); 1195 1196 /* 1197 * Colormap 1198 * 1199 * Note that, even on less than 8 bit depth frame buffers, we 1200 * expect the colormap to be programmable with 8 bit values. 1201 * As of now, this is indeed the case on all OpenBSD supported 1202 * graphics hardware. 1203 */ 1204 if (!miCreateDefColormap(pScreen)) 1205 return FALSE; 1206 flags = CMAP_RELOAD_ON_MODE_SWITCH; 1207 1208 ncolors = 0; 1209 if (fPtr->fbi.fbi_pixeltype == WSFB_CI) { 1210 ncolors = fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries; 1211 } 1212 1213 /* On StaticGray visuals, fake a 256 entries colormap. */ 1214 if (ncolors == 0) 1215 ncolors = 256; 1216 if(!xf86HandleColormaps(pScreen, ncolors, 8, WsfbLoadPalette, 1217 NULL, flags)) 1218 return FALSE; 1219 1220#if defined(__NetBSD__) && defined(WSDISPLAY_TYPE_LUNA) 1221 if (wstype == WSDISPLAY_TYPE_LUNA) { 1222 ncolors = fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries; 1223 if (ncolors > 0 1224#ifdef HAVE_SHADOW_AFB 1225 && !fPtr->planarAfb 1226#endif 1227 ) { 1228 /* 1229 * Override palette to use 4bpp/8bpp framebuffers as 1230 * monochrome server by using only the first plane. 1231 * See also comment in WsfbPreInit(). 1232 */ 1233 struct wsdisplay_cmap cmap; 1234 uint8_t r[256], g[256], b[256]; 1235 int p; 1236 1237 for (p = 0; p < ncolors; p++) 1238 r[p] = g[p] = b[p] = (p & 1) ? 0xff : 0; 1239 cmap.index = 0; 1240 cmap.count = ncolors; 1241 cmap.red = r; 1242 cmap.green = g; 1243 cmap.blue = b; 1244 if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP, &cmap) == -1) { 1245 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1246 "ioctl WSDISPLAYIO_PUTCMAP: %s\n", 1247 strerror(errno)); 1248 } 1249 } 1250 } 1251#endif 1252 1253 pScreen->SaveScreen = WsfbSaveScreen; 1254 1255#ifdef XvExtension 1256 { 1257 XF86VideoAdaptorPtr *ptr; 1258 1259 int n = xf86XVListGenericAdaptors(pScrn,&ptr); 1260 if (n) { 1261 xf86XVScreenInit(pScreen,ptr,n); 1262 } 1263 } 1264#endif 1265 1266 /* Wrap the current CloseScreen function. */ 1267 fPtr->CloseScreen = pScreen->CloseScreen; 1268 pScreen->CloseScreen = WsfbCloseScreen; 1269 1270 TRACE_EXIT("WsfbScreenInit"); 1271 return TRUE; 1272} 1273 1274static Bool 1275WsfbCloseScreen(CLOSE_SCREEN_ARGS_DECL) 1276{ 1277 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 1278 PixmapPtr pPixmap; 1279 WsfbPtr fPtr = WSFBPTR(pScrn); 1280 1281 1282 TRACE_ENTER("WsfbCloseScreen"); 1283 1284 pPixmap = pScreen->GetScreenPixmap(pScreen); 1285 if (fPtr->shadowFB) 1286 shadowRemove(pScreen, pPixmap); 1287 1288 if (pScrn->vtSema) { 1289 WsfbRestore(pScrn); 1290 if (munmap(fPtr->fbmem, fPtr->fbmem_len + fPtr->fbi.fbi_fboffset) == -1) { 1291 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1292 "munmap: %s\n", strerror(errno)); 1293 } 1294 1295 fPtr->fbmem = NULL; 1296 } 1297#ifdef XFreeXDGA 1298 if (fPtr->pDGAMode) { 1299 free(fPtr->pDGAMode); 1300 fPtr->pDGAMode = NULL; 1301 fPtr->nDGAMode = 0; 1302 } 1303#endif 1304 pScrn->vtSema = FALSE; 1305 1306 /* Unwrap CloseScreen. */ 1307 pScreen->CloseScreen = fPtr->CloseScreen; 1308 TRACE_EXIT("WsfbCloseScreen"); 1309 return (*pScreen->CloseScreen)(CLOSE_SCREEN_ARGS); 1310} 1311 1312static void * 1313WsfbWindowLinear(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode, 1314 CARD32 *size, void *closure) 1315{ 1316 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 1317 WsfbPtr fPtr = WSFBPTR(pScrn); 1318 1319 if (fPtr->fbi.fbi_stride) 1320 *size = fPtr->fbi.fbi_stride; 1321 else { 1322 if (ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, size) == -1) 1323 return NULL; 1324 fPtr->fbi.fbi_stride = *size; 1325 } 1326 return ((CARD8 *)fPtr->fbstart + row * fPtr->fbi.fbi_stride + offset); 1327} 1328 1329#ifdef HAVE_SHADOW_AFB 1330/* 1331 * For use with shadowUpdateAfb8 1332 * 1333 * For video memory layout with non-interleaved bitplanes. 1334 */ 1335static void * 1336WsfbWindowAfb(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode, 1337 CARD32 *size, void *closure) 1338{ 1339 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 1340 WsfbPtr fPtr = WSFBPTR(pScrn); 1341 1342 /* size is offset from start of bitplane to next bitplane */ 1343 *size = fPtr->fbi.fbi_stride * fPtr->fbi.fbi_height; 1344 return ((CARD8 *)fPtr->fbstart + row * fPtr->fbi.fbi_stride + offset); 1345} 1346#endif 1347 1348static void 1349WsfbPointerMoved(SCRN_ARG_TYPE arg, int x, int y) 1350{ 1351 SCRN_INFO_PTR(arg); 1352 WsfbPtr fPtr = WSFBPTR(pScrn); 1353 int newX, newY; 1354 1355 switch (fPtr->rotate) 1356 { 1357 case WSFB_ROTATE_CW: 1358 /* 90 degrees CW rotation. */ 1359 newX = pScrn->pScreen->height - y - 1; 1360 newY = x; 1361 break; 1362 1363 case WSFB_ROTATE_CCW: 1364 /* 90 degrees CCW rotation. */ 1365 newX = y; 1366 newY = pScrn->pScreen->width - x - 1; 1367 break; 1368 1369 case WSFB_ROTATE_UD: 1370 /* 180 degrees UD rotation. */ 1371 newX = pScrn->pScreen->width - x - 1; 1372 newY = pScrn->pScreen->height - y - 1; 1373 break; 1374 1375 default: 1376 /* No rotation. */ 1377 newX = x; 1378 newY = y; 1379 break; 1380 } 1381 1382 /* Pass adjusted pointer coordinates to wrapped PointerMoved function. */ 1383 (*fPtr->PointerMoved)(arg, newX, newY); 1384} 1385 1386static Bool 1387WsfbEnterVT(VT_FUNC_ARGS_DECL) 1388{ 1389 SCRN_INFO_PTR(arg); 1390 WsfbPtr fPtr = WSFBPTR(pScrn); 1391 int mode; 1392 1393 TRACE_ENTER("EnterVT"); 1394 pScrn->vtSema = TRUE; 1395 1396 /* Restore the graphics mode. */ 1397 mode = WSDISPLAYIO_MODE_DUMBFB; 1398 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) { 1399 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1400 "error setting graphics mode %s\n", strerror(errno)); 1401 } 1402 1403 TRACE_EXIT("EnterVT"); 1404 return TRUE; 1405} 1406 1407static void 1408WsfbLeaveVT(VT_FUNC_ARGS_DECL) 1409{ 1410 SCRN_INFO_PTR(arg); 1411 WsfbPtr fPtr = WSFBPTR(pScrn); 1412 int mode; 1413 1414 TRACE_ENTER("LeaveVT"); 1415 1416 /* 1417 * stuff to do: 1418 * - turn off hw cursor 1419 * - restore colour map if WSFB_CI 1420 * - ioctl(WSDISPLAYIO_MODE_EMUL) to notify the kernel driver that 1421 * we're backing off 1422 */ 1423 1424 if (fPtr->fbi.fbi_pixeltype == WSFB_CI && 1425 fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries > 0) { 1426 /* reset colormap for text mode */ 1427 if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP, 1428 &(fPtr->saved_cmap)) == -1) { 1429 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1430 "error restoring colormap %s\n", 1431 strerror(errno)); 1432 } 1433 } 1434 1435 /* Restore the text mode. */ 1436 mode = WSDISPLAYIO_MODE_EMUL; 1437 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) { 1438 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1439 "error setting text mode %s\n", strerror(errno)); 1440 } 1441 1442 pScrn->vtSema = FALSE; 1443 TRACE_EXIT("LeaveVT"); 1444} 1445 1446static Bool 1447WsfbSwitchMode(SWITCH_MODE_ARGS_DECL) 1448{ 1449#if DEBUG 1450 SCRN_INFO_PTR(arg); 1451#endif 1452 1453 TRACE_ENTER("SwitchMode"); 1454 /* Nothing else to do. */ 1455 return TRUE; 1456} 1457 1458static int 1459WsfbValidMode(SCRN_ARG_TYPE arg, DisplayModePtr mode, Bool verbose, int flags) 1460{ 1461#if DEBUG 1462 SCRN_INFO_PTR(arg); 1463#endif 1464 1465 TRACE_ENTER("ValidMode"); 1466 return MODE_OK; 1467} 1468 1469static void 1470WsfbLoadPalette(ScrnInfoPtr pScrn, int numColors, int *indices, 1471 LOCO *colors, VisualPtr pVisual) 1472{ 1473 WsfbPtr fPtr = WSFBPTR(pScrn); 1474 struct wsdisplay_cmap cmap; 1475 unsigned char red[256],green[256],blue[256]; 1476 int i, indexMin=256, indexMax=0; 1477 1478 TRACE_ENTER("LoadPalette"); 1479 1480 /* nothing to do if there is no color palette support */ 1481 if (fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries == 0) 1482 return; 1483 1484 cmap.count = 1; 1485 cmap.red = red; 1486 cmap.green = green; 1487 cmap.blue = blue; 1488 1489 if (numColors == 1) { 1490 /* Optimisation */ 1491 cmap.index = indices[0]; 1492 red[0] = colors[indices[0]].red; 1493 green[0] = colors[indices[0]].green; 1494 blue[0] = colors[indices[0]].blue; 1495 if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1) 1496 ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno)); 1497 } else { 1498 /* 1499 * Change all colors in 2 ioctls 1500 * and limit the data to be transferred. 1501 */ 1502 for (i = 0; i < numColors; i++) { 1503 if (indices[i] < indexMin) 1504 indexMin = indices[i]; 1505 if (indices[i] > indexMax) 1506 indexMax = indices[i]; 1507 } 1508 cmap.index = indexMin; 1509 cmap.count = indexMax - indexMin + 1; 1510 cmap.red = &red[indexMin]; 1511 cmap.green = &green[indexMin]; 1512 cmap.blue = &blue[indexMin]; 1513 /* Get current map. */ 1514 if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP, &cmap) == -1) 1515 ErrorF("ioctl FBIOGETCMAP: %s\n", strerror(errno)); 1516 /* Change the colors that require updating. */ 1517 for (i = 0; i < numColors; i++) { 1518 red[indices[i]] = colors[indices[i]].red; 1519 green[indices[i]] = colors[indices[i]].green; 1520 blue[indices[i]] = colors[indices[i]].blue; 1521 } 1522 /* Write the colormap back. */ 1523 if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1) 1524 ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno)); 1525 } 1526 TRACE_EXIT("LoadPalette"); 1527} 1528 1529static Bool 1530WsfbSaveScreen(ScreenPtr pScreen, int mode) 1531{ 1532 ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); 1533 WsfbPtr fPtr = WSFBPTR(pScrn); 1534 int state; 1535 1536 TRACE_ENTER("SaveScreen"); 1537 1538 if (!pScrn->vtSema) 1539 return TRUE; 1540 1541 if (mode != SCREEN_SAVER_FORCER) { 1542 state = xf86IsUnblank(mode)?WSDISPLAYIO_VIDEO_ON: 1543 WSDISPLAYIO_VIDEO_OFF; 1544 ioctl(fPtr->fd, 1545 WSDISPLAYIO_SVIDEO, &state); 1546 } 1547 TRACE_EXIT("SaveScreen"); 1548 return TRUE; 1549} 1550 1551 1552static void 1553WsfbSave(ScrnInfoPtr pScrn) 1554{ 1555 WsfbPtr fPtr = WSFBPTR(pScrn); 1556 1557 TRACE_ENTER("WsfbSave"); 1558 1559 /* nothing to save if we don't run in colour-indexed mode */ 1560 if (fPtr->fbi.fbi_pixeltype != WSFB_CI) 1561 return; 1562 1563 /* nothing to do if no color palette support */ 1564 if (fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries == 0) 1565 return; 1566 1567 fPtr->saved_cmap.index = 0; 1568 fPtr->saved_cmap.count = fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries; 1569 if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP, 1570 &(fPtr->saved_cmap)) == -1) { 1571 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1572 "error saving colormap %s\n", strerror(errno)); 1573 } 1574 TRACE_EXIT("WsfbSave"); 1575 1576} 1577 1578static void 1579WsfbRestore(ScrnInfoPtr pScrn) 1580{ 1581 WsfbPtr fPtr = WSFBPTR(pScrn); 1582 int mode; 1583 1584 TRACE_ENTER("WsfbRestore"); 1585 1586 if (fPtr->fbi.fbi_pixeltype == WSFB_CI && 1587 fPtr->fbi.fbi_subtype.fbi_cmapinfo.cmap_entries > 0) { 1588 /* reset colormap for text mode */ 1589 if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP, 1590 &(fPtr->saved_cmap)) == -1) { 1591 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1592 "error restoring colormap %s\n", 1593 strerror(errno)); 1594 } 1595 } 1596 1597 /* Clear the screen. */ 1598 memset(fPtr->fbstart, 0, fPtr->fbmem_len); 1599 1600 /* Restore the text mode. */ 1601 mode = WSDISPLAYIO_MODE_EMUL; 1602 if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) { 1603 xf86DrvMsg(pScrn->scrnIndex, X_ERROR, 1604 "error setting text mode %s\n", strerror(errno)); 1605 } 1606 TRACE_EXIT("WsfbRestore"); 1607} 1608 1609#ifdef XFreeXDGA 1610/*********************************************************************** 1611 * DGA stuff 1612 ***********************************************************************/ 1613 1614static Bool 1615WsfbDGAOpenFramebuffer(ScrnInfoPtr pScrn, char **DeviceName, 1616 unsigned char **ApertureBase, int *ApertureSize, 1617 int *ApertureOffset, int *flags) 1618{ 1619 *DeviceName = NULL; /* No special device */ 1620 *ApertureBase = (unsigned char *)(pScrn->memPhysBase); 1621 *ApertureSize = pScrn->videoRam; 1622 *ApertureOffset = pScrn->fbOffset; 1623 *flags = 0; 1624 1625 return TRUE; 1626} 1627 1628static Bool 1629WsfbDGASetMode(ScrnInfoPtr pScrn, DGAModePtr pDGAMode) 1630{ 1631 DisplayModePtr pMode; 1632 int frameX0, frameY0; 1633 1634 if (pDGAMode) { 1635 pMode = pDGAMode->mode; 1636 frameX0 = frameY0 = 0; 1637 } else { 1638 if (!(pMode = pScrn->currentMode)) 1639 return TRUE; 1640 1641 frameX0 = pScrn->frameX0; 1642 frameY0 = pScrn->frameY0; 1643 } 1644 1645 if (!(*pScrn->SwitchMode)(SWITCH_MODE_ARGS(pScrn, pMode))) 1646 return FALSE; 1647 (*pScrn->AdjustFrame)(ADJUST_FRAME_ARGS(pScrn, frameX0, frameY0)); 1648 1649 return TRUE; 1650} 1651 1652static void 1653WsfbDGASetViewport(ScrnInfoPtr pScrn, int x, int y, int flags) 1654{ 1655 (*pScrn->AdjustFrame)(ADJUST_FRAME_ARGS(pScrn, x, y)); 1656} 1657 1658static int 1659WsfbDGAGetViewport(ScrnInfoPtr pScrn) 1660{ 1661 return (0); 1662} 1663 1664static DGAFunctionRec WsfbDGAFunctions = 1665{ 1666 WsfbDGAOpenFramebuffer, 1667 NULL, /* CloseFramebuffer */ 1668 WsfbDGASetMode, 1669 WsfbDGASetViewport, 1670 WsfbDGAGetViewport, 1671 NULL, /* Sync */ 1672 NULL, /* FillRect */ 1673 NULL, /* BlitRect */ 1674 NULL, /* BlitTransRect */ 1675}; 1676 1677static void 1678WsfbDGAAddModes(ScrnInfoPtr pScrn) 1679{ 1680 WsfbPtr fPtr = WSFBPTR(pScrn); 1681 DisplayModePtr pMode = pScrn->modes; 1682 DGAModePtr pDGAMode; 1683 1684 do { 1685 pDGAMode = realloc(fPtr->pDGAMode, 1686 (fPtr->nDGAMode + 1) * sizeof(DGAModeRec)); 1687 if (!pDGAMode) 1688 break; 1689 1690 fPtr->pDGAMode = pDGAMode; 1691 pDGAMode += fPtr->nDGAMode; 1692 (void)memset(pDGAMode, 0, sizeof(DGAModeRec)); 1693 1694 ++fPtr->nDGAMode; 1695 pDGAMode->mode = pMode; 1696 pDGAMode->flags = DGA_CONCURRENT_ACCESS | DGA_PIXMAP_AVAILABLE; 1697 pDGAMode->byteOrder = pScrn->imageByteOrder; 1698 pDGAMode->depth = pScrn->depth; 1699 pDGAMode->bitsPerPixel = pScrn->bitsPerPixel; 1700 pDGAMode->red_mask = pScrn->mask.red; 1701 pDGAMode->green_mask = pScrn->mask.green; 1702 pDGAMode->blue_mask = pScrn->mask.blue; 1703 pDGAMode->visualClass = pScrn->bitsPerPixel > 8 ? 1704 TrueColor : PseudoColor; 1705 pDGAMode->xViewportStep = 1; 1706 pDGAMode->yViewportStep = 1; 1707 pDGAMode->viewportWidth = pMode->HDisplay; 1708 pDGAMode->viewportHeight = pMode->VDisplay; 1709 1710 if (fPtr->fbi.fbi_stride) 1711 pDGAMode->bytesPerScanline = fPtr->fbi.fbi_stride; 1712 else { 1713 ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, 1714 &fPtr->fbi.fbi_stride); 1715 pDGAMode->bytesPerScanline = fPtr->fbi.fbi_stride; 1716 } 1717 1718 pDGAMode->imageWidth = pMode->HDisplay; 1719 pDGAMode->imageHeight = pMode->VDisplay; 1720 pDGAMode->pixmapWidth = pDGAMode->imageWidth; 1721 pDGAMode->pixmapHeight = pDGAMode->imageHeight; 1722 pDGAMode->maxViewportX = pScrn->virtualX - 1723 pDGAMode->viewportWidth; 1724 pDGAMode->maxViewportY = pScrn->virtualY - 1725 pDGAMode->viewportHeight; 1726 1727 pDGAMode->address = fPtr->fbstart; 1728 1729 pMode = pMode->next; 1730 } while (pMode != pScrn->modes); 1731} 1732 1733static Bool 1734WsfbDGAInit(ScrnInfoPtr pScrn, ScreenPtr pScreen) 1735{ 1736 WsfbPtr fPtr = WSFBPTR(pScrn); 1737 1738 if (pScrn->depth < 8) 1739 return FALSE; 1740 1741 if (!fPtr->nDGAMode) 1742 WsfbDGAAddModes(pScrn); 1743 1744 return (DGAInit(pScreen, &WsfbDGAFunctions, 1745 fPtr->pDGAMode, fPtr->nDGAMode)); 1746} 1747#endif 1748 1749static Bool 1750WsfbDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op, 1751 pointer ptr) 1752{ 1753 xorgHWFlags *flag; 1754 1755 switch (op) { 1756 case GET_REQUIRED_HW_INTERFACES: 1757 flag = (CARD32*)ptr; 1758 (*flag) = 0; 1759 return TRUE; 1760 default: 1761 return FALSE; 1762 } 1763} 1764 1765static inline void 1766WsfbCopyRGB16ToYUY2(void *dest, void *src, int len) 1767{ 1768 uint16_t *src16 = src; 1769 uint32_t *dest32 = dest; 1770 1771 while (len > 0) { 1772 const uint16_t rgb0 = src16[0]; 1773 const uint16_t rgb1 = src16[1]; 1774 const uint16_t rgb = ((rgb0 >> 1) & ~0x8410) + 1775 ((rgb1 >> 1) & ~0x8410) + 1776 ((rgb0 & rgb1) & 0x0841); 1777 const uint32_t y0 = mapRGB16ToY[rgb0]; 1778 const uint32_t y1 = mapRGB16ToY[rgb1]; 1779 const uint32_t u = mapRGB16ToU[rgb]; 1780 const uint32_t v = mapRGB16ToV[rgb]; 1781 1782 *dest32 = (y0 << 24) | (u << 16) | (y1 << 8) | v; 1783 1784 dest32++; 1785 src16 += 2; 1786 len -= 4; 1787 } 1788} 1789 1790void 1791WsfbShadowUpdateRGB16ToYUY2(ScreenPtr pScreen, shadowBufPtr pBuf) 1792{ 1793 RegionPtr damage = DamageRegion (pBuf->pDamage); 1794 PixmapPtr pShadow = pBuf->pPixmap; 1795 int nbox = RegionNumRects (damage); 1796 BoxPtr pbox = RegionRects (damage); 1797 FbBits *shaBase, *shaLine, *sha; 1798 FbStride shaStride; 1799 int scrBase, scrLine, scr; 1800 int shaBpp; 1801 int shaXoff, shaYoff; /* XXX assumed to be zero */ 1802 int x, y, w, h, width; 1803 int i; 1804 FbBits *winBase = NULL, *win; 1805 CARD32 winSize; 1806 1807 fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff); 1808 while (nbox--) 1809 { 1810 x = pbox->x1 * shaBpp; 1811 y = pbox->y1; 1812 w = (pbox->x2 - pbox->x1) * shaBpp; 1813 h = pbox->y2 - pbox->y1; 1814 1815 scrLine = (x >> FB_SHIFT); 1816 shaLine = shaBase + y * shaStride + (x >> FB_SHIFT); 1817 1818 x &= FB_MASK; 1819 w = (w + x + FB_MASK) >> FB_SHIFT; 1820 1821 while (h--) 1822 { 1823 winSize = 0; 1824 scrBase = 0; 1825 width = w; 1826 scr = scrLine; 1827 sha = shaLine; 1828 while (width) { 1829 /* how much remains in this window */ 1830 i = scrBase + winSize - scr; 1831 if (i <= 0 || scr < scrBase) 1832 { 1833 winBase = (FbBits *) (*pBuf->window) (pScreen, 1834 y, 1835 scr * sizeof (FbBits), 1836 SHADOW_WINDOW_WRITE, 1837 &winSize, 1838 pBuf->closure); 1839 if(!winBase) 1840 return; 1841 scrBase = scr; 1842 winSize /= sizeof (FbBits); 1843 i = winSize; 1844 } 1845 win = winBase + (scr - scrBase); 1846 if (i > width) 1847 i = width; 1848 width -= i; 1849 scr += i; 1850 WsfbCopyRGB16ToYUY2(win, sha, i * sizeof(FbBits)); 1851 sha += i; 1852 } 1853 shaLine += shaStride; 1854 y++; 1855 } 1856 pbox++; 1857 } 1858} 1859 1860static inline void 1861memcpy32sw(void *dest, void *src, int len) 1862{ 1863 uint32_t *d = dest, *s = src; 1864 1865#if DEBUG 1866 if ((((long)dest & 3) + ((long)src & 3) + (len & 3)) != 0) { 1867 xf86Msg(X_ERROR, "unaligned %s\n", __func__); 1868 return; 1869 } 1870#endif 1871 while (len > 0) { 1872 *d = bswap32(*s); 1873 d++; 1874 s++; 1875 len -= 4; 1876 } 1877} 1878 1879/* adapted from miext/shadow/shpacked.c::shadowUpdatePacked() */ 1880void 1881WsfbShadowUpdateSwap32(ScreenPtr pScreen, shadowBufPtr pBuf) 1882{ 1883 RegionPtr damage = DamageRegion (pBuf->pDamage); 1884 PixmapPtr pShadow = pBuf->pPixmap; 1885 int nbox = RegionNumRects (damage); 1886 BoxPtr pbox = RegionRects (damage); 1887 FbBits *shaBase, *shaLine, *sha; 1888 FbStride shaStride; 1889 int scrBase, scrLine, scr; 1890 int shaBpp; 1891 int shaXoff, shaYoff; /* XXX assumed to be zero */ 1892 int x, y, w, h, width; 1893 int i; 1894 FbBits *winBase = NULL, *win; 1895 CARD32 winSize; 1896 1897 fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff); 1898 while (nbox--) 1899 { 1900 x = pbox->x1 * shaBpp; 1901 y = pbox->y1; 1902 w = (pbox->x2 - pbox->x1) * shaBpp; 1903 h = pbox->y2 - pbox->y1; 1904 1905 scrLine = (x >> FB_SHIFT); 1906 shaLine = shaBase + y * shaStride + (x >> FB_SHIFT); 1907 1908 x &= FB_MASK; 1909 w = (w + x + FB_MASK) >> FB_SHIFT; 1910 1911 while (h--) 1912 { 1913 winSize = 0; 1914 scrBase = 0; 1915 width = w; 1916 scr = scrLine; 1917 sha = shaLine; 1918 while (width) { 1919 /* how much remains in this window */ 1920 i = scrBase + winSize - scr; 1921 if (i <= 0 || scr < scrBase) 1922 { 1923 winBase = (FbBits *) (*pBuf->window) (pScreen, 1924 y, 1925 scr * sizeof (FbBits), 1926 SHADOW_WINDOW_WRITE, 1927 &winSize, 1928 pBuf->closure); 1929 if(!winBase) 1930 return; 1931 scrBase = scr; 1932 winSize /= sizeof (FbBits); 1933 i = winSize; 1934 } 1935 win = winBase + (scr - scrBase); 1936 if (i > width) 1937 i = width; 1938 width -= i; 1939 scr += i; 1940 memcpy32sw(win, sha, i * sizeof(FbBits)); 1941 sha += i; 1942 } 1943 shaLine += shaStride; 1944 y++; 1945 } 1946 pbox++; 1947 } 1948} 1949 1950void 1951WsfbShadowUpdateSplit(ScreenPtr pScreen, shadowBufPtr pBuf) 1952{ 1953 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 1954 WsfbPtr fPtr = WSFBPTR(pScrn); 1955 RegionPtr damage = DamageRegion (pBuf->pDamage); 1956 PixmapPtr pShadow = pBuf->pPixmap; 1957 int nbox = RegionNumRects (damage); 1958 BoxPtr pbox = RegionRects (damage); 1959 FbBits *shaBase, *shaLine, *sha; 1960 FbStride shaStride; 1961 int scrBase, scrLine, scr; 1962 int shaBpp; 1963 int shaXoff, shaYoff; /* XXX assumed to be zero */ 1964 int x, y, w, h, width; 1965 int i; 1966 FbBits *winBase = NULL, *win, *win2; 1967 unsigned long split = fPtr->fbi.fbi_fbsize / 2; 1968 CARD32 winSize; 1969 1970 fbGetDrawable (&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, shaYoff); 1971 while (nbox--) 1972 { 1973 x = pbox->x1 * shaBpp; 1974 y = pbox->y1; 1975 w = (pbox->x2 - pbox->x1) * shaBpp; 1976 h = pbox->y2 - pbox->y1; 1977 1978 scrLine = (x >> FB_SHIFT); 1979 shaLine = shaBase + y * shaStride + (x >> FB_SHIFT); 1980 1981 x &= FB_MASK; 1982 w = (w + x + FB_MASK) >> FB_SHIFT; 1983 1984 while (h--) 1985 { 1986 winSize = 0; 1987 scrBase = 0; 1988 width = w; 1989 scr = scrLine; 1990 sha = shaLine; 1991 while (width) { 1992 /* how much remains in this window */ 1993 i = scrBase + winSize - scr; 1994 if (i <= 0 || scr < scrBase) 1995 { 1996 winBase = (FbBits *) (*pBuf->window) (pScreen, 1997 y, 1998 scr * sizeof (FbBits), 1999 SHADOW_WINDOW_WRITE, 2000 &winSize, 2001 pBuf->closure); 2002 if(!winBase) 2003 return; 2004 scrBase = scr; 2005 winSize /= sizeof (FbBits); 2006 i = winSize; 2007 } 2008 win = winBase + (scr - scrBase); 2009 win2 = (FbBits *)(split + (unsigned long)win); 2010 if (i > width) 2011 i = width; 2012 width -= i; 2013 scr += i; 2014 memcpy(win, sha, i * sizeof(FbBits)); 2015 memcpy(win2, sha, i * sizeof(FbBits)); 2016 sha += i; 2017 } 2018 shaLine += shaStride; 2019 y++; 2020 } 2021 pbox++; 2022 } 2023} 2024