 @@ -1,14 +1,14 @@
-/* $OpenBSD: wsfb_driver.c,v 1.19 2003/04/27 16:42:32 matthieu Exp $ */
+/* $OpenBSD: wsfb_driver.c,v 1.16 2009/09/13 19:33:49 matthieu Exp $ */
 /*
  * Copyright (c) 2001 Matthieu Herrb
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  *    - Redistributions of source code must retain the above copyright
  *      notice, this list of conditions and the following disclaimer.
  *    - Redistributions in binary form must reproduce the above
  *      copyright notice, this list of conditions and the following
  *      disclaimer in the documentation and/or other materials provided
 @@ -30,61 +30,71 @@
  */
 /*
  * Based on fbdev.c written by:
+ *
  * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>
  *	     Michel Dänzer, <michdaen@iiic.ethz.ch>
  */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/time.h>
 #include <errno.h>
 #include <dev/wscons/wsconsio.h>
-/* all driver need this */
+/* All drivers need this. */
 #include "xf86.h"
 #include "xf86_OSproc.h"
 #include "mipointer.h"
 #include "mibstore.h"
 #include "micmap.h"
 #include "colormapst.h"
 #include "xf86cmap.h"
 #include "shadow.h"
 #include "dgaproc.h"
-/* for visuals */
+/* For visuals */
 #ifdef HAVE_XF1BPP
 # include "xf1bpp.h"
 #endif
 #ifdef HAVE_XF4BPP
 # include "xf4bpp.h"
 #endif
 #include "fb.h"
 #if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
 #include "xf86Resources.h"
 #include "xf86RAC.h"
 #endif
 #ifdef XvExtension
 #include "xf86xv.h"
 #endif
 #include "wsfb.h"
 /* #include "wsconsio.h" */
 #include <sys/mman.h>
