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