-#ifdef USE_PRIVSEP
+#ifdef X_PRIVSEP
 extern int priv_open_device(const char *);
 #else
 #define priv_open_device(n)    open(n,O_RDWR|O_NONBLOCK|O_EXCL)
 #endif
 #if defined(__NetBSD__)
 #define WSFB_DEFAULT_DEV "/dev/ttyE0"
 #else
 #define WSFB_DEFAULT_DEV "/dev/ttyC0"
 #endif
 #define DEBUG 0
 @@ -112,50 +122,50 @@ static Bool WsfbScreenInit(int, ScreenPt
 static Bool WsfbCloseScreen(int, ScreenPtr);
 static void *WsfbWindowLinear(ScreenPtr, CARD32, CARD32, int, CARD32 *,
 			      void *);
 static void WsfbPointerMoved(int, int, int);
 static Bool WsfbEnterVT(int, int);
 static void WsfbLeaveVT(int, int);
 static Bool WsfbSwitchMode(int, DisplayModePtr, int);
 static int WsfbValidMode(int, DisplayModePtr, Bool, int);
 static void WsfbLoadPalette(ScrnInfoPtr, int, int *, LOCO *, VisualPtr);
 static Bool WsfbSaveScreen(ScreenPtr, int);
 static void WsfbSave(ScrnInfoPtr);
 static void WsfbRestore(ScrnInfoPtr);
-/* dga stuff */
+/* DGA stuff */
 #ifdef XFreeXDGA
 static Bool WsfbDGAOpenFramebuffer(ScrnInfoPtr, char **, unsigned char **,
 				   int *, int *, int *);
 static Bool WsfbDGASetMode(ScrnInfoPtr, DGAModePtr);
 static void WsfbDGASetViewport(ScrnInfoPtr, int, int, int);
 static Bool WsfbDGAInit(ScrnInfoPtr, ScreenPtr);
 #endif
 static Bool WsfbDriverFunc(ScrnInfoPtr pScrn, xorgDriverFuncOp op,
 				pointer ptr);
-/* helper functions */
+/* Helper functions */
 static int wsfb_open(char *);
 static pointer wsfb_mmap(size_t, off_t, int);
 enum { WSFB_ROTATE_NONE = 0,
        WSFB_ROTATE_CCW = 90,
        WSFB_ROTATE_UD = 180,
        WSFB_ROTATE_CW = 270
 };
 /*
- * This is intentionally screen-independent.  It indicates the binding
+ * This is intentionally screen-independent.
- * choice made in the first PreInit.
+ * It indicates the binding choice made in the first PreInit.
  */
 static int pix24bpp = 0;
 #define WSFB_VERSION 		4000
 #define WSFB_NAME		"wsfb"
 #define WSFB_DRIVER_NAME	"wsfb"
 _X_EXPORT DriverRec WSFB = {
 	WSFB_VERSION,
 	WSFB_DRIVER_NAME,
 	WsfbIdentify,
 	WsfbProbe,
 	WsfbAvailableOptions,
 @@ -221,27 +231,27 @@ static XF86ModuleVersionInfo WsfbVersRec
 	ABI_VIDEODRV_VERSION,
 	NULL,
 	{0, 0, 0, 0}
 };
 _X_EXPORT XF86ModuleData wsfbModuleData = { &WsfbVersRec, WsfbSetup, NULL };
 static pointer
 WsfbSetup(pointer module, pointer opts, int *errmaj, int *errmin)
+{
 	static Bool setupDone = FALSE;
 	const char *osname;
-	/* Check that we're being loaded on a OpenBSD or NetBSD system */
+	/* Check that we're being loaded on a OpenBSD or NetBSD system. */
 	LoaderGetOS(&osname, NULL, NULL, NULL);
 	if (!osname || (strcmp(osname, "openbsd") != 0 &&
 	                strcmp(osname, "netbsd") != 0)) {
 		if (errmaj)
 			*errmaj = LDR_BADOS;
 		if (errmin)
 			*errmin = 0;
 		return NULL;
+	}
 	if (!setupDone) {
 		setupDone = TRUE;
 		xf86AddDriver(&WSFB, module, HaveDriverFuncs);
 		LoaderRefSymLists(fbSymbols, shadowSymbols, ramdacSymbols,
 @@ -279,61 +289,61 @@ WsfbFreeRec(ScrnInfoPtr pScrn)
 static const OptionInfoRec *
 WsfbAvailableOptions(int chipid, int busid)
+{
 	return WsfbOptions;
+}
 static void
 WsfbIdentify(int flags)
+{
 	xf86PrintChipsets(WSFB_NAME, "driver for wsdisplay framebuffer",
 			  WsfbChipsets);
+}
-/* Open the framebuffer device */
+/* Open the framebuffer device. */
 static int
 wsfb_open(char *dev)
+{
 	int fd = -1;
-	/* try argument from XF86Config first */
+	/* Try argument from XF86Config first. */
 	if (dev == NULL || ((fd = priv_open_device(dev)) == -1)) {
-		/* second: environment variable */
+		/* Second: environment variable. */
 		dev = getenv("XDEVICE");
 		if (dev == NULL || ((fd = priv_open_device(dev)) == -1)) {
-			/* last try: default device */
+			/* Last try: default device. */
 			dev = WSFB_DEFAULT_DEV;
 			if ((fd = priv_open_device(dev)) == -1) {
 				return -1;
+			}
+		}
+	}
 	return fd;
+}
-/* Map the framebuffer's memory */
+/* Map the framebuffer's memory. */
 static pointer
 wsfb_mmap(size_t len, off_t off, int fd)
+{
 	int pagemask, mapsize;
 	caddr_t addr;
 	pointer mapaddr;
 	pagemask = getpagesize() - 1;
 	mapsize = ((int) len + pagemask) & ~pagemask;
 	addr = 0;
 	/*
-	 * try and make it private first, that way once we get it, an
+	 * Try and make it private first, that way once we get it, an
 	 * interloper, e.g. another server, can't get this frame buffer,
 	 * and if another server already has it, this one won't.
 	 */
 	mapaddr = (pointer) mmap(addr, mapsize,
 				 PROT_READ | PROT_WRITE, MAP_SHARED,
 				 fd, off);
 	if (mapaddr == MAP_FAILED) {
 		mapaddr = NULL;
+	}
 #if DEBUG
 	ErrorF("mmap returns: addr %p len 0x%x\n", mapaddr, mapsize);
 #endif
 	return mapaddr;
 @@ -406,55 +416,57 @@ WsfbPreInit(ScrnInfoPtr pScrn, int flags
 	if (flags & PROBE_DETECT) return FALSE;
 	TRACE_ENTER("PreInit");
 	if (pScrn->numEntities != 1) return FALSE;
 	pScrn->monitor = pScrn->confScreen->monitor;
 	WsfbGetRec(pScrn);
 	fPtr = WSFBPTR(pScrn);
 	fPtr->pEnt = xf86GetEntityInfo(pScrn->entityList[0]);
 #if GET_ABI_MAJOR(ABI_VIDEODRV_VERSION) < 6
 	pScrn->racMemFlags = RAC_FB | RAC_COLORMAP | RAC_CURSOR | RAC_VIEWPORT;
 	pScrn->racIoFlags = pScrn->racMemFlags;
 #endif
 	dev = xf86FindOptionValue(fPtr->pEnt->device->options, "device");
 	fPtr->fd = wsfb_open(dev);
 	if (fPtr->fd == -1) {
 		return FALSE;
+	}
 	if (ioctl(fPtr->fd, WSDISPLAYIO_GINFO, &fPtr->info) == -1) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "ioctl WSDISPLAY_GINFO: %s\n",
 			   strerror(errno));
 		return FALSE;
+	}
 	if (ioctl(fPtr->fd, WSDISPLAYIO_GTYPE, &wstype) == -1) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "ioctl WSDISPLAY_GTYPE: %s\n",
 			   strerror(errno));
 		return FALSE;
+	}
 	if (ioctl(fPtr->fd, WSDISPLAYIO_LINEBYTES, &fPtr->linebytes) == -1) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "ioctl WSDISPLAYIO_LINEBYTES: %s\n",
 			   strerror(errno));
 		return FALSE;
+	}
 	/*
-	 * Allocate room for saving the colormap
+	 * Allocate room for saving the colormap.
 	 */
 	if (fPtr->info.cmsize != 0) {
 		fPtr->saved_cmap.red =
 		    (unsigned char *)xalloc(fPtr->info.cmsize);
 		if (fPtr->saved_cmap.red == NULL) {
 			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			    "Cannot malloc %d bytes\n", fPtr->info.cmsize);
 			return FALSE;
+		}
 		fPtr->saved_cmap.green =
 		    (unsigned char *)xalloc(fPtr->info.cmsize);
 		if (fPtr->saved_cmap.green == NULL) {
 			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 @@ -470,105 +482,105 @@ WsfbPreInit(ScrnInfoPtr pScrn, int flags
 			xfree(fPtr->saved_cmap.red);
 			xfree(fPtr->saved_cmap.green);
 			return FALSE;
+		}
+	}
 	/* Handle depth */
 	default_depth = fPtr->info.depth <= 24 ? fPtr->info.depth : 24;
 	if (!xf86SetDepthBpp(pScrn, default_depth, default_depth,
 		fPtr->info.depth,
 		fPtr->info.depth >= 24 ? Support24bppFb|Support32bppFb : 0))
 		return FALSE;
-	/* Check consistency */
+	/* Check consistency. */
 	if (pScrn->bitsPerPixel != fPtr->info.depth) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 		    "specified depth (%d) or bpp (%d) doesn't match "
 		    "framebuffer depth (%d)\n", pScrn->depth,
 		    pScrn->bitsPerPixel, fPtr->info.depth);
 		return FALSE;
+	}
 	xf86PrintDepthBpp(pScrn);
-	/* Get the depth24 pixmap format */
+	/* Get the depth24 pixmap format. */
 	if (pScrn->depth == 24 && pix24bpp == 0)
 		pix24bpp = xf86GetBppFromDepth(pScrn, 24);
-	/* color weight */
+	/* Color weight */
 	if (pScrn->depth > 8) {
 		rgb zeros = { 0, 0, 0 }, masks;
 		if (wstype == WSDISPLAY_TYPE_SUN24 ||
 		    wstype == WSDISPLAY_TYPE_SUNCG12 ||
 		    wstype == WSDISPLAY_TYPE_SUNCG14 ||
 		    wstype == WSDISPLAY_TYPE_SUNTCX ||
 		    wstype == WSDISPLAY_TYPE_SUNFFB) {
 			masks.red = 0x0000ff;
 			masks.green = 0x00ff00;
 			masks.blue = 0xff0000;
 		} else {
 			masks.red = 0;
 			masks.green = 0;
 			masks.blue = 0;
+		}
 		if (!xf86SetWeight(pScrn, zeros, masks))
 			return FALSE;
+	}
-	/* visual init */
+	/* Visual init */
 	if (!xf86SetDefaultVisual(pScrn, -1))
 		return FALSE;
-	/* We don't currently support DirectColor at > 8bpp */
+	/* We don't currently support DirectColor at > 8bpp . */
 	if (pScrn->depth > 8 && pScrn->defaultVisual != TrueColor) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Given default visual"
 			   " (%s) is not supported at depth %d\n",
 			   xf86GetVisualName(pScrn->defaultVisual),
 			   pScrn->depth);
 		return FALSE;
+	}
 	xf86SetGamma(pScrn,zeros);
 	pScrn->progClock = TRUE;
 	pScrn->rgbBits   = 8;
 	pScrn->chipset   = "wsfb";
 	pScrn->videoRam  = fPtr->linebytes * fPtr->info.height;
 	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Vidmem: %dk\n",
 		   pScrn->videoRam/1024);
-	/* handle options */
+	/* Handle options. */
 	xf86CollectOptions(pScrn, NULL);
 	if (!(fPtr->Options = xalloc(sizeof(WsfbOptions))))
 		return FALSE;
 	memcpy(fPtr->Options, WsfbOptions, sizeof(WsfbOptions));
 	xf86ProcessOptions(pScrn->scrnIndex, fPtr->pEnt->device->options,
 			   fPtr->Options);
-	/* use shadow framebuffer by default, on depth >= 8 */
+	/* Use shadow framebuffer by default, on depth >= 8 */
 	if (pScrn->depth >= 8)
 		fPtr->shadowFB = xf86ReturnOptValBool(fPtr->Options,
 						      OPTION_SHADOW_FB, TRUE);
 	else
 		if (xf86ReturnOptValBool(fPtr->Options,
 					 OPTION_SHADOW_FB, FALSE)) {
 			xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 				   "Shadow FB option ignored on depth < 8");
+		}
-	/* rotation */
+	/* Rotation */
 	fPtr->rotate = WSFB_ROTATE_NONE;
 	if ((s = xf86GetOptValString(fPtr->Options, OPTION_ROTATE))) {
 		if (pScrn->depth >= 8) {
 			if (!xf86NameCmp(s, "CW")) {
 				fPtr->shadowFB = TRUE;
 				fPtr->rotate = WSFB_ROTATE_CW;
 				xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 				    "Rotating screen clockwise\n");
 			} else if (!xf86NameCmp(s, "CCW")) {
 				fPtr->shadowFB = TRUE;
 				fPtr->rotate = WSFB_ROTATE_CCW;
 				xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 				    "Rotating screen counter clockwise\n");
 @@ -581,27 +593,27 @@ WsfbPreInit(ScrnInfoPtr pScrn, int flags
 				xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 				    "\"%s\" is not a valid value for Option "
 				    "\"Rotate\"\n", s);
 				xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 				    "Valid options are \"CW\", \"CCW\","
 				    " or \"UD\"\n");
+			}
 		} else {
 			xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
 			    "Option \"Rotate\" ignored on depth < 8");
+		}
+	}
-	/* fake video mode struct */
+	/* Fake video mode struct. */
 	mode = (DisplayModePtr)xalloc(sizeof(DisplayModeRec));
 	mode->prev = mode;
 	mode->next = mode;
 	mode->name = "wsfb current mode";
 	mode->status = MODE_OK;
 	mode->type = M_T_BUILTIN;
 	mode->Clock = 0;
 	mode->HDisplay = fPtr->info.width;
 	mode->HSyncStart = 0;
 	mode->HSyncEnd = 0;
 	mode->HTotal = 0;
 	mode->HSkew = 0;
 	mode->VDisplay = fPtr->info.height;
 @@ -609,57 +621,68 @@ WsfbPreInit(ScrnInfoPtr pScrn, int flags
 	mode->VSyncEnd = 0;
 	mode->VTotal = 0;
 	mode->VScan = 0;
 	mode->Flags = 0;
 	if (pScrn->modes != NULL) {
 		xf86DrvMsg(pScrn->scrnIndex, X_INFO,
 		   "Ignoring mode specification from screen section\n");
+	}
 	pScrn->currentMode = pScrn->modes = mode;
 	pScrn->virtualX = fPtr->info.width;
 	pScrn->virtualY = fPtr->info.height;
 	pScrn->displayWidth = pScrn->virtualX;
-	/* Set the display resolution */
+	/* Set the display resolution. */
 	xf86SetDpi(pScrn, 0, 0);
 	from = X_DEFAULT;
 	fPtr->HWCursor = TRUE;
 	if (xf86GetOptValBool(fPtr->Options, OPTION_HW_CURSOR, &fPtr->HWCursor))
 		from = X_CONFIG;
 	if (xf86ReturnOptValBool(fPtr->Options, OPTION_SW_CURSOR, FALSE)) {
 		from = X_CONFIG;
 		fPtr->HWCursor = FALSE;
+	}
 	xf86DrvMsg(pScrn->scrnIndex, from, "Using %s cursor\n",
 		fPtr->HWCursor ? "HW" : "SW");
-	/* Load bpp-specific modules */
+	/* Load bpp-specific modules. */
 	switch(pScrn->bitsPerPixel) {
 #ifdef HAVE_XF1BPP
 	case 1:
 		mod = "xf1bpp";
 		reqSym = "xf1bppScreenInit";
 		break;
 #endif
 #ifdef HAVE_XF4BPP
 	case 4:
 		mod = "xf4bpp";
 		reqSym = "xf4bppScreenInit";
 		break;
 #endif
 	default:
 		mod = "fb";
 		break;
+	}
-	/* Load shadow if needed */
+	/* Load shadow if needed. */
 	if (fPtr->shadowFB) {
 		xf86DrvMsg(pScrn->scrnIndex, X_CONFIG,
 			   "Using \"Shadow Framebuffer\"\n");
 		if (xf86LoadSubModule(pScrn, "shadow") == NULL) {
 			WsfbFreeRec(pScrn);
 			return FALSE;
+		}
 		xf86LoaderReqSymLists(shadowSymbols, NULL);
+	}
 	if (mod && xf86LoadSubModule(pScrn, mod) == NULL) {
 		WsfbFreeRec(pScrn);
 		return FALSE;
+	}
 	if (xf86LoadSubModule(pScrn, "ramdac") == NULL) {
 		WsfbFreeRec(pScrn);
 		return FALSE;
+        }
 	if (mod) {
 @@ -755,46 +778,46 @@ WsfbScreenInit(int scrnIndex, ScreenPtr
 		break;
 	case 32:
 		if (fPtr->linebytes == fPtr->info.width) {
 			len = fPtr->info.width*fPtr->info.height*sizeof(int);
 		} else {
 			len = fPtr->linebytes*fPtr->info.height;
+		}
 		break;
 	default:
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "unsupported depth %d\n", fPtr->info.depth);
 		return FALSE;
+	}
-	/* Switch to graphics mode - required before mmap */
+	/* Switch to graphics mode - required before mmap. */
 	if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &wsmode) == -1) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "ioctl WSDISPLAYIO_SMODE: %s\n",
 			   strerror(errno));
 		return FALSE;
+	}
 	fPtr->fbmem = wsfb_mmap(len, 0, fPtr->fd);
 	if (fPtr->fbmem == NULL) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "wsfb_mmap: %s\n", strerror(errno));
 		return FALSE;
+	}
 	fPtr->fbmem_len = len;
 	WsfbSave(pScrn);
 	pScrn->vtSema = TRUE;
-	/* mi layer */
+	/* MI layer */
 	miClearVisualTypes();
 	if (pScrn->bitsPerPixel > 8) {
 		if (!miSetVisualTypes(pScrn->depth, TrueColorMask,
 				      pScrn->rgbBits, TrueColor))
 			return FALSE;
 	} else {
 		if (!miSetVisualTypes(pScrn->depth,
 				      miGetDefaultVisualMask(pScrn->depth),
 				      pScrn->rgbBits, pScrn->defaultVisual))
 			return FALSE;
+	}
 	if (!miSetPixmapDepths())
 		return FALSE;
 @@ -802,48 +825,75 @@ WsfbScreenInit(int scrnIndex, ScreenPtr
 	if (fPtr->rotate == WSFB_ROTATE_CW
 	    || fPtr->rotate == WSFB_ROTATE_CCW) {
 		int tmp = pScrn->virtualX;
 		pScrn->virtualX = pScrn->displayWidth = pScrn->virtualY;
 		pScrn->virtualY = tmp;
+	}
 	if (fPtr->rotate && !fPtr->PointerMoved) {
 		fPtr->PointerMoved = pScrn->PointerMoved;
 		pScrn->PointerMoved = WsfbPointerMoved;
+	}
 	fPtr->fbstart = fPtr->fbmem;
 	if (fPtr->shadowFB) {
 		fPtr->shadow = xcalloc(1, pScrn->virtualX * pScrn->virtualY *
 		    pScrn->bitsPerPixel);
 		if (!fPtr->shadow) {
 			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			    "Failed to allocate shadow framebuffer\n");
 			return FALSE;
+		}
+	}
 	switch (pScrn->bitsPerPixel) {
 	case 1:
 #ifdef HAVE_XF1BPP
 		ret = xf1bppScreenInit(pScreen, fPtr->fbstart,
 				       pScrn->virtualX, pScrn->virtualY,
 				       pScrn->xDpi, pScrn->yDpi,
 				       pScrn->displayWidth);
 		break;
 #endif
 	case 4:
 #ifdef HAVE_XF4BPP
 		ret = xf4bppScreenInit(pScreen, fPtr->fbstart,
 				       pScrn->virtualX, pScrn->virtualY,
 				       pScrn->xDpi, pScrn->yDpi,
 				       pScrn->displayWidth);
 		break;
 #endif
 	case 8:
 	case 16:
 	case 24:
 	case 32:
 		ret = fbScreenInit(pScreen,
 		    /*fPtr->shadowFB ? fPtr->shadow :*/ fPtr->fbstart,
 		    pScrn->virtualX, pScrn->virtualY,
 		    pScrn->xDpi, pScrn->yDpi,
 		    pScrn->displayWidth, pScrn->bitsPerPixel);
 		break;
 	default:
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "Unsupported bpp: %d", pScrn->bitsPerPixel);
 		return FALSE;
 	} /* case */
 	if (!ret)
 		return FALSE;
 	if (pScrn->bitsPerPixel > 8) {
-		/* Fixup RGB ordering */
+		/* Fixup RGB ordering. */
 		visual = pScreen->visuals + pScreen->numVisuals;
 		while (--visual >= pScreen->visuals) {
 			if ((visual->class | DynamicClass) == DirectColor) {
 				visual->offsetRed   = pScrn->offset.red;
 				visual->offsetGreen = pScrn->offset.green;
 				visual->offsetBlue  = pScrn->offset.blue;
 				visual->redMask     = pScrn->mask.red;
 				visual->greenMask   = pScrn->mask.green;
 				visual->blueMask    = pScrn->mask.blue;
+			}
+		}
+	}
 @@ -868,94 +918,107 @@ WsfbScreenInit(int scrnIndex, ScreenPtr
 	if (fPtr->rotate) {
 		xf86DrvMsg(scrnIndex, X_INFO, "Enabling Driver Rotation, "
 		    "disabling RandR\n");
 		xf86DisableRandR();
 		if (pScrn->bitsPerPixel == 24)
 			xf86DrvMsg(scrnIndex, X_WARNING,
 			    "Rotation might be broken in 24 bpp\n");
+	}
 	xf86SetBlackWhitePixels(pScreen);
 	miInitializeBackingStore(pScreen);
 	xf86SetBackingStore(pScreen);
-	/* software cursor */
+	/* Software cursor. */
 	miDCInitialize(pScreen, xf86GetPointerScreenFuncs());
 	/* check for hardware cursor support */
 	if (fPtr->HWCursor)
 		WsfbSetupCursor(pScreen);
-	/* colormap */
+	/*
 	 * Colormap
+	 *
 	 * Note that, even on less than 8 bit depth frame buffers, we
 	 * expect the colormap to be programmable with 8 bit values.
 	 * As of now, this is indeed the case on all OpenBSD supported
 	 * graphics hardware.
 	 */
 	if (!miCreateDefColormap(pScreen))
 		return FALSE;
 	flags = CMAP_RELOAD_ON_MODE_SWITCH;
 	ncolors = fPtr->info.cmsize;
-	/* on StaticGray visuals, fake a 256 entries colormap */
+	/* On StaticGray visuals, fake a 256 entries colormap. */
 	if (ncolors == 0)
 		ncolors = 256;
 	if(!xf86HandleColormaps(pScreen, ncolors, 8, WsfbLoadPalette,
 				NULL, flags))
 		return FALSE;
 	pScreen->SaveScreen = WsfbSaveScreen;
 #ifdef XvExtension
+	{
 		XF86VideoAdaptorPtr *ptr;
 		int n = xf86XVListGenericAdaptors(pScrn,&ptr);
 		if (n) {
 			xf86XVScreenInit(pScreen,ptr,n);
+		}
+	}
 #endif
-	/* Wrap the current CloseScreen function */
+	/* Wrap the current CloseScreen function. */
 	fPtr->CloseScreen = pScreen->CloseScreen;
 	pScreen->CloseScreen = WsfbCloseScreen;
 	TRACE_EXIT("WsfbScreenInit");
 	return TRUE;
+}
 static Bool
 WsfbCloseScreen(int scrnIndex, ScreenPtr pScreen)
+{
 	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 	PixmapPtr pPixmap;
 	WsfbPtr fPtr = WSFBPTR(pScrn);
 	TRACE_ENTER("WsfbCloseScreen");
 	pPixmap = pScreen->GetScreenPixmap(pScreen);
 	shadowRemove(pScreen, pPixmap);
 	if (pScrn->vtSema) {
 		WsfbRestore(pScrn);
 		if (munmap(fPtr->fbmem, fPtr->fbmem_len) == -1) {
 			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 				   "munmap: %s\n", strerror(errno));
+		}
 		fPtr->fbmem = NULL;
+	}
 #ifdef XFreeXDGA
 	if (fPtr->pDGAMode) {
 		xfree(fPtr->pDGAMode);
 		fPtr->pDGAMode = NULL;
 		fPtr->nDGAMode = 0;
+	}
 #endif
 	pScrn->vtSema = FALSE;
-	/* unwrap CloseScreen */
+	/* Unwrap CloseScreen. */
 	pScreen->CloseScreen = fPtr->CloseScreen;
 	TRACE_EXIT("WsfbCloseScreen");
 	return (*pScreen->CloseScreen)(scrnIndex, pScreen);
+}
 static void *
 WsfbWindowLinear(ScreenPtr pScreen, CARD32 row, CARD32 offset, int mode,
 		CARD32 *size, void *closure)
+{
 	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 	WsfbPtr fPtr = WSFBPTR(pScrn);
 	if (fPtr->linebytes)
 		*size = fPtr->linebytes;
 	else {
 @@ -1001,48 +1064,49 @@ WsfbPointerMoved(int index, int x, int y
+    }
     /* Pass adjusted pointer coordinates to wrapped PointerMoved function. */
     (*fPtr->PointerMoved)(index, newX, newY);
+}
 static Bool
 WsfbEnterVT(int scrnIndex, int flags)
+{
 	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 	TRACE_ENTER("EnterVT");
 	pScrn->vtSema = TRUE;
 	TRACE_EXIT("EnterVT");
 	return TRUE;
+}
 static void
 WsfbLeaveVT(int scrnIndex, int flags)
+{
 #if DEBUG
 	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 #endif
 	TRACE_ENTER("LeaveVT");
+}
 static Bool
 WsfbSwitchMode(int scrnIndex, DisplayModePtr mode, int flags)
+{
 #if DEBUG
 	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 #endif
 	TRACE_ENTER("SwitchMode");
-	/* Nothing else to do */
+	/* Nothing else to do. */
 	return TRUE;
+}
 static int
 WsfbValidMode(int scrnIndex, DisplayModePtr mode, Bool verbose, int flags)
+{
 #if DEBUG
 	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
 #endif
 	TRACE_ENTER("ValidMode");
 	return MODE_OK;
+}
 @@ -1062,119 +1126,123 @@ WsfbLoadPalette(ScrnInfoPtr pScrn, int n
 	cmap.red   = red;
 	cmap.green = green;
 	cmap.blue  = blue;
 	if (numColors == 1) {
 		/* Optimisation */
 		cmap.index = indices[0];
 		red[0]   = colors[indices[0]].red;
 		green[0] = colors[indices[0]].green;
 		blue[0]  = colors[indices[0]].blue;
 		if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1)
 			ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno));
 	} else {
-		/* Change all colors in 2 syscalls */
+		/*
-		/* and limit the data to be transfered */
+		 * Change all colors in 2 ioctls
 		 * and limit the data to be transfered.
 		 */
 		for (i = 0; i < numColors; i++) {
 			if (indices[i] < indexMin)
 				indexMin = indices[i];
 			if (indices[i] > indexMax)
 				indexMax = indices[i];
+		}
 		cmap.index = indexMin;
 		cmap.count = indexMax - indexMin + 1;
 		cmap.red = &red[indexMin];
 		cmap.green = &green[indexMin];
 		cmap.blue = &blue[indexMin];
-		/* Get current map */
+		/* Get current map. */
 		if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP, &cmap) == -1)
 			ErrorF("ioctl FBIOGETCMAP: %s\n", strerror(errno));
-		/* Change the colors that require updating */
+		/* Change the colors that require updating. */
 		for (i = 0; i < numColors; i++) {
 			red[indices[i]]   = colors[indices[i]].red;
 			green[indices[i]] = colors[indices[i]].green;
 			blue[indices[i]]  = colors[indices[i]].blue;
+		}
-		/* Write the colormap back */
+		/* Write the colormap back. */
 		if (ioctl(fPtr->fd,WSDISPLAYIO_PUTCMAP, &cmap) == -1)
 			ErrorF("ioctl FBIOPUTCMAP: %s\n", strerror(errno));
+	}
 	TRACE_EXIT("LoadPalette");
+}
 static Bool
 WsfbSaveScreen(ScreenPtr pScreen, int mode)
+{
 	ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
 	WsfbPtr fPtr = WSFBPTR(pScrn);
 	int state;
 	TRACE_ENTER("SaveScreen");
 	if (!pScrn->vtSema)
 		return TRUE;
 	if (mode != SCREEN_SAVER_FORCER) {
 		state = xf86IsUnblank(mode)?WSDISPLAYIO_VIDEO_ON:
 		                            WSDISPLAYIO_VIDEO_OFF;
 		ioctl(fPtr->fd,
 		      WSDISPLAYIO_SVIDEO, &state);
+	}
 	TRACE_EXIT("SaveScreen");
 	return TRUE;
+}
 static void
 WsfbSave(ScrnInfoPtr pScrn)
+{
 	WsfbPtr fPtr = WSFBPTR(pScrn);
 	TRACE_ENTER("WsfbSave");
 	if (fPtr->info.cmsize == 0)
 		return;
 	fPtr->saved_cmap.index = 0;
 	fPtr->saved_cmap.count = fPtr->info.cmsize;
 	if (ioctl(fPtr->fd, WSDISPLAYIO_GETCMAP,
 		  &(fPtr->saved_cmap)) == -1) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "error saving colormap %s\n", strerror(errno));
+	}
 	TRACE_EXIT("WsfbSave");
+}
 static void
 WsfbRestore(ScrnInfoPtr pScrn)
+{
 	WsfbPtr fPtr = WSFBPTR(pScrn);
 	int mode;
 	TRACE_ENTER("WsfbRestore");
 	if (fPtr->info.cmsize != 0) {
 		/* reset colormap for text mode */
 		if (ioctl(fPtr->fd, WSDISPLAYIO_PUTCMAP,
 			  &(fPtr->saved_cmap)) == -1) {
 			xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 				   "error restoring colormap %s\n",
 				   strerror(errno));
+		}
+	}
-	/* Clear the screen */
+	/* Clear the screen. */
 	memset(fPtr->fbmem, 0, fPtr->fbmem_len);
-	/* Restore the text mode */
+	/* Restore the text mode. */
 	mode = WSDISPLAYIO_MODE_EMUL;
 	if (ioctl(fPtr->fd, WSDISPLAYIO_SMODE, &mode) == -1) {
 		xf86DrvMsg(pScrn->scrnIndex, X_ERROR,
 			   "error setting text mode %s\n", strerror(errno));
+	}
 	TRACE_EXIT("WsfbRestore");
+}
 #ifdef XFreeXDGA
 /***********************************************************************
  * DGA stuff
  ***********************************************************************/